différence de résultats entre pathX.isvisible tracé a l'écran ou non

Bonjour,

je souhaite connaitre les points a l'intérieur d'un contour.
J'ai ma liste de points définissant mon contour, je crée un GraphicsPath a partir de cette liste.

et voici ce que j'obtiens quand je ne trace pas le contour a l'écran (tracé a a partir d'un logiciel exterieur en exportant les points dans des fichiers texte):
En Rouge : le contour
En noir : les points testés et non inclus dans le contour
En vert : les points inclus dans le contour
Pièce jointe 188949

on voit bien qu'il y a quelques soucis...

si je trace le contour à l'écran, et que je fais la meme chose, voici ce que j'ai
Pièce jointe 188953
c'est tout a fait correct !

est ce que c'est normale d'avoir des différences de résultats entre un contour tracé ou non a l'écran ?
La solution serait de tracé le contour a l'écran pour ne plus avoir de problème, mais j'aimerais comprendre pourquoi et je dois faire la manipe une 20 de fois, donc je veux éviter un défilement de contours et de points a l'écran.

code pour obtenir mon contour de points :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//path => contour avec les coordonnées initiales
for (int i = 0; i <= 360 / 3; i++)
            {
                
                a = i * 3 + (-90); b = (i + 1) * 3 + (-90);
                string tempo = "Angle >= '" + a  + "' AND" + " Angle <= '" + b + "'";
                foundRows2 = foundedTable.Select("Angle >= '" + a + "' AND" + " Angle <= '" + b + "'");
                if (foundRows2.Length > 0)
                {
                    foundedTable2 = foundRows2.CopyToDataTable();
                    DataTable test = foundRows2.OrderByDescending(row => row[3]).CopyToDataTable();

                    pathpoint.X = Convert.ToSingle( test.Rows[0]["X"]);
                    pathpoint.Y = Convert.ToSingle(test.Rows[0]["Y"]);
                    listpoints.Add(pathpoint); // <== liste des points définissant le contour
                    file3.WriteLine(String.Join(" ",a, pathpoint.X, pathpoint.Y));
                    file3.Flush();
                 }
            }
            
            path.AddPolygon(listpoints.ToArray());
            path.CloseFigure();

code pour voir si le point (i,j) est a l'intérieur ou non : (résultat = première figure)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
for (int i = 0; i <= nbx; i++)
            {
                for (int j = 0; j <= nby; j++)
                {
                    file5.WriteLine(String.Join(" ", ptemp.X, ptemp.Y));
                    file5.Flush();
                    ptemp.X = Convert.ToSingle((xmin + i * 0.5));
                    ptemp.Y = Convert.ToSingle((ymin + j * 0.5));
 
                    if (path.IsVisible(ptemp))
                    {
                        file4.WriteLine(String.Join(" ", ptemp.X, ptemp.Y));//Convert.ToSingle(xmin) + i * 0.5, Convert.ToSingle(ymin) + j * 0.5));
                        file4.Flush();
                    }
                    ptemp.X = ptemp.X * ratiox + (gxmax - gxmin) / 2;
                    ptemp.Y = ptemp.Y * ratioy + (gymax - gymin) / 2;
                    listpoints3.Add(ptemp); //série de points a tester avec la nouvelle échelle
                }
            }

code pour tracer le contour a l'écran et tester si le point (i,j) est dans le contour tracé a l'écran.
Je pars de ma liste de point déja crée avant, donc j'ai les meme données en entrée, j'applique juste une échelle, car je trace ça a l'arrache par dessus un graphique

Code:

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
 
//path2 => contour avec les coordonnées mises a l'échelle du graphique
PointF ptemp2=new PointF();
            for (int i = 0; i < listpoints.Count(); i++)
            {
                ptemp2.X = (listpoints[i].X) * ratiox + (gxmax - gxmin)/2;
                ptemp2.Y = (listpoints[i].Y) * ratioy + (gymax - gymin)/2;
                listpoints2.Add(ptemp2);
                file6.WriteLine(String.Join(" ",ptemp2.X,ptemp2.Y));
                file6.Flush();
            }
            path2.AddPolygon(listpoints2.ToArray());
            path2.CloseFigure();
            List<PointF> pointvisible = new List<PointF>();
            g.DrawPath(pen1, path2)
            for (int i = 0; i < listpoints3.Count(); i++)
            {
                ptemp2.X = listpoints3[i].X;
                ptemp2.Y = listpoints3[i].Y;
                if (path2.IsVisible(ptemp2))
                {
                    pointvisible.Add(listpoints3[i]);
                    file7.WriteLine(String.Join(" ",listpoints3[i].X,listpoints3[i].Y));
                    file7.Flush();
                }
            };

voila, donc pour moi j'ai le meme données en entrée (sur lesquelles j'applique juste un facteur) et j'ai pas le meme résultat :/

merci !