dit zou normaal gezien correcter moeten scalen, maar nu moet ik mijn scale methode nog fixen

Globals/MultiPolygonPunten.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using GeoJSON.Net.Geometry;
 
 namespace Globals
@@ -15,35 +14,38 @@ namespace Globals
         {
             PolygonPunten = polygonPunten;
             Naam = naam;
-            VindMaximumEnMinimum(polygonPunten);
+            UpdateMaximumEnMinimum();
         }
 
         public MultiPolygonPunten(MultiPolygon multiPolygon, string naam = "")
         {
             Naam = naam;
             PolygonPunten = new List<PolygonPunten>();
+            bool reverse = true;
             foreach (Polygon polygon in multiPolygon.Coordinates)
             {
-                PolygonPunten.Add(new PolygonPunten(polygon, naam));
-            }
-            VindMaximumEnMinimum(PolygonPunten);
-            bool sw = false;
-            foreach (PolygonPunten p in PolygonPunten)
-            {
-                if (sw) p.Punten.Reverse();
-                sw = !sw;
+                PolygonPunten p = new PolygonPunten(polygon, naam, reverse);
+                PolygonPunten.Add(p);
+                reverse = !reverse; //reverse parameter voor polygonpunten is sneler dan 
+                UpdateMaximumEnMinimum(p);
             }
         }
 
-        private void VindMaximumEnMinimum(List<PolygonPunten> polygonPunten)
+        private void UpdateMaximumEnMinimum(PolygonPunten polygon)
         {
-            MaximumX = polygonPunten.Max(p => p.MaximumX);
-            MaximumY = polygonPunten.Max(p => p.MaximumY);
-            MinimumX = polygonPunten.Max(p => p.MinimumX);
-            MinimumY = polygonPunten.Max(p => p.MinimumY);
-            
+            if (polygon.MaximumX > MaximumX) MaximumX = polygon.MaximumX;
+            else if (polygon.MinimumX < MinimumX) MinimumX = polygon.MinimumX;
+            if (polygon.MaximumY > MaximumY) MaximumY = polygon.MaximumY;
+            else if (polygon.MinimumY < MinimumY) MinimumY = polygon.MinimumY;
         }
 
+        public void UpdateMaximumEnMinimum()
+        {
+            foreach (PolygonPunten polygon in PolygonPunten)
+            {
+                UpdateMaximumEnMinimum(polygon);
+            }
+        }
 
         public override string ToString()
         {

Globals/PolygonPunten.cs

@@ -1,9 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Windows.Shapes;
 using GeoJSON.Net.Geometry;
 namespace Globals
 {
@@ -17,36 +14,67 @@ namespace Globals
         {
             Punten = punten;
             Naam = naam;
-            MaximumX = punten.Max(punt => punt.X);
-            MaximumY = punten.Max(punt => punt.Y);
-            MinimumX = punten.Min(punt => punt.X);
-            MinimumY = punten.Min(punt => punt.Y);
+            UpdateMaxEnMinPunt();
         }
 
-        public PolygonPunten(GeoJSON.Net.Geometry.Polygon p, string naam = "")
+        public PolygonPunten(GeoJSON.Net.Geometry.Polygon polygon, string naam = "", bool reverse = true)
         {
             Naam = naam;
             Punten = new List<Punt>();
-            foreach (LineString l in p.Coordinates)
+            
+            foreach (LineString linestring in polygon.Coordinates)
             {
-                foreach (Position pos in l.Coordinates)
+                if (reverse)
                 {
-                    Punt pu = new Punt(pos.Longitude, pos.Latitude, naam);
-                    if (!Punten.Contains(pu)) Punten.Add(pu); //dit vertraagd programma enorm, maar zorgt ervoor dat peuker beter werkt denk ik
-                    //de vertraging komt vooral door de .Contains methode, deze mag weggelaten worden voor snelheid maar peuker zal niet meer zo goed werken 
+                    foreach (Position positie in linestring.Coordinates.Reverse()) //sneller om eerst te reversen dan tegen einde deze bewerking te doen
+                    {
+                        Punt punt = new Punt(positie.Longitude, positie.Latitude, naam);
+                    
+                        if (!Punten.Contains(punt)) {
+                            Punten.Add(punt); //dit vertraagd programma enorm, maar zorgt ervoor dat peuker beter werkt denk ik
+                            UpdateMaxEnMinPunt(punt); //sneller dan eindigen met punten.max en punten.min
+                        }
+                        //de vertraging komt vooral door de .Contains methode, deze mag weggelaten worden voor snelheid maar peuker zal niet meer zo goed werken 
+                    }
                 }
+                else
+                {
+                    foreach (Position positie in linestring.Coordinates) 
+                    {
+                        Punt punt = new Punt(positie.Longitude, positie.Latitude, naam);
+                    
+                        if (!Punten.Contains(punt)) {
+                            Punten.Add(punt); //dit vertraagd programma enorm, maar zorgt ervoor dat peuker beter werkt denk ik
+                            UpdateMaxEnMinPunt(punt); //sneller dan eindigen met punten.max en punten.min
+                        }
+                        //de vertraging komt vooral door de .Contains methode, deze mag weggelaten worden voor snelheid maar peuker zal niet meer zo goed werken 
+                    }
+                }
+                
             }
-            Punten.Reverse();
-            MaximumX = Punten.Max(punt => punt.X);
-            MaximumY = Punten.Max(punt => punt.Y);
-            MinimumX = Punten.Min(punt => punt.X);
-            MinimumY = Punten.Min(punt => punt.Y);
         }
 
+        private void UpdateMaxEnMinPunt(Punt punt)
+        {
+            if (punt.X > MaximumX) MaximumX = punt.X;
+            else if (punt.X < MinimumX) MinimumX = punt.X;
+            if (punt.Y > MaximumY) MaximumY = punt.Y;
+            else if (punt.Y < MinimumY) MinimumY = punt.Y;
+        }
+
+        public void UpdateMaxEnMinPunt()
+        {
+            foreach (Punt punt in Punten)
+            {
+                UpdateMaxEnMinPunt(punt);
+            }
+        }
+
+
         public override string ToString()
         {
             if (string.Equals(Naam, "", StringComparison.Ordinal)) return "UNKNOWN";
-            else return Naam;
+            return Naam;
         }
 
         public MultiPolygonPunten ToMultiPolygonPunten()

Globals/Punt.cs

@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using System.Windows;
 
 namespace Globals
@@ -16,8 +12,8 @@ namespace Globals
             Naam = naam;
             if (Graden)
             {
-                X = ConvertToRadians(x) * 100;
-                Y = ConvertToRadians(y) * 100;
+                X = ConvertToPercentage(x) * 100;
+                Y = ConvertToPercentage(y) * 100;
             }
             else
             {
@@ -32,9 +28,10 @@ namespace Globals
             else return Naam;
         }
         
-        public double ConvertToRadians(double angle)
+        public double ConvertToPercentage(double angle)
         {
-            return (Math.PI / 180) * angle;
+            if (angle < 0) angle += 360;
+            return angle / 360;
         }
         
         public Point ToPoint()