Bonjour,

Décor:
J'ai une IHM en wpf, un robot, et une dll delphi qui fait l’intermédiaire.

Le robot fait des aller-retour.
Pendant que le robot effectue un "aller", je récupère des données au fil de l'eau (Point(distance, force exercé)) POUR CHAQUE itération du mouvement.
Ces point sont renvoyer par la dll delphi, avec un thread qui tourne en boucle et renvoie un point a chaque boucle lorsque le robot commence son mouvement un flag d’acquisition est levé, et baissé lorsque le robot à fini son "aller".
Ces points je les met dans une List<Point> au fur et à mesure pour chaque itération (1 Itération = 1 courbe avec des points différents) ET je l'affiche (enfin j'essaye vous l'aurais compris :p) en temps réel.

Mon(mes) problème(s):
1) j'ai de moins en moins de points pour chaque itération (pas le plus gros pb, mais quand même, c'est blizzard)
2) (IMPORTANT) je dessine les courbes par groupe de points (alors que je redessine les courbes a chaque nouveau point)
3) (TRES IMPORTANT) à chaque nouvelle courbe que je dessine, es précédentes deviennent n'importe quoi (des bouts de courbe formées de 3 point uniquement selon moi, mais ces points ne correspondent à rien ?!?!)

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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
//Interception des msg
private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
        {
           if (msg == msg_NOUVEAU_PT) // msg envoyé par delphi
           {    
               Point tp = new Point(Global.TCoordx(), Global.TCoordFaxiale()); // <- recup des données de la dll    
               phase1.courbe_resultats.Last().PointList.Add(tp);        
               UpdateCourbe(phase1, true);
           }
            if (msg == msg_NOUVELLE_ITERATION)// msg envoyé par delphi
            {
                    no_iteration = (int)wParam;
                    if (phase1.courbe_resultats == null)
                        phase1.courbe_resultats = new List<Liste<Point>>();
                    phase1.courbe_resultats.Add(new Liste<Point>()); //tCourbI);
                    phase1.courbe_resultats.Last().iteration = no_iteration;
                    phase1.courbe_resultats.Last().phase_id = phase1.id;
            }
            return IntPtr.Zero;
        }
 
public void UpdateCourbe(Phase APhase, bool AWithData)
        {
            if ((APhase != null) && (APhase.id != null))
            {
 
            // initCurve initialise les pinceaux et des trucs du genre
                graph1.initCurve(APhase.courbe_resultats, true);                 
                graph1.DrawCurve();
            }
        }
 
private void Bouton_Click(object sender, RoutedEventArgs e)
        {
        //prerequis pour l'interception des msg
            System.Windows.Interop.HwndSource source = PresentationSource.FromVisual(this) as System.Windows.Interop.HwndSource;
            source.AddHook(WndProc); 
 
                if (this.Exercice != null)
                {                
                    int NBi =  int.Parse(tb_NbI.Text);  // textbox où on declare le nombre d'iteration qu'on veut
 
                    // fonctions dans la dll
                    Global.EngineInit(2);
                    Global.StartExercice(phase1.acceleration,
                                                         phase1.deceleration,
                                                         phase1.vitesse,
                                                         int.Parse(tb_posRentree.Text), //textbox
                                                         int.Parse(tb_posSortie.Text),	//textbox
                                                         int.Parse(tb_pii.Text),				//textbox
                                                        NBi);
                }            
        }
 
 
public void DrawCurve()
        {          
            bool isConsigne = true;
            if (m_curves.Count == 0)
            {
                return;
            }
            int index = 0;
 
                foreach (List<Point> curv in m_curves)
                {
                    foreach (Point p in curv)
                    {
                        if (MinY > p.Y) { MinY = p.Y; }
                        if (MaxY < p.Y) { MaxY = p.Y; }
                        if (MinX > p.X) { MinX = p.X; }
                        if (MaxX < p.X) { MaxX = p.X; }
                    }
                }
                // initDraw cree l'echelle et redimentionne l'espace pour dessiner les courbes
                initDraw();
 
                double RatioX = ((ActualWidth - MargeL - MargeR) / (MaxX - MinX));
                double RatioY = ((ActualHeight - MargeT - MargeB) / (MaxY - MinY));
                foreach (List<Point> CurrentCurve in m_curves)
                {
                    this.lspos.Clear();
                    foreach (Point DP in CurrentCurve)
                    {
                        double X = (DP.X - MinX) * RatioX + MargeL;
                        double Y = (DP.Y - MinY) * RatioY + MargeT;
                        Y = ActualHeight - Y;
                        this.lspos.Add(new Point(double.Parse(string.Format("{0:0.00}", X)), double.Parse(string.Format("{0:0.00}", Y))));
                    }
                    if (this.lspos.Count < 2)
                        return;
 
                    if (index == 0) isConsigne = true;
                    else isConsigne = false;
                    Path path = SubDrawCurve(lspos, index, isConsigne);
                    Children.Add(path);
                    index++;                   
 
                    path.MouseMove += new System.Windows.Input.MouseEventHandler(path_MouseMoveToolTip);
               }                
        }
 
 
private Path SubDrawCurve(PointCollection lspos, int index, bool isConsigne)
        {
            PolyBezierSegment lines = new PolyBezierSegment();
 
            //largeur de courbure - atm 0.05% de la distance totale de part et d'autre // pour controler les courbures
            double paramCourbure = pc_courbure * (lspos.Last().X - lspos.First().X);
            if (isConsigne)
            {
                lines.Points.Add(new Point(lspos[0].X + paramCourbure, lspos[0].Y));
 
                for (int i = 1; i < lspos.Count - 1; i += 2)
                {
                //detPtsControles creer des point de controle pour la courbe de bezier // inutile pour la courbes de resultats
                    PointCollection tpc = detPtsControles(lspos[i], lspos[i + 1], paramCourbure);
                    lines.Points.Add(tpc[0]);
                    lines.Points.Add(lspos[i]);
                    lines.Points.Add(tpc[1]);
                    lines.Points.Add(tpc[2]);
                    lines.Points.Add(lspos[i + 1]);
                    lines.Points.Add(tpc[3]);
                }
                lines.Points.Add(new Point(lspos[lspos.Count - 1].X - paramCourbure, lspos[lspos.Count - 1].Y));
                lines.Points.Add(lspos[lspos.Count - 1]);
                //}
            }
            else
            {
                lines.Points = lspos;
            }
            // le nombre de points mod 3 = 0
            if (lines.Points.Count % 3 == 2)
            {
                Point p = new Point(lines.Points[lines.Points.Count - 1].X + 1, lines.Points[lines.Points.Count - 1].Y);
                lines.Points.Add(p);
            }
            else if (lines.Points.Count % 3 == 1)
            {
                Point p = new Point(lines.Points[lines.Points.Count - 1].X + 1, lines.Points[lines.Points.Count - 1].Y);
                lines.Points.Add(p);
                lines.Points.Add(new Point(p.X + 1, p.Y));
            }
 
            PathFigure f = new PathFigure();
            f.StartPoint = lspos[0];
            f.Segments.Add(lines);
            f.IsClosed = false;
 
            PathGeometry g = new PathGeometry(new PathFigure[] { f });
            return new Path() { Stroke = TabBrush[index], StrokeThickness = 3, Data = g };
        }
Merci de votre aide, et n'hésitez pas si j'ai manqué de clarté à me le dire