private void AjouterCoordonnee_Click(object sender, RoutedEventArgs e)
{
bool modificationOK = false;
POI p = new POI();
fenetrePOI fenetrePOI = new fenetrePOI(p);
fenetrePOI.Owner = this;
fenetrePOI.ShowDialog();
if (fenetrePOI.NewPOI != null)
{
p.Id = p.Id;
p.Latitude = fenetrePOI.NewPOI.Latitude;
p.Longitude = fenetrePOI.NewPOI.Longitude;
p.Description = fenetrePOI.NewPOI.Description;
Console.WriteLine("DEBUG newPoi to string : " + p.Draw());
PolylineActuel.CollectionDeCoordonnes.Add(p);
modificationOK = true;
UpdateListBox();
}
if (!modificationOK)
{
MessageBox.Show("L'ajout à échouée", "ERREUR", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private void tbDetails_Click(object sender, RoutedEventArgs e)
{
ICartoObj o = (ICartoObj)ListBox.SelectedItem;
string titreFenetre = "", messageFenetre = "";
if (o == null)
{
MessageBox.Show("Aucun élément de la ListBox est sélectionné", "ERREUR", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
if (o is POI)
{
POI p = o as POI;
titreFenetre = "Caractéristiques détaillées du POI sélectionné";
messageFenetre = p.Draw();
}
if (o is Polyline)
{
Polyline p = o as Polyline;
titreFenetre = "Caractéristiques détaillées du trajet (Polyline) sélectionné";
messageFenetre = p.Draw();
}
if (o is Polygon)
{
Polygon p = o as Polygon;
titreFenetre = "Caractéristiques détaillées de la surface (Polygon) sélectionné";
messageFenetre = p.Draw();
}
MessageBox.Show(messageFenetre, titreFenetre, MessageBoxButton.OK, MessageBoxImage.Information);
}
}
private void afficherTrajet(Polyline trajet)
{
MapPolyline mapPolyline = new MapPolyline();
mapPolyline.Opacity = 0.7;
mapPolyline.StrokeThickness = trajet.Epaisseur;
SolidColorBrush couleurTrajet = new SolidColorBrush(trajet.Couleur);
mapPolyline.Stroke = couleurTrajet;
mapPolyline.Locations = new LocationCollection();
foreach (CartoObj o in trajet.CollectionDeCoordonnes)
{
if (o is POI)
{
POI p = o as POI;
Pushpin pushpin = new Pushpin();
pushpin.ToolTip = p.Draw();
pushpin.Opacity = 0.7;
pushpin.Location = new Location(p.Latitude, p.Longitude);
pushpin.Background = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Colors.Red);
Carte.Children.Add(pushpin);
mapPolyline.Locations.Add(new Location(p.Latitude, p.Longitude));
}
}
Carte.Children.Add(mapPolyline);
}
private void afficherPOI(POI pOI)
{
Pushpin pushpin = new Pushpin();
pushpin.ToolTip = pOI.Draw();
pushpin.Opacity = 0.7;
pushpin.Location = new Location(pOI.Latitude, pOI.Longitude);
pushpin.Background = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Colors.Red);
Carte.Children.Add(pushpin);
}
private void ModifierCoordonnee_Click(object sender, RoutedEventArgs e)
{
bool modificationOK = false;
POI p = (POI)ListBox.SelectedItem;
if (p == null)
{
modificationOK = true;
MessageBox.Show("Aucun élément de la ListBox est sélectionné", "ERREUR", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
fenetrePOI fenetrePOI = new fenetrePOI(p);
fenetrePOI.Owner = this;
fenetrePOI.ShowDialog();
if (fenetrePOI.NewPOI != null)
{
foreach (CartoObj oInCollection in PolylineActuel.CollectionDeCoordonnes)
{
if (oInCollection is POI)
{
POI poiInCollection = oInCollection as POI;
if (poiInCollection.Id == p.Id)
{
if (PolylineActuel.CollectionDeCoordonnes.Remove(poiInCollection))
{
POI newPOI = new POI();
newPOI.Id = p.Id;
newPOI.Latitude = fenetrePOI.NewPOI.Latitude;
newPOI.Longitude = fenetrePOI.NewPOI.Longitude;
newPOI.Description = fenetrePOI.NewPOI.Description;
Console.WriteLine("DEBUG newPoi to string : " + newPOI.Draw());
PolylineActuel.CollectionDeCoordonnes.Add(newPOI);
modificationOK = true;
}
break;
}
}
}
}
else
{
modificationOK = true;
}
UpdateListBox();
}
if (!modificationOK)
{
MessageBox.Show("La modification à échouée", "ERREUR", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private void DetailsCoordonnee_Click(object sender, RoutedEventArgs e)
{
POI p = (POI)ListBox.SelectedItem;
if (p == null)
{
MessageBox.Show("Aucun élément de la ListBox est sélectionné", "ERREUR", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
MessageBox.Show(p.Draw(), "Caractéristiques détaillées du POI sélectionné", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
private void tbModifier_Click(object sender, RoutedEventArgs e)
{
bool modificationOK = false;
ICartoObj o = (ICartoObj)ListBox.SelectedItem;
if (o == null)
{
modificationOK = true;
MessageBox.Show("Aucun élément de la ListBox est sélectionné", "ERREUR", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
Carte.Children.Clear();
if (o is POI)
{
POI p = o as POI;
fenetrePOI fenetrePOI = new fenetrePOI(p);
fenetrePOI.Owner = this;
fenetrePOI.ShowDialog();
if (fenetrePOI.NewPOI != null)
{
foreach (ICartoObj oInCollection in PersonneConnectee.ObservableCollection)
{
if (oInCollection is POI)
{
POI poiInCollection = oInCollection as POI;
if (poiInCollection.Id == p.Id)
{
if (PersonneConnectee.ObservableCollection.Remove(poiInCollection))
{
POI newPOI = new POI();
newPOI.Id = p.Id;
newPOI.Latitude = fenetrePOI.NewPOI.Latitude;
newPOI.Longitude = fenetrePOI.NewPOI.Longitude;
newPOI.Description = fenetrePOI.NewPOI.Description;
Console.WriteLine("DEBUG newPoi to string : " + newPOI.Draw());
PersonneConnectee.ObservableCollection.Add(newPOI);
modificationOK = true;
}
break;
}
}
}
}
else
{
modificationOK = true;
}
}
if (o is Polyline)
{
Polyline p = o as Polyline;
Console.WriteLine("DEBUG polyline dans modifier fenetre principale:\n" + p.Draw());
FenetrePolyline fenetrePolyline = new FenetrePolyline(p);
fenetrePolyline.Owner = this;
fenetrePolyline.ShowDialog();
if (fenetrePolyline.NewPolyline != null)
{
foreach (ICartoObj oInCollection in PersonneConnectee.ObservableCollection)
{
if (oInCollection is Polyline)
{
Polyline polylineInCollection = oInCollection as Polyline;
if (polylineInCollection.Id == p.Id)
{
if (PersonneConnectee.ObservableCollection.Remove(polylineInCollection))
{
Polyline newPolyline = new Polyline();
newPolyline.Id = p.Id;
newPolyline.Epaisseur = fenetrePolyline.NewPolyline.Epaisseur;
newPolyline.Couleur = fenetrePolyline.NewPolyline.Couleur;
newPolyline.NomTrajet = fenetrePolyline.NewPolyline.NomTrajet;
newPolyline.CollectionDeCoordonnes = new List <Coordonnees>(fenetrePolyline.NewPolyline.CollectionDeCoordonnes);
PersonneConnectee.ObservableCollection.Add(newPolyline);
modificationOK = true;
}
break;
}
}
}
}
else
{
modificationOK = true;
}
}
//}
//if (o is Polygon)
//{
// Polygon p = o as Polygon;
// foreach (ICartoObj oInCollection in PersonneConnectee.ObservableCollection)
// {
// if (oInCollection is Polygon)
// {
// Polygon polygonInCollection = oInCollection as Polygon;
// if (polygonInCollection.Id == p.Id)
// {
// if (PersonneConnectee.ObservableCollection.Remove(polygonInCollection))
// {
// MessageBox.Show("Suppression du polyline OK", "", MessageBoxButton.OK, MessageBoxImage.Information);
// suppressionOK = true;
// }
// break;
// }
// }
// }
//}
UpdateListBox();
}
if (!modificationOK)
{
MessageBox.Show("La modification à échouée", "ERREUR", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
static void Main(string[] args)
{
//Test création
Console.WriteLine("Création des objets manuellement");
POI Test1 = new POI(28, 27);
POI Test2 = new POI(25.26, 27.38);
Test1.Draw();
Test2.Draw();
Polyline Test3 = new Polyline(new POI(22, 54));
Polyline Test4 = new Polyline();
Test3.Draw();
Test4.Draw();
Polygon Test5 = new Polygon();
Polygon Test6 = new Polygon(new Polyline());
Polygon Test7 = new Polygon(new Polyline(new POI(99, 97)));
Test5.Draw();
Test6.Draw();
Test7.Draw();
//Création liste
Console.WriteLine("Création de la liste");
List <CartoObj> myCartoObjList = new List <CartoObj>();
myCartoObjList.Add(Test1);
myCartoObjList.Add(Test2);
myCartoObjList.Add(Test3);
myCartoObjList.Add(Test4);
myCartoObjList.Add(Test5);
myCartoObjList.Add(Test6);
myCartoObjList.Add(Test7);
Console.WriteLine("Liste créée");
//Affichage via foreach
Console.WriteLine("Affichage via boucle foreach");
foreach (CartoObj unObjet in myCartoObjList)
{
unObjet.Draw();
}
//Parcourir la liste pour trouver les objets implémentant l'interface IPointy
Console.WriteLine("Affichage des objets implémentant IPointy");
foreach (CartoObj unObjet in myCartoObjList)
{
if (unObjet is IPointy)
{
unObjet.Draw();
}
}
//Parcourir la liste pour afficher les objets n'implémentant pas l'interface IPointy
Console.WriteLine("Affichage des objets n'implémentant pas IPointy");
foreach (CartoObj unObjet in myCartoObjList)
{
if (unObjet is POI)
{
unObjet.Draw();
}
}
//Création de la liste générique de 5 Polyline
Console.WriteLine("Création de la liste générique");
List <Polyline> listeGenPolyline = new List <Polyline>();
Polyline Poly1 = new Polyline(new POI(25.0, 65.2));
Poly1.AddPOI(new POI(60.0, 48.5));
Polyline Poly2 = new Polyline(new POI(85.1, 45.6));
Poly2.AddPOI(new POI(1, 1));
Poly2.AddPOI(new POI(5.5, 6.7));
Polyline Poly3 = new Polyline();
Poly3.AddPOI(new POI(8.7, 5.1));
Polyline Poly4 = new Polyline();
Poly4.AddPOI(new POI(10, 85));
Poly4.AddPOI(new POI(74, 65));
Polyline Poly5 = new Polyline();
Poly5.AddPOI(new POI(0, 0));
listeGenPolyline.Add(Poly1);
listeGenPolyline.Add(Poly2);
listeGenPolyline.Add(Poly3);
listeGenPolyline.Add(Poly4);
listeGenPolyline.Add(Poly5);
//Affichage de la liste
Console.WriteLine("Affichage de la liste générique");
foreach (Polyline unPoly in listeGenPolyline)
{
unPoly.Draw();
}
//Tri de la liste
Console.WriteLine("Tri de la liste sur sa longueur de facon croissante");
listeGenPolyline.Sort();
//Affichage de la liste triée
Console.WriteLine("Affichage de la liste triée");
foreach (Polyline unPoly in listeGenPolyline)
{
unPoly.Draw();
}
//Tri de la liste par taille de bounding box
Console.WriteLine("Tri de la liste par rapport a la taille de sa bounding box");
MyPolylineBoundingBoxComparer cmp = new MyPolylineBoundingBoxComparer();
listeGenPolyline.Sort(cmp);
foreach (Polyline unPoly in listeGenPolyline)
{
unPoly.Draw();
}
//Test de la méthode Equals
Console.WriteLine("Recherche d'une polyline ayant la meme longueur qu'une autre");
Polyline TestPoly1 = new Polyline(new POI(50, 21));
Polyline TestPoly2 = new Polyline(new POI(8.7, 5.1));
Polyline TestPoly3 = new Polyline();
TestPoly3.AddPOI(new POI(52.2, 89.2));
TestPoly3.AddPOI(new POI(0.2, 0.5));
Console.WriteLine("Test de Poly 1");
TestPoly1.Draw();
if (listeGenPolyline.Contains(TestPoly1))
{
Console.WriteLine("Trouvé");
}
else
{
Console.WriteLine("Non trouvé");
}
Console.WriteLine("Test de Poly 2");
TestPoly2.Draw();
if (listeGenPolyline.Contains(TestPoly2))
{
Console.WriteLine("Trouvé");
}
else
{
Console.WriteLine("Non trouvé");
}
Console.WriteLine("Test de Poly 3");
TestPoly3.Draw();
if (listeGenPolyline.Contains(TestPoly3))
{
Console.WriteLine("Trouvé");
}
else
{
Console.WriteLine("Non trouvé");
}
//Test de la méthode IsPointClose
Console.WriteLine("Test de la méthode IsPointClose");
foreach (Polyline unPoly in listeGenPolyline)
{
if (unPoly.IsPointClose(0, 0, 200))
{
Console.WriteLine("Polyline proche du point : ");
unPoly.Draw();
}
}
Console.WriteLine("Fin de l'applic test");
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("------------------------------------------------------------");
Console.WriteLine("---------créer et afficher 2 objets de chaque sorte---------");
Console.WriteLine("------------------------------------------------------------");
Console.WriteLine("------------------COORDONNEES------------------");
Coordonnees C1 = new Coordonnees();
Console.WriteLine("Constructeur par defaut de Coordonnees : C1");
Console.WriteLine(C1.ToString());
Console.WriteLine("Methode DRAW");
C1.Draw();
Console.WriteLine("C1 lat = 1, long = 1");
C1.Latitude = 1;
C1.Longitude = 1;
Console.WriteLine(C1.ToString());
Console.WriteLine("Methode DRAW");
C1.Draw();
Coordonnees C2 = new Coordonnees(1, 2);
Console.WriteLine("Constructeur initialisation Coordonnees : C2(1, 2)");
Console.WriteLine(C2.ToString());
Console.WriteLine("Methode DRAW");
C2.Draw();
bool returnIsPointClose;
Console.WriteLine("IsPointClose entre C1(lat/long) : " + C1.Latitude + "/" + C1.Longitude + " et C2(lat/long) : " + C2.Latitude + " / " + C2.Longitude);
Console.WriteLine("Precision = 1.0");
returnIsPointClose = C1.IsPointClose(C2, 1.0);
if (returnIsPointClose)
{
Console.WriteLine("Point proche...");
}
else
{
Console.WriteLine("Point pas proche...");
}
Console.WriteLine("IsPointClose entre C1(lat/long) : " + C1.Latitude + "/" + C1.Longitude + " et C2(lat/long) : " + C2.Latitude + " / " + C2.Longitude);
Console.WriteLine("Precision = 0.1");
returnIsPointClose = C1.IsPointClose(C2, 0.1);
if (returnIsPointClose)
{
Console.WriteLine("Point proche...");
}
else
{
Console.WriteLine("Point pas proche...");
}
Console.WriteLine("------------------POI------------------");
POI Sraing = new POI();
Console.WriteLine(Sraing.ToString());
Console.WriteLine("Latitude" + Sraing.Latitude);
Console.WriteLine("Longitude" + Sraing.Longitude);
Console.WriteLine("Methode DRAW");
Sraing.Draw();
Console.WriteLine("IsPointClose entre Sraing(lat/long) : " + Sraing.Latitude + "/" + Sraing.Longitude + " et C2(lat/long) : " + C2.Latitude + " / " + C2.Longitude);
Console.WriteLine("Precision = 100");
returnIsPointClose = Sraing.IsPointClose(C2, 100);
if (returnIsPointClose)
{
Console.WriteLine("Point proche...");
}
else
{
Console.WriteLine("Point pas proche...");
}
Console.WriteLine("IsPointClose entre Sraing(lat/long) : " + Sraing.Latitude + "/" + Sraing.Longitude + " et C2(lat/long) : " + C2.Latitude + " / " + C2.Longitude);
Console.WriteLine("Precision = 10");
returnIsPointClose = Sraing.IsPointClose(C2, 10);
if (returnIsPointClose)
{
Console.WriteLine("Point proche...");
}
else
{
Console.WriteLine("Point pas proche...");
}
Console.WriteLine("------------------POLYLINE------------------");
List <Coordonnees> tabCoordonnees = new List <Coordonnees>();
tabCoordonnees.Add(C1);
tabCoordonnees.Add(C2);
Polyline P1 = new Polyline(tabCoordonnees, Colors.Red, 5);
Console.WriteLine("Polyline avec C1 et C2, red, 5...");
Console.WriteLine(P1);
Console.WriteLine("Methode DRAW");
P1.Draw();
Polyline P2 = new Polyline();
Console.WriteLine("Polyline constructeur par defaut");
Console.WriteLine(P2.ToString());
Console.WriteLine("Polyline nbr de coordonnees differentes : ");
Console.WriteLine("P2: ");
Console.WriteLine(P2.GetNbPoints());
Console.WriteLine("P1: ");
Console.WriteLine(P1.GetNbPoints());
Console.WriteLine("P1 --> changement de coordonnees : Coordonnees[] tabCoordonnees2 = { C1, C2, C1 };");
List <Coordonnees> tabCoordonnees2 = new List <Coordonnees>();
tabCoordonnees2.Add(C1);
tabCoordonnees2.Add(C2);
tabCoordonnees2.Add(C1);
P1.CollectionDeCoordonnes = tabCoordonnees2;
Console.WriteLine("P1: ");
Console.WriteLine(P1.GetNbPoints());
Console.WriteLine("Polyline P3 avec comme coordonnees (lat,long): (1,1) / (2,3) / (3,1)");
List <Coordonnees> triangle = new List <Coordonnees>();
triangle.Add(new Coordonnees(1, 1));
triangle.Add(new Coordonnees(2, 3));
triangle.Add(new Coordonnees(3, 1));
Polyline P3 = new Polyline(triangle, Colors.Green, 1);
Coordonnees pointEN22 = new Coordonnees(2, 2);
Console.WriteLine("IsPointClose entre P3 et pointEN22 (lat/long) : " + pointEN22.Latitude + " / " + pointEN22.Longitude);
Console.WriteLine("Precision = 0.5");
returnIsPointClose = P3.IsPointClose(pointEN22, 0.5);
if (returnIsPointClose)
{
Console.WriteLine("Point proche...");
}
else
{
Console.WriteLine("Point pas proche...");
}
Console.WriteLine("Meme IsPointClose MAIS avec une precision de 1.0");
returnIsPointClose = P3.IsPointClose(pointEN22, 1);
if (returnIsPointClose)
{
Console.WriteLine("Point proche...");
}
else
{
Console.WriteLine("Point pas proche...");
}
Polyline droiteTest = new Polyline();
droiteTest.CollectionDeCoordonnes.Add(new Coordonnees(1, 1));
droiteTest.CollectionDeCoordonnes.Add(new Coordonnees(4, 2));
Console.WriteLine("Coordonnées de la droite : ");
droiteTest.Draw();
Console.WriteLine("IsPointClose avec cette droite : avec 2,2 et une precision de 1");
Console.WriteLine("return de isPointClose : {0}", droiteTest.IsPointClose(new Coordonnees(2, 2), 1.0));
Console.WriteLine();
Console.WriteLine("IsPointClose avec cette droite : {0} avec 2,3 et une precision de 1", droiteTest.ToString());
Console.WriteLine("return de isPointClose : {0}", droiteTest.IsPointClose(new Coordonnees(2, 3), 1.0));
Console.WriteLine("------------------POLYGON------------------");
Polygon PN1 = new Polygon(tabCoordonnees, Colors.BurlyWood, Colors.Transparent, 0.5);
Console.WriteLine("Polygon avec C1 et C2, couleur remplissage=BurlyWood, couleur de contour=Transparent, opacite = 0.5");
Console.WriteLine(PN1);
Console.WriteLine("Methode DRAW");
PN1.Draw();
Console.WriteLine("set de opacite à 10 (interdit)");
PN1.Opacite = 10;
Console.WriteLine("nouvelle valeur de opacite : " + PN1.Opacite);
Console.WriteLine("constructeur avec opacite à -1 (interdit)");
Polygon PN3 = new Polygon(tabCoordonnees, Colors.BurlyWood, Colors.Transparent, -1);
Console.WriteLine(PN3);
Polygon PN2 = new Polygon();
Console.WriteLine("Polygon constructeur par defaut");
Console.WriteLine(PN2);
Console.WriteLine("Methode DRAW");
PN2.Draw();
Console.WriteLine("Polygon nbr de coordonnees differentes : ");
Console.WriteLine("PN2: ");
Console.WriteLine(PN2.GetNbPoints());
Console.WriteLine("PN1: ");
Console.WriteLine(PN1.GetNbPoints());
Console.WriteLine("PN1 --> changement de coordonnees : Coordonnees[] tabCoordonnees3 = { C1, C2, C1, new Coordonnees(19, 9) };");
List <Coordonnees> tabCoordonnees3 = new List <Coordonnees>();
tabCoordonnees3.Add(C1);
tabCoordonnees3.Add(C2);
tabCoordonnees3.Add(C1);
tabCoordonnees3.Add(new Coordonnees(19, 9));
PN1._collectionDeCoordonnees = tabCoordonnees3;
Console.WriteLine("PN1: ");
Console.WriteLine(PN1.GetNbPoints());
Console.WriteLine("Polygon PNtriangle avec comme coordonnees (lat,long): (1,1) / (2,3) / (3,1)");
Polygon PNtriangle = new Polygon(triangle, Colors.DarkRed, Colors.Blue, 50.0);
Coordonnees pointEN42 = new Coordonnees(4, 2);
Console.WriteLine("IsPointClose entre PNtriangle et pointEN42 (lat/long) : " + pointEN42.Latitude + " / " + pointEN42.Longitude);
Console.WriteLine("Precision = 1.0");
returnIsPointClose = PNtriangle.IsPointClose(pointEN42, 1.0);
if (returnIsPointClose)
{
Console.WriteLine("Point proche...");
}
else
{
Console.WriteLine("Point pas proche...");
}
Console.WriteLine("IsPointClose entre PNtriangle et pointEN22 (lat/long) : " + pointEN22.Latitude + " / " + pointEN22.Longitude);
Console.WriteLine("Precision = 1.0");
returnIsPointClose = PNtriangle.IsPointClose(pointEN22, 1.0);
if (returnIsPointClose)
{
Console.WriteLine("Point proche...");
}
else
{
Console.WriteLine("Point pas proche...");
}
Console.WriteLine("-------------------------------------------------------------------------------------------------------");
Console.WriteLine("---------ajouter ses objets dans une liste générique d'objet de type CartoOjb (List<CartoObj>)---------");
Console.WriteLine("-------------------------------------------------------------------------------------------------------");
List <CartoObj> listeDeCartoObj = new List <CartoObj>();
listeDeCartoObj.Add(C1);
listeDeCartoObj.Add(C2);
listeDeCartoObj.Add(Sraing);
listeDeCartoObj.Add(P1);
listeDeCartoObj.Add(P2);
listeDeCartoObj.Add(PN1);
listeDeCartoObj.Add(PN2);
listeDeCartoObj.Add(PN3);
Console.WriteLine();
Console.WriteLine("----------------------------------------------------------------------");
Console.WriteLine("---------afficher cette liste en utilisant le mot clé foreach---------");
Console.WriteLine("----------------------------------------------------------------------");
int i = 0;
foreach (CartoObj o in listeDeCartoObj)
{
Console.Write("Elm[{0}]", i);
o.Draw();
Console.WriteLine();
i++;
}
Console.WriteLine();
Console.WriteLine("-------------------------------------------------------------------------------");
Console.WriteLine("---------afficher la liste des objets implémentant l'interface IPointy---------");
Console.WriteLine("-------------------------------------------------------------------------------");
i = 0;
foreach (CartoObj o in listeDeCartoObj)
{
if (o is IPointy)
{
Console.Write("Elm[{0}]", i);
i++;
o.Draw();
Console.WriteLine();
}
}
Console.WriteLine();
Console.WriteLine("-----------------------------------------------------------------------------------------");
Console.WriteLine("---------afficher la liste des objets qui n'implémentent pas l'interface IPointy---------");
Console.WriteLine("-----------------------------------------------------------------------------------------");
i = 0;
foreach (CartoObj o in listeDeCartoObj)
{
if (!(o is IPointy))
{
Console.Write("Elm[{0}]", i);
i++;
o.Draw();
Console.WriteLine();
}
}
Console.WriteLine();
Console.WriteLine("---------------------------------------------------------------------");
Console.WriteLine("---------Créer une liste générique de 5 Polyline, l’afficher---------");
Console.WriteLine("---------------------------------------------------------------------");
List <Polyline> listeGeneriquePolyline = new List <Polyline>();
listeGeneriquePolyline.Add(P1);
P2.CollectionDeCoordonnes = tabCoordonnees3;
listeGeneriquePolyline.Add(P2);
listeGeneriquePolyline.Add(P3);
listeGeneriquePolyline.Add(new Polyline(tabCoordonnees, Colors.Black, 19));
i = 0;
foreach (Polyline P in listeGeneriquePolyline)
{
Console.WriteLine("listeGeneriquePolyline[{0}]", i);
P.Draw();
Console.WriteLine();
i++;
}
Console.WriteLine();
Console.WriteLine("-----------------------------------------------------------------------------------");
Console.WriteLine("---------la trier par ordre de longueur croissante1 , l’afficher à nouveau---------");
Console.WriteLine("-----------------------------------------------------------------------------------");
listeGeneriquePolyline.Sort();
i = 0;
foreach (Polyline P in listeGeneriquePolyline)
{
Console.WriteLine("listeGeneriquePolyline[{0}]", i);
Console.WriteLine("longueur totale : {0}", P.longueurPolyline());
P.Draw();
Console.WriteLine();
i++;
}
Console.WriteLine();
Console.WriteLine("-------------------------------------------------------------------------------------------------");
Console.WriteLine("---------la trier par ordre croissante de surface de bounding box , l’afficher à nouveau---------");
Console.WriteLine("-------------------------------------------------------------------------------------------------");
MyPolylineBoundingBoxComparer triParSurface = new MyPolylineBoundingBoxComparer();
listeGeneriquePolyline.Sort(triParSurface);
i = 0;
foreach (Polyline P in listeGeneriquePolyline)
{
Console.WriteLine("listeGeneriquePolyline[{0}]", i);
Console.WriteLine("surface : {0}", P.surfaceBoundingBox());
P.Draw();
Console.WriteLine();
i++;
}
Console.WriteLine("Find P1 ? {0}", listeGeneriquePolyline.Find(x => x.Id == P1.Id));
Console.WriteLine();
Console.WriteLine("-------------------------------------------------------------------------------------------------------------------");
Console.WriteLine("---------la trier par ordre croissante de nombre d'objet (différent) de coordonnees , l’afficher à nouveau---------");
Console.WriteLine("-------------------------------------------------------------------------------------------------------------------");
NbrCoordonneesComparer triParNbrDeCoordonnees = new NbrCoordonneesComparer();
listeGeneriquePolyline.Sort(triParNbrDeCoordonnees);
i = 0;
foreach (Polyline P in listeGeneriquePolyline)
{
Console.WriteLine("listeGeneriquePolyline[{0}]", i);
Console.WriteLine("nbr de coordonnees differentes : {0}", P.GetNbPoints());
P.Draw();
Console.WriteLine();
i++;
}
Console.WriteLine();
Console.WriteLine("-----------------------------------");
Console.WriteLine("---------MyPersonalMapData---------");
Console.WriteLine("-----------------------------------");
//MyPersonalMapData TestmyPersonalMapData = new MyPersonalMapData();
//Console.WriteLine("MyPersonalMapData : constructeur par defaut");
//Console.WriteLine(TestmyPersonalMapData.ToString());
//Console.WriteLine("\nConstructeur avec paramètres...");
//string nom;
//Console.Write("Saisir votre nom : "); nom = Console.ReadLine();
//string prenom;
//Console.Write("Saisir votre prenom : "); prenom = Console.ReadLine();
//string email;
//Console.Write("Saisir votre email : "); email = Console.ReadLine();
ObservableCollection <ICartoObj> newObservableCollectionCartoObj = new ObservableCollection <ICartoObj>();
newObservableCollectionCartoObj.Add(Sraing);
newObservableCollectionCartoObj.Add(P1);
newObservableCollectionCartoObj.Add(PNtriangle);
MyPersonalMapData Test2myPersonalMapData = new MyPersonalMapData("zeevaert", "arnaud", "*****@*****.**", newObservableCollectionCartoObj);
Console.WriteLine("MyPersonalMapData : new MyPersonalMapData(zeevaert, arnaud, [email protected], listeDeCartoObj);");
Console.WriteLine(Test2myPersonalMapData.ToString());
//newObservableCollectionCartoObj.ge
string inutile;
inutile = Console.ReadLine();
}
static void Main(string[] args)
{
try
{
//objet pour les tests!
POI tPoi = new POI(), tPoi0 = new POI(0, 0);
POI tPoi1 = new POI(1, 0), tPoi2 = new POI(2, 0);
POI tPoi3 = new POI(0, 1), tPoi4 = new POI(1, 2);
POI tPoi5 = new POI(2, 1), tPoi6 = new POI(0, 2);
POI tPoi7 = new POI(1, 2), tPoi8 = new POI(2, 2);
Polyline tPolyline = new Polyline();
Polyline tPolyline1 = new Polyline(), tPolyline2 = new Polyline();
Polyline tPolyline3 = new Polyline(), tPolyline4 = new Polyline();
Polygon tPolygon1 = new Polygon(), tPolygon2 = new Polygon();
Polygon tPolygon3 = new Polygon(), tPolygon4 = new Polygon();
//construction des polyline et polygon
tPolyline1.LPOI.Add(tPoi0); tPolyline1.LPOI.Add(tPoi1); tPolyline1.LPOI.Add(tPoi3);
tPolyline2.LPOI.Add(tPoi0); tPolyline2.LPOI.Add(tPoi2); tPolyline2.LPOI.Add(tPoi6);
tPolyline3.LPOI.Add(tPoi6); tPolyline3.LPOI.Add(tPoi7); tPolyline3.LPOI.Add(tPoi8); tPolyline3.LPOI.Add(tPoi4);
tPolygon1.LPolyline.Add(tPolyline2);
tPolygon2.LPolyline.Add(tPolyline2); tPolygon2.LPolyline.Add(tPolyline1);
tPolygon3.LPolyline.Add(tPolyline2);
tPolygon3.LPolyline.Add(tPolyline3);
tPolygon3.LPolyline.Add(tPolyline1);
//list de base pour test normaux
List <CartoObj> lCartoObj = new List <CartoObj>();
lCartoObj.Add(tPoi2);
lCartoObj.Add(tPolyline2);
lCartoObj.Add(tPolygon2);
lCartoObj.Add(tPolyline1);
//list de polyline trié
List <Polyline> lPolyline = new List <Polyline>();
lPolyline.Add(tPolyline1);
lPolyline.Add(tPolyline3);
lPolyline.Add(tPolyline2);
lPolyline.Add(tPolyline3);
lPolyline.Add(tPolyline);
char lec = '1';
Console.Write("Veuillez entrez le numero de test voulu :");
lec = (char)Console.Read();
while (lec != 'q')
{
switch (lec)
{
case '1':
// Test 1
//affichage test1
Console.WriteLine("Affichage du test 1 :");
Console.WriteLine("Zone POI :");
tPoi1.Draw();
tPoi2.Draw();
Console.WriteLine("\nZone Polyline :");
tPolyline1.Draw();
tPolyline2.Draw();
Console.WriteLine("\nZone Polygon :");
tPolygon1.Draw();
tPolygon2.Draw();
break;
case '2':
case '3':
//test 2 et 3
// Afficher cette liste en utilisant le mot clé foreach,
Console.WriteLine("Affichage du test 2 et 3 :");
foreach (CartoObj tmpCartoObj in lCartoObj)
{
tmpCartoObj.Draw();
}
break;
case '4':
//test 4
//Afficher la liste des objets cartographiques implémentant l’interface IPointy,
Console.WriteLine("Affichage du test 4:");
foreach (CartoObj tmpCartoObj in lCartoObj)
{
if (tmpCartoObj is IPointy)
{
tmpCartoObj.Draw();
Console.WriteLine("Nombre de points : " + (tmpCartoObj as IPointy).NbPoints);
}
}
break;
case '5':
//test 5
// Afficher la liste des objets cartographiques n’implémentant pas l’interface IPointy,
int i = 0;
Console.WriteLine("Affichage du test 5:");
foreach (CartoObj tmpCartoObj in lCartoObj)
{
if (!(tmpCartoObj is IPointy))
{
tmpCartoObj.Draw();
i++;
}
}
break;
case '6':
//test 6
// Créer une liste générique de 5 Polyline, l’afficher,
// la trier par ordre de longueur croissante1, l’afficher à nouveau.
// Pour trier, la méthode Sort() de la classe List<T> utilise la méthode CompareTo()
// définie grâce à l’implémentation dans la classe Polyline
// de l’interface Icomparable<Polyline>,
Console.WriteLine("Affichage du test 6: liste polyline non trié:\n");
foreach (Polyline tmpPolyline in lPolyline)
{
tmpPolyline.Draw();
}
lPolyline.Sort();
Console.WriteLine("\n\n\nAffichage liste polyline trié:\n");
foreach (Polyline tmpPolyline in lPolyline)
{
tmpPolyline.Draw();
}
break;
case '7':
// test 7
// Sans modifier la méthode CompareTo(), trier la précédente liste par ordre croissant
// de taille de la surface de la bounding box englobant la polyline.
// Pour ce faire, il s’agit de créer une classe MyPolylineBoundingBoxComparer
// implémentant l’interface IComparer<Polyline>,
MyPolylineBoundingBoxComparer polylineCmp = new MyPolylineBoundingBoxComparer();
CartoObj.Precision = 1;
Console.WriteLine("Affichage du test 7: liste polyline non trié:\n");
foreach (Polyline tmpPolyline in lPolyline)
{
tmpPolyline.Draw();
}
lPolyline.Sort(polylineCmp);
Console.WriteLine("\n\n\nAffichage liste polyline trié par taille bouding box:\n");
foreach (Polyline tmpPolyline in lPolyline)
{
tmpPolyline.Draw();
Console.WriteLine(" bouding : " + tmpPolyline.BoudingBox);
}
break;
case '8':
// test 8
// Rechercher, parmi les polyline de la liste,
// celles qui présentent la même taille qu’une polyline de référence.
// Pour ce faire, il s’agit d’implémenter l’interface IEquatable<Polyline>,
Console.WriteLine("Test 8 :");
Console.WriteLine("Polyline de ref : ");
tPolyline1.Draw();
Console.WriteLine("\n");
foreach (Polyline tmpPolyline in lPolyline)
{
tmpPolyline.Draw();
if (tmpPolyline.Equals(tPolyline1))
{
// les deux polyline on la même longueur
Console.WriteLine("Equals !!");
}
else
{
Console.WriteLine("Not Equals!!!");
}
}
break;
case '9':
// test 9
// Rechercher, parmi les polyline de la liste,
// celles qui sont proches d’un point passé en paramètre.
// Pour ce faire, il s’agit d’utiliser la méthode IsPointClose()
// contenue dans l’interface IIsPointClose.
double x = 0.5, y = 0.5, preci = 0.9;
Console.Write(" Point (" + x + "," + y + ") \n\n");
foreach (Polyline tmpPolyline in lPolyline)
{
tmpPolyline.Draw();
if (tmpPolyline.IsPointClose(x, y, preci) == true)
{
Console.WriteLine("Proche !");
}
else
{
Console.WriteLine(" Eloignee !!");
}
}
break;
default:
Console.Clear();
Console.WriteLine("Mauvais numero !!!");
break;
}
Console.ReadKey();
Console.Clear();
Console.Write("Veuillez entrez le numero de test voulu :");
lec = (char)Console.Read();
}
}
catch (Exception r)
{
Console.WriteLine("ERREUR !!! " + r.ToString());
Console.ReadKey();
}
}