static void Main()
{
List <Coordonnees> squareCoords = new List <Coordonnees> {
new Coordonnees(0, 0),
new Coordonnees(0, 10),
new Coordonnees(10, 10),
new Coordonnees(10, 0)
};
List <Coordonnees> rectCoords = new List <Coordonnees> {
new Coordonnees(0, 0),
new Coordonnees(25, 0),
new Coordonnees(25, 10),
new Coordonnees(0, 10)
};
List <Coordonnees> rand1Coords = new List <Coordonnees> {
new Coordonnees(0, 0),
new Coordonnees(20, 0),
new Coordonnees(25, 10),
new Coordonnees(0, 10)
};
List <Coordonnees> rand2Coords = new List <Coordonnees> {
new Coordonnees(0, 0),
new Coordonnees(5, 5),
new Coordonnees(5, 2),
new Coordonnees(3, 1)
};
List <Coordonnees> rand3Coords = new List <Coordonnees> {
new Coordonnees(0, 0),
new Coordonnees(0, 15),
new Coordonnees(5, 10),
new Coordonnees(5, 0),
new Coordonnees(9, 9)
};
Polyline pl1 = new Polyline(squareCoords), pl2 = new Polyline(pl1);
Polygon pg1 = new Polygon(pl1), pg2 = new Polygon(rand3Coords);
Coordonnees coord1 = new Coordonnees(12, 7), coord2 = new Coordonnees();
POI poi1 = new POI(), poi2 = new POI(7, 9, "Second one");
List <CartoObj> cartoObjs = new List <CartoObj> {
pl1, pl2, pg1, pg2, coord1, coord2, poi1, poi2
};
Console.WriteLine("All elements:\n");
foreach (CartoObj cartoObj in cartoObjs)
{
Console.WriteLine(cartoObj + "\n");
}
Console.WriteLine("\n-----------------------------------------------\nIPointy elements:\n");
foreach (CartoObj cartoObj in cartoObjs)
{
if (cartoObj is IPointy)
{
cartoObj.Draw();
}
}
Console.WriteLine("\n-----------------------------------------------\nNot IPointy elements:\n");
foreach (CartoObj cartoObj in cartoObjs)
{
if (!(cartoObj is IPointy))
{
cartoObj.Draw();
}
}
Console.WriteLine("\n-----------------------------------------------\nThe 5 polylines:\n");
List <Polyline> polylines = new List <Polyline> {
pl1, pl2,
new Polyline(rand1Coords),
new Polyline(rand2Coords),
new Polyline(rand3Coords)
};
foreach (Polyline polyline in polylines)
{
polyline.Draw();
}
Console.WriteLine("\n-----------------------------------------------\nSorted polylines (by perimeter):\n");
polylines.Sort();
foreach (Polyline polyline in polylines)
{
Console.WriteLine(polyline.GetPerimeter().ToString("0.00") + "cm => (#" + polyline.Id + ") " + polyline.GetType());
}
Console.WriteLine("\n-----------------------------------------------\nSorted polylines (by bouding box area):\n");
MyPolylineBoundingBoxComparer comparer = new MyPolylineBoundingBoxComparer();
polylines.Sort(comparer);
foreach (Polyline polyline in polylines)
{
Console.WriteLine(polyline.GetBoundingBoxArea().ToString("0.00") + "cm^2 => (#" + polyline.Id + ") " + polyline.GetType());
}
Console.WriteLine("\n-----------------------------------------------\nFind same polylines:\n");
Polyline toFind = new Polyline(), findResult = polylines.Find(x => x.GetPerimeter() == toFind.GetPerimeter());
if (findResult != null)
{
Console.WriteLine("Polyline #{0} ({1}cm)\nHas the same perimeter as\nPolyline #{2} ({3}cm)", findResult.Id, findResult.GetPerimeter(), toFind.Id, toFind.GetPerimeter());
}
else
{
Console.WriteLine("No polylines have the same perimeter.");
}
Coordonnees pointToFind = new Coordonnees(2, 2);
Console.WriteLine("\n-----------------------------------------------\nPolylines that are near the point: {0}\n", pointToFind);
double precision = 5;
foreach (Polyline polyline in polylines)
{
if (polyline.IsPointClose(pointToFind, precision))
{
Console.WriteLine("Polyline #{0} is near the point!", polyline.Id);
}
}
Console.WriteLine("\n-----------------------------------------------\nSorted cartoObjs (number of Coordonnees objects contained in it):\n");
MyCartoObjCoordonneesComparer comparer2 = new MyCartoObjCoordonneesComparer();
cartoObjs.Sort(comparer2);
foreach (CartoObj cartoObj in cartoObjs)
{
Console.WriteLine(cartoObj.GetCoordonneesNb() + " coordonnees => (#" + cartoObj.Id + ") " + cartoObj.GetType());
}
Console.ReadKey();
}
static void Main(string[] args)
{
#region DECLARATION
Coordonnees c = new Coordonnees(150, 120);
Coordonnees cDef = new Coordonnees();
POI poi = new POI(125, 38, "Test");
POI poiDef = new POI();
List <Coordonnees> maliste = new List <Coordonnees>();
{
maliste.Add(c);
maliste.Add(cDef);
}
Polyline pl = new Polyline(maliste, Color.FromRgb(255, 0, 0), 17);
Polyline plDef = new Polyline();
Polygon pg = new Polygon("", Colors.Red, Colors.Blue, 0, maliste);
Polygon pgDef = new Polygon();
List <CartoObj> listeCO = new List <CartoObj>()
{
c, cDef, poi, poiDef, pl, plDef, pg, pgDef
};
// Polyline
List <Coordonnees> listCD2 = new List <Coordonnees>();
{
listCD2.Add(new Coordonnees(6, 9));
listCD2.Add(new Coordonnees(7, 2));
}
List <Coordonnees> listCD4 = new List <Coordonnees>();
{
listCD4.Add(new Coordonnees(8, 4));
listCD4.Add(new Coordonnees(3, 0));
listCD4.Add(new Coordonnees(2, 9));
}
List <Coordonnees> listCD5 = new List <Coordonnees>();
{
listCD5.Add(new Coordonnees(8, 3));
listCD5.Add(new Coordonnees(3, 3));
listCD5.Add(new Coordonnees(5, 7));
}
Polyline pl1 = new Polyline();
Polyline pl2 = new Polyline(listCD2, Colors.Aqua, 5);
Polyline pl3 = new Polyline();
Polyline pl4 = new Polyline(listCD4, Colors.Red, 7);
Polyline pl5 = new Polyline(listCD5, Colors.Green, 9);
List <Polyline> listePL = new List <Polyline>()
{
pl1, pl2, pl3, pl4, pl5
};
MyPersonalMapData mdataDef = new MyPersonalMapData();
mdataDef.OcICartoObj.Add(poiDef); // plante
mdataDef.OcICartoObj.Add(pgDef);
mdataDef.OcICartoObj.Add(plDef);
Polygon prout = new Polygon("", Colors.RosyBrown, Colors.Teal, 15, listCD4);
ObservableCollection <ICartoObj> OCtest = new ObservableCollection <ICartoObj>();
{
OCtest.Add(prout);
OCtest.Add(pl2);
OCtest.Add(poiDef);
}
MyPersonalMapData mdata = new MyPersonalMapData("Jooris", "Yannick", "*****@*****.**", OCtest);
// test depuis le 15/04
Polyline pl10 = new Polyline(Colors.White, 10);
Polyline pl11 = new Polyline(Colors.Blue, 11);
#endregion
#region TESTS
bool exit = false;
ConsoleKeyInfo choix;
while (!exit)
{
PrintMenu();
choix = Console.ReadKey();
Console.Clear();
switch (choix.Key)
{
case ConsoleKey.D1:
#region TEST 01
Console.WriteLine("Test Coordonnées: ");
Console.WriteLine(c.ToString());
Console.WriteLine(cDef.ToString());
Console.ReadKey();
Console.Clear();
Console.WriteLine("Test POI: ");
Console.WriteLine(poi.ToString());
Console.WriteLine(poiDef.ToString());
Console.ReadKey();
Console.Clear();
Console.WriteLine("Test Polyline: ");
pl.Draw();
plDef.Draw();
Console.ReadKey();
Console.Clear();
Console.WriteLine("Test Polygon: ");
pg.Draw();
pgDef.Draw();
Console.ReadKey();
Console.Clear();
#endregion
break;
case ConsoleKey.D2:
#region TEST 02
Console.WriteLine("Liste générique d'objets CartoObjs: ");
foreach (CartoObj co in listeCO)
{
co.Draw();
}
Console.ReadKey();
Console.Clear();
Console.WriteLine("Objets implémentant IPointy: ");
foreach (CartoObj co in listeCO)
{
if (co is IPointy)
{
Console.WriteLine(co.ToString() + "\n");
}
}
Console.ReadKey();
Console.Clear();
Console.WriteLine("Objets n'implémentant pas IPointy: ");
foreach (CartoObj co in listeCO)
{
if (!(co is IPointy))
{
Console.WriteLine(co.ToString() + "\n");
}
}
Console.ReadKey();
Console.Clear();
#endregion
break;
case ConsoleKey.D3:
#region TEST 03
Console.WriteLine("Liste générique de 5 objets Polyline: ");
foreach (Polyline polyline in listePL)
{
polyline.Draw();
}
Console.ReadKey();
Console.Clear();
Console.WriteLine("Tri par ordre croissant de longueur:");
listePL.Sort();
foreach (Polyline polyline in listePL)
{
polyline.Draw();
}
Console.ReadKey();
Console.Clear();
Console.WriteLine("Tri par ordre croissant de surface:");
MyPolylineBoundingBoxComparer polylineCmp = new MyPolylineBoundingBoxComparer();
listePL.Sort(polylineCmp);
foreach (Polyline polyline in listePL)
{
polyline.Draw();
}
Console.ReadKey();
Console.Clear();
#endregion
break;
case ConsoleKey.D4:
#region TEST 04
Console.WriteLine("Comparaison à un Polyline de référence:");
listePL.Add(pl2);
foreach (Polyline polyline in listePL.FindAll(cmp => cmp.Equals(pl1)))
{
Console.WriteLine(polyline.ToString());
}
listePL.Remove(pl2);
Console.ReadKey();
Console.Clear();
Console.WriteLine("Polylines proches d'un point passé en paramètre:");
foreach (Polyline polyline in listePL)
{
if (polyline.IsPointClose(5, 5, 2))
{
Console.WriteLine(polyline.ToString());
}
}
Console.ReadKey();
Console.Clear();
#endregion
break;
case ConsoleKey.D5:
#region TEST 05
Console.WriteLine("Mécanisme qui trie une liste de CartoObjs selon le nombre de coordonnées:");
foreach (CartoObj co in listeCO)
{
Console.WriteLine(co.ToString() + "\n");
}
Console.ReadKey();
Console.Clear();
MyNombreCoordonneesComparer ncComparer = new MyNombreCoordonneesComparer();
listeCO.Sort(ncComparer);
foreach (CartoObj co in listeCO)
{
Console.WriteLine(co.ToString() + "\n");
}
#endregion
break;
case ConsoleKey.D6:
#region TEST 06
Console.WriteLine("Test d'objets MyPersonalMapData et de leurs méthodes");
Console.WriteLine(mdataDef.ToString() + "\n");
Console.WriteLine(mdata.ToString());
Console.ReadKey();
//Console.Clear();
Console.WriteLine("Test BinaryFormatter (save)");
Console.WriteLine("Saving...");
mdata.Save(@"C:\Users\Yannick\OneDrive\Prog\mapdata.dat");
Console.WriteLine("Done!");
Console.ReadKey();
//Console.Clear();
Console.WriteLine("Test BinaryFormatter (load)");
MyPersonalMapData fromfile = new MyPersonalMapData("Jooris", "Yannick", "3");
Console.WriteLine("Loading...");
fromfile.Load(@"C:\Users\Yannick\OneDrive\Prog\mapdata.dat");
Console.WriteLine("Done!");
Console.WriteLine(fromfile.ToString());
Console.ReadKey();
#endregion
break;
case ConsoleKey.D7:
#region TEST 07
Console.WriteLine("Resultat CompareTo: " + pl10.CompareTo(pl11));
Console.ReadKey();
#endregion
break;
case ConsoleKey.D8:
#region TEST 08
Console.ReadKey();
#endregion
break;
case ConsoleKey.Escape:
exit = true;
break;
}
}
#endregion
}
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)
{
Coordonnees coordonnees = new Coordonnees(1, 1);
Polygon polygon = new Polygon(coordonnees, Colors.Black, Colors.Black, 1);
polygon.Coordonnees.Add(new Coordonnees(2, 4));
polygon.Coordonnees.Add(new Coordonnees(5, 3));
polygon.Coordonnees.Add(new Coordonnees(6, 1));
Console.WriteLine(polygon.ToString());
Console.WriteLine("Le point est il proche selon la precision : {0}", polygon.IsPointClose(new Coordonnees(3, 1), 1));
Console.WriteLine("Le point est il proche selon la precision : {0}", polygon.IsPointClose(new Coordonnees(8, 3), 1));
Console.WriteLine("Nombre de point du polygon : {0}", polygon.NbPoints);
POI poi = new POI();
Polygon polygon1 = new Polygon(new Coordonnees(2, 2), Colors.Black, Colors.Black, 1);
Polygon polygon2 = new Polygon();
Polyline polyline1 = new Polyline(null, Colors.Black, 1);
Polyline polyline2 = new Polyline();
polygon2.Coordonnees.Add(new Coordonnees(2, 4));
polygon2.Coordonnees.Add(new Coordonnees(5, 3));
polygon2.Coordonnees.Add(new Coordonnees(6, 1));
polyline2.Coordonnees.Add(new Coordonnees(0, 0));
polyline2.Coordonnees.Add(new Coordonnees(0, 1));
polyline2.Coordonnees.Add(new Coordonnees(1, 1));
polyline2.Coordonnees.Add(new Coordonnees(1, 0));
polyline1.Coordonnees.Add(new Coordonnees(10, 0));
polyline1.Coordonnees.Add(new Coordonnees(8, 8));
polyline1.Coordonnees.Add(new Coordonnees(10, 10));
Console.WriteLine("\n\n polygon 1 : ");
Console.WriteLine(polygon1.ToString());
Console.WriteLine("\n\n polygon 2 : ");
Console.WriteLine(polygon2.ToString());
Console.WriteLine("\n\n polyline 1 : ");
Console.WriteLine(polyline1.ToString());
Console.WriteLine("\n\n polyline 2 : ");
Console.WriteLine(polyline2.ToString());
Console.WriteLine("Le point est il proche selon la precision : {0}", polygon2.IsPointClose(new Coordonnees(1, 5), 1));
Console.WriteLine("Le point est il proche selon la precision : {0}", polygon2.IsPointClose(new Coordonnees(5, 1), 1));
List <CartoObj> ListCart = new List <CartoObj>
{
polyline1,
polyline2,
polygon2,
new Coordonnees(),
polygon1,
poi
};
Console.WriteLine("\n\n\n-- Liste de CartoObj --");
foreach (CartoObj cart in ListCart)
{
Console.WriteLine(cart.ToString());
}
List <IPointy> IP = new List <IPointy>
{
polygon1,
polyline2,
polygon2,
polyline1
};
Console.WriteLine("\n\n\n-- Liste de IPointy --");
foreach (IPointy ip in IP)
{
Console.WriteLine(ip.ToString());
}
List <Polyline> t = new List <Polyline>
{
polyline1,
polyline2
};
Console.WriteLine("\n\n\n-- Liste de Polyline avant sort --");
foreach (CartoObj cart in t)
{
Console.WriteLine(cart.ToString());
}
t.Sort();
Console.WriteLine("\n\n\n-- Liste de Polyline apres sort --");
foreach (CartoObj cart in t)
{
Console.WriteLine(cart.ToString());
}
MyPolylineBoundingBoxComparer mpoly = new MyPolylineBoundingBoxComparer();
Console.WriteLine("\n\n\n-- Tri par la longueur du bounding --");
t.Sort(mpoly);
foreach (Polyline cart in t)
{
Console.WriteLine(cart.ToString());
}
Console.WriteLine("\n\n\n-- Find --");
Console.WriteLine(t.Find(x => x.CalculLongueur() == 0));
Console.WriteLine("\n\n\n-- FindAll --");
List <Polyline> poly = t.FindAll(x => x.CalculLongueur() == 3);
Affiche(poly);
Console.WriteLine("\n\n\n-- FindAll ISPointClose --");
poly = t.FindAll(x => x.IsPointClose(new Coordonnees(1, 0.5), 1));
Affiche(poly);
Console.WriteLine("\n\n\n-- Compare CartoObj --");
Console.WriteLine("\n-- UnSort --");
CartoComparer carte = new CartoComparer();
foreach (CartoObj obj in ListCart)
{
Console.WriteLine(obj.ToString());
Console.WriteLine("----------------------------------------------------------");
}
Console.WriteLine("\n\n-- Sort --");
ListCart.Sort(carte);
foreach (CartoObj obj in ListCart)
{
Console.WriteLine(obj.ToString());
Console.WriteLine("----------------------------------------------------------");
}
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)
{
//Constructeur par defaut
Coordonnees c1 = new Coordonnees();
POI poi1 = new POI();
Polyline PolyL1 = new Polyline();
Polygon PolyG1 = new Polygon();
//Constructeur d'initialisation
Coordonnees c2 = new Coordonnees(2, 2);
Coordonnees c3 = new Coordonnees(4, -2);
Coordonnees c4 = new Coordonnees(1, -5);
Coordonnees c5 = new Coordonnees(-3, 0);
Coordonnees c6 = new Coordonnees(5, 5);
POI poi2 = new POI("Magnée", c3);
Coordonnees[] tab1 = { new Coordonnees(2, 0), new Coordonnees(-4, 0), new Coordonnees(-4, -4) };
Coordonnees[] tab2 = { c3, c2, c4, c5, c6 };
Coordonnees[] tab3 = { new Coordonnees(3, 3), new Coordonnees(3, 8), new Coordonnees(2, 8) };
Coordonnees[] tab4 = { new Coordonnees(-3, 3), new Coordonnees(0, 5), new Coordonnees(5, 2), new Coordonnees(2, -4), new Coordonnees(-2, -3) };
Coordonnees[] tabref = { new Coordonnees(0, 0), new Coordonnees(6, 0) };
Polyline PolyL2 = new Polyline(tab1, Colors.Blue, 10);
Polygon PolyG2 = new Polygon(tab2, Colors.Lime, Colors.Aqua, 1);
Polyline pol1 = new Polyline(tab1, Colors.Azure, 5);
Polyline pol2 = new Polyline(tab2, Colors.CornflowerBlue, 2);
Polyline pol3 = new Polyline(tab3, Colors.Coral, 7);
Polyline pol4 = new Polyline(tab4, Colors.DarkRed, 9);
Polyline Reference = new Polyline(tabref, Colors.DarkBlue, 2);
MyPolylineBoundingBoxComparer pcomp = new MyPolylineBoundingBoxComparer();
CartoObjComparer ocomp = new CartoObjComparer();
//Liste générique
List <CartoObj> cartoObj = new List <CartoObj>()
{
c1,
c2,
poi1,
poi2,
PolyL1,
PolyL2,
PolyG1,
PolyG2
};
List <Polyline> polyline = new List <Polyline>()
{
pol1,
pol2,
pol3,
pol4
};
Console.WriteLine("==============================================");
Console.WriteLine("------ c1 (Cpd) ---------");
Console.WriteLine(c1);
Console.WriteLine("------ poi1 (Cpd) -------");
Console.WriteLine(poi1);
Console.WriteLine("\n==============================================");
Console.WriteLine("------ c2 (Cinit) -------");
Console.WriteLine(c2);
Console.WriteLine("------ poi2 (Cinit) -----");
Console.WriteLine(poi2);
Console.WriteLine("\n==============================================");
Console.WriteLine("------ PolyL1 (Cpd) -----");
PolyL1.Draw();
Console.WriteLine("\n------ PolyG1 (Cpd) -----");
PolyG1.Draw();
Console.WriteLine("\n==============================================");
Console.WriteLine("------ PolyL2 (Cinit) -----");
PolyL2.Draw();
Console.WriteLine("\n------ PolyG2 (Cinit) -----");
PolyG2.Draw();
Console.WriteLine("\n==============================================");
Console.WriteLine("\nc1 IsPointClose c2");
Console.WriteLine("---> " + c1.IsPointClose(new Coordonnees(1, 6), 6));
Console.WriteLine("\npoi1 IsPointClose poi2");
Console.WriteLine("---> " + poi1.IsPointClose(poi2, 4.9));
Console.WriteLine("\nPolyline IsPointClose c");
Console.WriteLine("---> " + PolyL2.IsPointClose(new Coordonnees(-3, -4), 1.1));
Console.WriteLine("\nPolygon IsPointClose c");
Console.WriteLine("---> " + PolyG2.IsPointClose(new Coordonnees(-3, 3), 0));
Console.WriteLine("\nNbrPoint PolyLline");
Console.WriteLine("---> " + PolyL2.GetNumberOfPoint());
Console.WriteLine("\nNbrPoint Polygon");
Console.WriteLine("---> " + PolyG2.GetNumberOfPoint());
Console.WriteLine("\n==============================================");
Console.WriteLine("\nAffichage de la liste générique de CartoObj\n");
foreach (CartoObj c in cartoObj)
{
c.Draw();
}
Console.WriteLine("\n==============================================");
Console.WriteLine("\nAffichage des CartoObj IPointy\n");
foreach (CartoObj c in cartoObj)
{
if (c is IPointy)
{
c.Draw();
Console.WriteLine("-----> is Ipointy\n");
}
}
Console.WriteLine("\n==============================================");
Console.WriteLine("\nAffichage des CartoObj qui ne sont pas IPointy\n");
foreach (CartoObj c in cartoObj)
{
if (!(c is IPointy))
{
Console.WriteLine(c + " is not Ipointy");
}
}
Console.WriteLine("\n==============================================");
Console.WriteLine("\nAffichage de la liste générique de polyline\n");
foreach (Polyline p in polyline)
{
p.Draw();
Console.WriteLine("Longueur du Polyline = " + MathUtile.Longueur(p.Collection) + "\n");
}
Console.WriteLine("\n==============================================");
Console.WriteLine("\nAffichage des polyline trier par ordre de longueur\n");
polyline.Sort();
foreach (Polyline p in polyline)
{
p.Draw();
Console.WriteLine("Longueur du Polyline = " + MathUtile.Longueur(p.Collection) + "\n");
}
Console.WriteLine("\n==============================================");
Console.WriteLine("\nAffichage des polyline trier par ordre de surface de BoundingBox\n");
polyline.Sort(pcomp);
foreach (Polyline p in polyline)
{
p.Draw();
Console.WriteLine("Surface de la BoundingBox = " + p.PolylineBoundingBox() + "\n");
}
Console.WriteLine("\n==============================================");
Console.WriteLine("\nRecherche si une liste de Polyline contient un polyline de même longueur qu'un polyline de reference\n");
double longueur = MathUtile.Longueur(Reference.Collection);
Polyline res = polyline.Find(x => MathUtile.Longueur(x.Collection) == longueur);
if (res == null)
{
Console.WriteLine("Aucune Polyline trouver");
}
else
{
Console.WriteLine("Longueur polyline de reference = " + longueur);
Console.WriteLine("Longueur polyline trouver = " + MathUtile.Longueur(res.Collection));
res.Draw();
}
Console.WriteLine("\n==============================================");
Console.WriteLine("\nAffichage des polyline qui sont proche d'un point\n");
int cpt = 0;
foreach (Polyline p in polyline)
{
if ((p.IsPointClose(new Coordonnees(0, 0), 1)) == true)
{
Console.WriteLine("Ce polyline est proche du point");
p.Draw();
cpt++;
}
}
if (cpt == 0)
{
Console.WriteLine("Aucun Polyline n'est proche du point...");
}
Console.WriteLine("\n==============================================");
Console.WriteLine("\nAffichage d'une liste de CartoObj trier par nombre de point\n");
cartoObj.Sort(ocomp);
foreach (CartoObj c in cartoObj)
{
c.Draw();
Console.WriteLine("Nombre de point -------> " + c.NbrPointCarto() + "\n");
}
Console.ReadKey();
}
public static void Main(string[] args)
{
Console.WriteLine("************COORDONNEES************\n");
Coordonnees A = new Coordonnees(40.25, 48.25);
Coordonnees B = new Coordonnees(2.25, 12.25);
Coordonnees C = new Coordonnees(3.45, 50.45);
Coordonnees D = new Coordonnees(3.25, 10.45);
Coordonnees Z = new Coordonnees(5.2, 11);
A.latitude = 41.2;
Console.WriteLine(A.ToString());
Console.WriteLine(C.ToString());
Console.WriteLine("\n**************POI**************\n");
POI E = new POI();
POI F = new POI("ici", 25.2, 1.25);
POI Y = new POI("ok", 14, 2);
Console.WriteLine(E.ToString());
Console.WriteLine(F.ToString());
Console.WriteLine("\n**************** Polyline******************\n");
Polyline Poly1 = new Polyline(new List <Coordonnees>()
{
A, D, Y
}, 10, Color.FromArgb(255, 255, 255, 255), 1);
Polyline Poly2 = new Polyline(new List <Coordonnees>()
{
E, F
}, 15, Color.FromArgb(0, 0, 0, 0), 1);
Polyline Poly3 = new Polyline(new List <Coordonnees>()
{
Z, A
}, 11, Color.FromArgb(254, 0, 211, 0), 0);
Polyline Poly4 = new Polyline(new List <Coordonnees>()
{
Z, B
}, 11, Color.FromArgb(254, 158, 251, 0), 0);
Console.WriteLine(Poly1.ToString());
Console.WriteLine(Poly2.ToString());
Console.WriteLine("\n**************Polygone**********************\n");
Polygone Polygone = new Polygone(new List <Coordonnees>()
{
A, D, E
}, Color.FromArgb(165, 187, 195, 0), Color.FromArgb(165, 200, 140, 165), 1, 1);
Polygone P5 = new Polygone();
Console.WriteLine(Polygone.ToString());
Console.WriteLine(P5.ToString());
Console.WriteLine("\n******************Liste CartObj********************\n");
List <CartoObj> ListeCart = new List <CartoObj>();
ListeCart.Add(A);
ListeCart.Add(E);
ListeCart.Add(F);
ListeCart.Add(Poly1);
ListeCart.Add(Poly2);
//Afficher la liste
ListeCart.ForEach(item => Console.WriteLine(item));
//Afficher ceux qui utilise ipointy
Console.Write("\n****************On affiche ceux qui utilise IPOINTY*************\n");
foreach (CartoObj item in ListeCart)
{
if (!(item is IPointy))
{
item.Draw();
}
}
Console.Write("\n****************On affiche ceux qui n'utilise pas IPOINTY*************\n");
foreach (CartoObj item in ListeCart)
{
if (item is IPointy)
{
item.Draw();
}
}
Console.WriteLine("\n****************Cree une liste de 5 polyline***********************\n");
List <Polyline> Polyliste = new List <Polyline>();
Polyliste.Add(Poly1);
Polyliste.Add(Poly2);
Polyliste.Add(Poly3);
Polyliste.Add(Poly4);
foreach (Polyline item in Polyliste)
{
Console.WriteLine(item.ToString());
}
Polyliste.Sort();
Console.WriteLine("\n*************************** On Affiche la liste polyline triee -> longueur********************");
foreach (Polyline item in Polyliste)
{
Console.WriteLine(item.ToString());
}
Console.WriteLine("\n*************************** On Affiche la liste polyline triee -> AIR Box********************");
MyPolylineBoundingBoxComparer Compare = new MyPolylineBoundingBoxComparer();
Polyliste.Sort(Compare);
foreach (Polyline item in Polyliste)
{
Console.WriteLine(item.ToString());
}
Console.WriteLine("\n******************Nombre de point Different Dans poly 1 : **************************");
int point = Poly1.NbPoints;
Console.WriteLine("il y a : " + point + "point(s) différent");
Console.WriteLine("\n**************** Utilisation de IPointCLose*************");
Polyline P = Polyliste.Find(i => i.IsPointClose(25.2, 71, 1) == 1); //recherche dans la liste un element qui correspont
if (P == null) // il ne sera pas proche
{
Console.WriteLine("Le point n'est pas proche.");
}
else
{
Console.WriteLine("Le point est proche ===>");
P.Draw();
}
Polyline P2 = Polyliste.Find(i => i.IsPointClose(41.2, 48, 1) == 1); //recherche dans la liste un element qui correspont
if (P2 == null) // il sera proche de la coordonnee A
{
Console.WriteLine("Le point n'est pas proche.");
}
else
{
Console.WriteLine("Le point est proche ===>");
P2.Draw();
}
Console.WriteLine("\n*********************Test Longueur*******************\n");
double longueur = Poly1.LongueurPoly();
Console.WriteLine("Voici la longueur: " + longueur);
Polyline PP = Polyliste.Find(i => i.LongueurPoly() == longueur);
if (PP == null)
{
Console.WriteLine("Aucun point ne correspond a cette longueur");
}
else
{
PP.Draw();
}
Console.WriteLine("TestLoad et Save");
ObservableCollection <ICartoObj> ListeTest = new ObservableCollection <ICartoObj>();
ListeTest.Add(Poly1);
MyPersonalMapData user = new MyPersonalMapData("Dresse", "Amarige", "email1");
user.ObservableCollection = ListeTest;
user.Save();
Console.ReadKey();
}
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();
}
}
