Exemplo n.º 1
0
        const double Exp = 2; // 2=euclid, 1=manhatten
        
        // Minkowski dist
        // if lat lon precise dist is needed, use Haversine or similar formulas
        // this is approx calc for clustering, no precise dist is needed
        public static double Distance(MapPoint a, MapPoint b)
        {
            // lat lon wrap, values don't seem needed to be normalized to [0;1] for better distance calc
            var absx = LatLonDiff(a.X, b.X);
            var absy = LatLonDiff(a.Y, b.Y);

            return Math.Pow(Math.Pow(absx, Exp) +
                Math.Pow(Math.Abs(absy), Exp), 1.0 / Exp);
        }
Exemplo n.º 2
0
 public int CompareTo(MapPoint other, int dimension)
 {
     switch (dimension)
     {
         case 0:
             return this.X.CompareTo(other.X);
         case 1:
             return this.Y.CompareTo(other.Y);
         default:
             throw new ArgumentException("Invalid dimension.");
     }
 }
        public void BuildContent(MapPoint point)
        {
            if (point == null)
            {
                Content = "Marker could not be found";
                return;
            }

            Id = point.MarkerId.ToString();
            Type = point.MarkerType;
            Lat = point.Lat;
            Long = point.Long;

            var stringBuilder = new StringBuilder();
            stringBuilder.AppendLine("<div class='gmcKN-marker-info'>");
            stringBuilder.AppendFormat("Time: {0}<br/>",DateTime.Now.ToString("HH:mm:ss"));
            stringBuilder.AppendFormat("Id: {0}<br /> Type: {1}<br />", Id, Type);
            stringBuilder.AppendFormat("Lat: {0} Lon: {1}", point.Lat, point.Long);
            stringBuilder.AppendLine("</div>");

            Content = stringBuilder.ToString();
        }        
        // To work properly it requires the p is already normalized
        protected static int[] GetPointMappedIds(MapPoint point, Boundary grid, double deltaX, double deltaY)
        {
            #region Naive
            // Naive version, lon points near 180 and lat points near 90 are not clustered together
            //idx = (int)(relativeX / deltax);
            //idy = (int)(relativeY / deltay);
            //var relativeX = p.X - grid.Minx;
            #endregion Naive

            /*
            You have to draw a line with longitude values 180, -180 on papir to understand this            
                
             e.g. _deltaX = 20
longitude        150   170  180  -170   -150
                 |      |          |     |
                 
       
   idx =         7      8    9    -9    -8
                            -10    
                                  
here we want idx 8, 9, -10 and -9 be equal to each other, we set them to idx=8
then the longitudes from 170 to -170 will be clustered together
             */

            var relativeY = point.Y - grid.MinY;

            var overlapMapMinX = (int)(LatLongInfo.MinLonValue / deltaX) - 1;
            var overlapMapMaxX = (int)(LatLongInfo.MaxLonValue / deltaX);

            // The deltaX = 20 example scenario, then set the value 9 to 8 and -10 to -9

            // Similar to if (LatLonInfo.MaxLonValue % deltax == 0) without floating presicion issue
            if (Math.Abs(LatLongInfo.MaxLonValue % deltaX - 0) < Numbers.Epsilon)
            {
                overlapMapMaxX--;
                overlapMapMinX++;
            }

            var idxx = (int)(point.X / deltaX);
            if (point.X < 0) idxx--;

            if (Math.Abs(LatLongInfo.MaxLonValue % point.X - 0) < Numbers.Epsilon)
            {
                if (point.X < 0) idxx++;
                else idxx--;
            }
            if (idxx == overlapMapMinX) idxx = overlapMapMaxX;

            var idx = idxx;

            // Latitude never wraps around with Google Maps, ignore 90, -90 wrap-around for latitude
            var idy = (int)(relativeY / deltaY);

            return new[] { idx, idy };
        }
Exemplo n.º 5
0
 public static double Haversine(MapPoint p1, MapPoint p2)
 {
     return Haversine(p1.Y, p1.X, p2.Y, p2.X);
 }
Exemplo n.º 6
0
 public static bool IsInside(Boundary b, MapPoint p)
 {
     return IsInside(b.MinX, b.MinY, b.MaxX, b.MaxY, p.X, p.Y, false, false);
 }
        // Circular mean, very relevant for points around New Zealand, where lon -180 to 180 overlap
        // Adapted Centroid Calculation of N Points for Google Maps usage
        // If you are working with points in a specific country only such as India or USA then a simpler centroid calc can be used
        // http://en.wikipedia.org/wiki/Centroid
        public static MapPoint GetCentroidFromClusterLatLon(List<MapPoint> list) //O(n)
        {
            int count;
            if (list == null || (count = list.Count) == 0) return null;

            if (count == 1)
            {
                return list.First();
            }

            // http://en.wikipedia.org/wiki/Circular_mean
            // http://stackoverflow.com/questions/491738/how-do-you-calculate-the-average-of-a-set-of-angles
            /*
                                  1/N*  sum_i_from_1_to_N sin(a[i])
                a = atan2      ---------------------------
                                  1/N*  sum_i_from_1_to_N cos(a[i])
             */

            double longSin = 0;
            double longCos = 0;
            double latSin = 0;
            double latCos = 0;
            foreach (var p in list)
            {
                longSin += Math.Sin(p.X.LatLongToRadian());
                longCos += Math.Cos(p.X.LatLongToRadian());
                latSin += Math.Sin(p.Y.LatLongToRadian());
                latCos += Math.Cos(p.Y.LatLongToRadian());
            }

            longSin /= count;
            longCos /= count;

            double radx = 0;
            double rady = 0;

            // if both are zero-ish
            if (Math.Abs(longSin - 0) > Numbers.Epsilon && Math.Abs(longCos - 0) > Numbers.Epsilon)
            {
                radx = Math.Atan2(longSin, longCos);
                rady = Math.Atan2(latSin, latCos);
            }
            var x = radx.RadianToLatLong();
            var y = rady.RadianToLatLong();

            var centroid = new MapPoint { X = x, Y = y, Count = count };
            return centroid;
        }
        public MapPoint GetClosestPoint(MapPoint from, List<MapPoint> list) // O(n)
        {
            var min = double.MaxValue;
            MapPoint closests = null;
            foreach (var p in list)
            {
                var dist = MathTool.Distance(from, p);
                if (dist >= min) continue;

                // update
                min = dist;
                closests = p;
            }
            return closests;
        }