public MapInfo(RectLatLng Area, int Zoom, GMapProvider Type, bool makeWorldFile)
 {
     this.Area = Area;
      this.Zoom = Zoom;
      this.Type = Type;
      this.MakeWorldFile = makeWorldFile;
 }

 public MapInfo(PureProjection Projection, RectLatLng Area, int Zoom, MapType Type)
 {
     this.Projection = Projection;
      this.Area = Area;
      this.Zoom = Zoom;
      this.Type = Type;
 }

 public static bool RectLatLngCollide(RectLatLng a, RectLatLng b)
 {
     if ((a.Left > b.Left && a.Left < b.Right) || (b.Left > a.Left && b.Left > a.Right))
     {
         if ((a.Top < b.Top && a.Top < b.Top) || (b.Top > a.Top && b.Top > a.Top))
         {
             return true;
         }
     }
     return false;
 }

 public GridDataPoints activeData(GridDataPoints allPoints, RectLatLng bounds, String id)
 {
     GridDataPoints activePoints = new GridDataPoints(id);
     foreach (GridDataPoint p in allPoints.points)
     {
         if (OverlayProcessor.RectLatLngCollide(p.loc,bounds))
         {
             activePoints.addPoint(p);
         }
     }
     return activePoints;
 }

 /// <summary>
 ///     Get the map data from the AA api service.
 ///     Required scopes: query_mapdata query_mapairdata
 /// </summary>
 /// <param name="latLongBounds">The bounds of the request.</param>
 /// <returns>A collection of GeoJSON features.</returns>
 public Task<AAFeatureCollection> GetMapData(RectLatLng latLongBounds)
 {
     return _apiUrl
         .AppendPathSegments("v2", "mapdata", "geojson")
         .SetQueryParams(new
         {
             n = latLongBounds.Top,
             e = latLongBounds.Right,
             s = latLongBounds.Bottom,
             w = latLongBounds.Left
         })
         .WithClient(_client)
         .GetJsonAsync<AAFeatureCollection>();
 }

        public GMapMarkerOverlapCount(PointLatLng p)
            : base(p)
        {
            area = new RectLatLng(p, SizeLatLng.Empty);

            if (colorbrushs == null)
            {
                colorbrushs = new SolidBrush[color.Length];
                int a = 0;
                foreach (var color1 in color)
                {
                    colorbrushs[a] = new SolidBrush(Color.FromArgb(140, color1.R, color1.G, color1.B));
                    a++;
                }
            }
        }

        public void Start(RectLatLng area, PureProjection prj, int zoom, MapType type, int sleep)
        {
            if(!worker.IsBusy)
             {
            this.label1.Text = "...";
            this.progressBar1.Value = 0;

            this.prj = prj;
            this.area = area;
            this.zoom = zoom;
            this.type = type;
            this.sleep = sleep;

            GMaps.Instance.UseMemoryCache = false;

            worker.RunWorkerAsync();

            this.ShowDialog();
             }
        }

        public void Start(RectLatLng area, int zoom, GMapProvider provider, int sleep)
        {
            if(!worker.IsBusy)
             {
            this.label1.Text = "...";
            this.progressBarDownload.Value = 0;

            this.area = area;
            this.zoom = zoom;
            this.provider = provider;
            this.sleep = sleep;

            GMaps.Instance.UseMemoryCache = false;
            GMaps.Instance.CacheOnIdleRead = false;
            GMaps.Instance.BoostCacheEngine = true;

            worker.RunWorkerAsync();

            this.ShowDialog();
             }
        }

        public SuperMapProjection(double[] mapScales, MapParameter defaultMapParameter)
        {
            if (mapScales == null)
                throw new ArgumentNullException();
            if (defaultMapParameter == null)
            {
                throw new ArgumentNullException();
            }

            _mapScales = mapScales;
            _bounds = RectLatLng.FromLTRB(defaultMapParameter.Bounds.LeftBottom.X, 
                defaultMapParameter.Bounds.RightTop.Y, 
                defaultMapParameter.Bounds.RightTop.X, 
                defaultMapParameter.Bounds.LeftBottom.Y);

            if (defaultMapParameter.Bounds == null)
                throw new ArgumentNullException();
            _minX = defaultMapParameter.Bounds.LeftBottom.X;
            _minY = defaultMapParameter.Bounds.LeftBottom.Y;
            _maxX = defaultMapParameter.Bounds.RightTop.X;
            _maxY = defaultMapParameter.Bounds.RightTop.Y;

            if (defaultMapParameter.PrjCoordSys != null &&
                defaultMapParameter.PrjCoordSys.CoordSystem != null &&
                defaultMapParameter.PrjCoordSys.CoordSystem.Datum != null &&
                defaultMapParameter.PrjCoordSys.CoordSystem.Datum.Spheroid != null)
            {
                _axis = defaultMapParameter.PrjCoordSys.CoordSystem.Datum.Spheroid.Axis;
                _flattening = defaultMapParameter.PrjCoordSys.CoordSystem.Datum.Spheroid.Flatten;
            }

            double refMapScale = defaultMapParameter.Scale;
            double refResolution = (defaultMapParameter.ViewBounds.RightTop.X - defaultMapParameter.ViewBounds.LeftBottom.X) /
                (defaultMapParameter.Viewer.Width);
            _resolutions = new double[_mapScales.Length];
            for (int i = 0; i < _mapScales.Length; i++)
            {
                _resolutions[i] = refResolution * refMapScale / mapScales[i];
            }
        }

 public bool Contains(RectLatLng rect)
 {
     return ((((this.Lng <= rect.Lng) && ((rect.Lng + rect.WidthLng) <= (this.Lng + this.WidthLng))) && (this.Lat >= rect.Lat)) && ((rect.Lat - rect.HeightLat) >= (this.Lat - this.HeightLat)));
 }

 // ok ???
 // http://greatmaps.codeplex.com/workitem/15981
 public static RectLatLng Union(RectLatLng a, RectLatLng b)
 {
     return RectLatLng.FromLTRB(
     Math.Min(a.Left, b.Left),
     Math.Max(a.Top, b.Top),
     Math.Max(a.Right, b.Right),
     Math.Min(a.Bottom, b.Bottom));
 }

 static RectLatLng()
 {
     Empty = new RectLatLng();
 }

        // ok ???
        public static RectLatLng Intersect(RectLatLng a, RectLatLng b)
        {
            double lng = Math.Max(a.Lng, b.Lng);
             double num2 = Math.Min((double)(a.Lng + a.WidthLng), (double)(b.Lng + b.WidthLng));

             double lat = Math.Max(a.Lat, b.Lat);
             double num4 = Math.Min((double)(a.Lat + a.HeightLat), (double)(b.Lat + b.HeightLat));

             if((num2 >= lng) && (num4 >= lat))
             {
            return new RectLatLng(lat, lng, num2 - lng, num4 - lat);
             }
             return Empty;
        }

 void GmapWidget_OnSelectionChange(RectLatLng Selection, bool ZoomToFit)
 {
     if (poligonSelection)
         return;
     var selected = addressesOverlay.Markers.Where(m => Selection.Contains(m.Position)).ToList();
     UpdateSelectedInfo(selected);
 }

            public bool LoadFile(string filename)
            {
                FileName = filename;

                log.InfoFormat("GeoTiff {0}", filename);

                using (Tiff tiff = Tiff.Open(filename, "r"))
                {
                    width = tiff.GetField(TiffTag.IMAGEWIDTH)[0].ToInt();
                    height = tiff.GetField(TiffTag.IMAGELENGTH)[0].ToInt();
                    bits = tiff.GetField(TiffTag.BITSPERSAMPLE)[0].ToInt();

                    if (bits != 16)
                        return false;

                    var modelscale = tiff.GetField(TiffTag.GEOTIFF_MODELPIXELSCALETAG);
                    var tiepoint = tiff.GetField(TiffTag.GEOTIFF_MODELTIEPOINTTAG);

                    i = BitConverter.ToDouble(tiepoint[1].ToByteArray(), 0);
                    j = BitConverter.ToDouble(tiepoint[1].ToByteArray(), 0 + 8);
                    k = BitConverter.ToDouble(tiepoint[1].ToByteArray(), 0 + 16);
                    x = BitConverter.ToDouble(tiepoint[1].ToByteArray(), 0 + 24);
                    y = BitConverter.ToDouble(tiepoint[1].ToByteArray(), 0 + 32);
                    z = BitConverter.ToDouble(tiepoint[1].ToByteArray(), 0 + 40);

                    log.InfoFormat("Tie Point ({0},{1},{2}) --> ({3},{4},{5})", i, j, k, x, y, z);

                    xscale = BitConverter.ToDouble(modelscale[1].ToByteArray(), 0);
                    yscale = BitConverter.ToDouble(modelscale[1].ToByteArray(), 0 + 8);
                    zscale = BitConverter.ToDouble(modelscale[1].ToByteArray(), 0 + 16);

                    log.InfoFormat("Scale ({0},{1},{2})", xscale, yscale, zscale);

                    Area = new RectLatLng(y, x, width*xscale, height*yscale);

                    log.InfoFormat("Coverage {0}", Area.ToString());

                    GeoTiff.index.Add(this);

                    /*

                short numberOfDirectories = tiff.NumberOfDirectories();
                for (short d = 0; d < numberOfDirectories; ++d)
                {
                    tiff.SetDirectory((short)d);

                    for (ushort t = ushort.MinValue; t < ushort.MaxValue; ++t)
                    {
                        TiffTag tag = (TiffTag)t;
                        FieldValue[] value = tiff.GetField(tag);
                        if (value != null)
                        {
                            for (int j2 = 0; j2 < value.Length; j2++)
                            {
                                Console.WriteLine("{0} : {1} : {2}", tag.ToString(), value[j2].Value.GetType().ToString(), value[j2].ToString());
                            }
                        }
                    }
                }
                     */
                }

                return true;
            }

        /// <summary>
        /// gets all tiles in rect at specific zoom
        /// </summary>
        public List<Point> GetAreaTileList(RectLatLng rect, int zoom, int padding)
        {
            List<Point> ret = new List<Point>();

            Point topLeft = FromPixelToTileXY(FromLatLngToPixel(rect.LocationTopLeft, zoom));
            Point rightBottom = FromPixelToTileXY(FromLatLngToPixel(rect.LocationRightBottom, zoom));

            for (int x = (topLeft.X - padding); x <= (rightBottom.X + padding); x++)
            {
                for (int y = (topLeft.Y - padding); y <= (rightBottom.Y + padding); y++)
                {
                    Point p = new Point(x, y);
                    if (!ret.Contains(p) && p.X >= 0 && p.Y >= 0)
                    {
                        ret.Add(p);
                    }
                }
            }
            ret.TrimExcess();

            return ret;
        }

        static PointF GetPixel(RectLatLng area, PointLatLngAlt loc, Size size) 
        {
            double lon =  loc.Lng;
            double lat = loc.Lat;

            double lonscale = (lon - area.Left) * (size.Width - 0) / (area.Right - area.Left) + 0;

            double latscale = (lat - area.Top) * (size.Height - 0) / (area.Bottom - area.Top) + 0;

            return new PointF((float)lonscale, (float)latscale);
        }

        /// <summary>
        /// sets zoom to max to fit rect
        /// </summary>
        /// <param name="rect">area</param>
        /// <returns></returns>
        public bool SetZoomToFitRect(RectLatLng rect)
        {
            int maxZoom = Core.GetMaxZoomToFitRect(rect);
             if(maxZoom > 0)
             {
            PointLatLng center = new PointLatLng(rect.Lat - (rect.HeightLat / 2), rect.Lng + (rect.WidthLng / 2));
            CurrentPosition = center;

            if(maxZoom > MaxZoom)
            {
               maxZoom = MaxZoom;
            }

            if(ZoomStep != maxZoom)
            {
               Zoom = maxZoom;
            }

            return true;
             }
             return false;
        }

 // ok ???
 public bool IntersectsWith(RectLatLng rect)
 {
     return ((((rect.Lng < (this.Lng + this.WidthLng)) && (this.Lng < (rect.Lng + rect.WidthLng))) && (rect.Lat < (this.Lat + this.HeightLat))) && (this.Lat < (rect.Lat + rect.HeightLat)));
 }

 // ok ???
 public static RectLatLng Union(RectLatLng a, RectLatLng b)
 {
     double lng = Math.Min(a.Lng, b.Lng);
      double num2 = Math.Max((double) (a.Lng + a.WidthLng), (double) (b.Lng + b.WidthLng));
      double lat = Math.Min(a.Lat, b.Lat);
      double num4 = Math.Max((double) (a.Lat + a.HeightLat), (double) (b.Lat + b.HeightLat));
      return new RectLatLng(lng, lat, num2 - lng, num4 - lat);
 }