--- /dev/null
+#include "Connexion.h"
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include <sys/types.h>
+
+#include "SocketTCP.h"
+#include "SocketUDP.h"
+
+Connexion::Connexion()
+:socket_communication(NULL), type_connexion(P_TCP)
+{
+ socket_connexion = new SocketTCP();
+
+ socket_connexion->Listen();
+
+}
+
+Connexion::Connexion(const int &t)
+:socket_communication(NULL), type_connexion(t)
+{
+ switch(t)
+ {
+ case P_TCP :
+ socket_connexion = new SocketTCP();
+ break;
+ case P_UDP :
+ socket_connexion = new SocketUDP();
+ break;
+ }
+ socket_connexion->Listen();
+}
+
+Connexion::Connexion(const int &t, const int &port)
+:socket_communication(NULL), type_connexion(t)
+{
+ switch(t)
+ {
+ case P_TCP :
+ socket_connexion = new SocketTCP(port);
+ break;
+ case P_UDP :
+ socket_connexion = new SocketUDP(port);
+ break;
+ }
+ socket_connexion->Listen();
+}
+
+Connexion::Connexion(const int &t, const char *hote, const int &port)
+:socket_communication(NULL), type_connexion(t)
+{
+ switch(t)
+ {
+ case P_TCP :
+ socket_connexion = new SocketTCP(hote,port);
+ break;
+ case P_UDP :
+ socket_connexion = new SocketUDP(hote,port);
+ break;
+ }
+ socket_connexion->Listen();
+}
+
+Connexion::~Connexion()
+{
+ delete socket_communication;
+}
+
+int Connexion::GetPort() const
+{
+ return socket_connexion->Port();
+}
+
+int Connexion::GetType() const
+{
+ return type_connexion;
+}
+
+Socket* Connexion::SockConnexion(void)
+{
+ return socket_connexion;
+}
+
+Socket* Connexion::AttendConnexion()
+{
+ return socket_connexion->Accept();
+}
--- /dev/null
+#ifndef _CONNEXION_
+#define _CONNEXION_
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#include "Socket.h"
+#include "../Global.h"
+
+#define P_TCP 0
+#define P_UDP 1
+
+//! Classe Connexion.
+/*!
+ Les objets de type Connexions servent à créer une connexion par sochet. Lors de la création on précise le type de connexion : P_TCP ou P_UDP, et éventuellement le port et l'hote.
+*/
+class Connexion
+{
+ public:
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit une socket TCP sur localhost avec un port aléatoire
+ */
+ Connexion();
+ //! Constructeur.
+ /*!
+ Construction d'une connexion en TCP ou UDP.
+ \param t : P_TCP pour une socket TCP et P_UDP pour une socket UDP.
+ \sa AttendConnexion(), SockConnexion(), GetPort(), GetType()
+ */
+ Connexion(const int &t);
+ //! Constructeur.
+ /*!
+ Construction d'une connexion en TCP ou UDP sur un port donné.
+ \param t : P_TCP pour une socket TCP et P_UDP pour une socket UDP.
+ \param port : port sur lequel sera connecté la socket
+ \sa AttendConnexion(), SockConnexion(), GetPort(), GetType()
+ */
+ Connexion(const int &t, const int &port);
+ //! Constructeur.
+ /*!
+ Construction d'une connexion en TCP ou UDP sur un port donné et un hote donné.
+ \param t : P_TCP pour une socket TCP et P_UDP pour une socket UDP.
+ \param hote : nom de l'hote de la socket
+ \param port : port sur lequel sera connecté la socket
+ \sa AttendConnexion(), SockConnexion(), GetPort(), GetType()
+ */
+ Connexion(const int &t, const char *hote, const int &port);
+ //! Destructeur.
+ /*!
+ Destructeur. On détruit la socket d'écoute.
+ */
+ ~Connexion();
+
+ //! Fonction qui attend une demande de connexion sur le socket d'écoute.
+ /*!
+ \return Une socket vers celui qui s'est connecté.
+ */
+ Socket *AttendConnexion(void);
+ //! Accesseur.
+ /*!
+ \return La socket d'écoute.
+ */
+ Socket *SockConnexion(void);
+ //! Accesseur.
+ /*!
+ \return Le port de la socket.
+ */
+ int GetPort() const;
+ //! Accesseur.
+ /*!
+ \return Le type de socket.
+ */
+ int GetType() const;
+
+ private:
+ //! Donnée privée.
+ /*!
+ Socket de communication vers un client.
+ */
+ Socket *socket_communication;
+ //! Donnée privée.
+ /*!
+ Socket d'écoute.
+ */
+ Socket *socket_connexion;
+ //! Donnée privée.
+ /*!
+ Type de connexion : P_TCP ou P_UDP.
+ */
+ int type_connexion;
+};
+
+#endif
--- /dev/null
+CPPC = g++
+OBJS = Connexion.o Socket.o SocketTCP.o SocketUDP.o
+
+connexion : $(OBJS)
+
+Connexion.o : Connexion.h Connexion.cpp
+ $(CPPC) -c Connexion.cpp
+
+Socket.o : Socket.h Socket.cpp
+ $(CPPC) -c Socket.cpp
+
+SocketTCP.o : Socket.h SocketTCP.h SocketTCP.cpp
+ $(CPPC) -c SocketTCP.cpp
+
+SocketUDP.o : Socket.h SocketUDP.h SocketUDP.cpp
+ $(CPPC) -c SocketUDP.cpp
+
+clean :
+ rm *.o
--- /dev/null
+#include "Socket.h"
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include <sys/types.h>
+
+Socket::Socket()
+:sock(-1)
+{
+ memset(&adresse, 0, sizeof(struct sockaddr_in));
+ adresse.sin_family = AF_INET;
+ adresse.sin_port = htons(0);
+ adresse.sin_addr.s_addr = htonl(INADDR_ANY);
+
+ memset(&distand, 0, sizeof(struct sockaddr_in));
+ distand.sin_family = AF_INET;
+ distand.sin_port = htons(0);
+ distand.sin_addr.s_addr = htonl(INADDR_ANY);
+}
+
+Socket::Socket(const int &port)
+:sock(-1)
+{
+ memset(&adresse, 0, sizeof(struct sockaddr_in));
+ adresse.sin_family = AF_INET;
+ adresse.sin_port = htons(port);
+ adresse.sin_addr.s_addr = htonl(INADDR_ANY);
+
+ memset(&distand, 0, sizeof(struct sockaddr_in));
+ distand.sin_family = AF_INET;
+ distand.sin_port = htons(0);
+ distand.sin_addr.s_addr = htonl(INADDR_ANY);
+}
+
+
+Socket::Socket(const char *hote, const int &port)
+:sock(-1)
+{
+ struct hostent *hostent;
+
+ memset(&adresse, 0, sizeof(struct sockaddr_in));
+ adresse.sin_family = AF_INET;
+ adresse.sin_port = htons(port);
+
+ if (hote == NULL)
+ adresse.sin_addr.s_addr = htonl(INADDR_ANY);
+ else
+ {
+ if ((hostent = gethostbyname(hote)) == NULL)
+ {
+ perror("gethostbyname");
+ adresse.sin_addr.s_addr = htonl(INADDR_ANY);
+ }
+ else
+ adresse.sin_addr.s_addr = ((struct in_addr *)(hostent->h_addr))->s_addr;
+ }
+
+ memset(&distand, 0, sizeof(struct sockaddr_in));
+ distand.sin_family = AF_INET;
+ distand.sin_port = htons(0);
+ distand.sin_addr.s_addr = htonl(INADDR_ANY);
+}
+/*
+Socket::Socket(const Socket &s)
+:sock(-1)
+{
+ struct hostent *hostent;
+
+ memset(&adresse, 0, sizeof(struct sockaddr_in));
+ adresse.sin_family = AF_INET;
+ adresse.sin_port = htons(s.Port());
+
+ if (s.Hote() == NULL)
+ adresse.sin_addr.s_addr = htonl(INADDR_ANY);
+ else
+ {
+ if ((hostent = gethostbyname(s.Hote())) == NULL)
+ {
+ perror("gethostbyname");
+ adresse.sin_addr.s_addr = htonl(INADDR_ANY);
+ }
+ else
+ adresse.sin_addr.s_addr = ((struct in_addr *)(hostent->h_addr))->s_addr;
+ }
+}
+*/
+
+Socket::~Socket()
+{
+ if (sock != -1)
+ close(sock);
+}
+
+int Socket::GetSock() const
+{
+ return sock;
+}
+
+void Socket::SetSock(const int &s)
+{
+ sock = s;
+}
+
+int Socket::Port() const
+{
+ return ntohs(adresse.sin_port);
+}
+
+char *Socket::Hote() const
+{
+ return inet_ntoa(adresse.sin_addr);
+}
+
+void Socket::Close()
+{
+ if (sock != -1)
+ close(sock);
+ sock = -1;
+}
+
+void Socket::Listen()
+{
+ if (sock>=0)
+ listen(sock,MAX_CONNEXION);
+}
--- /dev/null
+#ifndef _SOCKET_
+#define _SOCKET_
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#include "../Global.h"
+
+//! Classe Socket.
+/*!
+ Les objets de type Socket contiennent une socket, une struct sockaddr_in pour la socket et une autre pour le distand qui sert lors d'un Accept. Le rôle de cette classe est d'utiliser une socket TCP ou UDP sans modifier l'algorithme qui l'utilise.
+*/
+class Socket
+{
+ public:
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit une socket sur localhost avec un port aléatoire
+ */
+ Socket();
+ //! Constructeur.
+ /*!
+ Construction d'une socket sur un port donné. L'hote est localhost.
+ \param port : port sur lequel la socket sera raccordée.
+ */
+ Socket(const int &port);
+ //! Constructeur.
+ /*!
+ Construction d'une socket sur un port donné et sur un hote donné.
+ \param hote : hote sur lequel la socket sera raccordée.
+ \param port : port sur lequel la socket sera raccordée.
+ */
+ Socket(const char *hote, const int &port);
+ //Socket(const Socket &);
+ //! Destructeur.
+ /*!
+ Le destructeur ferme la socket au cas où elle st ouverte.
+ */
+ ~Socket();
+
+ //! Accesseur.
+ /*!
+ \return Le port de la socket.
+ */
+ int Port() const;
+ //! Accesseur.
+ /*!
+ \return L'hote de la socket.
+ */
+ char *Hote() const;
+
+ //! Fonction.
+ /*!
+ Associe la socket à l'hote et au port qui sont dans la struct sockaddr_in.
+ */
+ virtual void Open()=0;
+ //! Fonction.
+ /*!
+ Ferme la socket.
+ */
+ virtual void Close();
+ //! Fonction.
+ /*!
+ Fais le listen la socket.
+ */
+ virtual void Listen();
+ //! Accesseur.
+ /*!
+ \return La socket.
+ */
+ int GetSock() const;
+ //! Accesseur.
+ /*!
+ Modifie la socket : ne doit pas être utilisé en théorie.
+ */
+ void SetSock(const int &s);
+ //! Fonction.
+ /*!
+ Attend une connexion sur la socket.
+ \return une socket vers le client.
+ */
+ virtual Socket *Accept()=0;
+ //! Fonction.
+ /*!
+ Lit une chaine sur la socket.
+ \return la chaine lue.
+ */
+ virtual char *Lire()=0;
+ //! Fonction.
+ /*!
+ Ecrit une chaine sur la socket.
+ */
+ virtual void Ecrire(const char *)=0;
+
+ protected:
+ //! Donnée protégée.
+ /*!
+ Structure contenant l'adresse et le port de la socket.
+ */
+ struct sockaddr_in adresse;
+ //! Donnée protégée.
+ /*!
+ Structure contenant l'adresse et le port de la socket distante.
+ */
+ struct sockaddr_in distand;
+ //! Donnée protégée.
+ /*!
+ Descripteur de fichier de la socket.
+ */
+ int sock;
+};
+
+#endif
--- /dev/null
+#include "SocketTCP.h"
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include <sys/types.h>
+
+SocketTCP::SocketTCP()
+{
+ Open();
+}
+
+SocketTCP::SocketTCP(const int &port)
+:Socket(port)
+{
+ Open();
+}
+
+
+SocketTCP::SocketTCP(const char *hote, const int &port)
+:Socket(hote,port)
+{
+ Open();
+}
+/*
+SocketTCP::SocketTCP(const SocketTCP &s)
+:Socket(s)
+{
+}*/
+
+SocketTCP::~SocketTCP()
+{
+}
+
+Socket *SocketTCP::Accept()
+{
+ Socket *sock_temp = new SocketTCP(*this);
+
+ socklen_t longueur = sizeof(struct sockaddr_in);
+ sock_temp->SetSock(accept(sock, (sockaddr *)&adresse, &longueur));
+
+ if (sock_temp->GetSock() < 0)
+ {
+ perror("accept");
+ return NULL;
+ }
+
+ return sock_temp;
+}
+
+void SocketTCP::Ecrire(const char *chaine)
+{
+ write(sock, chaine, strlen(chaine));
+}
+
+char *SocketTCP::Lire()
+{
+ int nblus;
+ char *buffer=new char[TAILLE_BUFFER];
+
+ if ((nblus = read(sock,buffer,TAILLE_BUFFER)) <= 0)
+ {
+ delete [] buffer;
+ return NULL;
+ }
+
+ if (nblus < TAILLE_BUFFER)
+ buffer[nblus] = '\0';
+
+ while ((strlen(buffer)>0) && (buffer[strlen(buffer)-1] == '\n' || buffer[strlen(buffer)-1] == '\r'))
+ buffer[strlen(buffer)-1] = '\0';
+
+ if (strlen(buffer) < 0)
+ {
+ delete []buffer;
+ buffer = NULL;
+ }
+
+ return buffer;
+}
+
+void SocketTCP::Open()
+{
+ if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
+ {
+ perror("socket");
+ sock = -1;
+ }
+
+ if (bind(sock, (struct sockaddr *) &adresse, sizeof(struct sockaddr_in)) < 0)
+ {
+ perror("bind");
+ close(sock);
+ sock=-1;
+ }
+
+ socklen_t longueur=sizeof(struct sockaddr_in);
+ getsockname(sock, (struct sockaddr *) &adresse, &longueur);
+}
--- /dev/null
+#ifndef _SOCKETTCP_
+#define _SOCKETTCP_
+
+//! Classe SocketTCP.
+/*!
+ La classe SocketTCP dérive la classe Socket afin de pouvoir créer des sockets TCP.
+*/
+
+#include "Socket.h"
+
+class SocketTCP : public Socket
+{
+ public:
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit une socket TCP sur localhost avec un port aléatoire
+ */
+ SocketTCP();
+ //! Constructeur.
+ /*!
+ Construction d'une socket TCP sur un port donné. L'hote est localhost.
+ \param port : port sur lequel la socket sera raccordée.
+ */
+ SocketTCP(const int &port);
+ //! Constructeur.
+ /*!
+ Construction d'une socket TCP sur un port donné et sur un hote donné.
+ \param hote : hote sur lequel la socket sera raccordée.
+ \param port : port sur lequel la socket sera raccordée.
+ */
+ SocketTCP(const char *hote, const int &port);
+ //SocketTCP(const SocketTCP &s);
+ //! Destructeur.
+ /*!
+ Le destructeur ne fait rien.
+ */
+ ~SocketTCP();
+
+ //! Fonction.
+ /*!
+ Associe la socket à l'hote et au port qui sont dans la struct sockaddr_in. Le listen est compris dedans. ! Cas d'une socket client ???
+ */
+ void Open();
+ //! Fonction.
+ /*!
+ Attend une connexion sur la socket. Attention, la socket retournée est allouée : penser à la désallouer quelque part !
+ \return une socket vers le client.
+ */
+ Socket *Accept();
+ //! Fonction.
+ /*!
+ Lit une chaine sur la socket. Les '\r' et '\n' à la fin sont supprimés.
+ \return la chaine lue.
+ */
+ char *Lire();
+ //! Fonction.
+ /*!
+ Ecrit une chaine sur la socket. Il s'agit d'un simple write.
+ */
+ void Ecrire(const char *);
+};
+
+#endif
--- /dev/null
+#include "SocketUDP.h"
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include <sys/types.h>
+
+SocketUDP::SocketUDP()
+{
+ Open();
+}
+
+SocketUDP::SocketUDP(const int &port)
+:Socket(port)
+{
+ Open();
+}
+
+
+SocketUDP::SocketUDP(const char *hote, const int &port)
+:Socket(hote,port)
+{
+ Open();
+}
+/*
+SocketUDP::SocketUDP(const Socket &s)
+:Socket(s)
+{}*/
+
+SocketUDP::~SocketUDP()
+{
+}
+
+//FONCTION NON UTILISEE : NE SERT A RIEN ET BLOQUE
+Socket *SocketUDP::Accept()
+{
+ char *h=new char[TAILLE_BUFFER];
+ char *reponse = Lire();
+
+ u_long fromaddr = distand.sin_addr.s_addr;
+
+ h = (gethostbyaddr((char *)&fromaddr,sizeof(fromaddr), AF_INET))->h_name;
+
+ Socket *sock_temp = new SocketUDP(h, ntohs(distand.sin_port));
+
+ delete []h;
+
+ if (strcmp(reponse,"CONNECT") != 0)
+ sock_temp->Close();
+
+ delete []reponse;
+
+ if (sock_temp->GetSock() < 0)
+ {
+ printf("Connexion refusée\n");
+ return NULL;
+ }
+
+ return sock_temp;
+}
+
+void SocketUDP::Ecrire(const char *chaine)
+{
+ socklen_t longueur = sizeof(struct sockaddr_in);
+ sendto(sock,chaine,strlen(chaine),0, (struct sockaddr *) &distand, longueur);
+}
+
+char *SocketUDP::Lire()
+{
+ int nblus;
+ char *buffer=new char[TAILLE_BUFFER];
+
+ socklen_t longueur = sizeof(struct sockaddr_in);
+ if ((nblus = recvfrom(sock,buffer,TAILLE_BUFFER,0, (struct sockaddr *)&distand, &longueur)) <= 0)
+ {
+ delete [] buffer;
+ return NULL;
+ }
+
+ if (nblus < TAILLE_BUFFER)
+ buffer[nblus] = '\0';
+
+ while(strlen(buffer)>0 && (buffer[strlen(buffer)-1] == '\n' || buffer[strlen(buffer)-1] == '\r'))
+ buffer[strlen(buffer)-1] = '\0';
+
+ if (strlen(buffer) < 0)
+ {
+ delete []buffer;
+ buffer = NULL;
+ }
+
+ return buffer;
+}
+
+void SocketUDP::Open()
+{
+ if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
+ {
+ perror("socket");
+ sock = -1;
+ }
+ if (bind(sock, (struct sockaddr *) &adresse, sizeof(struct sockaddr_in)) < 0)
+ {
+ perror("bind");
+ close(sock);
+ sock=-1;
+ }
+
+ socklen_t longueur=sizeof(struct sockaddr_in);
+ getsockname(sock, (struct sockaddr *) &adresse, &longueur);
+}
+
+//en UDP on ne fais pas de listen
+void SocketUDP::Listen()
+{
+}
--- /dev/null
+#ifndef _SOCKETUDP_
+#define _SOCKETUDP_
+
+//! Classe SocketUDP.
+/*!
+ La classe SocketUDP dérive la classe Socket afin de pouvoir créer des sockets UDP.
+*/
+
+#include "Socket.h"
+
+class SocketUDP : public Socket
+{
+ public:
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit une socket UDP sur localhost avec un port aléatoire
+ */
+ SocketUDP();
+ //! Constructeur.
+ /*!
+ Construction d'une socket UDP sur un port donné. L'hote est localhost.
+ \param port : port sur lequel la socket sera raccordée.
+ */
+ SocketUDP(const int &port);
+ //! Constructeur.
+ /*!
+ Construction d'une socket UDP sur un port donné et sur un hote donné.
+ \param hote : hote sur lequel la socket sera raccordée.
+ \param port : port sur lequel la socket sera raccordée.
+ */
+ SocketUDP(const char *hote, const int &port);
+ //SocketUDP(const Socket &s);
+ //! Destructeur.
+ /*!
+ Le destructeur ne fait rien.
+ */
+ ~SocketUDP();
+
+ //! Fonction.
+ /*!
+ Associe la socket à l'hote et au port qui sont dans la struct sockaddr_in.
+ */
+ void Open();
+ //! Fonction.
+ /*!
+ Empèche de faire le listen la socket en surchargeant la fonction Listen de Socket.
+ */
+ virtual void Listen();
+ //! Fonction.
+ /*!
+ Attend une connexion sur la socket. Attention, la socket retournée est allouée : penser à la désallouer quelque part ! Il faut regarder encore cette fonction : il doit y avoir des erreurs.
+ \return une socket vers le client.
+ */
+ Socket *Accept();
+ //! Fonction.
+ /*!
+ Lit une chaine sur la socket. Les '\r' et '\n' à la fin sont supprimés.
+ \return la chaine lue.
+ */
+ char *Lire();
+ //! Fonction.
+ /*!
+ Ecrit une chaine sur la socket. Il y a encore quelques binz là dedans.
+ */
+ void Ecrire(const char *);
+};
+
+#endif
--- /dev/null
+#include "CCercle.h"
+
+#include "stdlib.h"
+
+CCercle::CCercle()
+:choix(NULL)
+{}
+
+CCercle::CCercle(const CCercle &o)
+:Objet(o), choix(new Cercle [o.possibilites])
+{
+ int i;
+ for (i=0 ; i<possibilites ; i++)
+ choix[i] = o.choix[i];
+}
+
+CCercle::~CCercle()
+{
+ delete [] choix;
+}
+
+const Cercle *CCercle::Solution() const
+{
+ if ((retenu == -1) || (possibilites <= 0))
+ return NULL;
+
+ if (retenu > possibilites - 1)
+ return &(choix[possibilites -1]);
+
+ return &(choix[retenu]);
+}
+
+void CCercle::EnvoyerSolutions(Socket *sock) const
+{
+ char buffer[TAILLE_BUFFER];
+
+ //Envoyer le nombre de solutions possibles
+ sprintf(buffer,"%d\n",possibilites);
+ sock->Ecrire(buffer);
+
+ //envoi des solutions
+ int i;
+ for (i=0 ; i<possibilites ; i++)
+ {
+ sprintf(buffer,"%lf %lf %lf\n", choix[i].GetCentre().GetX(), choix[i].GetCentre().GetY(), choix[i].GetRayon());
+ sock->Ecrire(buffer);
+ }
+}
--- /dev/null
+#ifndef __CCERCLE__
+#define __CCERCLE__
+
+#include "../Formes/Cercle.h"
+#include "Objet.h"
+
+//! Classe CCercle. Classe à dériver pour faire un Cercle construit par contraintes.
+/*!
+ On a dérivé la classe Objet pour en hériter les fonctionnalités qui sont communes à toutes les formes. On y rajoute le tableau de Cercle qui correspond aux possibilités de constructions relativement aux contraintes enregistrées.
+*/
+class CCercle : public Objet
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Ne fait rien vu qu'il n'y a pas de possibilités de trouver une solution.
+ */
+ CCercle();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param c : cercle à copier.
+ */
+ CCercle(const CCercle &c);
+ //! Destructeur.
+ /*!
+ Détruit le tableau des possibilités.
+ */
+ virtual ~CCercle();
+
+ //! Fonction
+ /*!
+ Retourne un pointeur vers la solution sélectionnée. Si il n'y a pas de solution possible la fonction retourne NULL.
+ */
+ const Cercle *Solution() const;
+
+ //! Fonction
+ /*!
+ Envoie la liste des possibilités dans la socket passée en paramètre. On envoie d'abord le nombre de solutions puis les solutions elles mêmes. Pour envoyer une solution on envoit sur une même ligne les coordonnées x et y du centre et le rayon. Voir le code pour les détails.
+ \param sock : Socket dans laquelle on envoit la liste.
+ */
+ void EnvoyerSolutions(Socket *sock) const;
+
+ protected :
+ //! Donnée privée.
+ /*!
+ Tableau des possibilités.
+ */
+ Cercle *choix;
+};
+
+#endif
--- /dev/null
+#include "CCerclePassant1P.h"
+
+#include "../Formes/Cercle.h"
+#include "../Formes/Point.h"
+
+#include "math.h"
+
+CCerclePassant1P::CCerclePassant1P()
+:p(NULL),x(0),y(0),r(0)
+{
+ CalculerCoordonnees();
+}
+
+CCerclePassant1P::CCerclePassant1P(const CCerclePassant1P &cd)
+:CCercle(cd),p(cd.p),r(cd.r),x(cd.x),y(cd.y)
+{}
+
+CCerclePassant1P::CCerclePassant1P(CPoint *pp, const double &rr, const double &xx, const double &yy)
+:p(pp),r(rr),x(xx),y(yy)
+{
+ //on signale à pp que ce Cercle a été construit par contraintes sur lui.
+ if (pp != NULL)
+ pp->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CCerclePassant1P::~CCerclePassant1P()
+{
+}
+
+void CCerclePassant1P::CalculerCoordonnees()
+{
+ const Point *pp = p->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si le point n'est pas défini
+ //alors il n'y a pas de solutions
+ if (pp == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //les centres possibles sont sur le cercle de centre pp et de rayon r
+ //on va projeter le point de coordonnées (x,y) sur ce cercle pour
+ //avoir le centre du cercle
+ //si le point donné est le centre, on ne retourne aucune solution
+
+ //si le centre est le point par lequel le cercle doit passer on
+ //retourne un cercle de rayon 0
+ if (fabs(pp->GetX() - x) < EPSILON && fabs(pp->GetY() - y) < EPSILON)
+ {
+ possibilites = 1;
+ choix = new Cercle[possibilites];
+ choix[0] = Cercle(Point(x,y),0);
+ }
+ else
+ {
+ //on calcule le vecteur colinéaire
+ double vx = x - pp->GetX();
+ double vy = y - pp->GetY();
+
+ //on calcule la norme du vecteur
+ double norme = sqrt(vx*vx + vy*vy);
+
+ //on change la norme du vecteur pour qu'elle soit egale au rayon
+ vx *= (r/norme);
+ vy *= (r/norme);
+
+ //on utilise directement le constructeur de Cercle avec deux Point
+ possibilites = 1;
+ choix = new Cercle[possibilites];
+ choix[0] = Cercle(Point(pp->GetX()+vx,pp->GetY()+vy),r);
+ }
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CCERCLEPASSANT1P__
+#define __CCERCLEPASSANT1P__
+
+#include "CCercle.h"
+#include "CPoint.h"
+
+//! Classe CCerclePassant1P.
+/*!
+ Définit un cercle de rayon donné passant par un point. Comme il y a une infinité de solutions possibles on demande au client de fournir un centre approximatif. L'ensemble des centres possibles est le cercle de centre le point par lequel doit passer le cercle et de rayon celui qui a été passé en paraètres. On projètera le centre approximatif sur ce cercle.
+*/
+class CCerclePassant1P : public CCercle
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des paramètres inconnues. Ne doit pas être utilisé.
+ */
+ CCerclePassant1P();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param c : Cercle à copier.
+ */
+ CCerclePassant1P(const CCerclePassant1P &c);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de trois points. C'est celui qui devra être utilisé.
+ param p : point par lequel doit passer le cercle.
+ param r : rayon du cercle.
+ param x : coordonnée x du centre approximatif.
+ param y : coordonnée y du centre approximatif.
+ */
+ CCerclePassant1P(CPoint *p, const double &r, const double &x, const double &y);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CCerclePassant1P();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées de la Cercle.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Point du Cercle.
+ */
+ const CPoint *p;
+
+ //! Donnée privée.
+ /*!
+ rayon du Cercle.
+ */
+ const double r;
+
+ //! Donnée privée.
+ /*!
+ coordonnée x du centre approximatif.
+ */
+ const double x;
+
+ //! Donnée privée.
+ /*!
+ coordonnée y du centre approximatif.
+ */
+ const double y;
+};
+
+#endif
--- /dev/null
+#include "CCerclePassant3P.h"
+
+#include "../Formes/Cercle.h"
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+
+#include "math.h"
+
+CCerclePassant3P::CCerclePassant3P()
+:p1(NULL),p2(NULL),p3(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CCerclePassant3P::CCerclePassant3P(const CCerclePassant3P &cd)
+:CCercle(cd),p1(cd.p1),p2(cd.p2),p3(cd.p3)
+{}
+
+CCerclePassant3P::CCerclePassant3P(CPoint *pp1, CPoint *pp2, CPoint *pp3)
+:p1(pp1),p2(pp2),p3(pp3)
+{
+ //on signale à pp1, pp2 et p3 que ce Cercle a été construit par contraintes sur eux.
+ if (pp1 != NULL)
+ pp1->AjouterEnfant(this);
+ if (pp2 != NULL)
+ pp2->AjouterEnfant(this);
+ if (pp3 != NULL)
+ pp3->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CCerclePassant3P::~CCerclePassant3P()
+{
+}
+
+void CCerclePassant3P::CalculerCoordonnees()
+{
+ const Point *pp1 = p1->Solution();
+ const Point *pp2 = p2->Solution();
+ const Point *pp3 = p3->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si un des points n'est pas défini
+ //alors il n'y a pas de solutions
+ if (pp1 == NULL || pp2 == NULL || pp3 == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //Si deux des points sont égaux
+ //alors il y a une infinité de solutions
+ if (fabs(pp1 - pp2) < EPSILON || fabs(pp2 - pp3) < EPSILON || fabs(pp3 - pp1) < EPSILON)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //on calcule les deux médiatrices
+
+ //coordonnées du vecteur formé par les deux points
+ double vx1 = pp2->GetX() - pp1->GetX();
+ double vy1 = pp2->GetY() - pp1->GetY();
+ double vx2 = pp2->GetX() - pp3->GetX();
+ double vy2 = pp2->GetY() - pp3->GetY();
+
+ //si les vecteurs sont colinéaires il n'y a pas de solutions
+ if (fabs(vx1*vy2 - vy1*vx2) < EPSILON)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //calcul des coordonnées du milieu des deux points
+ double mx1 = (pp1->GetX() + pp2->GetX())/2.0;
+ double my1 = (pp1->GetY() + pp2->GetY())/2.0;
+ double mx2 = (pp3->GetX() + pp2->GetX())/2.0;
+ double my2 = (pp3->GetY() + pp2->GetY())/2.0;
+
+ //on calcule les deux médianes
+ Droite dd1 = Droite(Point(mx1,my1), Point(mx1 + vy1,my1 - vx1));
+ Droite dd2 = Droite(Point(mx2,my2), Point(mx2 + vy2,my2 - vx2));
+
+ //calcul du points d'intersection
+ double xx = (dd1.C()*dd2.B() - dd2.C()*dd1.B())/(dd2.A()*dd1.B() - dd1.A()*dd2.B());
+ double yy;
+ if (fabs(dd1.B()) > EPSILON)
+ yy = (-dd1.C() - dd1.A()*xx)/dd1.B();
+ else if (fabs(dd2.B()) > EPSILON)
+ yy = (-dd2.C() - dd2.A()*xx)/dd2.B();
+ else
+ {
+ possibilites = -1;
+ CalculerDependants();
+ return;
+ }
+
+ //on calcule le rayon
+ double rayon = sqrt(PUISS2(xx-pp1->GetX())+PUISS2(yy-pp1->GetY()));
+
+ //on utilise directement le constructeur de Cercle avec deux Point
+ possibilites = 1;
+ choix = new Cercle[possibilites];
+ choix[0] = Cercle(Point(xx,yy),rayon);
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CCERCLEPASSANT3P__
+#define __CCERCLEPASSANT3P__
+
+#include "CCercle.h"
+#include "CPoint.h"
+
+//! Classe CCerclePassant3P.
+/*!
+ Définit un cercle passant par trois points. Si les deux points des points sont confondus il y a une infinité de solutions, sinon il y en a une et une seule. Pour calculer ce cercle il suffit de prendre l'intersection des médiatrices formées par les segments formés par deux des points.
+*/
+class CCerclePassant3P : public CCercle
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des points inconnues. Ne doit pas être utilisé.
+ */
+ CCerclePassant3P();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param c : Cercle à copier.
+ */
+ CCerclePassant3P(const CCerclePassant3P &c);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de trois points. C'est celui qui devra être utilisé.
+ param p1 : premier point.
+ param p2 : deuxier point.
+ param p3 : deuxier point.
+ */
+ CCerclePassant3P(CPoint *p1, CPoint *p2, CPoint *p3);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CCerclePassant3P();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées de la Cercle.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Premier Point de la Cercle.
+ */
+ const CPoint *p1;
+
+ //! Donnée privée.
+ /*!
+ Deuxième Point de la Cercle.
+ */
+ const CPoint *p2;
+
+ //! Donnée privée.
+ /*!
+ Troisième Point de la Cercle.
+ */
+ const CPoint *p3;
+};
+
+#endif
--- /dev/null
+#include "CCercleTangent2C.h"
+
+#include "../Formes/Cercle.h"
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+
+#include "math.h"
+
+CCercleTangent2C::CCercleTangent2C()
+:d1(NULL),d2(NULL),r(0)
+{
+ CalculerCoordonnees();
+}
+
+CCercleTangent2C::CCercleTangent2C(const CCercleTangent2C &cc)
+:CCercle(cc),c1(cc.c1),c2(cc.c2),r(cc.r)
+{}
+
+CCercleTangent2C::CCercleTangent2C(CCerclte *cc1, CCercle *cc2, const double &rr)
+:c1(cc1),c2(cc2),r(rr)
+{
+ //on signale à cc1 et cc2 que ce Cercle a été construit par contraintes sur lui.
+ if (cc1 != NULL)
+ cc1->AjouterEnfant(this);
+ if (cc2 != NULL)
+ cc2->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CCercleTangent2C::~CCercleTangent2C()
+{
+}
+
+void CCercleTangent2C::CalculerCoordonnees()
+{
+ const Cercle *cc1 = c1->Solution();
+ const Cercle *cc2 = c2->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si l'un des cercles n'est pas défini
+ //alors il n'y a pas de solutions
+ if (cc1 == NULL || cc2 == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //cas de la distance nulle : il y a une infinité de solutions
+ if (fabs(r) < EPSILON)
+ {
+ possibilites = -1;
+ CalculerDependants();
+ return;
+ }
+
+ Cercle cp1, cp2, cp3, cp4;
+
+ cp1 = Cercle(cc1->GetCentre(),r + cc1->GetRayon());
+ cp3 = Cercle(cc2->GetCentre(),r + cc2->GetRayon());
+
+ //si le rayon du premier cercle est inférieur
+ //au rayon désiré il y a un seul cercle pour les
+ //centres possibles
+ if (fabs(r - cc1->GetRayon()) > EPSILON)
+ {
+ cp2 = Cercle(cc1->GetCentre(),r - cc1->GetRayon());
+
+ //si le rayon du deuxième cercle est inférieur
+ //au rayon désiré il y a un seul cercle pour les
+ //centres possibles
+ if (fabs(r - cc2->GetRayon()) > EPSILON)
+ {
+ cp4 = Cercle(cc2->GetCentre(),r - cc2->GetRayon());
+
+ //il y a 8 solutions max, on va calculer cc1&cc4 et cc2&cc4
+ possibilites = 8;
+ choix = new Cercle[possibilites];
+
+ choix[4] = Cercle(Point(x5,y5),r);
+ choix[5] = Cercle(Point(x6,y6),r);
+
+ choix[6] = Cercle(Point(x7,y7),r);
+ choix[7] = Cercle(Point(x8,y8),r);
+ }
+ else
+ {
+ //il y a 4 possibilités max
+ possibilites = 4;
+ choix = new Cercle[possibilites];
+ }
+
+ //on calcule cc2&cc3
+ choix[2] = Cercle(Point(x3,y3),r);
+ choix[3] = Cercle(Point(x4,y4),r);
+ }
+ else if (fabs(r - cc2->GetRayon()) > EPSILON)
+ {
+ //il y a 4 solutions, on calcule cc1&cc4
+ cp4 = Cercle(cc2->GetCentre(),r - cc2->GetRayon());
+ choix[2] = Cercle(Point(x3,y3),r);
+ choix[3] = Cercle(Point(x4,y4),r);
+ }
+ else
+ {
+ }
+
+ //on calcule cc1&cc3
+ choix[0] = Cercle(Point(x1,y1),r);
+ choix[1] = Cercle(Point(x2,y2),r);
+
+
+
+
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CCERCLETANGENT2C__
+#define __CCERCLETANGENT2C__
+
+#include "CCercle.h"
+#include "CDroite.h"
+#include "CPoint.h"
+
+//! Classe CCercleTangent2C.
+/*!
+ Définit un cercle tangent à deux cercles et de rayon donné. Pour construire ce cercle on va considérer les cercles concentriques aux deux cercles données de rayon + et - r par rapport aux cercles d'origine et faire leur intersection. Il y a 8 solutions dans le cas général et une infinité de solutions si les cercles sont concentriques.
+*/
+class CCercleTangent2C : public CCercle
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des paramètres inconnus. Ne doit pas être utilisé.
+ */
+ CCercleTangent2C();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param c : Cercle à copier.
+ */
+ CCercleTangent2C(const CCercleTangent2C &c);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de deux cercles. C'est celui qui devra être utilisé.
+ param c1 : premier cercle auquel le cercle doit être tangent.
+ param c2 : deuxième cercle auquel le cercle doit être tangent.
+ param r : rayon du cercle
+ */
+ CCercleTangent2C(CCercle *c1, CCercle *c2, const double &r);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CCercleTangent2C();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées de la Cercle.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ premièr Cercle.
+ */
+ const CCercle *c1;
+
+ //! Donnée privée.
+ /*!
+ deuxième Cercle.
+ */
+ const Ccercle *c2;
+
+ //! Donnée privée.
+ /*!
+ rayon du cercle.
+ */
+ const double &r;
+};
+
+#endif
--- /dev/null
+#include "CCercleTangent2D.h"
+
+#include "../Formes/Cercle.h"
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+
+#include "math.h"
+
+CCercleTangent2D::CCercleTangent2D()
+:d1(NULL),d2(NULL),r(0)
+{
+ CalculerCoordonnees();
+}
+
+CCercleTangent2D::CCercleTangent2D(const CCercleTangent2D &cc)
+:CCercle(cc),d1(cc.d1),d2(cc.d2),r(cc.r)
+{}
+
+CCercleTangent2D::CCercleTangent2D(CDroite *dd1, CDroite *dd2, const double &rr)
+:d1(dd1),d2(dd2),r(rr)
+{
+ //on signale à dd1 et dd2 que ce Cercle a été construit par contraintes sur lui.
+ if (dd1 != NULL)
+ dd1->AjouterEnfant(this);
+ if (dd2 != NULL)
+ dd2->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CCercleTangent2D::~CCercleTangent2D()
+{
+}
+
+void CCercleTangent2D::CalculerCoordonnees()
+{
+ const Droite *dd1 = d1->Solution();
+ const Droite *dd2 = d2->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si l'une des droites n'est pas définie
+ //alors il n'y a pas de solutions
+ if (dd1 == NULL || dd2 == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+
+ //cas de la distance nulle : il y a une infinité de solutions
+ if (fabs(r) < EPSILON)
+ {
+ possibilites = -1;
+ CalculerDependants();
+ return;
+ }
+
+ Droite dp1, dp2, dp3, dp4;
+
+ //recherche des points appartenant aux droites
+ Point p1, p2, p3, p4;
+
+ double aa1 = dd1->A();
+ double bb1 = dd1->B();
+ double cc1 = dd1->C();
+
+ double aa2 = dd2->A();
+ double bb2 = dd2->B();
+ double cc2 = dd2->C();
+
+ //on regarde si il y a une infinité (ou aucune) solutions
+ if (fabs(aa2*bb1 - aa1*bb2) < EPSILON)
+ {
+ possibilites = -1;
+ CalculerDependants();
+ return;
+ }
+
+ //cas d'une droite horizontale
+ if (fabs(aa1) < EPSILON)
+ {
+ p1 = Point(0,-cc1/bb1);
+ p2 = Point(1,-cc1/bb1);
+ }
+ //cas d'une droite verticale
+ else if (fabs(bb1) < EPSILON)
+ {
+ p1 = Point(-cc1/aa1,0);
+ p2 = Point(-cc1/aa1,1);
+ }
+ //droite quelconque
+ else
+ {
+ //dans ce cas on prend le point dont le x est égal à 0
+ //et son translaté par le vecteur directeur
+ p1 = Point(0,-cc1/bb1);
+ //on ne prend pas ce cas car si la droite passe par
+ //(0,0) on aura deux fois le même point
+ //p2 = Point(-cc1/aa1,0);
+ p2 = Point(-bb1,p1.GetY()+aa1);
+ }
+
+ //cas d'une droite horizontale
+ if (fabs(aa2) < EPSILON)
+ {
+ p3 = Point(0,-cc2/bb2);
+ p4 = Point(1,-cc2/bb2);
+ }
+ //cas d'une droite verticale
+ else if (fabs(bb2) < EPSILON)
+ {
+ p3 = Point(-cc2/aa2,0);
+ p4 = Point(-cc2/aa2,1);
+ }
+ //droite quelconque
+ else
+ {
+ //dans ce cas on prend le point dont le x est égal à 0
+ //et son translaté par le vecteur directeur
+ p3 = Point(0,-cc2/bb2);
+ //on ne prend pas ce cas car si la droite passe par
+ //(0,0) on aura deux fois le même point
+ //p4 = Point(-cc2/aa2,0);
+ p4 = Point(-bb2,p3.GetY()+aa2);
+ }
+
+ //calcul de la norme des vecteurs normaux
+ //inutile car on a normalisé les constantes
+ /*double norme1 = sqrt(PUISS2(aa1)+PUISS2(bb1));
+ double norme2 = sqrt(PUISS2(aa2)+PUISS2(bb2));*/
+
+ //on construit les quatre droites.
+ /*dp1 = Droite(Point(p1.GetX() + aa1*r/norme1, p1.GetY() + bb1*r/norme1),Point(p2.GetX() + aa1*r/norme1, p2.GetY() + bb1*r/norme1));
+ dp2 = Droite(Point(p1.GetX() - aa1*r/norme1, p1.GetY() - bb1*r/norme1),Point(p2.GetX() - aa1*r/norme1, p2.GetY() - bb1*r/norme1));
+ dp3 = Droite(Point(p3.GetX() + aa2*r/norme2, p3.GetY() + bb2*r/norme2),Point(p4.GetX() + aa2*r/norme2, p4.GetY() + bb2*r/norme2));
+ dp4 = Droite(Point(p3.GetX() - aa2*r/norme2, p3.GetY() - bb2*r/norme2),Point(p4.GetX() - aa2*r/norme2, p4.GetY() - bb2*r/norme2));*/
+ dp1 = Droite(Point(p1.GetX() + aa1*r, p1.GetY() + bb1*r),Point(p2.GetX() + aa1*r, p2.GetY() + bb1*r));
+ dp2 = Droite(Point(p1.GetX() - aa1*r, p1.GetY() - bb1*r),Point(p2.GetX() - aa1*r, p2.GetY() - bb1*r));
+ dp3 = Droite(Point(p3.GetX() + aa2*r, p3.GetY() + bb2*r),Point(p4.GetX() + aa2*r, p4.GetY() + bb2*r));
+ dp4 = Droite(Point(p3.GetX() - aa2*r, p3.GetY() - bb2*r),Point(p4.GetX() - aa2*r, p4.GetY() - bb2*r));
+ possibilites = 4;
+ choix = new Cercle[possibilites];
+ //calcul des solutions
+
+ double x1, x2, x3, x4, y1, y2, y3, y4;
+ //d1 INTER D3
+ x1 = (dp1.C()*dp3.B() - dp3.C()*dp1.B())/(dp3.A()*dp1.B() - dp1.A()*dp3.B());
+ if (fabs(dp1.B()) > EPSILON)
+ y1 = (-dp1.C() - dp1.A()*x1)/dp1.B();
+ else if (fabs(dp3.B()) > EPSILON)
+ y1 = (-dp3.C() - dp3.A()*x1)/dp3.B();
+
+ //d1 INTER D4
+ x2 = (dp1.C()*dp4.B() - dp4.C()*dp1.B())/(dp4.A()*dp1.B() - dp1.A()*dp4.B());
+ if (fabs(dp1.B()) > EPSILON)
+ y2 = (-dp1.C() - dp1.A()*x2)/dp1.B();
+ else if (fabs(dp4.B() > EPSILON))
+ y2 = (-dp4.C() - dp4.A()*x2)/dp4.B();
+
+ //d2 INTER D3
+ x3 = (dp2.C()*dp3.B() - dp3.C()*dp2.B())/(dp3.A()*dp2.B() - dp2.A()*dp3.B());
+ if (fabs(dp2.B()) > EPSILON)
+ y3 = (-dp2.C() - dp2.A()*x3)/dp2.B();
+ else if (fabs(dp3.B()) > EPSILON)
+ y3 = (-dp3.C() - dp3.A()*x3)/dp3.B();
+
+ //d2 INTER D4
+ x4 = (dp2.C()*dp4.B() - dp4.C()*dp2.B())/(dp4.A()*dp2.B() - dp2.A()*dp4.B());
+ if (fabs(dp2.B()) > EPSILON)
+ y4 = (-dp2.C() - dp2.A()*x4)/dp2.B();
+ else if (fabs(dp4.B()) > EPSILON)
+ y4 = (-dp4.C() - dp4.A()*x4)/dp4.B();
+
+ //on utilise directement le constructeur de Cercle avec deux Point
+ choix[0] = Cercle(Point(x1,y1),r);
+ choix[1] = Cercle(Point(x2,y2),r);
+ choix[2] = Cercle(Point(x3,y3),r);
+ choix[3] = Cercle(Point(x4,y4),r);
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CCERCLETANGENT2D__
+#define __CCERCLETANGENT2D__
+
+#include "CCercle.h"
+#include "CDroite.h"
+#include "CPoint.h"
+
+//! Classe CCercleTangent2D.
+/*!
+ Définit un cercle tangent à deux droites et de rayon donné. Pour construire ce cercle on va considérer les droites parallèles aux deux droites données distantes de r et faire leur intersection. Il y a 4 solutions dans le cas général et une infinité de solutions si les droites sont parallèles ou confondues.
+*/
+class CCercleTangent2D : public CCercle
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des paramètres inconnus. Ne doit pas être utilisé.
+ */
+ CCercleTangent2D();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param c : Cercle à copier.
+ */
+ CCercleTangent2D(const CCercleTangent2D &c);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de deux droites. C'est celui qui devra être utilisé.
+ param d1 : première droite à laquelle le cercle doit être tangent cercle.
+ param d2 : pdeuxième droite à laquelle le cercle doit être tangent cercle.
+ param r : rayon du cercle
+ */
+ CCercleTangent2D(CDroite *d1, CDroite *d2, const double &r);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CCercleTangent2D();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées de la Cercle.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ première Droite.
+ */
+ const CDroite *d1;
+
+ //! Donnée privée.
+ /*!
+ deuxième Droite.
+ */
+ const CDroite *d2;
+
+ //! Donnée privée.
+ /*!
+ rayon du cercle.
+ */
+ const double &r;
+};
+
+#endif
--- /dev/null
+#include "CDroite.h"
+
+#include "stdlib.h"
+
+CDroite::CDroite()
+:choix(NULL)
+{}
+
+CDroite::CDroite(const CDroite &o)
+:Objet(o), choix(new Droite [o.possibilites])
+{
+ int i;
+ for (i=0 ; i<possibilites ; i++)
+ choix[i] = o.choix[i];
+}
+
+CDroite::~CDroite()
+{
+ delete [] choix;
+}
+
+const Droite *CDroite::Solution() const
+{
+ if ((retenu == -1) || (possibilites <= 0))
+ return NULL;
+
+ if (retenu > possibilites - 1)
+ return &(choix[possibilites -1]);
+
+ return &(choix[retenu]);
+}
+
+void CDroite::EnvoyerSolutions(Socket *sock) const
+{
+ char buffer[TAILLE_BUFFER];
+
+ //Envoyer le nombre de solutions possibles
+ sprintf(buffer,"%d\n",possibilites);
+ sock->Ecrire(buffer);
+
+ //envoi des solutions
+ int i;
+ for (i=0 ; i<possibilites ; i++)
+ {
+ sprintf(buffer,"%lf %lf %lf\n", choix[i].A(), choix[i].B(), choix[i].C());
+ sock->Ecrire(buffer);
+ }
+}
--- /dev/null
+#ifndef __CDROITE__
+#define __CDROITE__
+
+#include "../Formes/Droite.h"
+#include "Objet.h"
+
+//! Classe CDroite. Classe à dériver pour faire un Droite construit par contraintes.
+/*!
+ On a dérivé la classe Objet pour en hériter les fonctionnalités qui sont communes à toutes les formes. On y rajoute le tableau de Droite qui correspond aux possibilités de constructions relativement aux contraintes enregistrées.
+*/
+class CDroite : public Objet
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Ne fait rien vu qu'il n'y a pas de possibilités de trouver une solution.
+ */
+ CDroite();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param d : droite à copier.
+ */
+ CDroite(const CDroite &d);
+ //! Destructeur.
+ /*!
+ Détruit le tableau des possibilités.
+ */
+ virtual ~CDroite();
+
+ //! Fonction
+ /*!
+ Retourne un pointeur vers la solution sélectionnée. Si il n'y a pas de solution possible la fonction retourne NULL.
+ */
+ const Droite *Solution() const;
+
+ //! Fonction
+ /*!
+ Envoie la liste des possibilités dans la socket passée en paramètre. On envoie d'abord le nombre de solutions puis les solutions elles mêmes. Pour envoyer une solution on envoit les trois constantes de l'équation cartésienne de la droite. Voir le code pour les détails.
+ \param sock : Socket dans laquelle on envoit la liste.
+ */
+ void EnvoyerSolutions(Socket *sock) const;
+
+ protected :
+ //! Donnée privée.
+ /*!
+ Tableau des possibilités.
+ */
+ Droite *choix;
+};
+
+#endif
--- /dev/null
+#include "CDteHorizPassant1P.h"
+
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+#include "stdlib.h"
+
+CDteHorizPassant1P::CDteHorizPassant1P()
+:p(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CDteHorizPassant1P::CDteHorizPassant1P(const CDteHorizPassant1P &cd)
+:CDroite(cd),p(cd.p)
+{}
+
+CDteHorizPassant1P::CDteHorizPassant1P(CPoint *pp)
+:p(pp)
+{
+ //on signale à pp que cette droite a été construit par contraintes sur eux.
+ if (pp != NULL)
+ pp->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CDteHorizPassant1P::~CDteHorizPassant1P()
+{
+}
+
+void CDteHorizPassant1P::CalculerCoordonnees()
+{
+ const Point *pp = p->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si le point n'est pas défini
+ //alors il n'y a pas de solutions
+ if (pp == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ possibilites = 1;
+ choix = new Droite[possibilites];
+ choix[0] = Droite(0, 1, - pp->GetY());
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CDTEHORIZPASSANT1P__
+#define __CDTEHORIZPASSANT1P__
+
+#include "CDroite.h"
+#include "CPoint.h"
+
+//! Classe CDteHorizPassant1P.
+/*!
+ Définit une droite horizontale passant par un points. Il y a toujours une seule solution.
+*/
+class CDteHorizPassant1P : public CDroite
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec un point inconnu. Ne doit pas être utilisé.
+ */
+ CDteHorizPassant1P();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param d : droite à copier.
+ */
+ CDteHorizPassant1P(const CDteHorizPassant1P &d);
+ //! Constructeur.
+ /*!
+ Constructeur à partir d'un point. C'est celui qui devra être utilisé.
+ param p : point par lequel la droite passera.
+ */
+ CDteHorizPassant1P(CPoint *p);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CDteHorizPassant1P();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Point de la Droite.
+ */
+ const CPoint *p;
+};
+
+#endif
--- /dev/null
+#include "CDteMediatrice2P.h"
+
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+
+#include "math.h"
+
+CDteMediatrice2P::CDteMediatrice2P()
+:p1(NULL),p2(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CDteMediatrice2P::CDteMediatrice2P(const CDteMediatrice2P &cd)
+:CDroite(cd),p1(cd.p1),p2(cd.p2)
+{}
+
+CDteMediatrice2P::CDteMediatrice2P(CPoint *pp1, CPoint *pp2)
+:p1(pp1),p2(pp2)
+{
+ //on signale à pp1 et pp2 que cette droite a été construit par contraintes sur eux.
+ if (pp1 != NULL)
+ pp1->AjouterEnfant(this);
+ if (pp2 != NULL)
+ pp2->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CDteMediatrice2P::~CDteMediatrice2P()
+{
+}
+
+void CDteMediatrice2P::CalculerCoordonnees()
+{
+ const Point *pp1 = p1->Solution();
+ const Point *pp2 = p2->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si un des points n'est pas définie
+ //alors il n'y a pas de solutions
+ if (pp1 == NULL || pp2 == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //si les deux points sont les mêmes
+ //alors il n'y a pas de solutions
+ if (fabs(pp1 - pp2) < EPSILON)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //coordonnées du vecteur formé par les deux points
+ double vx = pp2->GetX() - pp1->GetX();
+ double vy = pp2->GetY() - pp1->GetY();
+
+ //calcul des coordonnées du milieu des deux points
+ double mx = (pp1->GetX() + pp2->GetX())/2.0;
+ double my = (pp1->GetY() + pp2->GetY())/2.0;
+
+ //on utilise directement le constructeur de Droite avec deux Point :
+ //le milieu et son translaté par le vecteur directeur
+ possibilites = 1;
+ choix = new Droite[possibilites];
+ choix[0] = Droite(Point(mx,my), Point(mx + vy,my - vx));
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CDTEMEDIATRICE2P__
+#define __CDTEMEDIATRICE2P__
+
+#include "CDroite.h"
+#include "CPoint.h"
+
+//! Classe CDteMediatrice2P.
+/*!
+ Définit une droite médiatrice de deux points. Si les deux points sont confondus il n'y a pas de solutions, sinon il y en a une et une seule.
+ Pour la construire il suffit de calculer le milieu de ces deux points. Ce point appartient à la droite. Ensuite il suffit de déterminer un vecteur directeur de la droite qui est tout simplement un vecteur orthogonal au vecteur formé par les deux points. Il ne reste plus qu'à faire une translation du point milieu par ce vecteur pour avoir un second point de la droite désirée. Le compte est bon.
+*/
+class CDteMediatrice2P : public CDroite
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des points inconnues. Ne doit pas être utilisé.
+ */
+ CDteMediatrice2P();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param d : droite à copier.
+ */
+ CDteMediatrice2P(const CDteMediatrice2P &d);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de deux points. C'est celui qui devra être utilisé.
+ param p1 : premier point.
+ param p2 : deuxier point.
+ */
+ CDteMediatrice2P(CPoint *p1, CPoint *p2);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CDteMediatrice2P();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées de la droite.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Premier Point de la Droite.
+ */
+ const CPoint *p1;
+
+ //! Donnée privée.
+ /*!
+ Deuxième Point de la Droite.
+ */
+ const CPoint *p2;
+};
+
+#endif
--- /dev/null
+#include "CDteParall1D.h"
+
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+
+#include "math.h"
+
+CDteParall1D::CDteParall1D()
+:dist(0),d(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CDteParall1D::CDteParall1D(const CDteParall1D &cd)
+:CDroite(cd),dist(cd.dist),d(cd.d)
+{}
+
+CDteParall1D::CDteParall1D(CDroite *dd, const double &dist)
+:dist(dist),d(dd)
+{
+ //on signale à dd que cette droite a été construite par contraintes sur elle.
+ if (dd != NULL)
+ dd->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CDteParall1D::~CDteParall1D()
+{
+}
+
+void CDteParall1D::CalculerCoordonnees()
+{
+ const Droite *dd = d->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si lla droite n'est pas définie
+ //alors il n'y a pas de solutions
+ if (dd == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //cas de la distance nulle : il y a une solution et c'est la droite elle même
+ if (fabs(dist) < EPSILON)
+ {
+ possibilites = 1;
+ choix = new Droite[possibilites];
+ choix[0] = Droite(*dd);
+ CalculerDependants();
+ return;
+ }
+ //on va récupérer deux points de la droite originale. Pour cela on récupère les coefficients
+ //de l'équation cartésienne. Au cas ou a ou b est nul c'est facile vu qu'il s'agit d'une droite
+ //horizontale ou verticale. Sinon il suffit de résoudre a*0+by+c=0 et ax+b*0+c pour avoir deux
+ //points appartenant à la droite.
+ //ensuite on calcule un vecteur normal que l'on va normaliser (c'est à dire rendre sa norme à 1)
+ //puis translater les deux points précédemment récupérés d'un vecteur +- distance * vecteur normal
+ possibilites = 2;
+ choix = new Droite[possibilites];
+
+ //recherche des deux points
+ Point p1, p2;
+
+ double aa = dd->A();
+ double bb = dd->B();
+ double cc = dd->C();
+
+ //cas d'une droite horizontale
+ if (fabs(aa) < EPSILON)
+ {
+ p1 = Point(0,-cc/bb);
+ p2 = Point(1,-cc/bb);
+ }
+ //cas d'une droite verticale
+ else if (fabs(bb) < EPSILON)
+ {
+ p1 = Point(-cc/aa,0);
+ p2 = Point(-cc/aa,1);
+ }
+ //droite quelconque
+ else
+ {
+ //dans ce cas on prend le point dont le x est égal à 0
+ //et son translaté par le vecteur directeur
+ p1 = Point(0,-cc/bb);
+ //on ne prend pas ce cas car si la droite passe par
+ //(0,0) on aura deux fois le même point
+ //p2 = Point(-cc/aa,0);
+ p2 = Point(-bb,p1.GetY()+aa);
+
+ }
+
+ //calcul de la norme du vecteur normal
+ //p as besoin : on a normalisé les coordonnées
+ //double norme = sqrt(aa*aa+bb*bb);
+
+ //on construit les deux solutions.
+/* choix[0] = Droite(Point(p1.GetX() + aa*dist/norme, p1.GetY() + bb*dist/norme),Point(p2.GetX() + aa*dist/norme, p2.GetY() + bb*dist/norme));
+ choix[1] = Droite(Point(p1.GetX() - aa*dist/norme, p1.GetY() - bb*dist/norme),Point(p2.GetX() - aa*dist/norme, p2.GetY() - bb*dist/norme));*/
+ choix[0] = Droite(Point(p1.GetX() + aa*dist, p1.GetY() + bb*dist),Point(p2.GetX() + aa*dist, p2.GetY() + bb*dist));
+ choix[1] = Droite(Point(p1.GetX() - aa*dist, p1.GetY() - bb*dist),Point(p2.GetX() - aa*dist, p2.GetY() - bb*dist));
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CDTEPARALL1D__
+#define __CDTEPARALL1D__
+
+#include "CDroite.h"
+#include "CPoint.h"
+
+//! Classe CDteParall1D.
+/*!
+ Définit une droite parallèle à une autre droite se trouvant à une distance d de celle ci. Il y a une seule solution au cas où la distance est nulle et deux solutions sinon.
+ Pour la construire on va récupérer deux points de la droite originale. Pour cela on récupère les coefficients de l'équation cartésienne. Au cas ou a ou b est nul c'est facile vu qu'il s'agit d'une droite horizontale ou verticale. Sinon il suffit de résoudre a*0+by+c=0 et ax+b*0+c pour avoir deux points appartenant à la droite.
+ Ensuite on calcule un vecteur normal que l'on va normaliser (c'est à dire rendre sa norme à 1) puis translater les deux points précédemment récupérés d'un vecteur +- distance * vecteur normal
+*/
+class CDteParall1D : public CDroite
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec un point inconnu. Ne doit pas être utilisé.
+ */
+ CDteParall1D();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param d : droite à copier.
+ */
+ CDteParall1D(const CDteParall1D &d);
+ //! Constructeur.
+ /*!
+ Constructeur à partir d'une droite. C'est celui qui devra être utilisé.
+ param d : droite à laquelle la droite doit être parallèle.
+ param dist : distance entre les deux droites.
+ */
+ CDteParall1D(CDroite *d, const double &dist);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CDteParall1D();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Droite perpendiculaire à cette droite.
+ */
+ const CDroite *d;
+
+ //! Donnée privée.
+ /*!
+ Distance entre les droites parallèles.
+ */
+ const double dist;
+};
+
+#endif
--- /dev/null
+#include "CDteParall1DPassant1P.h"
+
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+
+CDteParall1DPassant1P::CDteParall1DPassant1P()
+:p(NULL),d(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CDteParall1DPassant1P::CDteParall1DPassant1P(const CDteParall1DPassant1P &cd)
+:CDroite(cd),p(cd.p),d(cd.d)
+{}
+
+CDteParall1DPassant1P::CDteParall1DPassant1P(CDroite *dd, CPoint *pp)
+:p(pp),d(dd)
+{
+ //on signale à dd que cette droite a été construite par contraintes sur elle.
+ if (dd != NULL)
+ dd->AjouterEnfant(this);
+ //on signale à pp que cette droite a été construite par contraintes sur elle.
+ if (pp != NULL)
+ pp->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CDteParall1DPassant1P::~CDteParall1DPassant1P()
+{
+}
+
+void CDteParall1DPassant1P::CalculerCoordonnees()
+{
+ const Droite *dd = d->Solution();
+ const Point *pp = p->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si la droite ou le point n'est pas défini
+ //alors il n'y a pas de solutions
+ if ((dd == NULL) || (dd == NULL))
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ possibilites = 1;
+ choix = new Droite[possibilites];
+
+ //on construit la solution.
+ choix[0] = Droite(Point(pp->GetX(), pp->GetY()),Point(pp->GetX() - dd->B(), pp->GetY() + dd->A()));
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CDteParall1DPassant1P__
+#define __CDteParall1DPassant1P__
+
+#include "CDroite.h"
+#include "CPoint.h"
+
+//! Classe CDteParall1DPassant1P.
+/*!
+ Définit une droite parallèle à une autre droite passant par un point donné. Il y a une seule solution dans tous les cas.
+ Pour la construire il suffit de trouver un vecteur directeur de la droite d'origine et de déduire le translaté du point donné par ce vecteur et ces deux points peuvent servir à construire la droite voulue.
+*/
+class CDteParall1DPassant1P : public CDroite
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec un point inconnu. Ne doit pas être utilisé.
+ */
+ CDteParall1DPassant1P();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param d : droite à copier.
+ */
+ CDteParall1DPassant1P(const CDteParall1DPassant1P &d);
+ //! Constructeur.
+ /*!
+ Constructeur à partir d'une droite et d'un point. C'est celui qui devra être utilisé.
+ param d : droite à laquelle la droite doit être parallèle.
+ param p : point appartenant à la droite que l'on veut.
+ */
+ CDteParall1DPassant1P(CDroite *d, CPoint *p);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CDteParall1DPassant1P();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Droite perpendiculaire à cette droite.
+ */
+ const CDroite *d;
+
+ //! Donnée privée.
+ /*!
+ Point par lequel devra passer cette droite.
+ */
+ const CPoint *p;
+
+};
+
+#endif
--- /dev/null
+#include "CDtePassant2P.h"
+
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+#include "math.h"
+
+CDtePassant2P::CDtePassant2P()
+:p1(NULL),p2(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CDtePassant2P::CDtePassant2P(const CDtePassant2P &cd)
+:CDroite(cd),p1(cd.p1),p2(cd.p2)
+{}
+
+CDtePassant2P::CDtePassant2P(CPoint *pp1, CPoint *pp2)
+:p1(pp1),p2(pp2)
+{
+ //on signale à pp1 et pp2 que cette droite a été construit par contraintes sur eux.
+ if (pp1 != NULL)
+ pp1->AjouterEnfant(this);
+ if (pp2 != NULL)
+ pp2->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CDtePassant2P::~CDtePassant2P()
+{
+}
+
+void CDtePassant2P::CalculerCoordonnees()
+{
+ const Point *pp1 = p1->Solution();
+ const Point *pp2 = p2->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si un des points n'est pas définie
+ //alors il n'y a pas de solutions
+ if (pp1 == NULL || pp2 == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //si les deux point sont les mêmes il y a une infinité de solutions
+ if (fabs(pp1->GetX() - pp2->GetX()) < EPSILON && fabs(pp1->GetY() - pp2->GetY()) < EPSILON)
+ {
+ possibilites = -1;
+ CalculerDependants();
+ return;
+ }
+
+ //on utilise directement le constructeur de Droite avec deux Point
+ possibilites = 1;
+ choix = new Droite[possibilites];
+ choix[0] = Droite(*pp1, *pp2);
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CDTEPASSANT2P__
+#define __CDTEPASSANT2P__
+
+#include "CDroite.h"
+#include "CPoint.h"
+
+//! Classe CDtePassant2P.
+/*!
+ Définit une droite passant par deux points. Si les deux points sont confondus il n'y a pas de solutions, sinon il y en a une et une seule.
+*/
+class CDtePassant2P : public CDroite
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des points inconnues. Ne doit pas être utilisé.
+ */
+ CDtePassant2P();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param d : droite à copier.
+ */
+ CDtePassant2P(const CDtePassant2P &d);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de deux points. C'est celui qui devra être utilisé.
+ param p1 : premier point.
+ param p2 : deuxier point.
+ */
+ CDtePassant2P(CPoint *p1, CPoint *p2);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CDtePassant2P();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées de la droite.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Premier Point de la Droite.
+ */
+ const CPoint *p1;
+
+ //! Donnée privée.
+ /*!
+ Deuxième Point de la Droite.
+ */
+ const CPoint *p2;
+};
+
+#endif
--- /dev/null
+#include "CDtePerp1DPassant1P.h"
+
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+#include "stdlib.h"
+
+CDtePerp1DPassant1P::CDtePerp1DPassant1P()
+:p(NULL),d(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CDtePerp1DPassant1P::CDtePerp1DPassant1P(const CDtePerp1DPassant1P &cd)
+:CDroite(cd),p(cd.p),d(cd.d)
+{}
+
+CDtePerp1DPassant1P::CDtePerp1DPassant1P(CDroite *dd, CPoint *pp)
+:p(pp),d(dd)
+{
+ //on signale à pp que cette droite a été construite par contraintes sur eux.
+ if (pp != NULL)
+ pp->AjouterEnfant(this);
+ //on signale à dd que cette droite a été construite par contraintes sur eux.
+ if (dd != NULL)
+ dd->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CDtePerp1DPassant1P::~CDtePerp1DPassant1P()
+{
+}
+
+void CDtePerp1DPassant1P::CalculerCoordonnees()
+{
+ const Point *pp = p->Solution();
+ const Droite *dd = d->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si le point ou la droite n'est pas défini
+ //alors il n'y a pas de solutions
+ if ((dd == NULL) || (pp == NULL))
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //avec l'équation cartésienne ax+by+c=0 de la droite on extrait un vecteur normal
+ //de coordonnées (a,b) : pour construire la droite il suffit de la construire à
+ //partir du point par lequel elle est censée passer et à partir du point qui est
+ //le translaté du point précédent par le vecteur
+ possibilites = 1;
+ choix = new Droite[possibilites];
+ choix[0] = Droite(Point(pp->GetX(), pp->GetY()),Point(pp->GetX()+dd->A(), pp->GetY()+dd->B()));
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CDTEPERP1DPASSANT1P__
+#define __CDTEPERP1DPASSANT1P__
+
+#include "CDroite.h"
+#include "CPoint.h"
+
+//! Classe CDtePerp1DPassant1P.
+/*!
+ Définit une droite perpendiculaire à une autre droite passant par un points. Il y a toujours une seule solution.
+*/
+class CDtePerp1DPassant1P : public CDroite
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec un point inconnu. Ne doit pas être utilisé.
+ */
+ CDtePerp1DPassant1P();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param d : droite à copier.
+ */
+ CDtePerp1DPassant1P(const CDtePerp1DPassant1P &d);
+ //! Constructeur.
+ /*!
+ Constructeur à partir d'un point. C'est celui qui devra être utilisé.
+ param d : droite à laquelle la droite doit être perpendiculaire.
+ param p : point par lequel la droite passera.
+ */
+ CDtePerp1DPassant1P(CDroite *d, CPoint *p);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CDtePerp1DPassant1P();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Point de la Droite.
+ */
+ const CPoint *p;
+
+ //! Donnée privée.
+ /*!
+ Droite perpendiculaire à cette droite.
+ */
+ const CDroite *d;
+};
+
+#endif
--- /dev/null
+#include "CDteVertPassant1P.h"
+
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+#include "stdlib.h"
+
+CDteVertPassant1P::CDteVertPassant1P()
+:p(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CDteVertPassant1P::CDteVertPassant1P(const CDteVertPassant1P &cd)
+:CDroite(cd),p(cd.p)
+{}
+
+CDteVertPassant1P::CDteVertPassant1P(CPoint *pp)
+:p(pp)
+{
+ //on signale ? pp que cette droite a ?t? construit par contraintes sur eux.
+ if (pp != NULL)
+ pp->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CDteVertPassant1P::~CDteVertPassant1P()
+{
+}
+
+void CDteVertPassant1P::CalculerCoordonnees()
+{
+ const Point *pp = p->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si le point n'est pas d?fini
+ //alors il n'y a pas de solutions
+ if (pp == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ possibilites = 1;
+ choix = new Droite[possibilites];
+ choix[0] = Droite(1, 0, - pp->GetX());
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CDteVertPassant1P__
+#define __CDteVertPassant1P__
+
+#include "CDroite.h"
+#include "CPoint.h"
+
+//! Classe CDteVertPassant1P.
+/*!
+ Définit une droite verticale passant par un points. Il y a toujours une seule solution.
+*/
+class CDteVertPassant1P : public CDroite
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec un point inconnu. Ne doit pas être utilisé.
+ */
+ CDteVertPassant1P();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param d : droite à copier.
+ */
+ CDteVertPassant1P(const CDteVertPassant1P &d);
+ //! Constructeur.
+ /*!
+ Constructeur à partir d'un point. C'est celui qui devra être utilisé.
+ param p : point par lequel la droite passera.
+ */
+ CDteVertPassant1P(CPoint *p);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CDteVertPassant1P();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Point de la Droite.
+ */
+ const CPoint *p;
+};
+
+#endif
--- /dev/null
+#include "CPoint.h"
+
+#include "stdlib.h"
+
+CPoint::CPoint()
+: choix(NULL)
+{}
+
+CPoint::CPoint(const CPoint &o)
+:Objet(o), choix(new Point [o.possibilites])
+{
+ int i;
+ for (i=0 ; i<possibilites ; i++)
+ choix[i] = o.choix[i];
+}
+
+CPoint::~CPoint()
+{
+ delete [] choix;
+}
+
+const Point *CPoint::Solution() const
+{
+ if ((retenu == -1) || (possibilites <= 0))
+ return NULL;
+
+ if (retenu > possibilites - 1)
+ return &(choix[possibilites -1]);
+
+ return &(choix[retenu]);
+}
+
+void CPoint::EnvoyerSolutions(Socket *sock) const
+{
+ char buffer[TAILLE_BUFFER];
+
+ //Envoyer le nombre de solutions possibles
+ sprintf(buffer,"%d\n",possibilites);
+ sock->Ecrire(buffer);
+
+ //envoi des solutions
+ int i;
+ for (i=0 ; i<possibilites ; i++)
+ {
+ sprintf(buffer,"%lf %lf\n", choix[i].GetX(), choix[i].GetY());
+ sock->Ecrire(buffer);
+ }
+}
+
+void CPoint::ModifierPoint(const double &x, const double &y)
+{
+}
--- /dev/null
+#ifndef __CPOINT__
+#define __CPOINT__
+
+#include "../Formes/Point.h"
+#include "Objet.h"
+
+//! Classe CPoint. Classe à dériver pour faire un Point construit par contraintes.
+/*!
+ On a dérivé la classe Objet pour en hériter les fonctionnalités qui sont communes à toutes les formes. On y rajoute le tableau de Point qui correspond aux possibilités de constructions relativement aux contraintes enregistrées.
+*/
+class CPoint : public Objet
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Ne fait rien vu qu'il n'y a pas de possibilités de trouver une solution.
+ */
+ CPoint();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param p : point à copier.
+ */
+ CPoint(const CPoint &p);
+ //! Destructeur.
+ /*!
+ Détruit le tableau des possibilités.
+ */
+ virtual ~CPoint();
+
+ //! Fonction
+ /*!
+ Retourne un pointeur vers la solution sélectionnée. Si il n'y a pas de solution possible la fonction retourne NULL. Cette fonction est virtuelle afin d'être surchargée au cas où il y a un changement de la solution retenue à cause d'une diminution du nombre de solutions.
+ */
+ const Point *Solution() const;
+
+ //! Fonction
+ /*!
+ Envoie la liste des possibilités dans la socket passée en paramètre. On envoie d'abord le nombre de solutions puis les solutions elles mêmes. Pour envoyer une solution on envoit sur une même ligne les coordonnées x et y du point. Voir le code pour les détails.
+ \param sock : Socket dans laquelle on envoit la liste.
+ */
+ void EnvoyerSolutions(Socket *sock) const;
+
+ //! Fonction
+ /*!
+ Modifie le point si celui ci est modifiable. Cette fonction doit être surchargée pour faire des modifiacations, sinon rien n'est modifiée.
+ */
+ virtual void ModifierPoint(const double &x, const double &y);
+
+ protected :
+ //! Donnée privée.
+ /*!
+ Tableau des possibilités.
+ */
+ Point *choix;
+};
+
+#endif
--- /dev/null
+#include "CPointAppart1C.h"
+
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+#include "../Formes/Cercle.h"
+
+#include "math.h"
+
+CPointAppart1C::CPointAppart1C()
+:c(NULL),x(0),y(0)
+{
+ CalculerCoordonnees();
+}
+
+CPointAppart1C::CPointAppart1C(const CPointAppart1C &cp)
+:CPoint(cp),c(cp.c),x(cp.x),y(cp.y)
+{}
+
+CPointAppart1C::CPointAppart1C(CCercle *cc, const double &xx, const double &yy)
+:c(cc),x(xx),y(yy)
+{
+ //on signale à cc que ce point a été construit par contraintes sur eux.
+ if (cc != NULL)
+ cc->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CPointAppart1C::~CPointAppart1C()
+{
+}
+
+//Définit un Point appartenant à un cercle. Pour construire un point on calcule le point
+//d'intersection le plus proche entre le cercle et la droite passant par le point dont les
+//coordonnées sont fourinies au constructeur et le centre du cercle.
+//pour cela on va construire un vecteur colinéaire au vecteur formé par le centre du cercle
+//et le point fourni et de norme le rayon. Le point désiré est le translaté du centre par
+//ce vecteur.
+void CPointAppart1C::CalculerCoordonnees()
+{
+ delete [] choix;
+ choix = NULL;
+
+ const Cercle *cc = c->Solution();
+
+ //si le cercle n'existe pas on ne renvoit pas de possibilités
+ if (cc == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ Point pc = cc->GetCentre();
+
+ //si le point donné est le centre, on ne retourne aucune solution
+ if (fabs(pc.GetX() - x) < EPSILON && fabs(pc.GetY() - y) < EPSILON)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //on calcule le vecteur colinéaire
+ double vx = x - pc.GetX();
+ double vy = y - pc.GetY();
+
+ //on calcule la norme du vecteur
+ double norme = sqrt(vx*vx + vy*vy);
+
+ //on change la norme du vecteur pour qu'elle soit egale au rayon
+ vx *= (cc->GetRayon()/norme);
+ vy *= (cc->GetRayon()/norme);
+
+ possibilites = 1;
+ choix = new Point[possibilites];
+ choix[0] = Point(pc.GetX()+vx,pc.GetY()+vy);
+
+ CalculerDependants();
+}
+
+void CPointAppart1C::ModifierPoint(const double &xx, const double &yy)
+{
+ x = xx;
+ y = yy;
+ CalculerCoordonnees();
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CPOINTAPPART1C__
+#define __CPOINTAPPART1C__
+
+#include "CCercle.h"
+#include "CPoint.h"
+
+//! Classe CPointAppart1C.
+/*!
+ Définit un Point appartenant à un cercle. Pour construire un point on calcule le point d'intersection le plus proche entre le cercle et la droite passant par le point dont les coordonnées sont fourinies au constructeur et le centre du cercle. Si le point est le centre il n'y a pas de solutions sinon il y en a une et une seule
+*/
+class CPointAppart1C : public CPoint
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des droites inconnues. Ne doit pas être utilisé.
+ */
+ CPointAppart1C();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param p : point à copier.
+ */
+ CPointAppart1C(const CPointAppart1C &p);
+ //! Constructeur.
+ /*!
+ Constructeur à partir d'un cercle. C'est celui qui devra être utilisé.
+ param c : cercle auquel le point doit appartenir.
+ param x : coordonnée x du point à projeter sur la droite.
+ param y : coordonnée y du point à projeter sur la droite.
+ */
+ CPointAppart1C(CCercle *c, const double &x, const double &y);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CPointAppart1C();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point.
+ */
+ void CalculerCoordonnees();
+
+ //! Fonction
+ /*!
+ On change les coordonnées et on recalcule par dépendances les points construit par contraintes.
+ */
+ void ModifierPoint(const double &x, const double &y);
+
+ private :
+ //! Donnée privée.
+ /*!
+ Cercle sur lequel le point doit se trouver.
+ */
+ const CCercle *c;
+
+ //! Donnée privée.
+ /*!
+ coordonnée x du point à projeter.
+ */
+ double x;
+
+ //! Donnée privée.
+ /*!
+ coordonnée y du point à projeter.
+ */
+ double y;
+};
+
+#endif
--- /dev/null
+#include "CPointAppart1D.h"
+
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+
+#include "math.h"
+
+CPointAppart1D::CPointAppart1D()
+:d(NULL),x(0),y(0)
+{
+ CalculerCoordonnees();
+}
+
+CPointAppart1D::CPointAppart1D(const CPointAppart1D &cp)
+:CPoint(cp),d(cp.d),x(cp.x),y(cp.y)
+{}
+
+CPointAppart1D::CPointAppart1D(CDroite *dd, const double &xx, const double &yy)
+:d(dd),x(xx),y(yy)
+{
+ //on signale à dd que ce point a été construit par contraintes sur eux.
+ if (dd != NULL)
+ dd->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CPointAppart1D::~CPointAppart1D()
+{
+}
+
+//Définit un Point appartenant à une droite. Pour construire un point on fait le projeté orthogonal du
+//point sur la droite. Pour ce faire on construit la droite perpendiculaire à celle passée en paramètres
+//passant par le point et on fait l'intersection avec la droite. Il y a toujours une possibilité.
+void CPointAppart1D::CalculerCoordonnees()
+{
+ double diff, xx, yy;
+ const Droite *dd = d->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si la droite n'est pas définie
+ //alors il n'y a pas de solutions
+ if (dd == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //on calcule la droite perpendiculaire
+ Droite dperp = Droite(Point(x, y), Point(x+dd->A(), y+dd->B()));
+
+ //on calcule le point d'intersection
+ diff = dperp.A()*dd->B() - dd->A()*dperp.B();
+
+ //calcul de la solution
+ xx = (dd->C()*dperp.B() - dperp.C()*dd->B())/diff;
+ if (fabs(dd->B()) > EPSILON)
+ yy = (-dd->C() - dd->A()*xx)/dd->B();
+ else if (fabs(dperp.B()) > EPSILON)
+ yy = (-dperp.C() - dperp.A()*xx)/dperp.B();
+ else
+ {
+ possibilites = -1;
+ CalculerDependants();
+ return;
+ }
+
+ possibilites = 1;
+ choix = new Point[possibilites];
+ choix[0] = Point(xx,yy);
+
+ CalculerDependants();
+}
+
+void CPointAppart1D::ModifierPoint(const double &xx, const double &yy)
+{
+ x = xx;
+ y = yy;
+ CalculerCoordonnees();
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CPOINTAPPART1D__
+#define __CPOINTAPPART1D__
+
+#include "CDroite.h"
+#include "CPoint.h"
+
+//! Classe CPointAppart1D.
+/*!
+ Définit un Point appartenant à une droite. Pour construire un point on fait le projeté orthogonal du point sur la droite. Pour ce faire on construit la droite perpendiculaire à celle passée en paramètres passant par le point et on fait l'intersection avec la droite. Il y a toujours une possibilité.
+*/
+class CPointAppart1D : public CPoint
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des droites inconnues. Ne doit pas être utilisé.
+ */
+ CPointAppart1D();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param p : point à copier.
+ */
+ CPointAppart1D(const CPointAppart1D &p);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de deux droites. C'est celui qui devra être utilisé.
+ param d : droite à laquelle le point doit appartenir.
+ param x : coordonnée x du point à projeter sur la droite.
+ param y : coordonnée y du point à projeter sur la droite.
+ */
+ CPointAppart1D(CDroite *d, const double &x, const double &y);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CPointAppart1D();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point.
+ */
+ void CalculerCoordonnees();
+
+ //! Fonction
+ /*!
+ On change les coordonnées et on recalcule par dépendances les points construit par contraintes.
+ */
+ void ModifierPoint(const double &x, const double &y);
+
+ private :
+ //! Donnée privée.
+ /*!
+ Première droite du point.
+ */
+ const CDroite *d;
+
+ //! Donnée privée.
+ /*!
+ coordonnée x du point à projeter.
+ */
+ double x;
+
+ //! Donnée privée.
+ /*!
+ coordonnée y du point à projeter.
+ */
+ double y;
+};
+
+#endif
--- /dev/null
+#include "CPointCentre1C.h"
+
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+
+CPointCentre1C::CPointCentre1C()
+:c(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CPointCentre1C::CPointCentre1C(const CPointCentre1C &cp)
+:CPoint(cp),c(cp.c)
+{}
+
+CPointCentre1C::CPointCentre1C(CCercle *cc)
+:c(cc)
+{
+ //on signale à cc que ce point a été construit par contraintes sur eux.
+ if (cc != NULL)
+ cc->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CPointCentre1C::~CPointCentre1C()
+{
+}
+
+void CPointCentre1C::CalculerCoordonnees()
+{
+ const Cercle *cc = c->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si le cercle n'est pas défini
+ //alors il n'y a pas de solutions
+ if (cc == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ possibilites = 1;
+ choix = new Point[possibilites];
+ choix[0] = Point(cc->GetCentre());
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CPOINTCENTRE1C__
+#define __CPOINTCENTRE1C__
+
+#include "CPoint.h"
+#include "CCercle.h"
+
+//! Classe CPointCentre1C.
+/*!
+ Définit un point comme étant le milieu de deux autres points.
+*/
+class CPointCentre1C : public CPoint
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des points inconnus. Ne doit pas être utilisé.
+ */
+ CPointCentre1C();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param p : point à copier.
+ */
+ CPointCentre1C(const CPointCentre1C &p);
+ //! Constructeur.
+ /*!
+ Constructeur à partir d'un cercle. C'est celui qui devra être utilisé.
+ param c : cercle dont on veut le centre.
+ */
+ CPointCentre1C(CCercle *c);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CPointCentre1C();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Cercle dont on veut le centre.
+ */
+ const CCercle *c;
+};
+
+#endif
--- /dev/null
+#include "CPointInter1C1D.h"
+
+#include "../Formes/Cercle.h"
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+
+#include "math.h"
+
+CPointInter1C1D::CPointInter1C1D()
+:d(NULL),c(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CPointInter1C1D::CPointInter1C1D(const CPointInter1C1D &cp)
+:CPoint(cp),c(cp.c),d(cp.d)
+{}
+
+CPointInter1C1D::CPointInter1C1D(CCercle *cc, CDroite *dd)
+:c(cc),d(dd)
+{
+ //on signale à dd et à cc que ce point a été construit par contraintes sur eux.
+ if (dd != NULL)
+ dd->AjouterEnfant(this);
+ if (cc != NULL)
+ cc->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CPointInter1C1D::~CPointInter1C1D()
+{
+}
+
+void CPointInter1C1D::CalculerCoordonnees()
+{
+ const Droite *dd = d->Solution();
+ const Cercle *cc = c->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si le cercle ou la droite n'est pas défini
+ //alors il n'y a pas de solutions
+ if (dd == NULL || cc == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //on projète le centre sur la droite
+
+ //on calcule la droite perpendiculaire
+ Droite dperp = Droite(Point(cc->GetCentre().GetX(), cc->GetCentre().GetY()), Point(cc->GetCentre().GetX()+dd->A(), cc->GetCentre().GetY()+dd->B()));
+
+ //on calcule le point d'intersection
+ double diff = dperp.A()*dd->B() - dd->A()*dperp.B();
+
+ //calcul de la solution
+ double xx = (dd->C()*dperp.B() - dperp.C()*dd->B())/diff;
+ double yy;
+ if (fabs(dd->B()) > EPSILON)
+ yy = (-dd->C() - dd->A()*xx)/dd->B();
+ else if (fabs(dperp.B()) > EPSILON)
+ yy = (-dperp.C() - dperp.A()*xx)/dperp.B();
+ else
+ {
+ possibilites = -1;
+ CalculerDependants();
+ return;
+ }
+ Point proj = Point(xx,yy);
+
+ //on translate le point pour se retrouver dans un cas simple
+ Point trans = Point(proj.GetX() - cc->GetCentre().GetX() , proj.GetY() - cc->GetCentre().GetY());
+
+ //on calcule la distance au carré entre les solutions et le point projeté
+ double dist = (PUISS2(cc->GetRayon()) - (PUISS2(trans.GetX()) + PUISS2(trans.GetY())));
+
+ //si ce carré est négatif alors il n'y a pas de solutions
+ if (dist < - EPSILON)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+ //si c'est 0 alors proj est la solution
+ else if (dist < EPSILON)
+ {
+ possibilites = 1;
+ choix = new Point[possibilites];
+ choix[0] = proj;
+ CalculerDependants();
+ return;
+ }
+
+ //on récupère la vraie distance
+ dist = sqrt(dist);
+
+ possibilites = 2;
+ choix = new Point[possibilites];
+
+ //calcul d'un vecteur directeur de la droite
+ double vx = - dd->B();
+ double vy = dd->A();
+
+ //on modifie la norme du vecteur pour qu'elle soit égale à dist
+ //plus besoin de normaliser le cecteur car c'est déjà fait
+ //double norme = sqrt((vx*vx)+(vy*vy));
+ /*vx *= (dist/norme);
+ vy *= (dist/norme);*/
+ vx *= dist;
+ vy *= dist;
+
+ //calcul de la solution
+ choix[0] = Point(proj.GetX() + vx , proj.GetY() + vy);
+ choix[1] = Point(proj.GetX() - vx , proj.GetY() - vy);
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CPOINTINTER1C1D__
+#define __CPOINTINTER1C1D__
+
+#include "CCercle.h"
+#include "CDroite.h"
+#include "CPoint.h"
+
+//! Classe CPointInter1C1D.
+/*!
+ Définit un Point construit par intersection d'un cercle et d'une droite. Pour cela on va projeter le centre du cercle sur la droite. Ce point sera le milieu du segment formé par les deux solutions. Au cas où il y a une seule solution ce sera directement la solution. Le cas où il n'y a pas de solutions est repérable par le fait que la distance entre ce point et le centre du cercle sera supérieure au rayon du cercle.
+*/
+class CPointInter1C1D : public CPoint
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des droites inconnues. Ne doit pas être utilisé.
+ */
+ CPointInter1C1D();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param p : point à copier.
+ */
+ CPointInter1C1D(const CPointInter1C1D &p);
+ //! Constructeur.
+ /*!
+ Constructeur à partir d'un cercle et d'une droites. C'est celui qui devra être utilisé.
+ param c : cercle.
+ param d : droite.
+ */
+ CPointInter1C1D(CCercle *c, CDroite *d);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CPointInter1C1D();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ droite à laquelle le point doit appartenir point.
+ */
+ const CDroite *d;
+
+ //! Donnée privée.
+ /*!
+ cercle auquel le point doit appartenir.
+ */
+ const CCercle *c;
+};
+
+#endif
--- /dev/null
+#include "CPointInter2C.h"
+
+#include "../Formes/Cercle.h"
+#include "../Formes/Point.h"
+
+#include "math.h"
+
+CPointInter2C::CPointInter2C()
+:c1(NULL),c2(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CPointInter2C::CPointInter2C(const CPointInter2C &cp)
+:CPoint(cp),c1(cp.c1),c2(cp.c2)
+{}
+
+CPointInter2C::CPointInter2C(CCercle *cc1, CCercle *cc2)
+:c1(cc1),c2(cc2)
+{
+ //on signale à cc1 et cc2 que ce point a été construit par contraintes sur eux.
+ if (cc1 != NULL)
+ cc1->AjouterEnfant(this);
+ if (cc2 != NULL)
+ cc2->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CPointInter2C::~CPointInter2C()
+{
+}
+
+void CPointInter2C::CalculerCoordonnees()
+{
+ const Cercle *cc1 = c1->Solution();
+ const Cercle *cc2 = c2->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si une des cercles n'est pas défini
+ //alors il n'y a pas de solutions
+ if (cc1 == NULL || cc1 == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //on calcule les coordonnées du centre du deuxième cercle par rapport
+ //aux coordonnées du premier
+ Point ccc2 = Point(cc2->GetCentre().GetX()-cc1->GetCentre().GetX() , cc2->GetCentre().GetY()-cc1->GetCentre().GetY());
+
+ //on calcule le carré de la distance entre les deux centres
+ double d = PUISS2(ccc2.GetX()) + PUISS2(ccc2.GetY());
+
+ //on regarde si il y a une infinité de solutions
+ if (fabs(d) < EPSILON)
+ {
+ possibilites = -1;
+ CalculerDependants();
+ return;
+ }
+
+ double x = -(PUISS4(cc1->GetRayon()) + PUISS2(d - PUISS2(cc2->GetRayon())) -2 * PUISS2(cc1->GetRayon()) * (PUISS2(cc2->GetRayon()) + d));
+
+ //on teste si il n'y a pas de solutions
+ if (x < - EPSILON)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+ //on regarde si il y a une seule solution
+ else if (fabs(x) < EPSILON)
+ {
+ possibilites = 1;
+ choix = new Point[possibilites];
+ double xx,yy;
+
+ //si les cercles sont emboités
+ if (d < PUISS2(MAXIMUM(cc1->GetRayon() , cc2->GetRayon())))
+ {
+ xx = ccc2.GetX()*cc1->GetRayon() / (cc1->GetRayon() - cc2->GetRayon()) + cc1->GetCentre().GetX();
+ yy = ccc2.GetY()*cc1->GetRayon() / (cc1->GetRayon() - cc2->GetRayon()) + cc1->GetCentre().GetY();
+ }
+ else
+ {
+ xx = ccc2.GetX()*cc1->GetRayon() / (cc1->GetRayon() + cc2->GetRayon()) + cc1->GetCentre().GetX();
+ yy = ccc2.GetY()*cc1->GetRayon() / (cc1->GetRayon() + cc2->GetRayon()) + cc1->GetCentre().GetY();
+ }
+ choix[0] = Point(xx,yy);
+ }
+ //sinon il y a deux solutions
+ else
+ {
+ possibilites = 2;
+ choix = new Point[possibilites];
+
+ x = sqrt(x);
+
+ double xx1,yy1,xx2,yy2;
+
+ xx1 = (ccc2.GetX() * (PUISS2(cc1->GetRayon()) - PUISS2(cc2->GetRayon()) + d) - ccc2.GetY() * x) / (2 * d) + cc1->GetCentre().GetX();
+ yy1 = (ccc2.GetY() * (PUISS2(cc1->GetRayon()) - PUISS2(cc2->GetRayon()) + d) + ccc2.GetX() * x) / (2 * d) + cc1->GetCentre().GetY();
+
+ xx2 = (ccc2.GetX() * (PUISS2(cc1->GetRayon()) - PUISS2(cc2->GetRayon()) + d) + ccc2.GetY() * x) / (2 * d) + cc1->GetCentre().GetX();
+ yy2 = (ccc2.GetY() * (PUISS2(cc1->GetRayon()) - PUISS2(cc2->GetRayon()) + d) - ccc2.GetX() * x) / (2 * d) + cc1->GetCentre().GetY();
+
+ choix[0] = Point(xx1,yy1);
+ choix[1] = Point(xx2,yy2);
+
+ }
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CPOINTINTER2C__
+#define __CPOINTINTER2C__
+
+#include "CCercle.h"
+#include "CPoint.h"
+
+//! Classe CPointInter2C.
+/*!
+ Définit un Point construit par intersection de deux cercles. Dans le cas général il y a deux solutions. Si les cercles sont tangents il y a une seule solution, si les cercles sont confondus il y en a une infinité et si ils ne se croisent pas il y a aucune solution.
+*/
+class CPointInter2C : public CPoint
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des droites inconnues. Ne doit pas être utilisé.
+ */
+ CPointInter2C();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param p : point à copier.
+ */
+ CPointInter2C(const CPointInter2C &p);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de deux cercles. C'est celui qui devra être utilisé.
+ param c1 : premier cercle.
+ param c2 : deuxième cercle.
+ */
+ CPointInter2C(CCercle *c1, CCercle *c2);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CPointInter2C();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Premier cercle du point.
+ */
+ const CCercle *c1;
+
+ //! Donnée privée.
+ /*!
+ Deuxième cercle du point.
+ */
+ const CCercle *c2;
+};
+
+#endif
--- /dev/null
+#include "CPointInter2D.h"
+
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+
+#include "math.h"
+
+CPointInter2D::CPointInter2D()
+:d1(NULL),d2(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CPointInter2D::CPointInter2D(const CPointInter2D &cp)
+:CPoint(cp),d1(cp.d1),d2(cp.d2)
+{}
+
+CPointInter2D::CPointInter2D(CDroite *dd1, CDroite *dd2)
+:d1(dd1),d2(dd2)
+{
+ //on signale à dd1 et dd2 que ce point a été construit par contraintes sur eux.
+ if (dd1 != NULL)
+ dd1->AjouterEnfant(this);
+ if (dd2 != NULL)
+ dd2->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CPointInter2D::~CPointInter2D()
+{
+}
+
+void CPointInter2D::CalculerCoordonnees()
+{
+ double d, x, y;
+ const Droite *dd1 = d1->Solution();
+ const Droite *dd2 = d2->Solution();
+
+ delete []choix;
+ choix=NULL;
+
+ //Si une des droites n'est pas définie
+ //alors il n'y a pas de solutions
+ if (dd1 == NULL || dd1 == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ //on regarde si il y a une infinité de solutions
+ if (fabs(d = dd2->A()*dd1->B() - dd1->A()*dd2->B()) < EPSILON)
+ {
+ possibilites = -1;
+ CalculerDependants();
+ return;
+ }
+
+ possibilites = 1;
+ choix = new Point[possibilites];
+ //calcul de la solution
+ x = (dd1->C()*dd2->B() - dd2->C()*dd1->B())/d;
+ if (fabs(dd1->B()) > EPSILON)
+ y = (-dd1->C() - dd1->A()*x)/dd1->B();
+ else if (fabs(dd2->B()) > EPSILON)
+ y = (-dd2->C() - dd2->A()*x)/dd2->B();
+ else
+ {
+ possibilites = -1;
+ CalculerDependants();
+ return;
+ }
+
+ choix[0] = Point(x,y);
+
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CPOINTINTER2D__
+#define __CPOINTINTER2D__
+
+#include "CDroite.h"
+#include "CPoint.h"
+
+//! Classe CPointInter2D.
+/*!
+ Définit un Point construit par intersection de deux droites. Dans le cas général il y a une seule solution.
+ Dans le cas où les droites sont parallèles il n'y a pas d'intersection.
+ Dans le cas où les droites sont confondues il y a une infinité de solutions.
+ Les deux derniers cas arrivent quand d2.A()*d1.B() - d1.A()*d2.B()
+ IL FAUT DIFFERENCIER LES DEUX CAS : PARALLELES ET CONFONDUES.
+*/
+class CPointInter2D : public CPoint
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des droites inconnues. Ne doit pas être utilisé.
+ */
+ CPointInter2D();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param p : point à copier.
+ */
+ CPointInter2D(const CPointInter2D &p);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de deux droites. C'est celui qui devra être utilisé.
+ param d1 : première droite.
+ param d2 : deuxième droite.
+ */
+ CPointInter2D(CDroite *d1, CDroite *d2);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CPointInter2D();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point. Selon la solution retenue on va calculer les coordonnées. Dans le cas où il n'y a pas de solutions ou une infinité on ne fait rien.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Première droite du point.
+ */
+ const CDroite *d1;
+
+ //! Donnée privée.
+ /*!
+ Deuxième droite du point.
+ */
+ const CDroite *d2;
+};
+
+#endif
--- /dev/null
+#include "CPointIsole.h"
+
+CPointIsole::CPointIsole()
+:x(0),y(0)
+{
+ CalculerCoordonnees();
+}
+
+CPointIsole::CPointIsole(const CPointIsole &cp)
+:CPoint(cp),x(cp.x),y(cp.y)
+{
+}
+
+CPointIsole::CPointIsole(const double &xx, const double &yy)
+:x(xx),y(yy)
+{
+ CalculerCoordonnees();
+}
+
+CPointIsole::~CPointIsole()
+{
+}
+
+void CPointIsole::CalculerCoordonnees()
+{
+ delete [] choix;
+
+ possibilites = 1;
+ choix = new Point[possibilites];
+ choix[0] = Point(x,y);
+
+ CalculerDependants();
+}
+
+void CPointIsole::ModifierPoint(const double &xx, const double &yy)
+{
+ x = xx;
+ y = yy;
+ CalculerCoordonnees();
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CPOINTISOLE__
+#define __CPOINTISOLE__
+
+#include "CPoint.h"
+
+//! Classe CPointIsole. Définit un Point construit par contraintes.
+/*!
+ Il n'y a aucun cas particulier : dans tous les cas il y a une et une seule possibilité.
+*/
+class CPointIsole : public CPoint
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit un Point de coordonnées nulles.
+ */
+ CPointIsole();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param p : point à copier.
+ */
+ CPointIsole(const CPointIsole &p);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de deux réels.
+ param x : coordonnée x du point.
+ param y : coordonnée y du point.
+ */
+ CPointIsole(const double &x, const double &y);
+ //! Destructeur.
+ /*!
+ Destructeur. On détruit les possibilités créées.
+ */
+ ~CPointIsole();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point. il n'y a aucun changement en théorie vu que l'objet est construit qu'à partir de constantes.
+ */
+ void CalculerCoordonnees();
+
+ //! Fonction
+ /*!
+ On change les coordonnées et on recalcule par dépendances les points construit par contraintes.
+ */
+ void ModifierPoint(const double &x, const double &y);
+
+ private :
+ //! Donnée privée.
+ /*!
+ coordonnée X du point.
+ */
+ double x;
+
+ //! Donnée privée.
+ /*!
+ coordonnée Y du point.
+ */
+ double y;
+};
+
+#endif
--- /dev/null
+#include "CPointMilieu2P.h"
+
+#include "../Formes/Droite.h"
+#include "../Formes/Point.h"
+#include "stdlib.h"
+
+CPointMilieu2P::CPointMilieu2P()
+:p1(NULL),p2(NULL)
+{
+ CalculerCoordonnees();
+}
+
+CPointMilieu2P::CPointMilieu2P(const CPointMilieu2P &cp)
+:CPoint(cp),p1(cp.p1),p2(cp.p2)
+{}
+
+CPointMilieu2P::CPointMilieu2P(CPoint *pp1, CPoint *pp2)
+:p1(pp1),p2(pp2)
+{
+ //on signale à pp1 et pp2 que ce point a été construit par contraintes sur eux.
+ if (pp1 != NULL)
+ pp1->AjouterEnfant(this);
+ if (pp2 != NULL)
+ pp2->AjouterEnfant(this);
+
+ CalculerCoordonnees();
+}
+
+CPointMilieu2P::~CPointMilieu2P()
+{
+}
+
+void CPointMilieu2P::CalculerCoordonnees()
+{
+ const Point *pp1 = p1->Solution();
+ const Point *pp2 = p2->Solution();
+
+ delete []choix;
+ choix = NULL;
+
+ //Si un des points n'est pas définie
+ //alors il n'y a pas de solutions
+ if (pp1 == NULL || pp2 == NULL)
+ {
+ possibilites = 0;
+ CalculerDependants();
+ return;
+ }
+
+ possibilites = 1;
+ choix = new Point[possibilites];
+ choix[0] = Point((pp1->GetX()+pp2->GetX())/2, (pp1->GetY()+pp2->GetY())/2);
+ CalculerDependants();
+}
--- /dev/null
+#ifndef __CPOINTMILIEU2P__
+#define __CPOINTMILIEU2P__
+
+#include "CPoint.h"
+
+//! Classe CPointMilieu2P.
+/*!
+ Définit un point comme étant le milieu de deux autres points.
+*/
+class CPointMilieu2P : public CPoint
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit avec des points inconnus. Ne doit pas être utilisé.
+ */
+ CPointMilieu2P();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param p : point à copier.
+ */
+ CPointMilieu2P(const CPointMilieu2P &p);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de deux points. C'est celui qui devra être utilisé.
+ param p1 : premier point.
+ param p2 : deuxier point.
+ */
+ CPointMilieu2P(CPoint*p1, CPoint *p2);
+ //! Destructeur.
+ /*!
+ Détruit les solutions possibles.
+ */
+ ~CPointMilieu2P();
+
+ //! Fonction.
+ /*!
+ On recalcule les coordonnées du point. Selon la solution retenue on va calculer les coordonnées. Dans le cas où il n'y a pas de solutions ou une infinité on ne fait rien.
+ */
+ void CalculerCoordonnees();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Premier Point.
+ */
+ const CPoint *p1;
+
+ //! Donnée privée.
+ /*!
+ Deuxième Point.
+ */
+ const CPoint *p2;
+};
+
+#endif
--- /dev/null
+#include "Objet.h"
+
+#include "stdlib.h"
+
+Objet::Objet()
+:possibilites(0), retenu(-1)
+{}
+
+Objet::Objet(const Objet &o)
+:possibilites(o.possibilites), retenu(o.retenu)
+{
+}
+
+Objet::~Objet()
+{
+ //il faut détruire les objets dépendant de celui ci
+ list<Objet *>::iterator itliste;
+
+ for (itliste=enfants.begin();itliste!=enfants.end();++itliste)
+ delete *itliste;
+
+}
+
+void Objet::Choisir (const int &i)
+{
+ if (i<=0)
+ retenu = 0;
+ else if (i>possibilites-1)
+ retenu = possibilites-1;
+ else
+ retenu=i;
+}
+
+void Objet::AjouterEnfant (Objet *o)
+{
+ enfants.push_front(o);
+}
+
+void Objet::CalculerDependants()
+{
+ list<Objet *>::iterator itliste;
+
+ for (itliste=enfants.begin();itliste!=enfants.end();++itliste)
+ (*itliste)->CalculerCoordonnees();
+}
--- /dev/null
+#ifndef __OBJET__
+#define __OBJET__
+
+#include "../Connexion/Socket.h"
+#include "stdio.h"
+
+#include "list"
+using namespace std;
+
+//! Classe Objet. Classe à dériver pour faire un objet construit par contraintes.
+/*!
+ Un Objet est ce que l'on va créer par l'intermédiaire du client. Ceci contient les contraintes. Ainsi on mémorise le nombre de possibilités qu'offrent les contraintes saisies et le choix retenu par l'utilisateur. Le tableau des choix possibles quand les possibilités sont finies sera contenu dans une sous classe pour être spécifique à une Forme : Point, Cercle ou Droite.
+*/
+class Objet
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. les possibilités sont nulles, aucun choix n'est proposé et aucun n'est retenu (-1).
+ */
+ Objet();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param p : objet à copier.
+ */
+ Objet(const Objet &o);
+ //! Destructeur.
+ /*!
+ Ne fait rien.
+ */
+ virtual ~Objet();
+
+ //! Fonction.
+ /*!
+ Cette fonction abstraite devra être définie dans la classe finale pour calculer les possibilités en fonction des contraintes de l'Objet.
+ */
+ virtual void CalculerCoordonnees()=0;
+
+ //! Fonction.
+ /*!
+ Cette fonction permet de choisir une des solutions proposées. Elle est virtuelle car si il y a plusieurs solutions possibles on utilise deux variables pour stocker le choix désiré : le choix entré et le choix réel qui peut être différent si le nombre de solutions a diminué depuis et que la solution n'est plus possible.
+ \param i : solution qu l'on choisit
+ */
+ virtual void Choisir (const int &i);
+
+ //! Fonction
+ /*!
+ Envoie la liste des possibilités dans la socket passée en paramètre. On envoie d'abord le nombre de solutions puis les solutions elles mêmes. Selon la forme le format d'envoi est différent.
+ \param sock : Socket dans laquelle on envoit la liste.
+ */
+ virtual void EnvoyerSolutions(Socket *sock) const=0;
+
+ //! Fonction.
+ /*!
+ Ajoute un objet dépendant de cet objet.
+ \param o : pointeur sur l'objet dépendant de cet objet à rajouter.
+ */
+ void AjouterEnfant (Objet *o);
+
+ protected :
+ //! Donnée protégée.
+ /*!
+ Nombre de possibilités de construction selon le dernier calcul de coordonnées.
+ */
+ int possibilites;
+ //! Donnée protégée.
+ /*!
+ Indice de la solution retenue.
+ */
+ int retenu;
+
+ //! Fonction.
+ /*!
+ Fonction qui va recalculer les coordonnées des objets dépendants de celui ci.
+ */
+ void CalculerDependants();
+
+ private :
+ //! Donnée privée.
+ /*!
+ Liste des objets construits par contraintes sur cet objet.
+ */
+ list<Objet *> enfants;
+};
+
+#endif
--- /dev/null
+CPPC = g++
+OBJS = Objet.o CPoint.o CDroite.o CCercle.o CPointIsole.o CPointAppart1D.o CPointAppart1C.o CPointInter2D.o CPointInter2C.o CPointInter1C1D.o CPointMilieu2P.o CPointCentre1C.o CDtePassant2P.o CDteHorizPassant1P.o CDteVertPassant1P.o CDtePerp1DPassant1P.o CDteParall1D.o CDteParall1DPassant1P.o CDteMediatrice2P.o CCerclePassant3P.o CCerclePassant1P.o CCercleTangent2D.o
+
+contraintes : $(OBJS)
+
+Objet.o : Objet.h ../Connexion/Socket.h
+ $(CPPC) -c Objet.cpp
+
+CPoint.o : CPoint.h CPoint.cpp ../Formes/Point.h Objet.h
+ $(CPPC) -c CPoint.cpp
+
+CDroite.o : CDroite.h CDroite.cpp ../Formes/Droite.h Objet.h
+ $(CPPC) -c CDroite.cpp
+
+CCercle.o : CCercle.h CCercle.cpp ../Formes/Cercle.h Objet.h
+ $(CPPC) -c CCercle.cpp
+
+#Point 1
+CPointIsole.o : CPointIsole.h CPointIsole.cpp CPoint.h
+ $(CPPC) -c CPointIsole.cpp
+
+#Point 2
+CPointAppart1D.o : CPointAppart1D.h CPointAppart1D.cpp CPoint.h CDroite.h
+ $(CPPC) -c CPointAppart1D.cpp
+
+#Point 3
+CPointAppart1C.o : CPointAppart1C.h CPointAppart1C.cpp CPoint.h CCercle.h
+ $(CPPC) -c CPointAppart1C.cpp
+
+#Point 4
+CPointInter2D.o : CPointInter2D.h CPointInter2D.cpp CDroite.h CPoint.h
+ $(CPPC) -c CPointInter2D.cpp
+
+#Point 5
+CPointInter2C.o : CPointInter2C.h CPointInter2C.cpp CDroite.h CPoint.h
+ $(CPPC) -c CPointInter2C.cpp
+
+#Point 6
+CPointInter1C1D.o : CPointInter1C1D.h CPointInter1C1D.cpp CDroite.h CPoint.h
+ $(CPPC) -c CPointInter1C1D.cpp
+
+#Point 7
+CPointMilieu2P.o : CPointMilieu2P.h CPointMilieu2P.cpp CPoint.h
+ $(CPPC) -c CPointMilieu2P.cpp
+
+#Point 8
+CPointCentre1C.o : CPointCentre1C.h CPointCentre1C.cpp CPoint.h CCercle.h
+ $(CPPC) -c CPointCentre1C.cpp
+
+
+#Droite 1
+CDtePassant2P.o : CDtePassant2P.h CDtePassant2P.cpp CDroite.h CPoint.h
+ $(CPPC) -c CDtePassant2P.cpp
+
+#Droite 2
+CDteHorizPassant1P.o : CDteHorizPassant1P.h CDteHorizPassant1P.cpp CDroite.h CPoint.h
+ $(CPPC) -c CDteHorizPassant1P.cpp
+
+#Droite 3
+CDteVertPassant1P.o : CDteVertPassant1P.h CDteVertPassant1P.cpp CDroite.h CPoint.h
+ $(CPPC) -c CDteVertPassant1P.cpp
+
+#Droite 4
+CDtePerp1DPassant1P.o : CDtePerp1DPassant1P.h CDtePerp1DPassant1P.cpp CDroite.h CPoint.h
+ $(CPPC) -c CDtePerp1DPassant1P.cpp
+
+#Droite 5
+CDteParall1D.o : CDteParall1D.h CDteParall1D.cpp CDroite.h CPoint.h
+ $(CPPC) -c CDteParall1D.cpp
+
+#Droite 6
+CDteParall1DPassant1P.o : CDteParall1DPassant1P.h CDteParall1DPassant1P.cpp CDroite.h CPoint.h
+ $(CPPC) -c CDteParall1DPassant1P.cpp
+
+#Droite 7
+CDteMediatrice2P.o : CDteMediatrice2P.h CDteMediatrice2P.cpp CDroite.h CPoint.h
+ $(CPPC) -c CDteMediatrice2P.cpp
+
+#Cercle 1
+CCerclePassant3P.o : CCerclePassant3P.h CCerclePassant3P.cpp CPoint.h CDroite.h CCercle.h
+ $(CPPC) -c CCerclePassant3P.cpp
+
+#Cercle 2 et 3
+CCerclePassant1P.o : CCerclePassant1P.h CCerclePassant1P.cpp CPoint.h CCercle.h
+ $(CPPC) -c CCerclePassant1P.cpp
+
+#Cercle 4
+CCercleTangent2D.o : CCercleTangent2D.h CCercleTangent2D.cpp CPoint.h CDroite.h CCercle.h
+ $(CPPC) -c CCercleTangent2D.cpp
+
+#Cercle 5
+#Cercle 6
+#Cercle 7
+
+clean :
+ rm *.o
--- /dev/null
+# Doxyfile 1.3.5
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME = Dessin
+PROJECT_NUMBER = 0
+OUTPUT_DIRECTORY = /home/tom/public_html/
+OUTPUT_LANGUAGE = French
+USE_WINDOWS_ENCODING = NO
+BRIEF_MEMBER_DESC = YES
+REPEAT_BRIEF = YES
+ABBREVIATE_BRIEF =
+ALWAYS_DETAILED_SEC = YES
+INLINE_INHERITED_MEMB = YES
+FULL_PATH_NAMES = NO
+STRIP_FROM_PATH =
+SHORT_NAMES = NO
+JAVADOC_AUTOBRIEF = NO
+MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP = NO
+INHERIT_DOCS = NO
+DISTRIBUTE_GROUP_DOC = NO
+TAB_SIZE = 8
+ALIASES =
+OPTIMIZE_OUTPUT_FOR_C = YES
+OPTIMIZE_OUTPUT_JAVA = NO
+SUBGROUPING = YES
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL = YES
+EXTRACT_PRIVATE = YES
+EXTRACT_STATIC = YES
+EXTRACT_LOCAL_CLASSES = YES
+HIDE_UNDOC_MEMBERS = NO
+HIDE_UNDOC_CLASSES = NO
+HIDE_FRIEND_COMPOUNDS = NO
+HIDE_IN_BODY_DOCS = NO
+INTERNAL_DOCS = NO
+CASE_SENSE_NAMES = YES
+HIDE_SCOPE_NAMES = YES
+SHOW_INCLUDE_FILES = YES
+INLINE_INFO = NO
+SORT_MEMBER_DOCS = YES
+GENERATE_TODOLIST = NO
+GENERATE_TESTLIST = NO
+GENERATE_BUGLIST = NO
+GENERATE_DEPRECATEDLIST= NO
+ENABLED_SECTIONS =
+MAX_INITIALIZER_LINES = 30
+SHOW_USED_FILES = YES
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET = NO
+WARNINGS = YES
+WARN_IF_UNDOCUMENTED = YES
+WARN_IF_DOC_ERROR = YES
+WARN_FORMAT = "$file:$line: $text"
+WARN_LOGFILE =
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT =
+FILE_PATTERNS =
+RECURSIVE = YES
+EXCLUDE =
+EXCLUDE_SYMLINKS = NO
+EXCLUDE_PATTERNS =
+EXAMPLE_PATH =
+EXAMPLE_PATTERNS =
+EXAMPLE_RECURSIVE = NO
+IMAGE_PATH =
+INPUT_FILTER =
+FILTER_SOURCE_FILES = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER = YES
+INLINE_SOURCES = YES
+STRIP_CODE_COMMENTS = YES
+REFERENCED_BY_RELATION = YES
+REFERENCES_RELATION = YES
+VERBATIM_HEADERS = YES
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX = YES
+COLS_IN_ALPHA_INDEX = 4
+IGNORE_PREFIX =
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML = YES
+HTML_OUTPUT =
+HTML_FILE_EXTENSION = .html
+HTML_HEADER =
+HTML_FOOTER =
+HTML_STYLESHEET =
+HTML_ALIGN_MEMBERS = YES
+GENERATE_HTMLHELP = NO
+CHM_FILE =
+HHC_LOCATION =
+GENERATE_CHI = NO
+BINARY_TOC = NO
+TOC_EXPAND = NO
+DISABLE_INDEX = NO
+ENUM_VALUES_PER_LINE = 4
+GENERATE_TREEVIEW = NO
+TREEVIEW_WIDTH = 250
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX = NO
+LATEX_OUTPUT = latex
+LATEX_CMD_NAME = latex
+MAKEINDEX_CMD_NAME = makeindex
+COMPACT_LATEX = NO
+PAPER_TYPE = a4
+EXTRA_PACKAGES =
+LATEX_HEADER =
+PDF_HYPERLINKS = NO
+USE_PDFLATEX = YES
+LATEX_BATCHMODE = NO
+LATEX_HIDE_INDICES = NO
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF = NO
+RTF_OUTPUT = rtf
+COMPACT_RTF = NO
+RTF_HYPERLINKS = NO
+RTF_STYLESHEET_FILE =
+RTF_EXTENSIONS_FILE =
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN = NO
+MAN_OUTPUT = man
+MAN_EXTENSION = .3
+MAN_LINKS = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML = NO
+XML_OUTPUT = xml
+XML_SCHEMA =
+XML_DTD =
+XML_PROGRAMLISTING = YES
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF = NO
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD = NO
+PERLMOD_LATEX = NO
+PERLMOD_PRETTY = YES
+PERLMOD_MAKEVAR_PREFIX =
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING = YES
+MACRO_EXPANSION = NO
+EXPAND_ONLY_PREDEF = NO
+SEARCH_INCLUDES = NO
+INCLUDE_PATH =
+INCLUDE_FILE_PATTERNS =
+PREDEFINED =
+EXPAND_AS_DEFINED =
+SKIP_FUNCTION_MACROS = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to external references
+#---------------------------------------------------------------------------
+TAGFILES =
+GENERATE_TAGFILE =
+ALLEXTERNALS = NO
+EXTERNAL_GROUPS = YES
+PERL_PATH = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS = YES
+HIDE_UNDOC_RELATIONS = NO
+HAVE_DOT = NO
+CLASS_GRAPH = YES
+COLLABORATION_GRAPH = YES
+UML_LOOK = YES
+TEMPLATE_RELATIONS = NO
+INCLUDE_GRAPH = YES
+INCLUDED_BY_GRAPH = YES
+CALL_GRAPH = NO
+GRAPHICAL_HIERARCHY = YES
+DOT_IMAGE_FORMAT = png
+DOT_PATH =
+DOTFILE_DIRS =
+MAX_DOT_GRAPH_WIDTH = 1024
+MAX_DOT_GRAPH_HEIGHT = 1024
+MAX_DOT_GRAPH_DEPTH = 0
+GENERATE_LEGEND = YES
+DOT_CLEANUP = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to the search engine
+#---------------------------------------------------------------------------
+SEARCHENGINE = NO
--- /dev/null
+#include "Cercle.h"
+
+Cercle::Cercle()
+:centre(0,0),rayon(0)
+{}
+
+Cercle::Cercle(const Cercle &c)
+:centre(c.centre),rayon(c.rayon)
+{}
+
+Cercle::Cercle(const Point &c, const double &r)
+:centre(c),rayon(r)
+{}
+
+Cercle::~Cercle()
+{}
+
+Point Cercle::GetCentre() const
+{
+ return centre;
+}
+
+void Cercle::SetCentre(const Point &c)
+{
+ centre = Point(c);
+}
+
+double Cercle::GetRayon() const
+{
+ return rayon;
+}
+
+void Cercle::SetRayon(const double &r)
+{
+ rayon = r;
+}
+
+Cercle &Cercle::operator =(const Cercle &c)
+{
+ rayon = c.rayon;
+ centre = c.centre;
+ return *this;
+}
+
+bool Cercle::operator==(const Cercle &c) const
+{
+ return rayon == c.rayon && centre == c.centre;
+}
+
+bool Cercle::operator!=(const Cercle &c) const
+{
+ return rayon != c.rayon && centre != c.centre;
+}
--- /dev/null
+#ifndef __CERCLE__
+#define __CERCLE__
+
+#include "Point.h"
+
+#include "../Global.h"
+
+//! Classe Cercle.
+/*!
+ Définit un Cercle à partir d'un centre et d'un rayon.
+*/
+class Cercle
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit un cercle avec un centre à (0,0) et un rayon 0. Ce constructeur ne devrait pas être appelé en théorie.
+ */
+ Cercle();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ \param c : cercle à copier.
+ */
+ Cercle(const Cercle &c);
+ //! Constructeur.
+ /*!
+ Constructeur à partir d'un point et d'un entier.
+ \param centre : Point qui représente le centre du cercle.
+ \param rayon : rayon du cercle à créer.
+ */
+ Cercle(const Point ¢re, const double &rayon);
+ //! Destructeur.
+ /*!
+ Destructeur. On ne fait rien dedans.
+ */
+ ~Cercle();
+
+ //! Accesseur.
+ /*!
+ \return Le centre du cercle.
+ */
+ Point GetCentre() const;
+ //! Accesseur.
+ /*!
+ Modifie le centre du cercle.
+ */
+ void SetCentre(const Point &);
+ //! Accesseur.
+ /*!
+ \return Le rayon du cercle.
+ */
+ double GetRayon() const;
+ //! Accesseur.
+ /*!
+ Modifie le rayon du cercle.
+ */
+ void SetRayon(const double &);
+
+ Cercle &operator=(const Cercle &c);
+
+ bool operator==(const Cercle &c) const;
+ bool operator!=(const Cercle &c) const;
+
+ protected :
+ //! Donnée protégée.
+ /*!
+ Centre du cercle.
+ */
+ Point centre;
+ //! Donnée protégée.
+ /*!
+ Rayon du cercle.
+ */
+ double rayon;
+};
+
+#endif
--- /dev/null
+#include "Droite.h"
+
+#include "values.h"
+#include "math.h"
+#include "../Global.h"
+
+Droite::Droite()
+:a(0),b(0),c(0)
+{}
+
+Droite::Droite(const Droite &d)
+:a(d.a),b(d.b),c(d.c)
+{}
+
+Droite::Droite(const double &aa, const double &bb, const double &cc)
+:a(aa),b(bb),c(cc)
+{
+ //on va normaliser les coordonnées pour avoir des constantes plus petites
+ double norme = sqrt(a*a + b*b);
+ if (fabs(norme) > EPSILON)
+ {
+ a /= norme;
+ b /= norme;
+ c /= norme;
+ }
+}
+
+Droite::Droite(const Point &p1, const Point &p2)
+:a(p2.GetY() - p1.GetY()),b(p1.GetX() - p2.GetX()),c(p1.GetY()*(p2.GetX() - p1.GetX()) - p1.GetX()*(p2.GetY() - p1.GetY()))
+{
+ //on va normaliser les coordonnées pour avoir des constantes plus petites
+ double norme = sqrt(a*a + b*b);
+ if (fabs(norme) > EPSILON)
+ {
+ a /= norme;
+ b /= norme;
+ c /= norme;
+ }
+}
+
+Droite::~Droite()
+{}
+
+double Droite::A() const
+{
+ return a;
+}
+
+void Droite::SetA(const double &aa)
+{
+ a = aa;
+}
+
+double Droite::B() const
+{
+ return b;
+}
+
+void Droite::SetB(const double &bb)
+{
+ b = bb;
+}
+
+double Droite::C() const
+{
+ return c;
+}
+
+void Droite::SetC(const double &cc)
+{
+ c = cc;
+}
+
+double Droite::GetPente() const
+{
+ if (fabs(b) < EPSILON)
+ return MAXDOUBLE;
+ else
+ return -a/b;
+}
+
+Droite &Droite::operator =(const Droite &d)
+{
+ a = d.a;
+ b = d.b;
+ c = d.c;
+ return *this;
+}
+
+bool Droite::operator==(const Droite &d) const
+{
+ return (fabs(a - d.a) < EPSILON && fabs(b - d.b) < EPSILON && fabs(c - d.c) < EPSILON);
+}
+
+bool Droite::operator!=(const Droite &d) const
+{
+ return !(d == *this);
+}
--- /dev/null
+#ifndef __DROITE__
+#define __DROITE__
+
+#include "Point.h"
+
+#include "../Global.h"
+
+//! Classe Droite.
+/*!
+ Définit une Droite par son équation cartésienne.
+*/
+class Droite
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit une droite d'équation 0x + 0y +0 = 0. Cela ne doit pas être appelé en théorie.
+ */
+ Droite();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param d : droite que l'on veut copier.
+ */
+ Droite(const Droite &d);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de trois réels. Ces réels représentent les constants a, b et c de l'équation cartésienne : ax + by + c = 0
+ param a : première constante.
+ param b : deuxième constante.
+ param c : troisième constante.
+ */
+ Droite(const double &a, const double &b, const double &c);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de deux points. Les deux points sont deux points par lesquels passent la droite.
+ param p1 : premier point.
+ param p2 : deuxième point.
+ */
+ Droite(const Point &p1, const Point &p2);
+ //Droite(const Point *, const double &pente);
+ //! Destructeur.
+ /*!
+ Destructeur. On ne fait rien dedans.
+ */
+ ~Droite();
+
+ //! Accesseur.
+ /*!
+ \return La constante a de l'équation cartésienne de la droite.
+ */
+ double A() const;
+ //! Accesseur.
+ /*!
+ Modifie la constante a de l'équation cartésienne de la droite.
+ */
+ void SetA(const double &a);
+ //! Accesseur.
+ /*!
+ \return La constante b de l'équation cartésienne de la droite.
+ */
+ double B() const;
+ //! Accesseur.
+ /*!
+ Modifie la constante b de l'équation cartésienne de la droite.
+ */
+ void SetB(const double &b);
+ //! Accesseur.
+ /*!
+ \return La constante c de l'équation cartésienne de la droite.
+ */
+ double C() const;
+ //! Accesseur.
+ /*!
+ Modifie la constante c de l'équation cartésienne de la droite.
+ */
+ void SetC(const double &c);
+
+ //! Fonction.
+ /*!
+ Cette fonction retourne la pente de la droite. En cas de pente infinie (droite de type x = c) on retourne DBL_MAX
+ \return La pente de la droite.
+ */
+ double GetPente() const;
+
+
+ Droite &operator=(const Droite &d);
+
+ bool operator==(const Droite &d) const;
+ bool operator!=(const Droite &d) const;
+
+ protected :
+ //! Donnée protégée.
+ /*!
+ constante a de l'équation cartésienne de la droite.
+ */
+ double a;
+ //! Donnée protégée.
+ /*!
+ constante b de l'équation cartésienne de la droite.
+ */
+ double b;
+ //! Donnée protégée.
+ /*!
+ constante c de l'équation cartésienne de la droite.
+ */
+ double c;
+};
+
+#endif
--- /dev/null
+#include "Point.h"
+
+Point::Point()
+:x(0),y(0)
+{}
+
+Point::Point(const Point &p)
+:x(p.x), y(p.y)
+{}
+
+Point::Point(const double &cx, const double &cy)
+:x(cx), y(cy)
+{}
+
+Point::~Point()
+{}
+
+double Point::GetX() const
+{
+ return x;
+}
+
+void Point::SetX(const double &cx)
+{
+ x =cx;
+}
+
+double Point::GetY() const
+{
+ return y;
+}
+
+void Point::SetY(const double &cy)
+{
+ y=cy;
+}
+
+Point &Point::operator =(const Point &p)
+{
+ x = p.x;
+ y = p.y;
+ return *this;
+}
+
+bool Point::operator==(const Point &p) const
+{
+ return x == p.x && y == p.y;
+}
+
+bool Point::operator!=(const Point &p) const
+{
+ return x != p.x || y != p.y;
+}
--- /dev/null
+#ifndef __POINT__
+#define __POINT__
+
+#include "../Global.h"
+
+//! Classe Point.
+/*!
+ Définit un Point en 2D.
+*/
+class Point
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Dans ce cas on contruit un point de coordonnées (0,0).
+ */
+ Point();
+ //! Constructeur.
+ /*!
+ Constructeur par copie.
+ param p : point à copier.
+ */
+ Point(const Point &p);
+ //! Constructeur.
+ /*!
+ Constructeur à partir de deux réels.
+ param x : coordonnée X du point.
+ param y : coordonnée Y du point.
+ */
+ Point(const double &x, const double &y);
+ //! Destructeur.
+ /*!
+ Destructeur. On ne fait rien dedans.
+ */
+ ~Point();
+
+ //! Accesseur.
+ /*!
+ \return La coordonnée X du point.
+ */
+ double GetX() const;
+ //! Accesseur.
+ /*!
+ Modifie la coordonnée X du point.
+ param x : Coordonnée x à mettre.
+ */
+ void SetX(const double &x);
+ //! Accesseur.
+ /*!
+ \return La coordonnée Y du point.
+ */
+ double GetY() const;
+ //! Accesseur.
+ /*!
+ Modifie la coordonnée Y du point.
+ param y : Coordonnée y à mettre.
+ */
+ void SetY(const double &y);
+
+ Point &operator=(const Point &p);
+
+ bool operator==(const Point &p) const;
+ bool operator!=(const Point &p) const;
+
+ protected :
+ //! Donnée protégée.
+ /*!
+ coordonnée X du point.
+ */
+ double x;
+ //! Donnée protégée.
+ /*!
+ coordonnée Y du point.
+ */
+ double y;
+};
+
+#endif
--- /dev/null
+CPPC = g++
+OBJS = Cercle.o Droite.o Point.o
+
+formes : $(OBJS)
+
+Cercle.o : Cercle.h Cercle.cpp Point.h ../Global.h
+ $(CPPC) -c Cercle.cpp
+
+Droite.o : Droite.h Droite.cpp Point.h ../Global.h
+ $(CPPC) -c Droite.cpp
+
+Point.o : Point.h Point.cpp ../Global.h
+ $(CPPC) -c Point.cpp
+
+clean :
+ rm *.o
\ No newline at end of file
--- /dev/null
+//definition des constantes inclusions ... globales (communes)
+#ifndef _GLOBAL_
+#define _GLOBAL_
+
+#define C_FORK 0
+#define C_THREAD 1
+
+#define MAX_CONNEXION 10
+#define TAILLE_BUFFER 256
+
+#define EPSILON 0.000001
+#define PUISS4(x) ((x)*(x)*(x)*(x))
+#define PUISS2(x) ((x)*(x))
+#define MAXIMUM(x,y) ((x)<(y) ? (y) : (x))
+
+//ce define permet de faire un affichage de ce qui se passe dans le serveur
+#define VERBOSE
+
+#endif
--- /dev/null
+#include "ListeCercles.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+#include <unistd.h>
+
+ListeCercles::ListeCercles()
+:courant(0)
+{
+ pthread_rwlock_init(&verrou,NULL);
+}
+
+ListeCercles::~ListeCercles()
+{
+ map<int,CCercle *>::iterator itliste;
+
+ //on va détruire tous les Cercles de la liste
+ pthread_rwlock_wrlock(&verrou);
+
+ for (itliste=liste.begin();itliste!=liste.end();++itliste)
+ delete (*itliste).second;
+
+ pthread_rwlock_unlock(&verrou);
+
+ pthread_rwlock_destroy(&verrou);
+}
+
+int ListeCercles::AjouterCercle(CCercle *c)
+{
+ pthread_rwlock_wrlock(&verrou);
+
+ int r = courant;
+ liste[r]=c;
+ courant++;
+
+ pthread_rwlock_unlock(&verrou);
+
+ return r;
+}
+
+void ListeCercles::SupprCercle(const int &i)
+{
+ map<int,CCercle *>::iterator itliste;
+
+ pthread_rwlock_wrlock(&verrou);
+
+ //recherche de l'élément à supprimer
+ for (itliste=liste.begin() ; itliste!=liste.end(), (*itliste).first != i ; ++itliste);
+
+ //si l'élément i se trouve dans la liste
+ if (itliste!=liste.end())
+ {
+ liste.erase(itliste);
+ }
+
+ pthread_rwlock_unlock(&verrou);
+}
+
+CCercle *ListeCercles::GetCercle(const int &i)
+{
+ map<int,CCercle *>::iterator itliste;
+
+ pthread_rwlock_rdlock(&verrou);
+
+ //recherche de l'élément à supprimer
+ for (itliste=liste.begin();itliste!=liste.end();++itliste)
+ {
+ if ((*itliste).first == i)
+ {
+ pthread_rwlock_unlock(&verrou);
+ return (*itliste).second;
+ }
+ }
+
+ pthread_rwlock_unlock(&verrou);
+
+ return NULL;
+}
+
+int ListeCercles::NbCercles()
+{
+ map<int,CCercle *>::size_type nb;
+ nb = liste.size();
+ return int(nb);
+}
+
+void ListeCercles::EnvoyerListe(Socket *sock)
+{
+ char buffer[TAILLE_BUFFER];
+ map<int,CCercle *>::iterator itliste;
+ map<int,CCercle *>::size_type nb;
+
+ pthread_rwlock_rdlock(&verrou);
+
+ //envoi du nombre d'éléments dans la liste
+ nb = liste.size();
+ sprintf(buffer,"%d\n",int(nb));
+ sock->Ecrire(buffer);
+
+ //parcours de la liste pour envoyer les objets à afficher
+ for (itliste=liste.begin();itliste!=liste.end();++itliste)
+ {
+ const Cercle *sol = ((*itliste).second)->Solution();
+ //Si il y a une solution retenue on l'envoie
+ if (sol != NULL)
+ {
+ //numéro de Cercle, coordonnée X et Y du centre et rayon
+ sprintf(buffer,"%d %lf %lf %lf\n", (*itliste).first, sol->GetCentre().GetX(), sol->GetCentre().GetY(), sol->GetRayon());
+ sock->Ecrire(buffer);
+ }
+ else
+ {
+ //on dit que l'objet n'a pas de solutions
+ sprintf(buffer,"%d -1\n", (*itliste).first);
+ sock->Ecrire(buffer);
+ }
+ }
+
+ pthread_rwlock_unlock(&verrou);
+}
--- /dev/null
+#ifndef _LISTECERCLES_
+#define _LISTECERCLES_
+
+#include "../Connexion/Socket.h"
+#include "../Contraintes/CCercle.h"
+
+#include <pthread.h>
+#include <map>
+using namespace std;
+
+//! Classe ListeCercles.
+/*!
+ Cette classe sert à modéliser une liste qui fait la correspondance entre le numéro d'un Cercle et l'objet contraintes sur ce Cercle.
+*/
+class ListeCercles
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Le verrou d'accès à la liste est initialisé, ainsi que l'indice courant.
+ */
+ ListeCercles();
+ //! Destructeur.
+ /*!
+ Les éléments de la liste sont désalloué. Le verrou est détruit.
+ */
+ ~ListeCercles();
+
+ //! Fonction.
+ /*!
+ Cette fonction ajoute un Cercle dans la liste.
+ \param c : Pointeur sur un objet de contraintes de Cercle à ajouter
+ \return : le numéro qui a été attribué au cercle
+ */
+ int AjouterCercle(CCercle *c);
+ //! Fonction.
+ /*!
+ Cette fonction enlève un cercle à la liste.
+ \param i : numéro du Cercle à supprimer
+ */
+ void SupprCercle(const int &i);
+
+ //! Fonction.
+ /*!
+ \param i : numéro du Cercle à récupérer
+ \return le Cercle i
+ */
+ CCercle *GetCercle(const int &i);
+
+ //! Accesseur.
+ /*!
+ \return le nombre de Cercles dans la liste.
+ */
+ int NbCercles();
+
+ //! Fonction.
+ /*!
+ Cette fonction envoie la liste des Cercles dans une socket.
+ \param s : socket dans laquelle on va envoyer
+ */
+ void EnvoyerListe(Socket *s);
+
+ private :
+ //! Donnée privée.
+ /*!
+ Liste réelle.
+ */
+ map<int,CCercle *> liste;
+
+ //! Donnée privée.
+ /*!
+ Prochain numéro de Cercle à attribuer. A chaque fois qu'on crée un Cercle on lui associe ce nombre et on incrémente la variable.
+ */
+ int courant;
+
+ //! Donnée privée.
+ /*!
+ Verrou qui permnet de réguler les accès à la liste.
+ */
+ pthread_rwlock_t verrou;
+};
+#endif
--- /dev/null
+#include "ListeCompo.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+#include <unistd.h>
+
+ListeCompo::ListeCompo()
+{
+ pthread_rwlock_init(&verrou,NULL);
+}
+
+ListeCompo::~ListeCompo()
+{
+ pthread_rwlock_destroy(&verrou);
+}
+
+void ListeCompo::AjouterCompo(const char *nom, const int &port)
+{
+ pthread_rwlock_wrlock(&verrou);
+
+ liste[string(nom)]=port;
+
+ pthread_rwlock_unlock(&verrou);
+}
+
+void ListeCompo::EnvoyerListe(Socket *sock)
+{
+ char buffer[TAILLE_BUFFER];
+ map<string,int>::iterator itliste;
+ map<string,int>::size_type nb;
+
+ pthread_rwlock_rdlock(&verrou);
+
+ //envoi du nombre d'éléments dans la liste
+ nb = liste.size();
+ sprintf(buffer,"%d\r\n",int(nb));
+ sock->Ecrire(buffer);
+
+ //parcours de la liste pour envoyer le nom des compositions
+ for (itliste=liste.begin();itliste!=liste.end();++itliste)
+ {
+ sprintf(buffer,"%s\r\n",((*itliste).first).c_str());
+ sock->Ecrire(buffer);
+ }
+
+ pthread_rwlock_unlock(&verrou);
+}
+
+void ListeCompo::SupprCompo(const int &i)
+{
+ char buffer[TAILLE_BUFFER];
+ int j;
+ map<string,int>::iterator itliste;
+
+ pthread_rwlock_wrlock(&verrou);
+
+ //recherche de l'élément à supprimer
+ for (itliste=liste.begin(),j=0;itliste!=liste.end(),j<i;++itliste,j++);
+
+ //si l'élément i se trouve dans la liste
+ if (itliste!=liste.end())
+ {
+ liste.erase(itliste);
+ }
+
+ pthread_rwlock_unlock(&verrou);
+}
+
+void ListeCompo::SupprCompo(const char *nom)
+{
+ map<string,int>::iterator itliste;
+
+ pthread_rwlock_wrlock(&verrou);
+
+ //recherche de l'élément à supprimer
+ for (itliste=liste.begin();itliste!=liste.end();++itliste)
+ {
+ if ((*itliste).first == string(nom))
+ {
+ liste.erase(itliste);
+ pthread_rwlock_unlock(&verrou);
+ return;
+ }
+ }
+
+ pthread_rwlock_unlock(&verrou);
+}
+
+
+int ListeCompo::GetPortOfCompo(const char *nom)
+{
+ map<string,int>::iterator itliste;
+
+ pthread_rwlock_rdlock(&verrou);
+
+ //recherche de l'élément à supprimer
+ for (itliste=liste.begin();itliste!=liste.end();++itliste)
+ {
+ if ((*itliste).first == string(nom))
+ {
+ pthread_rwlock_unlock(&verrou);
+ return (*itliste).second;
+ }
+ }
+
+ pthread_rwlock_unlock(&verrou);
+
+ return -1;
+}
+
+int ListeCompo::NbCompo()
+{
+ map<string,int>::size_type nb;
+
+ nb = liste.size();
+ return int(nb);
+}
--- /dev/null
+#ifndef _LISTECOMPO_
+#define _LISTECOMPO_
+
+
+#include "../Connexion/Socket.h"
+#include <pthread.h>
+#include <map>
+using namespace std;
+
+//! Classe ListeCompo.
+/*!
+ Cette classe sert à modéliser une liste qui permet de faire la correspondance entre une composition et le numéro de port du serveur qui lui est assoocié.
+*/
+class ListeCompo
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Par défaut la liste contient 0 éléments et le pointeur sur la liste vaut NULL. Le verrou d'accès à la liste est initialisé.
+ */
+ ListeCompo();
+ //! Destructeur.
+ /*!
+ Les éléments de la liste sont désalloué. Le verrou est détruit.
+ */
+ ~ListeCompo();
+
+ //! Fonction.
+ /*!
+ Cette fonction ajoute une compo dans la liste.
+ \param nom : nom de la composition à ajouter
+ \param port : port de la composition à ajouter
+ */
+ void AjouterCompo(const char *nom, const int &port);
+ //! Fonction.
+ /*!
+ Cette fonction enlève une compo à la liste.
+ \param i : index de la composition à supprimer
+ */
+ void SupprCompo(const int &i);
+ //! Fonction.
+ /*!
+ Cette fonction enlève une compo à la liste.
+ \param nom : nom de la composition à supprimer
+ */
+ void SupprCompo(const char *nom);
+
+ //! Fonction.
+ /*!
+ \param nom : nom de la composition dont on cherche le port
+ \return le port associé au nom donné en paramètre si la composition existe et -1 sinon.
+ */
+ int GetPortOfCompo(const char *nom);
+
+// //! Accesseur.
+// /*!
+// \return la première compo de la liste.
+// */
+// CompoInfo *FirstCompo();
+// //! Accesseur.
+// /*!
+// \param ci : élément dont on veut le suivant
+// \return la compo suivante dans la liste.
+// */
+// CompoInfo * NextCompo(CompoInfo *ci);
+ //! Accesseur.
+ /*!
+ \return le nombre de compos dans la liste.
+ */
+ int NbCompo();
+
+ //! Fonction.
+ /*!
+ Cette fonction envoie la liste des compos dans une socket.
+ \param s : socket dans laquelle on va envoyer
+ */
+ void EnvoyerListe(Socket *s);
+
+ private :
+ //! Donnée privée.
+ /*!
+ Liste réelle.
+ */
+ //CompoElement *liste;
+ map<string,int> liste;
+
+ //! Donnée privée.
+ /*!
+ Verrou qui permnet de réguler les accès à la liste.
+ */
+ pthread_rwlock_t verrou;
+};
+#endif
--- /dev/null
+#include "ListeDroites.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+#include <unistd.h>
+
+ListeDroites::ListeDroites()
+:courant(0)
+{
+ pthread_rwlock_init(&verrou,NULL);
+}
+
+ListeDroites::~ListeDroites()
+{
+ map<int,CDroite *>::iterator itliste;
+
+ //on va détruire tous les Droites de la liste
+ pthread_rwlock_wrlock(&verrou);
+
+ for (itliste=liste.begin();itliste!=liste.end();++itliste)
+ delete (*itliste).second;
+
+ pthread_rwlock_unlock(&verrou);
+
+ pthread_rwlock_destroy(&verrou);
+}
+
+int ListeDroites::AjouterDroite(CDroite *c)
+{
+ pthread_rwlock_wrlock(&verrou);
+
+ int r = courant;
+ liste[r]=c;
+ courant++;
+
+ pthread_rwlock_unlock(&verrou);
+ return r;
+}
+
+void ListeDroites::SupprDroite(const int &i)
+{
+ map<int,CDroite *>::iterator itliste;
+
+ pthread_rwlock_wrlock(&verrou);
+
+ //recherche de l'élément à supprimer
+ for (itliste=liste.begin() ; itliste!=liste.end(), (*itliste).first != i ; ++itliste);
+
+ //si l'élément i se trouve dans la liste
+ if (itliste!=liste.end())
+ liste.erase(itliste);
+
+ pthread_rwlock_unlock(&verrou);
+}
+
+CDroite *ListeDroites::GetDroite(const int &i)
+{
+ map<int,CDroite *>::iterator itliste;
+
+ pthread_rwlock_rdlock(&verrou);
+
+ //recherche de l'élément à supprimer
+ for (itliste=liste.begin();itliste!=liste.end();++itliste)
+ {
+ if ((*itliste).first == i)
+ {
+ pthread_rwlock_unlock(&verrou);
+ return (*itliste).second;
+ }
+ }
+
+ pthread_rwlock_unlock(&verrou);
+
+ return NULL;
+}
+
+int ListeDroites::NbDroites()
+{
+ map<int,CDroite *>::size_type nb;
+ nb = liste.size();
+ return int(nb);
+}
+
+void ListeDroites::EnvoyerListe(Socket *sock)
+{
+ char buffer[TAILLE_BUFFER];
+ map<int,CDroite *>::iterator itliste;
+ map<int,CDroite *>::size_type nb;
+
+ pthread_rwlock_rdlock(&verrou);
+
+ //envoi du nombre d'éléments dans la liste
+ nb = liste.size();
+ sprintf(buffer,"%d\n",int(nb));
+ sock->Ecrire(buffer);
+
+ //parcours de la liste pour envoyer les objets à afficher
+ for (itliste=liste.begin();itliste!=liste.end();++itliste)
+ {
+ const Droite *sol = ((*itliste).second)->Solution();
+ //Si il y a une solution retenue on l'envoie
+ if (sol != NULL)
+ {
+ //numéro de Droite, constantes a, b et c de l'équation cartésienne de la droite
+ sprintf(buffer,"%d %lf %lf %lf\n", (*itliste).first, sol->A(), sol->B(), sol->C());
+ sock->Ecrire(buffer);
+ }
+ else
+ {
+ //on dit que l'objet n'a pas de solutions
+ sprintf(buffer,"%d -1\n", (*itliste).first);
+ sock->Ecrire(buffer);
+ }
+ }
+
+ pthread_rwlock_unlock(&verrou);
+}
--- /dev/null
+#ifndef _LISTEDROITES_
+#define _LISTEDROITES_
+
+#include "../Connexion/Socket.h"
+#include "../Contraintes/CDroite.h"
+
+#include <pthread.h>
+#include <map>
+using namespace std;
+
+//! Classe ListeDroites.
+/*!
+ Cette classe sert à modéliser une liste qui fait la correspondance entre le numéro d'un Droite et l'objet contraintes sur ce Droite.
+*/
+class ListeDroites
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Le verrou d'accès à la liste est initialisé, ainsi que l'indice courant.
+ */
+ ListeDroites();
+ //! Destructeur.
+ /*!
+ Les éléments de la liste sont désalloué. Le verrou est détruit.
+ */
+ ~ListeDroites();
+
+ //! Fonction.
+ /*!
+ Cette fonction ajoute un Droite dans la liste.
+ \param d : Pointeur sur un objet de contraintes de Droite à ajouter.
+ \return : le numéro qui a été attribué à la droite.
+ */
+ int AjouterDroite(CDroite *d);
+ //! Fonction.
+ /*!
+ Cette fonction enlève un Droite à la liste.
+ \param i : numéro du Droite à supprimer
+ */
+ void SupprDroite(const int &i);
+
+ //! Fonction.
+ /*!
+ \param i : numéro du Droite à récupérer
+ \return le Droite i
+ */
+ CDroite *GetDroite(const int &i);
+
+ //! Accesseur.
+ /*!
+ \return le nombre de Droites dans la liste.
+ */
+ int NbDroites();
+
+ //! Fonction.
+ /*!
+ Cette fonction envoie la liste des Droites dans une socket.
+ \param s : socket dans laquelle on va envoyer
+ */
+ void EnvoyerListe(Socket *s);
+
+ private :
+ //! Donnée privée.
+ /*!
+ Liste réelle.
+ */
+ map<int,CDroite *> liste;
+
+ //! Donnée privée.
+ /*!
+ Prochain numéro de Droite à attribuer. A chaque fois qu'on crée un Droite on lui associe ce nombre et on incrémente la variable.
+ */
+ int courant;
+
+ //! Donnée privée.
+ /*!
+ Verrou qui permnet de réguler les accès à la liste.
+ */
+ pthread_rwlock_t verrou;
+};
+#endif
--- /dev/null
+#include "ListePoints.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+#include <unistd.h>
+
+ListePoints::ListePoints()
+:courant(0)
+{
+ pthread_rwlock_init(&verrou,NULL);
+}
+
+ListePoints::~ListePoints()
+{
+ map<int,CPoint *>::iterator itliste;
+
+ //on va détruire tous les points de la liste
+ pthread_rwlock_wrlock(&verrou);
+
+ for (itliste=liste.begin();itliste!=liste.end();++itliste)
+ delete (*itliste).second;
+
+ pthread_rwlock_unlock(&verrou);
+
+ pthread_rwlock_destroy(&verrou);
+}
+
+int ListePoints::AjouterPoint(CPoint *p)
+{
+ pthread_rwlock_wrlock(&verrou);
+
+ int r = courant;
+ liste[r]=p;
+ courant++;
+
+ pthread_rwlock_unlock(&verrou);
+ return r;
+}
+
+void ListePoints::SupprPoint(const int &i)
+{
+ map<int,CPoint *>::iterator itliste;
+
+ pthread_rwlock_wrlock(&verrou);
+
+ //recherche de l'élément à supprimer
+ for (itliste=liste.begin() ; itliste!=liste.end(), (*itliste).first != i ; ++itliste);
+
+ //si l'élément i se trouve dans la liste
+ if (itliste!=liste.end())
+ {
+ liste.erase(itliste);
+ }
+
+ pthread_rwlock_unlock(&verrou);
+}
+
+CPoint *ListePoints::GetPoint(const int &i)
+{
+ map<int,CPoint *>::iterator itliste;
+
+ pthread_rwlock_rdlock(&verrou);
+
+ //recherche de l'élément à supprimer
+ for (itliste=liste.begin();itliste!=liste.end();++itliste)
+ {
+ if ((*itliste).first == i)
+ {
+ CPoint *cp = (*itliste).second;
+ pthread_rwlock_unlock(&verrou);
+ return cp;
+ }
+ }
+
+ pthread_rwlock_unlock(&verrou);
+
+ return NULL;
+}
+
+int ListePoints::NbPoints()
+{
+ map<int,CPoint *>::size_type nb;
+
+ nb = liste.size();
+ return int(nb);
+}
+
+void ListePoints::EnvoyerListe(Socket *sock)
+{
+ char buffer[TAILLE_BUFFER];
+ map<int,CPoint *>::iterator itliste;
+ map<int,CPoint *>::size_type nb;
+
+ pthread_rwlock_rdlock(&verrou);
+
+ //envoi du nombre d'éléments dans la liste
+ nb = liste.size();
+ sprintf(buffer,"%d\n",int(nb));
+ sock->Ecrire(buffer);
+
+ //parcours de la liste pour envoyer les objets à afficher
+ for (itliste=liste.begin();itliste!=liste.end();++itliste)
+ {
+ const Point *sol = ((*itliste).second)->Solution();
+ //Si il y a une solution retenue on l'envoie
+ if (sol != NULL)
+ {
+ //numéro de point, coordonnée X et Y
+ sprintf(buffer,"%d %lf %lf\n", (*itliste).first, sol->GetX(), sol->GetY());
+ sock->Ecrire(buffer);
+ }
+ else
+ {
+ //on dit que l'objet n'a pas de solutions
+ sprintf(buffer,"%d -1\n", (*itliste).first);
+ sock->Ecrire(buffer);
+ }
+ }
+
+ pthread_rwlock_unlock(&verrou);
+}
--- /dev/null
+#ifndef _LISTEPOINTS_
+#define _LISTEPOINTS_
+
+#include "../Connexion/Socket.h"
+#include "../Contraintes/CPoint.h"
+
+#include <pthread.h>
+#include <map>
+using namespace std;
+
+//! Classe ListePoints.
+/*!
+ Cette classe sert à modéliser une liste qui fait la correspondance entre le numéro d'un Point et l'objet contraintes sur ce Point.
+*/
+class ListePoints
+{
+ public :
+ //! Constructeur.
+ /*!
+ Constructeur par défaut. Le verrou d'accès à la liste est initialisé, ainsi que l'indice courant.
+ */
+ ListePoints();
+ //! Destructeur.
+ /*!
+ Les éléments de la liste sont désalloué. Le verrou est détruit.
+ */
+ ~ListePoints();
+
+ //! Fonction.
+ /*!
+ Cette fonction ajoute un point dans la liste.
+ \param p : pointeur sur un objet de contraintes de point à ajouter.
+ \return : le numéro qui a été attribué au point.
+ */
+ int AjouterPoint(CPoint *p);
+ //! Fonction.
+ /*!
+ Cette fonction enlève un point à la liste.
+ \param i : numéro du point à supprimer
+ */
+ void SupprPoint(const int &i);
+
+ //! Fonction.
+ /*!
+ \param i : numéro du point à récupérer
+ \return le point i
+ */
+ CPoint *GetPoint(const int &i);
+
+ //! Accesseur.
+ /*!
+ \return le nombre de points dans la liste.
+ */
+ int NbPoints();
+
+ //! Fonction.
+ /*!
+ Cette fonction envoie la liste des points dans une socket.
+ \param s : socket dans laquelle on va envoyer
+ */
+ void EnvoyerListe(Socket *s);
+
+ private :
+ //! Donnée privée.
+ /*!
+ Liste réelle.
+ */
+ map<int,CPoint *> liste;
+
+ //! Donnée privée.
+ /*!
+ Prochain numéro de point à attribuer. A chaque fois qu'on crée un point on lui associe ce nombre et on incrémente la variable.
+ */
+ int courant;
+
+ //! Donnée privée.
+ /*!
+ Verrou qui permnet de réguler les accès à la liste.
+ */
+ pthread_rwlock_t verrou;
+};
+#endif
--- /dev/null
+CPPC = g++
+OBJS = ListeCompo.o ListePoints.o ListeCercles.o ListeDroites.o
+
+compo : $(OBJS)
+
+ListeCompo.o : ListeCompo.h ListeCompo.cpp ../Connexion/Socket.h
+ $(CPPC) -c ListeCompo.cpp
+
+ListePoints.o : ListePoints.h ListePoints.cpp ../Contraintes/CPoint.h ../Connexion/Socket.h
+ $(CPPC) -c ListePoints.cpp
+
+ListeDroites.o : ListeDroites.h ListeDroites.cpp ../Contraintes/CDroite.h ../Connexion/Socket.h
+ $(CPPC) -c ListeDroites.cpp
+
+ListeCercles.o : ListeCercles.h ListeCercles.cpp ../Contraintes/CCercle.h ../Connexion/Socket.h
+ $(CPPC) -c ListeCercles.cpp
+
+clean :
+ rm *.o
\ No newline at end of file
--- /dev/null
+#include "ServeurCompo.h"
+
+#include "../Contraintes/CPointIsole.h"
+#include "../Contraintes/CPointAppart1D.h"
+#include "../Contraintes/CPointAppart1C.h"
+#include "../Contraintes/CPointInter2D.h"
+#include "../Contraintes/CPointMilieu2P.h"
+#include "../Contraintes/CPointInter2C.h"
+#include "../Contraintes/CPointInter1C1D.h"
+#include "../Contraintes/CPointCentre1C.h"
+
+#include "../Contraintes/CDtePassant2P.h"
+#include "../Contraintes/CDteHorizPassant1P.h"
+#include "../Contraintes/CDteVertPassant1P.h"
+#include "../Contraintes/CDtePerp1DPassant1P.h"
+#include "../Contraintes/CDteParall1D.h"
+#include "../Contraintes/CDteParall1DPassant1P.h"
+#include "../Contraintes/CDteMediatrice2P.h"
+
+#include "../Contraintes/CCerclePassant3P.h"
+#include "../Contraintes/CCerclePassant1P.h"
+#include "../Contraintes/CCercleTangent2D.h"
+
+#include "../Global.h"
+
+#include "unistd.h"
+#include "stdio.h"
+#include "pthread.h"
+#include "string"
+using namespace std;
+
+struct paramthread
+{
+ Socket *sock;
+ ListePoints *points;
+ ListeDroites *droites;
+ ListeCercles *cercles;
+};
+
+void serveurcompo(char *nom, int typeserveur, Connexion * c)
+{
+ switch (c->GetType())
+ {
+ case C_FORK :
+ switch(fork())
+ {
+ case -1 :
+ fprintf(stderr, "Erreur de lancement du fork du serveur %s\n",nom);
+ break;
+
+ case 0 :
+ fk_creercompo(c);
+ break;
+
+ default:
+ delete []nom;
+ delete c;
+ }
+ break;
+
+ case C_THREAD :
+ pthread_t thr;
+ if (pthread_create(&thr,NULL,th_creercompo,(void *)c) != 0)
+ fprintf(stderr,"pthread_create (serveur %s)\n",nom);
+ delete []nom;
+ break;
+ }
+}
+
+void * th_creercompo(void * param)
+{
+ Connexion *p = (Connexion *)param;
+ fk_creercompo(p);
+
+ pthread_exit(NULL);
+}
+
+void fk_creercompo(Connexion * c)
+{
+ Socket * sock;
+ //pthread_t *thr;
+ pthread_t thr;
+
+ //Liste des points, des droites et des cercles définis par contraintes
+ ListePoints points;
+ ListeDroites droites;
+ ListeCercles cercles;
+
+ struct paramthread *param;
+
+ //écoute sur la socket
+ while(1)
+ {
+ if ((sock = c->AttendConnexion()) != NULL)
+ {
+ param = new (struct paramthread);
+ param->sock = sock;
+ param->points = &points;
+ param->droites = &droites;
+ param->cercles = &cercles;
+
+ /*thr = new pthread_t;
+ if (pthread_create(thr,NULL,thread_travail_client,(void *)param) != 0)
+ perror("pthread_create (thread_travail_client)");*/
+ if (pthread_create(&thr,NULL,thread_travail_client,(void *)param) != 0)
+ perror("pthread_create (thread_travail_client)");
+ pthread_detach(thr);
+ }
+ }
+ //quand c'est fini on détruit la connexion
+ delete c;
+}
+
+void *thread_travail_client(void *param)
+{
+ Socket *sock = ((struct paramthread *)param)->sock;
+ ListePoints *points = ((struct paramthread *)param)->points;
+ ListeDroites *droites = ((struct paramthread *)param)->droites;
+ ListeCercles *cercles = ((struct paramthread *)param)->cercles;
+
+ int i, p;
+ //char buffer[TAILLE_BUFFER];
+ char *lecture;
+
+ while (1)
+ {
+ //écoute de la réponse...
+ if ((lecture = sock->Lire()) == NULL)
+ break;
+ #ifdef VERBOSE
+ printf("client : \033[93m\033[40m%s\033[0m\n",lecture);
+ #endif
+ traiterRequete(lecture, sock, *points, *droites, *cercles);
+
+ delete []lecture;
+ }
+
+ #ifdef VERBOSE
+ printf("fin de la thread du client\n");
+ #endif
+ //on détruit la socket du client
+ delete sock;
+ pthread_exit((void *)0);
+
+}
+
+int traiterRequete(const char *ligne, Socket *sock, ListePoints &points, ListeDroites &droites, ListeCercles &cercles)
+{
+ char commande[TAILLE_BUFFER];
+ char *buffer;
+ int position;
+ double r, x, y;
+ int p1,p2,p3;
+ int d1, d2;
+ int c1, c2;
+ int nb;
+ CPoint *pp, *pp1, *pp2, *pp3;
+ CDroite *dd, *dd1, *dd2;
+ CCercle *cc, *cc1, *cc2;
+
+ //lit le type de requête
+ if (sscanf(ligne, "%s %n", commande, &position) !=1)
+ {
+ //aucune commande n'a été tapée
+ return -1;
+ }
+
+ //POINT
+ if (string(commande) == "P")
+ {
+ int position2, type;
+ //lit le type de requête
+ if (sscanf(&(ligne[position]), "%d %n", &type, &position2) !=1)
+ {
+ //il y a une erreur de saisie
+ return -1;
+ }
+ CPoint *p;
+ position2 += position;
+
+ switch(type)
+ {
+ case 1:
+ if (sscanf(&(ligne[position2]),"%lf %lf",&x,&y) != 2)
+ p = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("point isolé : x=%lf, y=%lf\n",x,y);
+ #endif
+ //on va ajouter un nouveau CPointIsole dans les points
+ p = new CPointIsole(x,y);
+ }
+ break;
+
+ case 2:
+ if (sscanf(&(ligne[position2]),"%d %lf %lf",&d1, &x, &y) != 3)
+ p = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("point appartenant à une droite : %lf %lf projeté sur d%d \n",x,y,d1);
+ #endif
+ //on récupère la droite
+ if ((dd = droites.GetDroite(d1)) == NULL)
+ p = NULL;
+ else
+ p = new CPointAppart1D(dd,x,y);
+ }
+ break;
+
+ case 3:
+ if (sscanf(&(ligne[position2]),"%d %lf %lf",&c1,&x,&y) != 3)
+ p = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("point appartenant à un cercle : c%d\n", c1);
+ #endif
+ //on récupère la droite
+ if ((cc = cercles.GetCercle(c1)) == NULL)
+ p = NULL;
+ else
+ p = new CPointAppart1C(cc,x,y);
+ }
+ break;
+
+ case 4:
+ if (sscanf(&(ligne[position2]),"%d %d", &d1, &d2) != 2)
+ p = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("point d'intersection de deux droites : d%d et d%d\n", d1, d2);
+ #endif
+ //on récupère les deux droites
+ if (((dd1 = droites.GetDroite(d1)) == NULL) || ((dd2 = droites.GetDroite(d2)) == NULL))
+ p = NULL;
+ else
+ p = new CPointInter2D(dd1,dd2);
+ }
+ break;
+
+ case 5:
+ if (sscanf(&(ligne[position2]),"%d %d", &c1, &c2) != 2)
+ p = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("point d'intersection entre deux cercles : c%d et c%d\n", c1, c2);
+ #endif
+ //on récupère les deux cercles
+ if (((cc1 = cercles.GetCercle(c1)) == NULL) || ((cc2 = cercles.GetCercle(c2)) == NULL))
+ p = NULL;
+ else
+ p = new CPointInter2C(cc1,cc2);
+ }
+ break;
+
+ case 6:
+ if (sscanf(&(ligne[position2]),"%d %d", &d1, &c1) != 2)
+ p = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("point d'intersection entre une droite et un cercle : d%d et c%d\n", d1, c1);
+ #endif
+ //on récupère le cercle et la droite
+ if (((dd = droites.GetDroite(d1)) == NULL) || ((cc = cercles.GetCercle(c1)) == NULL))
+ p = NULL;
+ else
+ p = new CPointInter1C1D(cc,dd);
+ }
+ break;
+
+ case 7:
+ if (sscanf(&(ligne[position2]),"%d %d", &p1, &p2) != 2)
+ p = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("point milieu de deux points : p%d et p%d\n", p1, p2);
+ #endif
+ //on récupère les deux points
+ if (((pp1 = points.GetPoint(p1)) == NULL) || ((pp2 = points.GetPoint(p2)) == NULL))
+ p = NULL;
+ else
+ p = new CPointMilieu2P(pp1,pp2);
+ }
+ break;
+
+ case 8:
+ if (sscanf(&(ligne[position2]),"%d", &c1) != 1)
+ p = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("point centre d'un cercle : c%d\n", c1);
+ #endif
+ //on récupère le cercle
+ if ((cc = cercles.GetCercle(c1)) == NULL)
+ p = NULL;
+ else
+ p = new CPointCentre1C(cc);
+ }
+ break;
+
+ default:
+ p = NULL;
+ }
+
+ if (p != NULL)
+ {
+ //RECUPERER LE NUMERO ET L'ENVOYER AU CLIENT A LA FIN.
+ int n = points.AjouterPoint(p);
+ //on envoie les solutions possibles
+ p->EnvoyerSolutions(sock);
+ //on lit la solution voulue
+ if (((buffer = sock->Lire()) == NULL) || (sscanf(buffer,"%d",&nb) != 1))
+ nb = 0;
+ else
+ {
+ delete [] buffer;
+ //on envoie le numéro du point créé. Ca tient lieu d'accusé de réception
+ char *buffer2 = new char[TAILLE_BUFFER];
+ sprintf(buffer2,"%d\n",n);
+ sock->Ecrire(buffer2);
+ delete [] buffer2;
+ }
+
+ //On affecte le choix du client
+ p->Choisir(nb);
+ }
+ #ifdef VERBOSE
+ else
+ printf("\033[05m\033[41m\033[97merreurs de paramètres\033[0m\n");
+ #endif
+ }
+
+ //DROITES
+ else
+ if (string(commande) == "D")
+ {
+ int position2, type;
+ //lit le type de requête
+ if (sscanf(&(ligne[position]), "%d %n", &type, &position2) !=1)
+ {
+ //il y a une erreur de saisie
+ return -1;
+ }
+ CDroite *d;
+ position2 += position;
+
+ switch(type)
+ {
+ case 1:
+ if (sscanf(&(ligne[position2]),"%d %d", &p1, &p2) != 2)
+ d = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("droite passant par deux points : p%d et p%d\n", p1, p2);
+ #endif
+ //on récupère les deux points
+ if (((pp1 = points.GetPoint(p1)) == NULL) || ((pp2 = points.GetPoint(p2)) == NULL))
+ d = NULL;
+ else
+ d = new CDtePassant2P(pp1,pp2);
+ }
+ break;
+
+ case 2:
+ if (sscanf(&(ligne[position2]),"%d", &p1) != 1)
+ d = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("droite horizontale passant par un point : p%d\n", p1);
+ #endif
+ //on récupère le point
+ if ((pp = points.GetPoint(p1)) == NULL)
+ d = NULL;
+ else
+ d = new CDteHorizPassant1P(pp);
+ }
+ break;
+
+ case 3:
+ if (sscanf(&(ligne[position2]),"%d", &p1) != 1)
+ d = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("droite verticale passant par un point : p%d\n", p1);
+ #endif
+ //on récupère le point
+ if ((pp = points.GetPoint(p1)) == NULL)
+ d = NULL;
+ else
+ d = new CDteVertPassant1P(pp);
+ }
+ break;
+
+ case 4:
+ if (sscanf(&(ligne[position2]),"%d %d", &d1, &p1) != 2)
+ d = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("droite perpendiculaire à une autre droite passant par un point : d%d et p%d\n", d1, p1);
+ #endif
+ //on récupère le point et la droite
+ if (((pp = points.GetPoint(p1)) == NULL) || ((dd = droites.GetDroite(d1)) == NULL))
+ d = NULL;
+ else
+ d = new CDtePerp1DPassant1P(dd,pp);
+ }
+ break;
+
+ case 5:
+ if (sscanf(&(ligne[position2]),"%d %lf", &d1, &x) != 2)
+ d = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("droite parallèle à une autre droite à une distance d : d%d à %lf\n", d1, x);
+ #endif
+ //on récupère la droite
+ if ((dd = droites.GetDroite(d1)) == NULL)
+ d = NULL;
+ else
+ d = new CDteParall1D(dd,x);
+ }
+ break;
+
+ case 6:
+ if (sscanf(&(ligne[position2]),"%d %d", &d1, &p1) != 2)
+ d = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("droite parallèle à une autre droite passant par un point : d%d et p%d\n", d1, p1);
+ #endif
+ //on récupère la droite et le point
+ if (((dd = droites.GetDroite(d1)) == NULL) || ((pp = points.GetPoint(p1)) == NULL))
+ d = NULL;
+ else
+ d = new CDteParall1DPassant1P(dd,pp);
+ }
+ break;
+
+ case 7:
+ if (sscanf(&(ligne[position2]),"%d %d", &p1, &p2) != 2)
+ d = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("droite médiatrice d'un segment : p%d et p%d\n", p1, p2);
+ #endif
+ //on récupère les points
+ if (((pp1 = points.GetPoint(p1)) == NULL) || ((pp2 = points.GetPoint(p2)) == NULL))
+ d = NULL;
+ else
+ d = new CDteMediatrice2P(pp1,pp2);
+ }
+ break;
+
+ default:
+ d = NULL;
+ }
+
+ if (d != NULL)
+ {
+ int n = droites.AjouterDroite(d);
+ //on envoie les solutions possibles
+ d->EnvoyerSolutions(sock);
+ //on lit la solution voulue
+ if (((buffer = sock->Lire()) == NULL) || (sscanf(buffer,"%d",&nb) != 1))
+ nb = 0;
+ else
+ {
+ delete [] buffer;
+ //on envoie le numéro de la droite créée. Ca tient lieu d'accusé de réception
+ char *buffer2 = new char[TAILLE_BUFFER];
+ sprintf(buffer2,"%d\n",n);
+ sock->Ecrire(buffer2);
+ delete [] buffer2;
+ }
+ //On affecte le choix du client
+ d->Choisir(nb);
+ }
+ #ifdef VERBOSE
+ else
+ printf("\033[05m\033[41m\033[97merreurs de paramètres\033[0m\n");
+ #endif
+ }
+
+ //CERCLES
+ else
+ if (string(commande) == "C")
+ {
+ int position2, type;
+ //lit le type de requête
+ if (sscanf(&(ligne[position]), "%d %n", &type, &position2) !=1)
+ {
+ //il y a une erreur de saisie
+ return -1;
+ }
+ CCercle *c;
+ position2 += position;
+
+ switch(type)
+ {
+ case 1:
+ if (sscanf(&(ligne[position2]),"%d %d %d", &p1, &p2, &p3) != 3)
+ c = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("cercle passant par trois points : p%d, p%d et p%d\n", p1, p2, p3);
+ #endif
+ //on récupère les trois points
+ if (((pp1 = points.GetPoint(p1)) == NULL) || (pp2 = points.GetPoint(p2)) == NULL || (pp3 = points.GetPoint(p3)) == NULL)
+ c = NULL;
+ else
+ c = new CCerclePassant3P(pp1,pp2,pp3);
+ }
+ break;
+
+ case 2:
+ if (sscanf(&(ligne[position2]),"%d %lf %lf %lf", &p1, &r, &x, &y) != 4)
+ c = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("cercle passant par un point et de rayon donné : p%d à %lf près de %lf %lf\n", p1, r, x, y);
+ #endif
+ //on récupère les trois points
+ if ((pp = points.GetPoint(p1)) == NULL)
+ c = NULL;
+ else
+ c = new CCerclePassant1P(pp,r,x,y);
+ }
+ break;
+
+ case 3:
+ if (sscanf(&(ligne[position2]),"%d %lf %lf %lf", &p1, &r, &x, &y) != 4)
+ c = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("cercle passant par un point et de diamètre donné : p%d à %lf près de %lf %lf\n", p1, r, x, y);
+ #endif
+ //on récupère les trois points
+ if ((pp = points.GetPoint(p1)) == NULL)
+ c = NULL;
+ else
+ c = new CCerclePassant1P(pp,r/2.0,x,y);
+ }
+ break;
+
+ case 4:
+ if (sscanf(&(ligne[position2]),"%d %d %lf", &d1, &d2, &r) != 3)
+ c = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("cercle tangent à deux droites et de rayon donné : d%d et d%d à %lf\n", d1, d2, r);
+ #endif
+ //on récupère ledeux droites
+ if (((dd1 = droites.GetDroite(d1)) == NULL) || ((dd2 = droites.GetDroite(d2)) == NULL))
+ c = NULL;
+ else
+ c = new CCercleTangent2D(dd1,dd2,r);
+ }
+ break;
+
+ case 5:
+ if (sscanf(&(ligne[position2]),"%d %d %lf", &c1, &c2, &r) != 3)
+ c = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("cercle tangent à deux cercles et de rayon donné : c%d et c%d à %lf\n", c1, c2, r);
+ #endif
+ c = NULL;
+ }
+ break;
+
+ case 6:
+ if (sscanf(&(ligne[position2]),"%d %d", &p1, &d1) != 2)
+ c = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("cercle passant par un point et tangent à une droite : p%d et d%d\n", p1, d1);
+ #endif
+ c = NULL;
+ }
+ break;
+
+ case 7:
+ if (sscanf(&(ligne[position2]),"%d %d", &p1, &c1) != 2)
+ c = NULL;
+ else
+ {
+ #ifdef VERBOSE
+ printf("cercle passant par un point et tangent à un cercle : p%d et c%d\n", p1, c1);
+ #endif
+ c = NULL;
+ }
+ break;
+
+ default:
+ c = NULL;
+ }
+ if (c != NULL)
+ {
+ int n = cercles.AjouterCercle(c);
+
+ //on envoie les solutions possibles
+ c->EnvoyerSolutions(sock);
+
+ //on lit la solution voulue
+ if (((buffer = sock->Lire()) == NULL) || (sscanf(buffer,"%d",&nb) != 1))
+ nb = 0;
+ else
+ {
+ delete [] buffer;
+ //on envoie le numéro du cercle créé. Ca tient lieu d'accusé de réception
+ char *buffer2 = new char[TAILLE_BUFFER];
+ sprintf(buffer2,"%d\n",n);
+ sock->Ecrire(buffer2);
+ delete [] buffer2;
+ }
+ //On affecte le choix du client
+ c->Choisir(nb);
+ }
+ #ifdef VERBOSE
+ else
+ printf("\033[05m\033[41m\033[97merreurs de paramètres\033[0m\n");
+ #endif
+ }
+
+ //MODIFICATION D'UN POINT
+ else
+ if (string(commande) == "M")
+ {
+ int position2, type;
+ //lit le type de requête
+ if (sscanf(&(ligne[position]), "%d %lf %lf", &p1, &x, &y) == 3)
+ {
+ #ifdef VERBOSE
+ printf("modification d'un point : point p%d vers %lf et %lf\n", p1, x, y);
+ #endif
+ //on récupère le point
+ if (points.GetPoint(p1) != NULL)
+ {
+ points.GetPoint(p1)->ModifierPoint(x,y);
+ //on envoie les coordonnées du point : cela permet au client de
+ //ssavoir si le point a été modifié
+ char *buffer2 = new char[TAILLE_BUFFER];
+ sprintf(buffer2,"%lf %lf\n", (points.GetPoint(p1)->Solution())->GetX(), (points.GetPoint(p1)->Solution())->GetY());
+ sock->Ecrire(buffer2);
+ delete [] buffer2;
+ }
+ #ifdef VERBOSE
+ else
+ printf("\033[05m\033[41m\033[97mle point %d n'existe pas\033[0m\n",p1);
+ #endif
+ }
+ #ifdef VERBOSE
+ else
+ printf("\033[05m\033[41m\033[97merreurs de paramètres\033[0m\n");
+ #endif
+ }
+ //ENVOI DE LISTES
+ else
+ if (string(commande) == "POINTS")
+ {
+ #ifdef VERBOSE
+ printf("Envoi de la liste des points\n");
+ #endif
+ points.EnvoyerListe(sock);
+ }
+ else
+ if (string(commande) == "DROITES")
+ {
+ #ifdef VERBOSE
+ printf("Envoi de la liste des droites\n");
+ #endif
+ droites.EnvoyerListe(sock);
+ }
+ else
+ if (string(commande) == "CERCLES")
+ {
+ #ifdef VERBOSE
+ printf("Envoi de la liste des cercles\n");
+ #endif
+ cercles.EnvoyerListe(sock);
+ }
+ else
+ if (string(commande) == "ALL")
+ {
+ #ifdef VERBOSE
+ printf("Envoi de la liste des points\n");
+ #endif
+ points.EnvoyerListe(sock);
+ #ifdef VERBOSE
+ printf("Envoi de la liste des droites\n");
+ #endif
+ droites.EnvoyerListe(sock);
+ #ifdef VERBOSE
+ printf("Envoi de la liste des cercles\n");
+ #endif
+ cercles.EnvoyerListe(sock);
+ }
+
+ #ifdef VERBOSE
+ //COMMANDE NON RECONNUE
+ else
+ {
+ printf("commande inconnue\n");
+ }
+ #endif
+ return 1;
+}
--- /dev/null
+//serveur de contraintes
+
+#ifndef _SERVCOMPO_
+#define _SERVCOMPO_
+
+#include "../Global.h"
+
+#include "../Connexion/Socket.h"
+#include "../Connexion/Connexion.h"
+
+#include "../Listes/ListePoints.h"
+#include "../Listes/ListeDroites.h"
+#include "../Listes/ListeCercles.h"
+
+void serveurcompo(char *nom, int typeserveur, Connexion * c);
+void * th_creercompo(void * param);
+void fk_creercompo(Connexion * c);
+void *thread_travail_client(void *socket);
+int traiterRequete(const char *ligne, Socket *sock, ListePoints &points, ListeDroites &droites, ListeCercles &cercles);
+
+#endif
--- /dev/null
+CPPC = g++
+OBJS = ServeurCompo.o
+
+serveur : $(OBJS)
+
+ServeurCompo.o : ServeurCompo.cpp ../Connexion/Socket.h ../Connexion/Connexion.h ../Listes/ListePoints.h ../Listes/ListeDroites.h ../Listes/ListeCercles.h ../Contraintes/CPoint.o ../Contraintes/CDroite.o ../Contraintes/CCercle.o ../Contraintes/Objet.o ../Contraintes/CPointIsole.o ../Contraintes/CPointInter2D.o ../Contraintes/CPointMilieu2P.o ../Contraintes/CDtePassant2P.o ../Contraintes/CDteHorizPassant1P.o ../Contraintes/CDteVertPassant1P.o ../Contraintes/CDtePerp1DPassant1P.o ../Contraintes/CDteParall1D.o ../Contraintes/CDteParall1DPassant1P.o ../Contraintes/CDteMediatrice2P.o ../Contraintes/CPointAppart1D.o ../Contraintes/CPointAppart1C.o ../Contraintes/CPointCentre1C.o ../Contraintes/CPointInter1C1D.o ../Contraintes/CPointInter2C.o ../Contraintes/CCerclePassant3P.o ../Contraintes/CCerclePassant1P.o ../Global.h
+ $(CPPC) -c ServeurCompo.cpp
+
+clean :
+ rm *.o
+
--- /dev/null
+CPPC = g++-3.4
+OBJS = s.o
+OBJCONN = Connexion/SocketTCP.o Connexion/SocketUDP.o Connexion/Socket.o Connexion/Connexion.o
+OBJLISTES = Listes/ListeCompo.o Listes/ListePoints.o Listes/ListeDroites.o Listes/ListeCercles.o
+OBJSERV = Serveur/ServeurCompo.o
+OBJCONTR = Contraintes/CPoint.o Contraintes/CDroite.o Contraintes/CCercle.o Contraintes/Objet.o Contraintes/CPointIsole.o Contraintes/CPointInter2D.o Contraintes/CPointMilieu2P.o Contraintes/CDtePassant2P.o Contraintes/CDteHorizPassant1P.o Contraintes/CDteVertPassant1P.o Contraintes/CDtePerp1DPassant1P.o Contraintes/CDteParall1D.o Contraintes/CDteParall1DPassant1P.o Contraintes/CDteMediatrice2P.o Contraintes/CPointAppart1D.o Contraintes/CPointAppart1C.o Contraintes/CPointCentre1C.o Contraintes/CPointInter1C1D.o Contraintes/CPointInter2C.o Contraintes/CCerclePassant3P.o Contraintes/CCerclePassant1P.o Contraintes/CCercleTangent2D.o
+OBJFORMES = Formes/Point.o Formes/Droite.o Formes/Cercle.o
+DOXYGEN = doxygen
+
+CPPS = s.cpp
+
+scompo : $(OBJS) $(OBJSERV) $(OBJCONN) $(OBJLISTES) $(OBJCONTR) $(OBJFORMES) $(DOXYGEN)
+ $(CPPC) -lnsl -lpthread -o scompo $(OBJCONN) $(OBJLISTES) $(OBJSERV) $(OBJCONTR) $(OBJFORMES) $(OBJS)
+
+s.o : Serveur/*.h Connexion/*.h Listes/*.h Contraintes/*.h Global.h s.cpp
+ $(CPPC) -c s.cpp
+
+doxygen : Doxyfile *.h *.cpp Listes/*.h Listes/*.cpp Connexion/*.h Connexion/*.cpp Serveur/*.h Serveur/*.cpp Contraintes/*.h Contraintes/*.cpp Formes/*.h Formes/*.cpp
+# doxygen Doxyfile
+
+clean :
+ rm *.o
+ rm scompo
--- /dev/null
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <pthread.h>
+
+#include "Connexion/Connexion.h"
+#include "Connexion/Socket.h"
+#include "Connexion/SocketUDP.h"
+//#include "Compo/CompoInfo.h"
+#include "Listes/ListeCompo.h"
+#include "Serveur/ServeurCompo.h"
+#include "Global.h"
+
+//#define TAILLE_BUFFER 2048
+#define DEFAULT_PORT 6666
+
+int port = DEFAULT_PORT; //port par défaut
+int typeserveur = C_FORK; //on utilise les fork par défaut
+ListeCompo compos;
+
+//fonction qui va traiter les demandes de création et d'ouverture de compositions
+void traiter(char *lecture,Socket *sock)
+{
+ int nb, i, p;
+ char *buffer = new char[TAILLE_BUFFER];
+ char *commande = new char[TAILLE_BUFFER];
+ Connexion *connectcompo=NULL;
+
+ if ((nb = sscanf(lecture,"%s %s", commande, buffer)) == 2)
+ {
+ if (strcmp(commande,"NEW") == 0)
+ {
+ #ifdef VERBOSE
+ printf("\033[91m\033[40mcréation de la composition %s\033[0m\n",buffer);
+ #endif
+ connectcompo = new Connexion(P_TCP);
+ if ((p = compos.GetPortOfCompo(buffer)) == -1)
+ {
+ compos.AjouterCompo(buffer,connectcompo->GetPort());
+ //lancement du fork ou de la thread ...
+ serveurcompo(strdup(buffer), typeserveur, connectcompo);
+ }
+ #ifdef VERBOSE
+ else
+ printf("\033[05m\033[41m\033[97mLa composition %s existe déjà au port %d\033[0m\n",buffer,p);
+ #endif
+ }
+ else
+ if (strcmp(commande,"OPEN") != 0)
+ {
+ #ifdef VERBOSE
+ printf("\033[41m\033[30mcommande inconnue : %s\033[0m\n",commande);
+ #endif
+ return;
+ }
+ #ifdef VERBOSE
+ else
+ {
+ printf("\033[40m\033[34mouverture de la composition %s\033[0m\n",buffer);
+ }
+
+ printf("\033[40m\033[36menvoi du numéro de port de la composition\033[0m\n");
+ #endif
+ p = compos.GetPortOfCompo(buffer);
+ #ifdef VERBOSE
+ printf("numero %d et nom %s\n",p,buffer);
+ #endif
+ sprintf(buffer,"%d\n",p);
+ sock->Ecrire(buffer);
+ }
+ //si c'est une demande de connexion on envoit la liste des compos
+ else if (nb == 1 && strcmp(lecture,"LIST") == 0)
+ compos.EnvoyerListe(sock);
+ else
+ sock->Ecrire("commande inconnue\n");
+
+ delete []lecture;
+ delete []buffer;
+ delete []commande;
+}
+
+void *thread_client(void *socket)
+{
+ char *lecture = NULL;
+ Socket *sock = (Socket *)socket;
+
+ //envoi de la liste des compositions au client
+ compos.EnvoyerListe(sock);
+
+ //écoute de la réponse...
+ if ((lecture = sock->Lire()) == NULL)
+ {
+ #ifdef VERBOSE
+ printf("le client est parti\n");
+ #endif
+ //détruire la socket vers le client : elle ne sert plus.
+ delete sock;
+ pthread_exit((void *)0);
+ }
+
+ #ifdef VERBOSE
+ printf("\033[91m\033[40mclient :\033[0m %s\n",lecture);
+ #endif
+ traiter(lecture,sock);
+
+ //détruire la socket vers le client : elle ne sert plus.
+ delete sock;
+
+ pthread_exit((void *)0);
+}
+
+void *thread_connect(void *proto)
+{
+ Connexion *c=NULL;
+ //pthread_t *thr;
+ pthread_t thr;
+ Socket * sock=NULL;
+
+ switch ((int)proto)
+ {
+ //si c'est le serveur TCP
+ case P_TCP:
+ #ifdef VERBOSE
+ printf("lancement du protocole TCP\n");
+ #endif
+
+ //création de la socket d'écoute TCP
+ c = new Connexion(P_TCP,port);
+
+ //écoute sur la socket
+ while(1)
+ {
+ if ((sock = c->AttendConnexion()) != NULL)
+ {
+ /*thr = new pthread_t;
+ if (pthread_create(thr,NULL,thread_client,(void *)sock) != 0)
+ perror("pthread_create (connect)");*/
+ if (pthread_create(&thr,NULL,thread_client,(void *)sock) != 0)
+ perror("pthread_create (connect)");
+ pthread_detach(thr);
+ }
+ }
+ #ifdef VERBOSE
+ printf("fin protocole TCP\n");
+ #endif
+ break;
+ //si c'est le serveur UDP
+ case P_UDP:
+ #ifdef VERBOSE
+ printf("lancement du protocole UDP\n");
+ #endif
+
+ //création de la socket d'écoute UDP
+ sock = new SocketUDP(port);
+
+ char *buffer;
+ //écoute sur la socket
+ while(1)
+ {
+ if ((buffer = sock->Lire()) != NULL)
+ //si c'est une autre commande on demande le traitement de cette commande
+ traiter(buffer,sock);
+ }
+ delete sock;
+
+ #ifdef VERBOSE
+ printf("fin du protocole UDP\n");
+ #endif
+ break;
+ //si c'est une erreur
+ default:
+ #ifdef VERBOSE
+ printf("protocole inconnu\n");
+ #endif
+ pthread_exit(NULL);
+ }
+
+ delete c;
+
+ pthread_exit((void *)0);
+}
+
+int main(int argc, char *argv[])
+{
+ //variables pour l'analyse de la liugne de commande
+ int option;
+ char *listeoptions = "p:s:";
+
+ pthread_t threadtcp,threadudp; //threads de connexion
+
+ //vérification du nombre d'arguments
+ if (argc > 5)
+ {
+ fprintf(stderr,"syntaxe : %s -p port -s [fork|thread]\n",argv[0]);
+ return(0);
+ }
+
+ //lecture des arguments
+ while ((option = getopt (argc, argv, listeoptions)) != -1)
+ {
+ switch(option)
+ {
+ //argument port
+ case 'p':
+ sscanf(optarg,"%d",&port);
+ break;
+ //argument fork/thread
+ case 's':
+ if (strcasecmp(optarg,"fork") == 0)
+ typeserveur = C_FORK;
+ else
+ {
+ if (strcasecmp(optarg,"thread") == 0)
+ typeserveur = C_THREAD;
+ else
+ {
+ fprintf(stderr,"syntaxe : %s -p port -s [fork|thread]\n",argv[0]);
+ return(0);
+ }
+ }
+ break;
+ }
+ }
+
+ #ifdef VERBOSE
+ //affichage du message de bienvenue
+ switch(typeserveur)
+ {
+ case C_FORK:
+ fprintf(stdout,"Lancement du serveur fork sur le port %d\n",port);
+ break;
+ case C_THREAD:
+ fprintf(stdout,"Lancement du serveur thread sur le port %d\n",port);
+ break;
+ }
+ #endif
+
+ if (pthread_create(&threadtcp,NULL,thread_connect,(void *)P_TCP)!=0)
+ {
+ perror("thread tcp");
+ return(0);
+ }
+
+ if (pthread_create(&threadudp,NULL,thread_connect,(void *)P_UDP)!=0)
+ {
+ perror("thread udp");
+ return(0);
+ }
+
+ pthread_join(threadtcp,(void **)NULL);
+ pthread_join(threadudp,(void **)NULL);
+
+ return (1);
+}
--- /dev/null
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <pthread.h>
+
+#include "Connexion/Connexion.h"
+#include "Connexion/Socket.h"
+//#include "Compo/CompoInfo.h"
+#include "Listes/ListeCompo.h"
+#include "Serveur/ServeurCompo.h"
+#include "Global.h"
+
+//#define TAILLE_BUFFER 2048
+#define DEFAULT_PORT 6666
+
+int port = DEFAULT_PORT; //port par défaut
+int typeserveur = C_FORK; //on utilise les fork par défaut
+ListeCompo compos;
+
+void *thread_client(void *socket)
+{
+ int i, p;
+ char *buffer = new char[TAILLE_BUFFER];
+ char *commande = new char[TAILLE_BUFFER];
+ char *lecture = NULL;
+ Socket *sock = (Socket *)socket;
+ Connexion *connectcompo;
+printf("envoi de la liste\n");
+ //envoi de la liste des compositions au client
+ compos.EnvoyerListe(sock);
+printf("liste envoyée\n");
+ //écoute de la réponse...
+ if ((lecture = sock->Lire()) == NULL)
+ {
+ #ifdef VERBOSE
+ printf("le client est parti\n");
+ #endif
+ pthread_exit((void *)0);
+ }
+
+ #ifdef VERBOSE
+ printf("\033[91m\033[40mclient :\033[0m %s\n",lecture);
+ #endif
+
+ if (sscanf(lecture,"%s %s", commande, buffer) == 2)
+ {
+ if (strcmp(commande,"NEW") == 0)
+ {
+ #ifdef VERBOSE
+ printf("\033[91m\033[40mcréation de la composition %s\033[0m\n",buffer);
+ #endif
+ connectcompo = new Connexion(P_TCP);
+ if ((p = compos.GetPortOfCompo(buffer)) == -1)
+ {
+ compos.AjouterCompo(buffer,connectcompo->GetPort());
+ //lancement du fork ou de la thread ...
+ serveurcompo(buffer, typeserveur, connectcompo);
+ }
+ #ifdef VERBOSE
+ else
+ printf("\033[05m\033[41m\033[97mLa composition %s existe déjà au port %d\033[0m\n",buffer,p);
+ #endif
+ }
+ else
+ if (strcmp(commande,"OPEN") != 0)
+ {
+ #ifdef VERBOSE
+ printf("\033[41m\033[30mcommande inconnue : %s\033[0m\n",commande);
+ #endif
+ pthread_exit((void *)-1);
+ }
+ #ifdef VERBOSE
+ else
+ {
+ printf("\033[40m\033[34mouverture de la composition %s\033[0m\n",buffer);
+ }
+
+ printf("\033[40m\033[36menvoi du numéro de port de la composition\033[0m\n");
+ #endif
+ p = compos.GetPortOfCompo(buffer);
+ #ifdef VERBOSE
+ printf("numero %d et nom %s\n",p,buffer);
+ #endif
+ sprintf(buffer,"%d\n",p);
+ sock->Ecrire(buffer);
+ }
+ else
+ sock->Ecrire("commande inconnue\n");
+
+ delete []lecture;
+ delete []buffer;
+ delete []commande;
+ delete sock;
+
+ //détruire la socket vers le client : elle ne sert plus.
+
+ pthread_exit((void *)0);
+}
+
+void *thread_connect(void *proto)
+{
+ Connexion *c;
+ //pthread_t *thr;
+ pthread_t thr;
+ Socket * sock;
+
+ switch ((int)proto)
+ {
+ //si c'est le serveur TCP
+ case P_TCP:
+ #ifdef VERBOSE
+ printf("lancement du protocole TCP\n");
+ #endif
+
+ //création de la socket d'écoute TCP
+ c = new Connexion(P_TCP,port);
+ break;
+ //si c'est le serveur UDP
+ case P_UDP:
+ #ifdef VERBOSE
+ printf("lancement du protocole UDP\n");
+ #endif
+
+ //création de la socket d'écoute TCP
+ c = new Connexion(P_UDP,port);
+ break;
+ //si c'est une erreur
+ default:
+ #ifdef VERBOSE
+ printf("protocole inconnu\n");
+ #endif
+ pthread_exit(NULL);
+ }
+
+ //écoute sur la socket
+ while(1)
+ {
+ if ((sock = c->AttendConnexion()) != NULL)
+ {
+ printf("un client est arrivé\n");
+ /*thr = new pthread_t;
+ if (pthread_create(thr,NULL,thread_client,(void *)sock) != 0)
+ perror("pthread_create (connect)");*/
+ if (pthread_create(&thr,NULL,thread_client,(void *)sock) != 0)
+ perror("pthread_create (connect)");
+ pthread_detach(thr);
+ }
+ }
+
+ #ifdef VERBOSE
+ switch ((int)proto)
+ {
+ //si c'est le serveur TCP
+ case P_TCP:
+ printf("fin protocole TCP\n");
+ break;
+ //si c'est le serveur UDP
+ case P_UDP:
+ printf("fin du protocole UDP\n");
+ break;
+ }
+ #endif
+
+ pthread_exit((void *)0);
+}
+
+int main(int argc, char *argv[])
+{
+ //variables pour l'analyse de la liugne de commande
+ int option;
+ char *listeoptions = "p:s:";
+
+ pthread_t threadtcp,threadudp; //threads de connexion
+
+ //vérification du nombre d'arguments
+ if (argc > 5)
+ {
+ fprintf(stderr,"syntaxe : %s -p port -s [fork|thread]\n",argv[0]);
+ return(0);
+ }
+
+ //lecture des arguments
+ while ((option = getopt (argc, argv, listeoptions)) != -1)
+ {
+ switch(option)
+ {
+ //argument port
+ case 'p':
+ sscanf(optarg,"%d",&port);
+ break;
+ //argument fork/thread
+ case 's':
+ if (strcasecmp(optarg,"fork") == 0)
+ typeserveur = C_FORK;
+ else
+ {
+ if (strcasecmp(optarg,"thread") == 0)
+ typeserveur = C_THREAD;
+ else
+ {
+ fprintf(stderr,"syntaxe : %s -p port -s [fork|thread]\n",argv[0]);
+ return(0);
+ }
+ }
+ break;
+ }
+ }
+
+ #ifdef VERBOSE
+ //affichage du message de bienvenue
+ switch(typeserveur)
+ {
+ case C_FORK:
+ fprintf(stdout,"Lancement du serveur fork sur le port %d\n",port);
+ break;
+ case C_THREAD:
+ fprintf(stdout,"Lancement du serveur thread sur le port %d\n",port);
+ break;
+ }
+ #endif
+
+ if (pthread_create(&threadtcp,NULL,thread_connect,(void *)P_TCP)!=0)
+ {
+ perror("thread tcp");
+ return(0);
+ }
+
+ if (pthread_create(&threadudp,NULL,thread_connect,(void *)P_UDP)!=0)
+ {
+ perror("thread udp");
+ return(0);
+ }
+
+ pthread_join(threadtcp,(void **)NULL);
+ pthread_join(threadudp,(void **)NULL);
+
+ return (1);
+}
projects / projetreseaucao.git / commitdiff
