Discussion :

[Ashireon]

Bonjour,
Je cherche a détecter certaines formes dans une photo.
Pour les caractères je me suis débrouiller avec l'API tesseract en faisant un peu de pre-traitement d'image.
voir ci dessous

traitement de l'image mettre les caractères en noir sur fond blanc tesseract réagit mieux.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
 private void button2_Click(object sender, EventArgs e)
        {
            openFileDialog1.ShowDialog();
            string Fichier = openFileDialog1.FileName;
            pictureBox2.Image = Image.FromFile(Fichier);
            // lecture fichier image
 
            Bitmap Bmp = new Bitmap(Fichier);
 
            // taille du fichier en pixel
            int largeur = Bmp.Width;
            int Hauteur = Bmp.Height;
 
            // Traitement 1 : negatif
            for ( int y = 0; y < Hauteur; y++)
            {
                for (int x = 0; x < largeur;x++)
                {
                    // pixel valeur
                    Color pixl=Bmp.GetPixel(x, y);
                    //extraction valer ARGB du pixel
                    int A = pixl.A;
                    int R = pixl.R;
                    int G = pixl.G;
                    int B = pixl.B;
 
                    // mettre en negatif
                    R = 255 - R;
                    G=255-G;
                    B=255-B;
 
                    // Modifier le pixel
                    Bmp.SetPixel(x,y,Color.FromArgb(A,R,G,B));
 
                }
 
            }
 
            // Traitement 2 : niveau de gris
            for (int y = 0; y < Hauteur; y++)
            {
                for (int x = 0; x < largeur; x++)
                {
                    // pixel valeur
                    Color pixl = Bmp.GetPixel(x, y);
                    //extraction valeur ARGB du pixel
                    int A = pixl.A;
                    int R = pixl.R;
                    int G = pixl.G;
                    int B = pixl.B;
 
                    // calcul  en niveau de gris
                    int gris =Convert.ToInt32(( 0.299 * R) + (0.587 * G )+ (0.114 * B));
 
                    // mettre en gris
 
                    R = gris ;
                    G = gris ;
                    B = gris;
 
                    // Modifier le pixel
                    Bmp.SetPixel(x, y, Color.FromArgb(A, R, G, B));
 
 
                }
 
            }
            // Traitement  : suppression du fond
            for (int y = 0; y < Hauteur; y++)
            {
                for (int x = 0; x < largeur; x++)
                {
                    // pixel valeur
                    Color pixl = Bmp.GetPixel(x, y);
                    //extraction valer ARGB du pixel
                    int A = pixl.A;
                    int R = pixl.R;
                    int G = pixl.G;
                    int B = pixl.B;
 
                    // mise en blanc le fond
                    if (B > 222)
                    {
                        R = 255;
                        G = 255;
                        B= 255; 
                    }
                    else
                    {
                        R = 0;
                        G = 0;
                        B =0;
                    }
                    //enregistrement de la cartographie
                    DataRow DR = Dt1.NewRow();
 
                    DR["X"] = x;
                    DR["Y"] = y;
                    DR["A"] = A;
                    DR["R"] = R;
                    DR["G"] = G;
                    DR["B"] = B;
 
                    Dt1.Rows.Add(DR);
                    // Modifier le pixel
                    Bmp.SetPixel(x, y, Color.FromArgb(A, R, G, B));
 
                }
 
            }
 
            dataGridView1.DataSource = Dt1;
 
            pictureBox3.Image = Bmp;
            FileInfo Fic = new FileInfo(Fichier);
            String Repertoire = Fic.Directory.FullName;
            string FichierSauvegarde = Repertoire + @"\Negatif.png";
            Bmp.Save(FichierSauvegarde);
        }

ensuite je fais la détection de caractères

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
     private void button1_Click(object sender, EventArgs e)
        {
            richTextBox1.Text = "";
            openFileDialog1.ShowDialog();
            string Fichier = openFileDialog1.FileName;  
            pictureBox1.Image=Image.FromFile(Fichier);
 
              var ocrengine = new TesseractEngine(@"c:\tessdata", "eng", EngineMode.Default);
 
                var img = Pix.LoadFromFile(Fichier);
 
             var res = ocrengine.Process(img, PageSegMode.Auto);
            richTextBox1.Text += res.GetText() + Environment.NewLine;
 
        }

Mais je sèche sur de la détection de formes géométriques.
j'ai des formes de L mais allongée sur la base et en miroir des cercles etc...

Merci si une personne saurait m'aiguiller soit vers un tuto ou qui a une idée une connaissance sur un API.

[umfred]

peut-être voir avec Emgu.CV (un wrapper d'openCV) => le tuto pour reconnaissance de forme https://www.emgu.com/wiki/index.php/...tion_in_CSharp

[Ashireon]

oui,
je suis dessus depuis vendredi mais je t'avoue que je galère à faire ce que je veux avec Emgu.CV.

Pour le moment j'arrive a détecter le contour et le dessiner mais faudrait que je compare celui ci a une forme qui peut être contenu dans ce contour ( genre le squelette filaire de la forme que je souhaite detecter)
si ma forme squelette peut être contenu dans le contour alors j'ai bien détecté la forme que je souhaite.

le Genre de texte a détecter c'est |__ToTo__| et donc |__ ce n'est que deux segments à 90 degrés mais bien sur sur le jpg ce n'est pas toujours propre la forme en pixel ressemble a ceci

**
**
**
**
**************
**************
*

J'ai des ersatz de pixels du fait que c'est la photo d'une pièce rétroéclairé.

voici ce que j'ai fait en etant aidé d'une certaine IA.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
 
 public void DetectionContours(string Fichier)
        {
            Image<Bgr, byte> sourceImage = new Image<Bgr, byte>(Fichier);
            Image<Gray, byte> grayImage = sourceImage.Convert<Gray, byte>();
            Image<Gray, byte> binaryImage = grayImage.ThresholdBinary(new Gray(128), new Gray(255));
 
            List<Point> contourPoints = new List<Point>();
            using (VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint())
            {
                CvInvoke.FindContours(grayImage, contours, null, Emgu.CV.CvEnum.RetrType.List, Emgu.CV.CvEnum.ChainApproxMethod.ChainApproxSimple);
 
                // Parcours des contours et récupération des points
                for (int i = 0; i < contours.Size; i++)
                {
                    VectorOfPoint contour = contours[i];
                    Point[] contourArray = contour.ToArray();
                    contourPoints.AddRange(contourArray);
                }
            }
 
 
            if (AreSegmentsContained(contourPoints, 1000) == true)
            {
                richTextBox1.Text = "Forme OK";
            }
            else
            {
                richTextBox1.Text = "Forme NON OK";
            }
 
 
 
 
        }
        bool AreSegmentsContained(List<Point> contour, double segmentLength)
        {
            for (int i = 0; i < contour.Count; i++)
            {
                Point pointA =contour[i];
                Point pointB = contour[(i + 1) % contour.Count]; // Point suivant (ou le premier point si nous sommes à la fin)
 
                // Calcul du vecteur orthogonal à la tangente au contour
                int tangentX = -(pointB.Y - pointA.Y);
                int tangentY = pointB.X - pointA.X;
 
                // Normalisation du vecteur orthogonal
                double length = Math.Sqrt(tangentX * tangentX + tangentY * tangentY);
                tangentX = (int)(tangentX / length);
                tangentY = (int)(tangentY / length);
 
                // Création des deux segments perpendiculaires
                int segment1StartX = pointA.X + tangentX * (int)(segmentLength / 2);
                int segment1StartY = pointA.Y + tangentY * (int)(segmentLength / 2);
                int segment1EndX = segment1StartX - tangentY * (int)segmentLength;
                int segment1EndY = segment1StartY + tangentX * (int)segmentLength;
 
                int segment2StartX = pointA.X - tangentX * (int)(segmentLength / 2);
                int segment2StartY = pointA.Y - tangentY * (int)(segmentLength / 2);
                int segment2EndX = segment2StartX - tangentY * (int)segmentLength;
                int segment2EndY = segment2StartY + tangentX * (int)segmentLength;
 
                List<Point> segment1Points = BresenhamLine(segment1StartX, segment1StartY, segment1EndX, segment1EndY);
                List<Point> segment2Points = BresenhamLine(segment2StartX, segment2StartY, segment2EndX, segment2EndY);
 
                // Vérification si tous les points des segments sont inclus dans le contour
                bool segment1Contained = segment1Points.All(p => contour.Contains(p));
                bool segment2Contained = segment2Points.All(p => contour.Contains(p));
 
                if (segment1Contained && segment2Contained)
                {
                    return true; // Les deux segments sont contenus dans le contour
                }
            }
 
            return false; // Les deux segments ne peuvent pas être contenus dans le contour
        }
 
        List<Point> BresenhamLine(int x0, int y0, int x1, int y1)
        {
            List<Point> points = new List<Point>();
 
            bool steep = Math.Abs(y1 - y0) > Math.Abs(x1 - x0);
            if (steep)
            {
                (x0, y0) = (y0, x0);
                (x1, y1) = (y1, x1);
            }
 
            bool swapped = false;
            if (x0 > x1)
            {
                (x0, x1) = (x1, x0);
                (y0, y1) = (y1, y0);
                swapped = true;
            }
 
            int dx = x1 - x0;
            int dy = Math.Abs(y1 - y0);
            int error = dx / 2;
            int ystep = (y0 < y1) ? 1 : -1;
            int y = y0;
 
            for (int x = x0; x <= x1; x++)
            {
                if (steep)
                    points.Add(new Point(y, x));
                else
                    points.Add(new Point(x, y));
 
                error -= dy;
                if (error < 0)
                {
                    y += ystep;
                    error += dx;
                }
            }
 
            if (swapped)
                points.Reverse();
 
            return points;
        }
        double CalculateDistance(Point p1, Point p2)
        {
            int dx = p2.X - p1.X;
            int dy = p2.Y - p1.Y;
            return Math.Sqrt(dx * dx + dy * dy);
        }

[Ashireon]

Je relance le truc,
En fait pour tester si j'ai la bonne forme le mieux je pense et de voir si le contour peut englober le squelette de la forme que je souhaite.
J'explique plus en détail : on grave sur une pièce rétroéclairé du texte et des formes géométriques. Je peut tester par photographie le texte mais pour les formes il faudrait juste que je sache si leur présence est bien la.
d'où la détection de contour et voir si tous les points de la forme squelette s'inscrit dedans. ce n'est pas bon si des points manquent ou que la forme ne s'y trouve pas du tout.

j'utilise un videophotmètre et la libraire LMK4 pour mesure en lum ( propriétaire à la machine) , Tesseract pour la détection du texte et Emgu.cv pour les formes.