public MainWindow(MyPersonalMapData m)
{
mP = new MyPersonalMapData(m.Nom, m.Prenom, m.Email);
foreach (ICartoObj obj in m.CartoCollection)
{
if (obj is POI)
{
mP.AddCartObj(new POI((POI)obj));
}
if (obj is ProjectLibraryClass.Polygon)
{
mP.AddCartObj(new ProjectLibraryClass.Polygon((ProjectLibraryClass.Polygon)obj));
}
if (obj is ProjectLibraryClass.Polyline)
{
mP.AddCartObj(new ProjectLibraryClass.Polyline((ProjectLibraryClass.Polyline)obj));
}
}
coordTmp = new List <ICoord>();
_lbBackgroundColor = new SolidColorBrush(System.Windows.Media.Colors.White);
_lbForegroundColor = new SolidColorBrush(Colors.Black);
status = null;
InitializeComponent();
ListBoxMyPersonalData.ItemsSource = mP.CartoCollection;
UpdateStatusBar("Zoom level = " + myMap.ZoomLevel.ToString());
ListBoxMyPersonalData.Background = BackgroundColor;
ListBoxMyPersonalData.Foreground = ForegroundColor;
BgColorChanged += BackgroundColorHasChanged;
FgColorChanged += ForegrounddColorHasChanged;
if (mP.CartoCollection.Count > 0)
{
RefreshMap();
}
}
//Fonction de chargement pour la page "Principal"
public void LoadPagePrincipal(MyPersonalMapData user)
{
currentControl = new PagePrincipal(user);
this.MonControle.Content = currentControl; //Affiche la nouvelle page 'Principal'
currentControl.PageChange += MainWindow_OnPageChange; //On s'abonne à l'évènement 'pageChange'
}
private void MenuFileOpen_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog openFile = new OpenFileDialog();
openFile.Filter = "MyCartographyObj files(*.az) | *.az";
openFile.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
openFile.ShowDialog();
//openFile.di
MyPersonalMapData personneTMP = null;
try
{
personneTMP = MyPersonalMapData.LoadFile(openFile.FileName);
}
catch (LoadSaveException messageErreurLoadFile)
{
MessageBox.Show(messageErreurLoadFile.Message, "ERREUR OUVERTURE", MessageBoxButton.OK, MessageBoxImage.Error);
personneTMP = null;
}
if (personneTMP != null)
{
MessageBox.Show("OUVERTURE REUSSIE", "", MessageBoxButton.OK, MessageBoxImage.Information);
PersonneConnectee = personneTMP;
UpdateListBox();
}
}
//Fonction pour switcher entre les pages
private void MainWindow_OnPageChange(int obj, MyPersonalMapData user)
{
switch (obj)
{
case 1: LoadPageLogin(); break; // si on vient de la page "Principal" on va vers la "page Login"
case 2: LoadPagePrincipal(user); break; // si on vient de la "Login" on va vers la page "Principal"
}
}
private void Connexion_Click(object sender, RoutedEventArgs e)
{
MyPersonalMapData utilisateur = new MyPersonalMapData(NomTB.Text, PrenomTB.Text, emailTB.Text);
WindowPrincipal w = new WindowPrincipal(utilisateur);
Coordonnees A = new Coordonnees(40.25, 48.25);
MyCartographyObjects.Polyline Poly1 = new MyCartographyObjects.Polyline(new List <Coordonnees>()
{
A
}, 10, Color.FromArgb(255, 201, 200, 152), 1);
ObservableCollection <ICartoObj> ListeTest = new ObservableCollection <ICartoObj>();
ListeTest.Add(Poly1);
utilisateur.ObservableCollection = ListeTest;
Coordonnees B = new Coordonnees(40.25, 48.25);
Coordonnees D = new Coordonnees(3.25, 10.45);
Coordonnees E = new Coordonnees(4.254, 5.2545);
Polygone Polygone = new Polygone(new List <Coordonnees>()
{
B, D, E
}, Color.FromArgb(165, 187, 195, 0), Color.FromArgb(165, 200, 140, 165), 1, 1);
ListeTest.Add(Polygone);
utilisateur.ObservableCollection = ListeTest;
string filename = utilisateur.Nom + utilisateur.Prenom + ".dat";
if (NomTB.Text.Length < 1 || PrenomTB.Text.Length < 1 || emailTB.Text.Length < 1)
{
ApresConnexion.Text = "Erreur : Veuillez remplir tous les champs";
MessageBox.Show("Erreur : Veuillez remplir tous les champs");
}
else
{
// ApresConnexion.Text = filename;
if (!(File.Exists(@"C:\Users\gaetan\source\repos\CartoProject\Test\bin\Debug\" + filename)))
{
ApresConnexion.Text = "Utilisateur n'existe pas";
MessageBox.Show("Utilisateur n'existe pas");
utilisateur.Save();
w.Show();
this.Close();
}
else
{
ApresConnexion.Text = "Utilisateur existe deja";
MessageBox.Show("Utilisateur existe deja");
// utilisateur.Load();
w.Show();
this.Close();
}
}
}
public PagePrincipal(MyPersonalMapData user)
{
InitializeComponent();
User = user;
ListeTmp = null;
ListDock.DataContext = User;
ListeCoo.ItemsSource = User.Liste;
AffichePin();
StatBar.Text = "User connected : " + User.Nom + " " + User.Prenom; //Affichage dans la StatusBar
}
public Map(MyPersonalMapData myMapData)
{
InitializeComponent();
MapCore point = new MapCore();
MapCore map = new MapCore();
_myMapData = myMapData;
listBox.SelectionMode = System.Windows.Controls.SelectionMode.Extended;
listBox.ItemsSource = _myMapData.ObservableCollection;
LoadCoordoonees();
this.Title += " User: "******" " + myMapData.Prenom + " " + myMapData.Email;
}
private void SeConnecter_Click(object sender, RoutedEventArgs e)
{
MyPersonalMapData temp = new MyPersonalMapData();
if (temp.Load(Prenom, Nom))
{
TextBoxInfo.Text = "Ce compte n'existe pas!";
return;
}
((MainWindow)Owner).myPersonalMapData = temp;
Close();
}
private void CréeUnCompte_Click(object sender, RoutedEventArgs e)
{
if (Nom.Length == 0 || Prenom.Length == 0 || Email.Length == 0)
{
TextBoxInfo.Text = "Un champs est vide!";
return;
}
MyPersonalMapData temp = new MyPersonalMapData(Nom, Prenom, Email, new ObservableCollection <ICartoObj> {
});
((MainWindow)Owner).myPersonalMapData = temp;
Close();
}
private void MenuFileSave_Click(object sender, RoutedEventArgs e)
{
SaveFileDialog saveFile = new SaveFileDialog();
saveFile.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
saveFile.Filter = "MyCartographyObj files(*.az) | *.az";
saveFile.ShowDialog();
if (MyPersonalMapData.SavePersonne(PersonneConnectee, saveFile.FileName, true))
{
MessageBox.Show("SAUVEGARDE REUSSIE", "", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
MessageBox.Show("ERREUR SAUVEGARDE", "", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private void OK_Button(object sender, RoutedEventArgs e)
{
MyPersonalMapData tmpUser = new MyPersonalMapData(lastName.Text, firstName.Text);
try
{
tmpUser.Load(); //Test s'il existe
User.Nom = lastName.Text;
User.Prenom = firstName.Text;
User.Load();
this.Close();
}
catch (Exception)
{
Window error = new ErrorWindow("An error occurred while loading the profile");
error.ShowDialog(); //bloque la page
}
}
public MainWindow()
{
InitializeComponent();
SolidColorBrush newBrush = new SolidColorBrush(Colors.Black);
superCombo.SelectedColor = newBrush;
userData = new MyPersonalMapData();
coord = new List <Coordonnees>();
loc = new LocationCollection();
nbItems = 0;
nbCoord = 0;
nbPoi = 0;
prevRadio = 0;
add = true;
modify = delete = false;
}
private void ButtonSubmit_Click(object sender, RoutedEventArgs e)
{
string nom = TextBoxNom.Text;
string prenom = TextBoxPrenom.Text;
string email = TextBoxMail.Text;
MyPersonalMapData data = new MyPersonalMapData(nom, prenom, email);
if (data.BinaryExist())
{
data = data.LoadAsBinary();
}
else
{
data.SaveAsBinary();
}
Map m = new Map(data);
m.Show();
this.Close();
}
private void MenuFileOpen_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog openFile = new OpenFileDialog();
openFile.Filter = "MyCartographyObj files(*.az) | *.az";
openFile.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
openFile.ShowDialog();
MyPersonalMapData personneTMP;
if ((personneTMP = MyPersonalMapData.LoadFile(openFile.FileName)) == null)
{
MessageBox.Show("ERREUR OUVERTURE", "", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
MessageBox.Show("OUVERTURE REUSSIE", "", MessageBoxButton.OK, MessageBoxImage.Information);
PersonneConnectee = personneTMP;
TextDebug.Content = PersonneConnectee.ToString();
}
}
private void MenuFileTrajetExport_Click(object sender, RoutedEventArgs e)
{
bool erreurExport = false;
ICartoObj o = (ICartoObj)ListBox.SelectedItem;
if (o == null)
{
MessageBox.Show("Aucun élément de la ListBox est sélectionné", "ERREUR", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
if (o is Polyline)
{
Polyline p = o as Polyline;
SaveFileDialog saveFile = new SaveFileDialog();
saveFile.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
saveFile.Filter = "Fichier CSV files(*.csv) | *.csv";
saveFile.ShowDialog();
try
{
MyPersonalMapData.saveCSVtrajet(p, saveFile.FileName);
}
catch (CSVexception messageErreurSaveTrajet)
{
MessageBox.Show(messageErreurSaveTrajet.Message, "ERREUR", MessageBoxButton.OK, MessageBoxImage.Error);
erreurExport = true;
}
if (!erreurExport)
{
MessageBox.Show("Exportation réussie", "", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
else
{
MessageBox.Show("L'élément sélectionné n'est pas un trajet (polyline)", "ERREUR", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
private void connectButton_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(tbEmail.Text) || string.IsNullOrEmpty(tbNom.Text) || string.IsNullOrEmpty(tbPrenom.Text))
{
tbBadSaisie.Text = "Veuillez saisir tous les champs !";
}
else
{
///On va vérifier le format d'email
if (!IsValidEmail(tbEmail.Text))
{
tbBadSaisie.Text = "Mauvais format d'adresse mail";
}
else
{
///Tout est bon
MyPersonalMapData mp = new MyPersonalMapData(tbNom.Text, tbPrenom.Text, tbEmail.Text);
/// On regarde si un fichier existe
if (File.Exists(tbPrenom.Text + tbNom.Text + ".txt"))
{
Console.WriteLine("FICHIER EXISTE");
///Le fichier existe, on va importer
Stream s = new FileStream(tbPrenom.Text + tbNom.Text + ".txt", FileMode.Open, FileAccess.Read);
IFormatter formatter = new BinaryFormatter();
ObservableCollection <ICartoObj> iCartoObjRead = (ObservableCollection <ICartoObj>)formatter.Deserialize(s);
foreach (ICartoObj carto in iCartoObjRead)
{
mp.AddCartObj(carto);
}
s.Close();
}
Console.WriteLine("ON CREE MAINWINDOW");
MainWindow mw = new MainWindow(mp);
mw.Show();
Close();
}
}
}
private void MenuFileSave_Click(object sender, RoutedEventArgs e)
{
SaveFileDialog saveFile = new SaveFileDialog();
saveFile.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
saveFile.Filter = "MyCartographyObj files(*.az) | *.az";
saveFile.ShowDialog();
MyPersonalMapData personneTMP = null;
try
{
personneTMP = MyPersonalMapData.SavePersonne(PersonneConnectee, saveFile.FileName);
}
catch (LoadSaveException messageErreurSave)
{
MessageBox.Show(messageErreurSave.Message, "ERREUR SAUVEGARDE", MessageBoxButton.OK, MessageBoxImage.Error);
personneTMP = null;
}
if (personneTMP != null)
{
PersonneConnectee = personneTMP;
MessageBox.Show("SAUVEGARDE REUSSIE", "", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
private void MenuFileOpen_Click(object sender, RoutedEventArgs e)//OUVRE UN
{
string filename = "";
Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
dlg.DefaultExt = ".dat";
dlg.Filter = "DAT Files (*.dat)|*.dat";
Nullable <bool> result = dlg.ShowDialog();
if (result == true)
{
filename = dlg.FileName;
_myMapData = new MyPersonalMapData().LoadAsBinary(filename);
Map m2 = new Map(_myMapData);
m2.Show();
this.Close();
listBox.Items.Refresh();
LoadCoordoonees();
}
}
private void MenuFileTrajetImport_Click(object sender, RoutedEventArgs e)
{
bool ouvertureOK = true;
OpenFileDialog openFile = new OpenFileDialog();
openFile.Filter = "Fichier CSV files(*.csv) | *.csv";
openFile.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
openFile.ShowDialog();
try
{
MyPersonalMapData.readCSVtrajet(PersonneConnectee, openFile.FileName);
}
catch (CSVexception messageErreurCSV)
{
MessageBox.Show(messageErreurCSV.Message, "ERREUR OUVERTURE", MessageBoxButton.OK, MessageBoxImage.Error);
ouvertureOK = false;
}
if (ouvertureOK)
{
UpdateListBox();
MessageBox.Show("OUVERTURE REUSSIE", "", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
public WindowPrincipal(MyPersonalMapData user) : this()
{
_user = user;
}
static void Main(string[] args)
{
int choix;
bool fin = false;
while (!fin)
{
choix = Choix("Classe Coordonnee", "Classe POI", "Classe Polyline", "Classe Polygon", "Interface IIsPointClose",
"Interface IPointy", "Liste générique CartoObj", "Liste générique Polyline", "Classer liste d'objet CartObj",
"Sauvegarder", "Charger", "Quitter");
switch (choix)
{
case 1:
{
Console.WriteLine("Test de la classe Coordonnee");
Coordonnees coord = new Coordonnees();
Console.WriteLine("Test du constructeur par défault et de la surcharge ToString()");
Console.WriteLine(coord.ToString());
double x1 = 2, y1 = 4;
Coordonnees coord2 = new Coordonnees(x1, y1);
Console.WriteLine("Test du constructeur d'initialisation (et de l'operateur ToString()");
Console.WriteLine(coord2.ToString());
break;
}
case 2:
{
Console.WriteLine("Test de la classe POI");
POI poi = new POI();
Console.WriteLine("Test du constructeur par défault et de la surcharge de l'opérateur ToString()");
Console.WriteLine(poi.ToString());
double x1 = 25.63987, y1 = 56.2235;
string tmp = "Classe de laboratoire";
Console.WriteLine("Test du constructeur d'initialisation et de la surcharge de l'opérateur ToString()");
POI poi2 = new POI(tmp, x1, y1);
Console.WriteLine(poi2.ToString());
break;
}
case 3:
{
Console.WriteLine("Test de la classe Polyline");
Polyline poly1 = new Polyline();
Console.WriteLine("Test du constructeur par défault et de la surcharge de l'opérateur ToString()");
Console.WriteLine(poly1.ToString());
Console.WriteLine("Test de la fonction Draw()");
poly1.Draw();
Color cou = Color.Aqua;
int epaisseur = 5;
Coordonnees coord1 = new Coordonnees(2.55, 2.669);
Coordonnees coord2 = new Coordonnees(4.569578, 97.59);
Coordonnees coord3 = new Coordonnees(588.2243, 6.20135);
Coordonnees[] tab = new Coordonnees[3];
tab[0] = coord1;
tab[1] = coord2;
tab[2] = coord3;
Polyline poly2 = new Polyline(epaisseur, cou, tab);
Console.WriteLine("Test du constructeur d'initialisation et de la surcharge de l'opérateur ToString()");
Console.WriteLine(poly2.ToString());
Console.WriteLine("Test de la fonction Draw()");
poly2.Draw();
break;
}
case 4:
{
Console.WriteLine("Test de la classe Polygon");
Polygon poly1 = new Polygon();
Console.WriteLine("Test du constructeur par défault et de la surcharge de l'opérateur ToString()");
Console.WriteLine(poly1.ToString());
Console.WriteLine("Test de la fonction Draw()");
poly1.Draw();
Color rempl = Color.Cyan;
Color cont = Color.Orange;
double opa = 0.233;
Coordonnees coord1 = new Coordonnees(2.55, 2.669);
Coordonnees coord2 = new Coordonnees(4.569578, 97.59);
Coordonnees coord3 = new Coordonnees(588.2243, 6.20135);
Coordonnees[] tab = new Coordonnees[3];
tab[0] = coord1;
tab[1] = coord2;
tab[2] = coord3;
Polygon poly2 = new Polygon(tab, rempl, cont, opa);
Console.WriteLine("Test du constructeur d'initialisation et de la surcharge de l'opérateur ToString()");
Console.WriteLine(poly2.ToString());
Console.WriteLine("Test de la fonction Draw()");
poly2.Draw();
break;
}
case 5:
{
///Test de l'interface IIsPointClose
///Il faut le test avec POI, Polyline et Polygone
double precision, x, y;
bool isClose;
Console.WriteLine("Test de l'interface IIsPointClose");
int choix2 = Choix("POI", "Polyline", "Polygon");
switch (choix2)
{
case 1:
{
Console.WriteLine("POI");
POI poi = new POI(2.035, 5.310);
Console.WriteLine(poi.ToString());
Console.WriteLine("Veuillez saisir des coordonnées : ");
Console.WriteLine("X = "); x = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Y = "); y = Convert.ToDouble(Console.ReadLine());
Coordonnees coordPerso = new Coordonnees(x, y);
Console.WriteLine(coordPerso.ToString());
Console.WriteLine("Veuillez saisir le taux de précision : "); precision = Convert.ToDouble(Console.ReadLine());
isClose = poi.IsPointClose(coordPerso.X, coordPerso.Y, precision);
Console.WriteLine("isClose = " + isClose);
break;
}
case 2:
{
Console.WriteLine("Polyline");
Coordonnees[] tab = new Coordonnees[3];
tab[0] = new Coordonnees(2.500, 2.500);
tab[1] = new Coordonnees(5.000, 5.000);
tab[2] = new Coordonnees(1.540, 1.540);
Color white = Color.White;
Polyline poly = new Polyline(5, white, tab);
Console.WriteLine(poly.ToString());
Console.WriteLine("Veuillez saisir des coordonnées : ");
Console.WriteLine("X = "); x = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Y = "); y = Convert.ToDouble(Console.ReadLine());
Coordonnees coordPerso = new Coordonnees(x, y);
Console.WriteLine(coordPerso.ToString());
Console.WriteLine("Veuillez saisir le taux de précision : "); precision = Convert.ToDouble(Console.ReadLine());
isClose = poly.IsPointClose(coordPerso.X, coordPerso.Y, precision);
Console.WriteLine("isClose = " + isClose);
break;
}
case 3:
{
Console.WriteLine("Polygone");
/*///Triangle Harcodé
* Coordonnees[] tab = new Coordonnees[3];
* tab[0] = new Coordonnees(1, 1);
* tab[1] = new Coordonnees(2, 3);
* tab[2] = new Coordonnees(3, 1);*/
/*///Carré négatif hardcodé*/
Coordonnees[] tab = new Coordonnees[4];
tab[0] = new Coordonnees(1, -1);
tab[1] = new Coordonnees(3, -1);
tab[2] = new Coordonnees(3, -3);
tab[3] = new Coordonnees(1, -3);
Color inte = Color.White;
Color cont = Color.Red;
Polygon poly = new Polygon(tab, inte, cont, 0.5);
Console.WriteLine(poly.ToString());
Console.WriteLine("Veuillez saisir des coordonnées : ");
Console.WriteLine("X = "); x = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Y = "); y = Convert.ToDouble(Console.ReadLine());
Coordonnees coordPerso = new Coordonnees(x, y);
Console.WriteLine(coordPerso.ToString());
isClose = poly.IsPointClose(coordPerso.X, coordPerso.Y, 0);
Console.WriteLine("isClose = " + isClose);
break;
}
}
break;
}
case 6:
{
Console.WriteLine("Test de l'interface IIPointy");
int choix2 = Choix("Polyline", "Polygon", "Quitter");
switch (choix2)
{
case 1:
{
double x, y;
Console.WriteLine("---Polyline---");
Coordonnees[] tab = new Coordonnees[3];
tab[0] = new Coordonnees(0.5, 2.3597);
tab[1] = new Coordonnees(5.6, 2.3597);
tab[2] = new Coordonnees(3.5, 5);
Color col = Color.White;
Polyline poly = new Polyline(2, col, tab);
Console.WriteLine(poly);
Console.WriteLine("Nombre de points = " + poly.nbPoint);
Console.WriteLine("Veuillez saisir les coordonnées d'un nouveau points :");
Console.Write("X = "); x = Convert.ToInt32(Console.ReadLine()); Console.WriteLine();
Console.Write("Y = "); y = Convert.ToInt32(Console.ReadLine()); Console.WriteLine();
poly.AddCoord(new Coordonnees(x, y));
Console.WriteLine(poly);
Console.WriteLine("Nombre de points = " + poly.nbPoint);
break;
}
case 2:
{
Console.WriteLine("---Polygon---");
Coordonnees[] tab = new Coordonnees[3];
tab[0] = new Coordonnees(0.5, 2.3597);
tab[1] = new Coordonnees(5.6, 2.3597);
tab[2] = new Coordonnees(3.5, 5);
Color col = Color.White;
Color col2 = Color.Red;
Polygon poly = new Polygon(tab, col, col2, 0.5);
Console.WriteLine("---Coordonnees---");
Console.WriteLine(poly);
Console.WriteLine("Nombre de points = " + poly.nbPoint);
break;
}
}
break;
}
case 7:
{
Console.WriteLine("---Test de la liste générique CartoObj---");
Coordonnees[] cTab = new Coordonnees[4];
cTab[0] = new Coordonnees(1, 1);
cTab[1] = new Coordonnees(3, 1);
cTab[2] = new Coordonnees(3, 3);
cTab[3] = new Coordonnees(3, 1);
Coordonnees[] cTab2 = new Coordonnees[3];
cTab2[0] = new Coordonnees(1, 1);
cTab2[1] = new Coordonnees(4, 4);
cTab2[2] = new Coordonnees(7, 1);
///J'implémente directement un objet de chaque sorte (hardcodé)
List <CartoObj> lCarto = new List <CartoObj>()
{
new Coordonnees(2.5013, 5.6978), new POI("POIDansListeGénérique",
5.697236, 60.348), new Polygon(cTab, Color.Red, Color.Green, 0.5), new Polyline(2, Color.DarkGray, cTab2)
};
int choix2 = Choix("Afficher la liste complete", "Afficher les objets implémentant IPointy", "Afficher les objets n'implémentant pas IPointy", "Quitter");
switch (choix2)
{
case 1:
{
Console.WriteLine("---Liste complete---");
foreach (CartoObj co in lCarto)
{
Console.WriteLine(co);
}
break;
}
case 2:
{
Console.WriteLine("---Liste des objets implémentant IPointy---");
foreach (CartoObj co in lCarto)
{
if (co is IPointy)
{
Console.WriteLine(co);
}
}
break;
}
case 3:
{
Console.WriteLine("---Liste des objets n'implémentant pas IPointy---");
foreach (CartoObj co in lCarto)
{
if (!(co is IPointy))
{
Console.WriteLine(co);
}
}
break;
}
default:
break;
}
break;
}
case 8:
{
Console.WriteLine("---Test de la liste générique Polyline---");
List <Polyline> lPoly = new List <Polyline>()
{
new Polyline(2, Color.White, new Coordonnees[3] {
new Coordonnees(2, 3), new Coordonnees(4, 5),
new Coordonnees(6, 7)
}),
new Polyline(1, Color.Red, new Coordonnees[3] {
new Coordonnees(0, 0), new Coordonnees(2, 10),
new Coordonnees(9, 4)
}),
new Polyline(3, Color.DarkBlue, new Coordonnees[3] {
new Coordonnees(0, 5), new Coordonnees(3, 10),
new Coordonnees(3, 5)
}),
new Polyline(5, Color.Cyan, new Coordonnees[3] {
new Coordonnees(5, 1), new Coordonnees(10, 5),
new Coordonnees(15, 8)
}),
new Polyline(9, Color.GreenYellow, new Coordonnees[3] {
new Coordonnees(10, 3), new Coordonnees(7, 9),
new Coordonnees(5, 1)
})
};
Console.WriteLine("---Affichage de la liste générique de polyline---");
foreach (Polyline pol in lPoly)
{
Console.WriteLine(pol);
}
///Tri
lPoly.Sort();
Console.WriteLine("---Affichage de la liste générique de polyline trié sur leur longueur---");
foreach (Polyline pol in lPoly)
{
Console.WriteLine("Longueur : " + pol.LongueurPolyline().ToString());
Console.WriteLine(pol);
}
lPoly.Sort(new MyPolylineBoundingBoxComparer());
Console.WriteLine("---Affichage de la liste générique du polyline trié sur leur surface---");
foreach (Polyline po1 in lPoly)
{
Console.WriteLine("Surface : " + po1.CalculSurface()); ///Temporaire, juste pour vérifier la valeur des surfaces
Console.WriteLine(po1);
}
ConsoleKeyInfo cki;
do
{
Console.WriteLine("Souhaitez-vous tester la fonctionnalité de recherche de polyline ayant la même" +
"surface qu'un polyline de référence (que vous saisirez-vous même) ? [y/n]");
cki = Console.ReadKey();
} while (cki.Key != ConsoleKey.Y && cki.Key != ConsoleKey.N);
if (cki.Key == ConsoleKey.Y)
{
Console.WriteLine();
///Je ne fais saisir que 3 coordonnées
Coordonnees[] lCoordU = new Coordonnees[3];
for (int i = 0; i < 3; i++)
{
lCoordU[i] = new Coordonnees();
Console.WriteLine("Veuillez saisir la " + (i + 1) + "e coordonnées ");
Console.Write("X = "); lCoordU[i].X = Convert.ToDouble(Console.ReadLine());
Console.Write("Y = "); lCoordU[i].Y = Convert.ToDouble(Console.ReadLine());
}
Polyline polyU = new Polyline(10, Color.White, lCoordU);
List <Polyline> lPolyResult = lPoly.FindAll(polyU.SurfaceSame);
if (lPolyResult.Count > 0)
{
Console.WriteLine("Polyline possédant la même surface");
foreach (Polyline pol in lPolyResult)
{
Console.WriteLine(polyU.CalculSurface());
Console.WriteLine(pol);
}
Console.WriteLine("Rappel du polyline de référence");
Console.WriteLine(polyU.CalculSurface());
Console.WriteLine(polyU);
}
else
{
Console.WriteLine("Aucun polyline dans la liste ne possède la même surface que le polyline de référence");
}
}
do
{
Console.WriteLine("Souhaitez-vous tester la fonctionnalité de recherche de polyline " +
"proche d'un point dont vous passez les paramètres ? [y/n]");
cki = Console.ReadKey();
} while (cki.Key != ConsoleKey.Y && cki.Key != ConsoleKey.N);
if (cki.Key == ConsoleKey.Y)
{
double prec;
///Saisie des coordonnées par l'utilisateur
double x, y;
Console.Write("X = "); x = Convert.ToDouble(Console.ReadLine()); Console.WriteLine();
Console.Write("Y = "); y = Convert.ToDouble(Console.ReadLine()); Console.WriteLine();
Console.Write("Precision = "); prec = Convert.ToDouble(Console.ReadLine()); Console.WriteLine();
///Recherche d'une certaines proximités avec un des polylines composant la liste
List <Polyline> lPolyProche = new List <Polyline>();
foreach (Polyline pol in lPoly)
{
if (pol.IsPointClose(x, y, prec))
{
lPolyProche.Add(pol);
}
}
if (lPolyProche.Count > 0)
{
foreach (Polyline pol in lPolyProche)
{
Console.WriteLine(pol);
}
}
else
{
Console.WriteLine("Aucun polyline présent dans la liste n'est proche du point rentrée en paramètre");
}
Console.WriteLine("Rappel des coordonnées : (" + x + "," + y + ")");
}
break;
}
case 9:
{
///Trier liste d'objet CartObj
Console.WriteLine("---Trier une liste d'objet CartObj---");
///Ici les polyline sont un peu hardcodé n'importe comment, je cherche juste a créer plusieurs polyline/polygone
///ayant un nombre de coordonnées différentes afin de tester le tri via la fonction Compare
List <CartoObj> lCarto = new List <CartoObj>()
{
new Polyline(2, Color.White, new Coordonnees[4] {
new Coordonnees(2, 3), new Coordonnees(4, 5),
new Coordonnees(6, 7), new Coordonnees(0, 5)
}),
new Polyline(1, Color.Red, new Coordonnees[3] {
new Coordonnees(0, 0), new Coordonnees(2, 10),
new Coordonnees(9, 4)
}),
new Polyline(3, Color.DarkBlue, new Coordonnees[6] {
new Coordonnees(0, 5), new Coordonnees(3, 10),
new Coordonnees(3, 5), new Coordonnees(5, 10), new Coordonnees(15, 20), new Coordonnees(0, 0)
}),
new Polyline(5, Color.Cyan, new Coordonnees[3] {
new Coordonnees(5, 1), new Coordonnees(10, 5),
new Coordonnees(15, 8)
}),
new Polyline(9, Color.GreenYellow, new Coordonnees[3] {
new Coordonnees(10, 3), new Coordonnees(7, 9),
new Coordonnees(5, 1)
}),
new Polygon(new Coordonnees[5] {
new Coordonnees(0, 0), new Coordonnees(0, 3), new Coordonnees(3, 3), new Coordonnees(2, 5), new Coordonnees(3, 0)
}, Color.Red, Color.Black, 1),
new Polygon(new Coordonnees[3] {
new Coordonnees(0, 0), new Coordonnees(0, 3), new Coordonnees(3, 3)
}, Color.Red, Color.Black, 1),
new Polygon(new Coordonnees[4] {
new Coordonnees(0, 0), new Coordonnees(0, 3), new Coordonnees(3, 3), new Coordonnees(3, 0)
}, Color.Red, Color.Black, 1),
};
Console.WriteLine("Affichage de la liste non trié");
foreach (CartoObj co in lCarto)
{
Console.WriteLine(co.ToString());
}
Console.WriteLine("Trie de la liste CartoObj");
lCarto.Sort(new CartoObjComparer());
Console.WriteLine("Affichage de la liste trié");
foreach (CartoObj co in lCarto)
{
Console.WriteLine(co.ToString());
}
break;
}
case 10:
{
Console.WriteLine("Sauvegarde des objets implémentant l'interface ICartoObj");
ObservableCollection <ICartoObj> cartoColl = new ObservableCollection <ICartoObj>()
{
new Polyline(2, Color.White, new Coordonnees[4] {
new Coordonnees(2, 3), new Coordonnees(4, 5),
new Coordonnees(6, 7), new Coordonnees(0, 5)
}),
new Polyline(1, Color.Red, new Coordonnees[3] {
new Coordonnees(0, 0), new Coordonnees(2, 10),
new Coordonnees(9, 4)
}),
new Polyline(3, Color.DarkBlue, new Coordonnees[6] {
new Coordonnees(0, 5), new Coordonnees(3, 10),
new Coordonnees(3, 5), new Coordonnees(5, 10), new Coordonnees(15, 20), new Coordonnees(0, 0)
}),
new Polyline(5, Color.Cyan, new Coordonnees[3] {
new Coordonnees(5, 1), new Coordonnees(10, 5),
new Coordonnees(15, 8)
}),
new Polyline(9, Color.GreenYellow, new Coordonnees[3] {
new Coordonnees(10, 3), new Coordonnees(7, 9),
new Coordonnees(5, 1)
}),
new Polygon(new Coordonnees[5] {
new Coordonnees(0, 0), new Coordonnees(0, 3), new Coordonnees(3, 3), new Coordonnees(2, 5), new Coordonnees(3, 0)
}, Color.Red, Color.Black, 1),
new Polygon(new Coordonnees[3] {
new Coordonnees(0, 0), new Coordonnees(0, 3), new Coordonnees(3, 3)
}, Color.Red, Color.Black, 1),
new Polygon(new Coordonnees[4] {
new Coordonnees(0, 0), new Coordonnees(0, 3), new Coordonnees(3, 3), new Coordonnees(3, 0)
}, Color.Red, Color.Black, 1),
new POI("TestPOI", 1.2345, 50.2),
new POI("POI2", 50.34, -20.3)
};
MyPersonalMapData mP = new MyPersonalMapData("Test", "TestP", "TestEm", cartoColl);
IFormatter formatter = new BinaryFormatter();
Stream fStream = new FileStream("C:/Users/Eric/Desktop/Bloc 2 offline/C#/Ecole/Projet2/LaboC#2.1/fichierTest.csv", FileMode.Create, FileAccess.Write);
/* foreach (ICartoObj icarto in lCarto)
* {
* formatter.Serialize(fStream,icarto);
* }*/
formatter.Serialize(fStream, cartoColl);
fStream.Close();
Console.WriteLine("Fichier sauvegardé");
Console.WriteLine("-------------------Deserialization---------------------");
Stream stream = new FileStream("C:/Users/Eric/Desktop/Bloc 2 offline/C#/Ecole/Projet2/LaboC#2.1/fichierTest.csv", FileMode.Open, FileAccess.Read);
/* List<ICartoObj> iCartoObjRead = new List<ICartoObj>();
* while (stream.CanRead)
* {
* iCartoObjRead.Add((ICartoObj)formatter.Deserialize(stream));
* }*/
MyPersonalMapData readMyPersonalMapData = new MyPersonalMapData();
ObservableCollection <ICartoObj> iCartoObjRead = (ObservableCollection <ICartoObj>)formatter.Deserialize(stream);
stream.Close();
Console.WriteLine("------------Ajout dans la liste----------");
foreach (ICartoObj iCarto in iCartoObjRead)
{
readMyPersonalMapData.AddCartObj(iCarto);
}
Console.WriteLine("--------------Lecture----------");
foreach (ICartoObj iCarto in readMyPersonalMapData.CartoCollection)
{
Console.WriteLine(iCarto);
}
break;
}
case 11:
{
Stream stream = new FileStream("C:/Users/Eric/Desktop/Bloc 2 offline/C#/Ecole/Projet2/LaboC#2.1/fichierTest.csv", FileMode.Open, FileAccess.Read);
IFormatter formatter = new BinaryFormatter();
MyPersonalMapData readMyPersonalMapData = new MyPersonalMapData();
ObservableCollection <ICartoObj> iCartoObjRead = (ObservableCollection <ICartoObj>)formatter.Deserialize(stream);
stream.Close();
Console.WriteLine("------------Ajout dans la liste----------");
foreach (ICartoObj iCarto in iCartoObjRead)
{
readMyPersonalMapData.AddCartObj(iCarto);
}
Console.WriteLine("--------------Lecture----------");
foreach (ICartoObj iCarto in readMyPersonalMapData.CartoCollection)
{
Console.WriteLine(iCarto);
}
break;
}
default:
fin = true;
break;
}
}
}
public FenetrePrincipale(MyPersonalMapData personne)
{
PersonneConnectee = personne;
InitializeComponent();
TextDebug.Content = PersonneConnectee.ToString();
}
public PageLogin()
{
InitializeComponent();
User = new MyPersonalMapData("Delaval", "Kevin");
CurrentStack.DataContext = User;
}
static void Main(string[] args)
{
/*List<CartoObj> list = new List<CartoObj> { };
* POI poi1 = new POI();
* POI poi2 = new POI();
* Polyline polyline1 = new Polyline();
* Polyline polyline2 = new Polyline();
* Polygon polygon1 = new Polygon();
* Polygon polygon2 = new Polygon();
*
* list.Add(poi1);
* list.Add(poi2);
* list.Add(polyline1);
* list.Add(polyline2);
* list.Add(polygon1);
* list.Add(polygon2);
*
* Console.WriteLine("Afficher cette liste en utilisant le mot clé foreach");
* foreach(CartoObj c in list)
* {
* c.Draw();
* }
*
* Console.WriteLine("\nAfficher la liste des objets implémentant l’interface IPointy");
* foreach(CartoObj c in list)
* {
* if(c is IPointy)
* {
* c.Draw();
* }
* }
*
* Console.WriteLine("\nAfficher la liste des objets n’implémentant pas l’interface IPointy");
* foreach(CartoObj c in list)
* {
* if(!(c is IPointy))
* {
* c.Draw();
* }
* }
*
* Console.WriteLine("\nCréer une liste générique de 5 Polyline, l’afficher");
* List<Polyline> listePoli = new List<Polyline> { };
* listePoli.Add(new Polyline(new List<Coordonnees>{new Coordonnees(0,0),new Coordonnees(1,1) },Colors.Black,0));
* listePoli.Add(new Polyline(new List<Coordonnees>{new Coordonnees(0,0),new Coordonnees(4,5) },Colors.Black,0));
* listePoli.Add(new Polyline(new List<Coordonnees>{new Coordonnees(0,0),new Coordonnees(1,1) },Colors.Black,0));
* listePoli.Add(new Polyline(new List<Coordonnees>{new Coordonnees(0,0),new Coordonnees(10,-1) },Colors.Black,0));
* listePoli.Add(new Polyline(new List<Coordonnees>{new Coordonnees(0,0),new Coordonnees(0,10) },Colors.Black,0));
*
* foreach(Polyline p in listePoli)
* {
* p.Draw();
* }
*
* Console.WriteLine("\nla trier par ordre de longueur croissante");
* listePoli.Sort();
*
* Console.WriteLine("\nl’afficher à nouveau");
* foreach (Polyline p in listePoli)
* {
* p.Draw();
* }
*
* Console.WriteLine("\ntrier la liste par ordre croissant de taille de surface de la bounding box englobant la polyline");
* MyPolylineBoundingBoxComparer triSurface = new MyPolylineBoundingBoxComparer();
* listePoli.Sort(triSurface);
* foreach (Polyline p in listePoli)
* {
* p.Draw();
* }
*
* Console.WriteLine("\nRechercher, parmi les polyline de la liste, celles qui présentent la même taille qu’une polyline de référence");
* Polyline polyline3 = new Polyline(new List<Coordonnees> { new Coordonnees(0, 0), new Coordonnees(1, 1) }, Colors.Black, 0);
* Console.WriteLine("Find : {0}", listePoli.Find(x => x.longeur().Equals(polyline3.longeur())));
*
* Console.WriteLine("\nRechercher, parmi les polyline de la liste, celles qui sont proches d’un point passé en paramètre");
* Coordonnees coordonnees1 = new Coordonnees(0, 2);
* Console.WriteLine("Coordonnees1: " + coordonnees1 + " Precision: 0.5");
* foreach(Polyline p in listePoli)
* {
* if(p.IsPointClose(coordonnees1,0.5))
* {
* Console.WriteLine("Le point " + coordonnees1 + " est proche de la listePoli!");
* }
* else
* {
* Console.WriteLine("Le point " + coordonnees1 + " n'est pas proche de la listePoli!");
* }
* }
* Coordonnees coordonnees2 = new Coordonnees(0, 0);
* Console.WriteLine("Coordonnees1: " + coordonnees2 + " Precision: 1");
* foreach (Polyline p in listePoli)
* {
* if (p.IsPointClose(coordonnees2, 1))
* {
* Console.WriteLine("Le point " + coordonnees2 + " est proche de la listePoli!");
* }
* else
* {
* Console.WriteLine("Le point " + coordonnees2 + " n'est pas proche de la listePoli!");
* }
* }
*
* Console.WriteLine("\nMettre en place et tester un mécanisme qui permet de classer une liste d’objets CartoObj sur base du nombre d’objets Coordonnees qui le compose via un …Comparer.");
* MyNbCoordonneesComparer triNbCoordonnees = new MyNbCoordonneesComparer();
* List < CartoObj > list1 = new List<CartoObj> { };
* list1.Add(new Polyline(new List<Coordonnees> { new Coordonnees(0, 0), new Coordonnees(1, 1),new Coordonnees(2,2) }, Colors.Black, 1));
* list1.Add(new Polyline(new List<Coordonnees> {new Coordonnees(0,0)},Colors.Black,1));
* list1.Add(new Polyline(new List<Coordonnees> {new Coordonnees(0,0),new Coordonnees(1,1)},Colors.Black,1));
* Console.WriteLine("Voici la liste:");
* foreach(CartoObj c in list1)
* {
* if(c is Polyline)
* {
* Polyline p1 = c as Polyline;
* p1.Draw();
* }
* if(c is Polygon)
* {
* Polygon p1 = c as Polygon;
* p1.Draw();
* }
* }
*
* list1.Sort(triNbCoordonnees);
*
* Console.WriteLine("Voici la liste triee:");
* foreach (CartoObj c in list1)
* {
* if (c is Polyline)
* {
* Polyline p1 = c as Polyline;
* p1.Draw();
* }
* if (c is Polygon)
* {
* Polygon p1 = c as Polygon;
* p1.Draw();
* }
* }*/
//Tester MyPersonalMapData
/*MyPersonalMapData mapData = new MyPersonalMapData("Gerard","Vincent","*****@*****.**",new ObservableCollection<ICartoObj> { });
* Polyline poly = new Polyline(new List<Coordonnees> { new Coordonnees(0,0),new Coordonnees(1,1)},Colors.Black,1);
* Polygon polygon = new Polygon(new List<Coordonnees> { new Coordonnees(3,3)},Colors.Black,Colors.Black,1);
* mapData.ObservableCollection.Add(poly);
* mapData.ObservableCollection.Add(polygon);
* mapData.Draw();
* mapData.Save();*/
MyPersonalMapData mapdata = new MyPersonalMapData();
mapdata.Load("Vincent", "Gerard");
Console.WriteLine(mapdata);
foreach (ICartoObj i in mapdata.ObservableCollection)
{
if (i is POI)
{
POI p = i as POI;
Console.Write("POI: ");
Console.WriteLine(p);
}
if (i is Polyline)
{
Polyline p = i as Polyline;
Console.Write("POLYLINE: ");
Console.WriteLine(p);
foreach (Coordonnees c in p.Collection)
{
Console.Write("\t\t -");
Console.WriteLine(c);
}
}
if (i is Polygon)
{
Polygon p = i as Polygon;
Console.Write("POLYGON: ");
Console.WriteLine(p);
foreach (Coordonnees c in p.Collection)
{
Console.Write("\t\t-");
Console.WriteLine(c);
}
}
}
Console.ReadLine();
}
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)
{
#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
}
public ChangeUserWindow(MyPersonalMapData user)
{
InitializeComponent();
User = user;
}
private void QuitterSauvegarde()
{
MyPersonalMapData personneTMP = null;
bool modif = true;
if (DossierDeTravail != null && PersonneConnectee.Emplacement == null)
{
PersonneConnectee.Emplacement = DossierDeTravail;
}
if (PersonneConnectee.Emplacement != null)
{
try
{
personneTMP = MyPersonalMapData.LoadFile(PersonneConnectee.Emplacement);
}
catch (LoadSaveException messageErreurLoadFile)
{
//MessageBox.Show("ERREUR OUVERTURE", messageErreurLoadFile.Message, MessageBoxButton.OK, MessageBoxImage.Error);
Console.WriteLine("(QuitterSauvegarde) ERREUR OUVERTURE : " + messageErreurLoadFile.Message);
personneTMP = null;
}
if (personneTMP != null)
{
if (personneTMP.ObservableCollection.Equals(PersonneConnectee.ObservableCollection))
{
modif = false;
}
}
}
if (modif)
{
MessageBoxResult resultNewClient = MessageBox.Show("Voulez-vous sauvegarder vos modifications ?", "", MessageBoxButton.YesNo, MessageBoxImage.Question);
switch (resultNewClient)
{
case MessageBoxResult.Yes:
try
{
personneTMP = MyPersonalMapData.SavePersonne(PersonneConnectee, PersonneConnectee.Emplacement);
}
catch (LoadSaveException messageErreurSave)
{
MessageBox.Show(messageErreurSave.Message, "ERREUR SAUVEGARDE", MessageBoxButton.OK, MessageBoxImage.Error);
personneTMP = null;
}
if (personneTMP != null)
{
PersonneConnectee = personneTMP;
MessageBox.Show("SAUVEGARDE REUSSIE", "", MessageBoxButton.OK, MessageBoxImage.Information);
this.Close();
}
break;
/*case MessageBoxResult.No:
*
* break;*/
}
}
else
{
this.Close();
}
}
public FenetrePrincipale(MyPersonalMapData personne)
{
InitializeComponent();
PersonneConnectee = personne;
}
public FenetrePrincipale()
{
InitializeComponent();
PersonneConnectee = new MyPersonalMapData();
}
