Exemplo n.º 1
0
 public static WierzcholekGrafu ZwrocWiekszyWierzcholek(WierzcholekGrafu wierzcholekA, WierzcholekGrafu wierzcholekB)
 {
     if (Punkt <double> .ZwrocPozycjeWiekszego(wierzcholekA.Pozycja, wierzcholekB.Pozycja).Equals(wierzcholekA.Pozycja))
     {
         return(wierzcholekA);
     }
     else
     {
         return(wierzcholekB);
     }
 }
        /// <summary>
        /// Wyznacza połączenia które są pewnikiem i są podstawą między innymi połączeniami
        /// </summary>
        private void GenerujPoloczeniaKonieczne()
        {
            Punkt <double> punktGorny = new Punkt <double>(0, rozmiarMapyY / 2);
            Punkt <double> punktDolny = new Punkt <double>(0, rozmiarMapyY / 2);
            Punkt <double> punktLewy  = new Punkt <double>(rozmiarMapyX / 2, 0);
            Punkt <double> punktPrawy = new Punkt <double>(rozmiarMapyX / 2, 0);

            foreach (WierzcholekDrogi wierzcholek in WierzcholkiDrog)
            {
                if (wierzcholek.Pozycja.Y < punktGorny.Y && wierzcholek.Pozycja.Y != GRANICA_GORNA)
                {
                    punktGorny = wierzcholek.Pozycja;
                }
                if (wierzcholek.Pozycja.Y > punktDolny.Y && wierzcholek.Pozycja.Y != GRANICA_DOLNA)
                {
                    punktDolny = wierzcholek.Pozycja;
                }
                if (wierzcholek.Pozycja.X > punktPrawy.X && wierzcholek.Pozycja.X != GRANICA_PRAWA)
                {
                    punktPrawy = wierzcholek.Pozycja;
                }
                if (wierzcholek.Pozycja.X < punktLewy.X && wierzcholek.Pozycja.X != GRANICA_LEWA)
                {
                    punktLewy = wierzcholek.Pozycja;
                }
            }

            List <WierzcholekDrogi> punktyWejscia = WierzcholkiDrog.ToList();

            foreach (WierzcholekDrogi wierzcholek in punktyWejscia)
            {
                Punkt <double> punktPrzeciecia = new Punkt <double>(0, 0);

                if (wierzcholek.Pozycja.Y == GRANICA_GORNA) // Góra
                {
                    punktPrzeciecia = new Punkt <double>(wierzcholek.Pozycja.X, punktGorny.Y);
                }
                else if (wierzcholek.Pozycja.X == GRANICA_PRAWA) // Prawa
                {
                    punktPrzeciecia = new Punkt <double>(punktPrawy.X, wierzcholek.Pozycja.Y);
                }
                else if (wierzcholek.Pozycja.Y == GRANICA_DOLNA) // Dół
                {
                    punktPrzeciecia = new Punkt <double>(wierzcholek.Pozycja.X, punktDolny.Y);
                }
                else if (wierzcholek.Pozycja.X == GRANICA_LEWA) // Lewa
                {
                    punktPrzeciecia = new Punkt <double>(punktLewy.X, wierzcholek.Pozycja.Y);
                }

                WierzcholekDrogi nowyWierzcholek = DodajLubZnajdzWierzcholek(punktPrzeciecia);
                drogi.Add(KrawedzGrafu.StworzDroge(nowyWierzcholek, wierzcholek));
            }
        }
        public Samochod(WierzcholekGrafu start, List <WierzcholekGrafu> trasa)
        {
            this.trasa         = trasa.ConvertAll(obiekt => (WierzcholekDrogi)obiekt);
            this.ObecnaPozycja = (WierzcholekDrogi)start;

            TworzObrazek();

            Punkt <double> przesuniecie = ((WejscieNaPunktWejscia)ObecnaPozycja.ObiektDrogi).PunktWejsciowy();

            UstawPozycje(new Punkt <double>(start.Pozycja.X * 80 + przesuniecie.X, start.Pozycja.Y * 80 + przesuniecie.Y));
        }
Exemplo n.º 4
0
        private WierzcholekChodnika DodajLubZnajdzWierzcholek(Punkt <double> pozycja)
        {
            WierzcholekChodnika wierzcholek = WierzcholkiChodnikow.Find(obiekt => obiekt.Pozycja.Equals(pozycja));

            if (wierzcholek == null)
            {
                WierzcholkiChodnikow.Add(wierzcholek = new WierzcholekChodnika(pozycja, TypWierzcholkaPieszych.ChodnikDrogi));
            }

            return(wierzcholek);
        }
        private WierzcholekDrogi DodajLubZnajdzWierzcholek(Punkt <double> pozycja, TypWierzcholkaSamochodow typWierzcholka = TypWierzcholkaSamochodow.Skrzyzowanie)
        {
            WierzcholekDrogi wierzcholek = WierzcholkiDrog.Find(obiekt => obiekt.Pozycja.Equals(pozycja));

            if (wierzcholek == null)
            {
                WierzcholkiDrog.Add(wierzcholek = new WierzcholekDrogi(pozycja, typWierzcholka));
            }

            return(wierzcholek);
        }
Exemplo n.º 6
0
        public static Relacja ZwrocRelacje(Punkt <T> punktA, Punkt <T> punktB)
        {
            if (punktA.X.Equals(punktB.X))
            {
                return(Relacja.Pionowe);
            }
            if (punktA.Y.Equals(punktB.Y))
            {
                return(Relacja.Poziome);
            }

            return(Relacja.Brak);
        }
Exemplo n.º 7
0
        private WierzcholekChodnika DzielTraseWPunkcie(KrawedzGrafu trasa, Punkt <double> punkt)
        {
            WierzcholekChodnika wierzcholekA        = (WierzcholekChodnika)trasa.WierzcholekA;
            WierzcholekChodnika wierzcholekB        = (WierzcholekChodnika)trasa.WierzcholekB;
            WierzcholekChodnika dzielacyWierzcholek = new WierzcholekChodnika(punkt, TypWierzcholkaPieszych.ChodnikDrogi);

            WierzcholkiChodnikow.Add(dzielacyWierzcholek);

            Chodniki.Remove(trasa.UsunKrawedz());
            Chodniki.Add(KrawedzGrafu.StworzDroge(wierzcholekA, dzielacyWierzcholek));
            Chodniki.Add(KrawedzGrafu.StworzDroge(dzielacyWierzcholek, wierzcholekB));

            return(dzielacyWierzcholek);
        }
Exemplo n.º 8
0
        public static Punkt <T> ZwrocPozycjeWiekszego(Punkt <T> punktA, Punkt <T> punktB)
        {
            Relacja relacja = ZwrocRelacje(punktA, punktB);

            if (relacja == Relacja.Poziome)
            {
                return((dynamic)punktA.X > punktB.X ? punktA : punktB);
            }
            else if (relacja == Relacja.Pionowe)
            {
                return((dynamic)punktA.Y > punktB.Y ? punktA : punktB);
            }

            throw new Exception("Brak relacji");
        }
        /// <summary>
        /// Przenoszenie na mapę drogi z generatoraPołączeń
        /// </summary>
        private void OdwzorujDroge(GeneratorPolaczenSamochodow generatorPolaczen)
        {
            foreach (WierzcholekDrogi wierzcholek in generatorPolaczen.WierzcholkiDrog)
            {
                Punkt <int> punkt = (Punkt <int>)wierzcholek.Pozycja;

                if (wierzcholek.TypWierzcholka != TypWierzcholkaSamochodow.PunktWejscia)
                {
                    Mapa[punkt.X * 2, punkt.Y * 2]         = TypPrzestrzeni.Droga;
                    Mapa[punkt.X * 2 + 1, punkt.Y * 2]     = TypPrzestrzeni.Droga;
                    Mapa[punkt.X * 2, punkt.Y * 2 + 1]     = TypPrzestrzeni.Droga;
                    Mapa[punkt.X * 2 + 1, punkt.Y * 2 + 1] = TypPrzestrzeni.Droga;
                }
            }
        }
        private void Tworz4Obrazki(Punkt <double> punkt, string lokalizacjaPlku1, string lokalizacjaPlku2, string lokalizacjaPlku3, string lokalizacjaPlku4)
        {
            Image obrazek;

            obrazek = TworzObrazek(lokalizacjaPlku1);
            UstawPozycjeObiektu(obrazek, new Punkt <double>(punkt.X * 2 * obrazek.Height, punkt.Y * 2 * obrazek.Width));

            obrazek = TworzObrazek(lokalizacjaPlku2);
            UstawPozycjeObiektu(obrazek, new Punkt <double>(punkt.X * 2 * obrazek.Height + obrazek.Height, punkt.Y * 2 * obrazek.Width));

            obrazek = TworzObrazek(lokalizacjaPlku3);
            UstawPozycjeObiektu(obrazek, new Punkt <double>(punkt.X * 2 * obrazek.Height, punkt.Y * 2 * obrazek.Width + obrazek.Width));

            obrazek = TworzObrazek(lokalizacjaPlku4);
            UstawPozycjeObiektu(obrazek, new Punkt <double>(punkt.X * 2 * obrazek.Height + obrazek.Height, punkt.Y * 2 * obrazek.Width + obrazek.Width));
        }
Exemplo n.º 11
0
 public Punkt <double> Przesuniecie(Punkt <double> punkt)
 {
     if (ja.CzyJestDrogaWGore() && ja.CzyJestDrogaWPrawo())
     {
         if (punkt.Y < ja.Pozycja.Y)
         {
             return(new Punkt <double>(20, 60));
         }
         else
         {
             return(new Punkt <double>(60, 20));
         }
     }
     else if (ja.CzyJestDrogaWGore() && ja.CzyJestDrogaWLewo())
     {
         if (punkt.Y < ja.Pozycja.Y)
         {
             return(new Punkt <double>(20, 20));
         }
         else
         {
             return(new Punkt <double>(60, 60));
         }
     }
     else if (ja.CzyJestDrogaWDol() && ja.CzyJestDrogaWLewo())
     {
         if (punkt.Y > ja.Pozycja.Y)
         {
             return(new Punkt <double>(60, 20));
         }
         else
         {
             return(new Punkt <double>(20, 60));
         }
     }
     else
     {
         if (punkt.Y > ja.Pozycja.Y)
         {
             return(new Punkt <double>(60, 60));
         }
         else
         {
             return(new Punkt <double>(20, 20));
         }
     }
 }
Exemplo n.º 12
0
 private KrawedzGrafu SzukajDrogiPomiedzyPunktem(Punkt <double> pozycja)
 {
     foreach (KrawedzGrafu krawedz in Chodniki)
     {
         if (krawedz.ZwrocRelacje() == Relacja.Pionowe && pozycja.X == krawedz.WierzcholekA.Pozycja.X &&
             krawedz.WierzcholekA.Pozycja.Y < pozycja.Y && krawedz.WierzcholekB.Pozycja.Y > pozycja.Y)
         {
             return(krawedz);
         }
         else if (pozycja.Y == krawedz.WierzcholekA.Pozycja.Y && krawedz.WierzcholekA.Pozycja.X < pozycja.X &&
                  krawedz.WierzcholekB.Pozycja.X > pozycja.X)
         {
             return(krawedz);
         }
     }
     return(null);
 }
Exemplo n.º 13
0
        private void ProbujLaczycChodnik(Punkt <double> punkt, WierzcholekChodnika wierzcholek)
        {
            WierzcholekChodnika szukanyWierzcholek = WierzcholkiChodnikow.Find(o => o.Pozycja.Equals(punkt));

            if (szukanyWierzcholek != null)
            {
                Chodniki.Add(KrawedzGrafu.StworzDroge(wierzcholek, szukanyWierzcholek));
            }
            else
            {
                KrawedzGrafu szukanaKrawedz = SzukajDrogiPomiedzyPunktem(punkt);
                if (szukanaKrawedz != null)
                {
                    szukanyWierzcholek = DzielTraseWPunkcie(szukanaKrawedz, punkt);
                    Chodniki.Add(KrawedzGrafu.StworzDroge(szukanyWierzcholek, wierzcholek));
                }
            }
        }
 /// <summary>
 /// Usówa ślepe połączenia, usówa nadmiarowe skrzyżowania, tworzy zakręty
 /// </summary>
 private void RedukujPolaczenia()
 {
     for (int i = 0; i < WierzcholkiDrog.Count; ++i)
     {
         WierzcholekDrogi wierzcholek = WierzcholkiDrog[i];
         if (wierzcholek.TypWierzcholka == TypWierzcholkaSamochodow.Skrzyzowanie)
         {
             if (wierzcholek.Krawedzie.Count == 1)
             {
                 for (int j = wierzcholek.Krawedzie.Count - 1; j >= 0; --j)
                 {
                     drogi.Remove(wierzcholek.Krawedzie[j].UsunKrawedz());
                 }
                 WierzcholkiDrog.Remove(wierzcholek);
             }
             else if (wierzcholek.Krawedzie.Count == 2)
             {
                 if (Punkt <double> .ZwrocRelacje(wierzcholek.Krawedzie[0].ZwrocPrzeciwnyWierzcholek(wierzcholek).Pozycja, wierzcholek.Krawedzie[1].ZwrocPrzeciwnyWierzcholek(wierzcholek).Pozycja) == Relacja.Brak)
                 {
                     wierzcholek.TypWierzcholka = TypWierzcholkaSamochodow.Zakret;
                 }
                 else
                 {
                     drogi.Add(KrawedzGrafu.StworzDroge(wierzcholek.Krawedzie[1].ZwrocPrzeciwnyWierzcholek(wierzcholek), wierzcholek.Krawedzie[0].ZwrocPrzeciwnyWierzcholek(wierzcholek)));
                     for (int j = wierzcholek.Krawedzie.Count - 1; j >= 0; --j)
                     {
                         drogi.Remove(wierzcholek.Krawedzie[j].UsunKrawedz() as KrawedzGrafu);
                     }
                     WierzcholkiDrog.Remove(wierzcholek);
                 }
             }
         }
         else if (wierzcholek.TypWierzcholka == TypWierzcholkaSamochodow.PunktWejscia)
         {
             if (wierzcholek.Krawedzie.Count == 0)
             {
                 WierzcholkiDrog.Remove(wierzcholek);
             }
         }
     }
 }
        private void BudujChodnik(Punkt <double> punktA, Punkt <double> punktB)
        {
            WierzcholekChodnika wierzcholekA;

            if (punktA.X == 0)
            {
                wierzcholekA = new WierzcholekChodnika(new Punkt <double>(punktA.X - 0.5, punktA.Y), TypWierzcholkaPieszych.PunktWejscia);
            }
            else if (punktA.Y == 0)
            {
                wierzcholekA = new WierzcholekChodnika(new Punkt <double>(punktA.X, punktA.Y - 0.5), TypWierzcholkaPieszych.PunktWejscia);
            }
            else
            {
                wierzcholekA = new WierzcholekChodnika(punktA, TypWierzcholkaPieszych.ChodnikPrzestrzeni);
            }

            WierzcholekChodnika wierzcholekB;

            if (punktB.X == rozmiarMapyX - 1)
            {
                wierzcholekB = new WierzcholekChodnika(new Punkt <double>(punktB.X + 0.5, punktB.Y), TypWierzcholkaPieszych.PunktWejscia);
            }
            else if (punktB.Y == rozmiarMapyY - 1)
            {
                wierzcholekB = new WierzcholekChodnika(new Punkt <double>(punktB.X, punktB.Y + 0.5), TypWierzcholkaPieszych.PunktWejscia);
            }
            else
            {
                wierzcholekB = new WierzcholekChodnika(punktB, TypWierzcholkaPieszych.ChodnikPrzestrzeni);
            }

            WierzcholkiChodnikow.Add(wierzcholekA);
            WierzcholkiChodnikow.Add(wierzcholekB);
            Chodniki.Add(KrawedzGrafu.StworzDroge(wierzcholekA, wierzcholekB));

            ZaznaczNaMapie <TypPrzestrzeni>(Mapa, new Prostokat((Punkt <int>)punktA, (Punkt <int>)punktB), TypPrzestrzeni.Chodnik);
        }
 public Punkt <double> Przesuniecie(Punkt <double> punkt, Punkt <double> kolejny)
 {
     if (kolejny.Y > pozycja.Y) // w dół
     {
         return(new Punkt <double>(20, 60));
     }
     else if (kolejny.Y < pozycja.Y) // w górę
     {
         return(new Punkt <double>(60, 20));
     }
     else if (kolejny.X > pozycja.X) //w prawo
     {
         return(new Punkt <double>(60, 60));
     }
     else if (kolejny.X < pozycja.X)  // w lewo
     {
         return(new Punkt <double>(20, 20));
     }
     else
     {
         return(Punkt <double> .PustyPunkt);
     }
 }
        private void RysujOzdobe(Punkt <double> punkt)
        {
            int rand = GeneratorLosowosci.Next(0, 14);

            if (rand == 0)
            {
                TworzIUstawObrazekOzdoby(@"Ozdoby/Lampa.png", punkt);
            }
            else if (rand == 1)
            {
                TworzIUstawObrazekOzdoby(@"Ozdoby/Lawka.png", punkt);
            }
            else if (rand == 2)
            {
                TworzIUstawObrazekOzdoby(@"Ozdoby/Poczta.png", punkt);
            }
            else if (rand == 3)
            {
                TworzIUstawObrazekOzdoby(@"Ozdoby/Smietnik.png", punkt);
            }
            else if (rand == 4)
            {
                TworzIUstawObrazekOzdoby(@"Ozdoby/Hydrant.png", punkt);
            }
            else if (rand >= 5 && rand <= 7)
            {
                TworzIUstawObrazekOzdoby(@"Ozdoby/Drzewo1.png", punkt);
            }
            else if (rand >= 8 && rand <= 10)
            {
                TworzIUstawObrazekOzdoby(@"Ozdoby/Drzewo2.png", punkt);
            }
            else if (rand >= 11 && rand <= 13)
            {
                TworzIUstawObrazekOzdoby(@"Ozdoby/Drzewo3.png", punkt);
            }
        }
 public bool CzyMogeWejsc(Samochod samochod)
 {
     if (PrzejscieDlaPieszych.CzyMogeWejsc(samochod))
     {
         if (Punkt <double> .ZwrocRelacje(samochod.ObecnaPozycja.Pozycja, pozycja) == Relacja.Pionowe)
         {
             if (samochod.ObecnaPozycja.Pozycja.Y > pozycja.Y)
             {
                 return(lewyPojazd == null);
             }
             else
             {
                 return(prawyPojazd == null);
             }
         }
         else if (Punkt <double> .ZwrocRelacje(samochod.ObecnaPozycja.Pozycja, pozycja) == Relacja.Poziome)
         {
             if (samochod.ObecnaPozycja.Pozycja.X > pozycja.X)
             {
                 return(prawyPojazd == null);
             }
             else
             {
                 return(lewyPojazd == null);
             }
         }
         else
         {
             throw new Exception("Nieprawidłowy obiekt na wejściu");
         }
     }
     else
     {
         return(false);
     }
 }
Exemplo n.º 19
0
        /// <summary>
        /// Łaczy chodniki generowane w przestrzeni między budynkami
        /// z chodnikami generowanymi z połączeń drogowych
        /// </summary>
        private void LaczChodniki()
        {
            List <KrawedzGrafu> chodnikiPrzestrzeni = Chodniki.Where <KrawedzGrafu>(o => (o.WierzcholekA as WierzcholekChodnika)
                                                                                    .TypWierzcholka == TypWierzcholkaPieszych.ChodnikPrzestrzeni || (o.WierzcholekA as WierzcholekChodnika)
                                                                                    .TypWierzcholka == TypWierzcholkaPieszych.PunktWejscia).ToList();

            foreach (KrawedzGrafu chodnikPrzestrzeni in chodnikiPrzestrzeni)
            {
                if (chodnikPrzestrzeni.ZwrocRelacje() == Relacja.Pionowe)
                {
                    if (chodnikPrzestrzeni.WierzcholekA.Pozycja.Y > GRANICA_GORNA)
                    {
                        Punkt <double> punkt = new Punkt <double>(chodnikPrzestrzeni.WierzcholekA.Pozycja.X, chodnikPrzestrzeni.WierzcholekA.Pozycja.Y - 0.5);
                        ProbujLaczycChodnik(punkt, (WierzcholekChodnika)chodnikPrzestrzeni.WierzcholekA);
                    }
                    if (chodnikPrzestrzeni.WierzcholekB.Pozycja.Y < GRANICA_DOLNA)
                    {
                        Punkt <double> punkt = new Punkt <double>(chodnikPrzestrzeni.WierzcholekB.Pozycja.X, chodnikPrzestrzeni.WierzcholekB.Pozycja.Y + 0.5);
                        ProbujLaczycChodnik(punkt, (WierzcholekChodnika)chodnikPrzestrzeni.WierzcholekB);
                    }
                }
                else
                {
                    if (chodnikPrzestrzeni.WierzcholekA.Pozycja.X > GRANICA_LEWA)
                    {
                        Punkt <double> punkt = new Punkt <double>(chodnikPrzestrzeni.WierzcholekA.Pozycja.X - 0.5, chodnikPrzestrzeni.WierzcholekA.Pozycja.Y);
                        ProbujLaczycChodnik(punkt, (WierzcholekChodnika)chodnikPrzestrzeni.WierzcholekA);
                    }
                    if (chodnikPrzestrzeni.WierzcholekB.Pozycja.X < GRANICA_PRAWA)
                    {
                        Punkt <double> punkt = new Punkt <double>(chodnikPrzestrzeni.WierzcholekB.Pozycja.X + 0.5, chodnikPrzestrzeni.WierzcholekB.Pozycja.Y);
                        ProbujLaczycChodnik(punkt, (WierzcholekChodnika)chodnikPrzestrzeni.WierzcholekB);
                    }
                }
            }
        }
 public WejscieNaPasy(Punkt <double> pozycja)
 {
     this.pozycja = pozycja;
 }
        private void RysujChodnik(Punkt <double> punkt)
        {
            Image obrazek = TworzObrazek(@"Inne/Chodnik.png", 0);

            UstawPozycjeObiektu(obrazek, new Punkt <double>(punkt.X * 40, punkt.Y * 40));
        }
        /// <summary>
        /// łączy skrzyżowania pewne
        /// </summary>
        private void LaczSkrzyzowania()
        {
            List <WierzcholekDrogi> skrzyzowania = WierzcholkiDrog.FindAll(o => o.TypWierzcholka == TypWierzcholkaSamochodow.Skrzyzowanie);

            foreach (WierzcholekDrogi wierzcholek in skrzyzowania)
            {
                WierzcholekDrogi wlasciwy = null;
                foreach (WierzcholekDrogi potencjalny in skrzyzowania)
                {
                    if (wierzcholek != potencjalny && wierzcholek.Krawedzie.Find(o => o.ZwrocPrzeciwnyWierzcholek(wierzcholek) == potencjalny) == null)
                    {
                        if ((wlasciwy == null || Punkt <double> .Odleglosc(wlasciwy.Pozycja, wierzcholek.Pozycja) > Punkt <double> .Odleglosc(potencjalny.Pozycja, wierzcholek.Pozycja)) &&
                            Punkt <double> .ZwrocRelacje(wierzcholek.Pozycja, potencjalny.Pozycja) != Relacja.Brak &&
                            !CzyIstniejeWierzcholekPomiedzy(wierzcholek, potencjalny))
                        {
                            wlasciwy = potencjalny;
                        }
                    }
                }
                if (wlasciwy != null)
                {
                    drogi.Add(KrawedzGrafu.StworzDroge(wlasciwy, wierzcholek));
                }
            }
        }
 private void UstawPozycjeObiektu(Image obrazek, Punkt <double> punkt)
 {
     Canvas.SetLeft(obrazek, punkt.X);
     Canvas.SetTop(obrazek, punkt.Y);
 }
 public WejscieNaSkrzyzowanie(Punkt <double> pozycja)
 {
     this.pozycja = pozycja;
 }
 public Punkt <double> Przesuniecie(Punkt <double> punkt)
 {
     throw new NotImplementedException();
 }
Exemplo n.º 26
0
 public static T Odleglosc(Punkt <T> punktA, Punkt <T> punktB)
 {
     return(Math.Abs((dynamic)punktA.X - punktB.X) + Math.Abs((dynamic)punktA.Y - punktB.Y));
 }
Exemplo n.º 27
0
 public Geometria(Punkt <double> obiektA, Punkt <double> obiektB)
 {
     this.obiektA = obiektA;
     this.obiektB = obiektB;
 }
Exemplo n.º 28
0
 public WejscieNaDroge(Punkt <double> pozycja)
 {
     this.pozycja = pozycja;
 }
Exemplo n.º 29
0
 private void UstawPozycje(Punkt <double> punkt)
 {
     Canvas.SetLeft(obrazek, punkt.X);
     Canvas.SetTop(obrazek, punkt.Y);
 }
Exemplo n.º 30
0
 public WierzcholekGrafu(Punkt <double> pozycja)
 {
     Pozycja = pozycja;
 }