Discussion :

[dany83]

Salut à tous, après m’être confronté à une armée de complications, de casse-tête, d’énigmes, et de phénomènes paradoxaux dans la programmation en builder c++, me revoilà de nouveau face à un combat singulier entre moi et le builder. Je précise que je suis débutant.

Les fonctions que j’utilise se rapportent principalement aux opérations effectuées sur une image chargée dans un Timage.

Alors voilà :
Imaginons qu’on a deux points : point de départ d’une ligne, et un point d’arrivé. Le premier point a ses cordonnées en x1,y1 et même chose pour le deuxième point.

Je voudrai une fonction qui me permet de relier ces deux points par des lignes et qu’ensuite parmi toutes ces lignes, je voudrai une fonction qui m’affiche la ligne qui a un coût minimum (la plus petite distance entre ces deux points) en cliquant sur un bouton.

Si vous avez la réponse aidez-moi SVP, je suis perdu !
Merci d’avance.

[henderson]

Salut !

Pour le segment entre tes deux points :

Code :

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

Canvas->MoveTo(x1,y1); Canvas->LineTo(x2,y2);

Cela suppose que Canvas->Pen soit paramètré (style, couleur et mode)

La distance entre ces deux points s'obtient par (si ma mémoire est bonne) :

Code :

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

double d = hypot((x2-x1), y2-y1)); //#include math.h

Pour les fameuses lignes ... doit-on supposer qu'on se déplace sur la ligne qui porte le segment ?

A plus !

[dany83]

Salut ! tout d’abord, merci beaucoup pour votre réponse. Je dois dire que cela m’a aidé à éclaircir quelques ambiguïtés.

Je vais être plus clair : mon but est de planifier une trajectoire entre ces deux points en prenant en compte tous les cas possible qui permettent de relier ces deux points, sachant qu’il y a des obstacles à éviter. Parmi ces lignes, il peut exister des lignes droites avec un seul segment, ou des lignes brisées qui contiennent une succession de segments de droite perpendiculaire. Peut-on réaliser ceci efficacement avec le code que vous m’avez donné, ou il existe un autre moyen ?
Merci.

[henderson]

Salut !

TCanvas::Polyline pour dessiner une ligne brisée.

ou bien

MoveTo sur le premier point et une suite de LineTo de point en point.

Le choix entre l'une ou l'autre dépend de la manière dont s'effectue le traitement.

Si on calcule les points dans un tableau, alors on peut utiliser Polyline.

Si les points sont mis en liste (c'est plus pratique à gérer qu'un tableau) dans ce cas on est contraint d'employer la deuxième méthode.

Dans ce dernier cas, on peut développer une classe permettant de gérer tout ça !

Ce n'est pas très compliqué, mais par contre je ne sais pas si cela peut être utile dans ton cas !

A plus !

[dany83]

Salut ! Merci henderson ; au moins grâce à ça, j’ai pu comprendre pas mal de choses ; particulièrement le calcul de la distance entre ces deux points m’a fait progressé un peu dans mes recherches. J’ai vérifié ce résultat avec ma calculatrice, et ça a fonctionné. C’est super !

Cependant, pour ce qui est des lignes brisées, je crois le mieux qu’il me reste à faire c’est de confirmer et de m’assurer de l’intérêt de ceci dans mon projet. Comme vous dites, cela peut ne pas être utile dans mon cas. Toutefois, j’aimerai bien avoir quand même un petit exemple d’utilisation de "TCanvas:olyline" car en parcourant l’aide de builder c++, j’ai trouvé un exemple, mais il n’a pas l’air de fonctionner : je reçois un message d’erreur indiquant qu’il est impossible de convertir ‘tagPoint *’ en ‘const Tpoint *’
Excusez-moi d’être un peu persistant, mais je suis à mes premiers pas en builder c++.

Merci encore.

[henderson]

Salut !

Pour Polyline, je déclare un tableau de TPoint en global.

Code :

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

TPoint Points[20];

Code :

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

Canvas->Polyline(Points, N);

Dans ma version BCB3 Pro, N n'est pas le nombre de points mais le nombre de segments dessinés.
Je passe donc toujours Nombre_de_Points - 1. C'est à vérifier chez toi !

Pour ce que est de la mise au point d'une classe dédiée...
Voici un exemple de classe permettant de gérer des TPoint dynamiquement et de dessiner la figure géométrique en fonction de ces points, à l'aide de MoveTo et LineTo.
Je parts du principe que j'ai 2 points (P1 et P2) pour définir le segment de la distance minimale, en tant que points de départ et d'arrivée du parcours.
La liste Points va servir à insérer d'autres points entre ces deux points pour définir un parcours différent.
Il va de soi qu'ici, ce n'est qu'un simple exemple et que l'on peut développer autrement... ce que l'on veut, en fonction de ses besoins réels !

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
#include <math.h>
 
class jParcours : public TComponent
{
private :
TList *Points;
 
protected :
    void __fastcall Purge();
 
public :
TPoint P1;
TPoint P2;
    __fastcall jParcours(TComponent *Owner);
    __fastcall ~jParcours();
 
    void __fastcall Draw(TCanvas *C);
    TPoint* __fastcall Add(int X, int Y);
    void __fastcall Clear();
 
    double __fastcall LongueurSegment();
    double __fastcall LongueurParcours();
};

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
//Constructeur
__fastcall jParcours::jParcours(TComponent *Owner)
    : TComponent(Owner)
{
Points = new TList;
}
 
//Destructeur
__fastcall jParcours::~jParcours()
{
Purge();
delete Points;
}
 
//Pour purger la liste
void __fastcall jParcours::Purge()
{
for(int j = 0; j < Points->Count; j++)
    {
    delete (TPoint*)Points->Items[j];
    }
Points->Clear();
}
 
//L'objet va se dessiner à l'aide du canvas donné comme paramètre
void __fastcall jParcours::Draw(TCanvas *C)
{
TPoint *P;
C->Pen->Color = clRed; //Parcours en rouge
C->MoveTo(P1.x, P1.y); //on démarre de P1
for(int j = 0; j < Points->Count; j++)
    {
    P = (TPoint*)Points->Items[j];
    C->LineTo(P->x, P->y); //on dessine autant de segments
    }
C->LineTo(P2.x, P2.y); //on termine la ligne brisée en P2
 
//Pour dessiner de P1 à P2, la distance la plus courte, on termine sur P1
C->Pen->Color = clBlue; //segment en bleu
C->LineTo(P1.x, P1.y);
}
 
//L'objet crée un point qu'il initialse avec X,Y, 
//qu'il enregistre en fin de liste et dont il renvoie le pointeur
TPoint* __fastcall jParcours::Add(int X, int Y)
{
TPoint *P = new TPoint;
*P = Point(X,Y);
Points->Add(P);
return P;
}
 
//Pour purger la liste de points
void __fastcall jParcours::Clear()
{
Purge();
}
 
//renvoie la longueur du segment
double __fastcall jParcours::LongueurSegment()
{
return hypot(P2.x - P1.x, P2.y - P1.y);
}
 
//renvoie la longueur du parcours
double __fastcall jParcours::LongueurParcours()
{
double n = 0.0;
 
//A toi de jouer parce que je ne vais pas tout faire ici !
 
return n;
}

Dériver de TComponent peut s'avérer très utile :
- L'objet sera détruit dès que son propriétaire sera détruit
- L'objet peut détenir d'autres objets qu'il aura instanciés lui-même et auquels il pourra accéder via sa propriété Components...

Voici comment j'ai utilisé cette classe :

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
jParcours *Chemin1;
 
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
Chemin1 = new jParcours(this);
Chemin1->P1 = Point(52,54);
Chemin1->P2 = Point(356, 212);
}
 
//OnPaint de Form1
void __fastcall TForm1::FormPaint(TObject *Sender)
{
//J'efface la fenêtre
Canvas->Brush->Color = Color;
Canvas->FillRect(Rect(0,0,ClientWidth,ClientHeight));
//Je dessine l'objet
Chemin1->Draw(Canvas);
}
 
//OnMouseDown de Form1
void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button,
      TShiftState Shift, int X, int Y)
{
//Je donne les coordonnées X,Y à l'objet pour rajouter un segment
Chemin1->Add(X,Y);
//Je redessine la fenêtre
Repaint();
}

Je me suis contenté de segmenter manuellement, en ajoutant des points... d'une manière tout à fait libre.
J'espère que par cet exemple, tu auras compris que l'on peut modéliser beaucoup de choses !
Par exemple, on peut faire en sorte que l'objet calcule lui-même le parcours, il suffira de rajouter une méthode !

A plus !

[dany83]

Salut ! Merci henderson, vraiment merci ! C’est tellement réconfortant de voir qu’il y a des personnes qui viennent à nos secours n’importe où, et n’importe quand. Je m’excuse si je n’ai pas pu répondre tout de suite, c’est parce que mon ordinateur avait apparemment piqué une petite grippe passagère ! Je lui ai donné quelques comprimés.
Quoi qu’il en soit, si je réussi à avoir un résultat satisfaisant, je vous tiendrais au courant. Merci encore.
A plus !