Beispiel #1
0
        public GeoCoord toGeoLocation(Point point, bool isPrint)
        {
            GeoCoord  ret = new GeoCoord(0.0d, 0.0d);

            double pX, pY;

            if(isPrint)
            {
                double offsetX = m_offsetXPrint / m_ratioXPrint;
                double offsetY = m_offsetYPrint / m_ratioYPrint;

                // this would be pixel screen coord if there were no scaling:
                pX = point.X / m_ratioXPrint - offsetX;	// tile pixels before scaling
                pY = - point.Y / m_ratioYPrint + offsetY + 200;
            }
            else
            {
                double offsetX = m_offsetX / m_ratioX;	// tile pixels before scaling
                double offsetY = m_offsetY / m_ratioY;

                // this would be pixel screen coord if there were no scaling:
                pX = point.X / m_ratioX - offsetX;	// tile pixels before scaling
                pY = - point.Y / m_ratioY + offsetY + 200;
            }

            // now calculate it in meters and offset the screen UTM
            pX = pX * m_metersPerPixel + screenUtmX;
            pY = pY * m_metersPerPixel + screenUtmY;

            UtmPt utmpt = new UtmPt();
            utmpt.X = pX;
            utmpt.Y = pY;
            utmpt.Zone = screenUtmZone;

            LonLatPt lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

            ret.Lat = lonlat.Lat;
            ret.Lng = lonlat.Lon;

            return ret;
        }
Beispiel #2
0
        protected void queryDisconnected()
        {
            GeoCoord covTL = m_cameraManager.CoverageTopLeft;
            GeoCoord covBR = m_cameraManager.CoverageBottomRight;

            double marginY = m_retilingSpecial ? 0.0d : ((covBR.Lng - covTL.Lng) / 40.0d);
            double marginX =  m_retilingSpecial ? 0.0d : ((covTL.Lat - covBR.Lat) / 40.0d * m_cameraManager.xScaleFactor);

            double covTL_Lng = covTL.Lng - marginX;
            double covTL_Lat = covTL.Lat + marginY;
            double covBR_Lng = covBR.Lng + marginX;
            double covBR_Lat = covBR.Lat - marginY;

            int currentZone = getZone(m_cameraManager.Location);

            LonLatPt lonlat = new LonLatPt();
            lonlat.Lat = covTL_Lat;
            lonlat.Lon = covTL_Lng;

            UtmPt utmptTL = Projection.LonLatPtToUtmNad83Pt(lonlat);		// can be in other than currentZone

            lonlat.Lat = covBR_Lat;
            lonlat.Lon = covBR_Lng;

            UtmPt utmptBR = Projection.LonLatPtToUtmNad83Pt(lonlat);		// can be in other than currentZone

            if(utmptTL.Zone != currentZone)
            {
                lonlat.Lat = m_cameraManager.Location.Lat;
                lonlat.Lon = m_cameraManager.Location.Lng;

                UtmPt utmptCam = Projection.LonLatPtToUtmNad83Pt(lonlat);	// can be in other than currentZone

                double dX = utmptBR.X - utmptCam.X;
                utmptTL.X = utmptCam.X - dX;
                utmptTL.Zone = currentZone;
            }
            else if(utmptBR.Zone != currentZone)
            {
                lonlat.Lat = m_cameraManager.Location.Lat;
                lonlat.Lon = m_cameraManager.Location.Lng;

                UtmPt utmptCam = Projection.LonLatPtToUtmNad83Pt(lonlat);	// can be in other than currentZone

                double dX = utmptCam.X - utmptTL.X;
                utmptBR.X = utmptCam.X + dX;
                utmptBR.Zone = currentZone;
            }

            int iScale = (int)m_tileScale;
            int metersPerPixel = (1 << ((int) iScale - 10));
            int factor = 200 * metersPerPixel;

            if(!firstSuperframe || xEnd - xStart == 0 || m_lastFactor == 0)
            {
                xStart =  (int)Math.Floor(utmptTL.X / factor);
                yStart =  (int)Math.Ceiling(utmptTL.Y / factor);

                xEnd =  (int)Math.Ceiling(utmptBR.X / factor);
                yEnd =  (int)Math.Floor(utmptBR.Y / factor);

                m_lastFactor = factor;
            }
            else
            {
                xStart =  xStart * m_lastFactor / factor;
                yStart =  yStart * m_lastFactor / factor;

                xEnd =  xEnd * m_lastFactor / factor;
                yEnd =  yEnd * m_lastFactor / factor;

                firstSuperframe = false;
            }

            int numTilesX = xEnd - xStart;
            int numTilesY = yStart - yEnd;

            // we need to remember UTM coordinates for Projection operation:
            m_scale = m_tileScale;
            m_metersPerPixel = (1 << ((Int32) m_scale - 10));
            screenUtmZone	 = currentZone;
            screenUtmX		 = xStart * factor;
            screenUtmY		 = (yStart - 1) * factor;

            cleanTiles();			// dispose of previous tile array, if any

            m_hCount = numTilesX;
            m_vCount = numTilesY;

            UtmPt utmpt = new UtmPt();
            utmpt.X = xStart * factor;
            utmpt.Y = yStart * factor;
            utmpt.Zone = currentZone;

            lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

            double topLeftLat = lonlat.Lat;
            double topLeftLng = lonlat.Lon;

            utmpt.X = (xStart + numTilesX) * factor;
            utmpt.Y = (yStart - numTilesY) * factor;

            lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

            double bottomRightLat = lonlat.Lat;
            double bottomRightLng = lonlat.Lon;

            m_tileResolutionDegreesH = Math.Abs(bottomRightLng - topLeftLng) / m_hCount;
            m_tileResolutionDegreesV = Math.Abs(bottomRightLat - topLeftLat) / m_vCount;
            #if DEBUG
            LibSys.StatusBar.Trace("m_tileResolutionDegreesH=" + m_tileResolutionDegreesH + " m_tileResolutionDegreesV=" + m_tileResolutionDegreesV);
            #endif

            int themeCode = getThemeCode();

            lock(tilesLock)
            {
                m_tiles = new TileTerra[m_vCount, m_hCount];

                SnapList snapLat = new SnapList(m_tileResolutionDegreesV, true);
                SnapList snapLng = new SnapList(m_tileResolutionDegreesH, true);

                int xx = (int)xStart;

                for(int hhh=0; hhh < m_hCount ;hhh++)
                {
                    int yy = (int)yStart;

                    for(int vvv=0; vvv < m_vCount ;vvv++)
                    {
                        utmpt.X = xx * factor;
                        utmpt.Y = (yy) * factor;
                        utmpt.Zone = currentZone;

                        lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

                        double tllat = lonlat.Lat;
                        double tllng = lonlat.Lon;

                        utmpt.X = (xx + 1) * factor;
                        utmpt.Y = (yy - 1) * factor;

                        lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

                        double brlat = lonlat.Lat;
                        double brlng = lonlat.Lon;

                        GeoCoord tileTopLeft = new GeoCoord(tllng, tllat);
                        GeoCoord tileBottomRight = new GeoCoord(brlng, brlat);

                        String baseName = String.Format("T{0}-S{1}-Z{2}-X{3}-Y{4}", themeCode, (Int32)m_tileScale, currentZone, xx, (yy - 1));
                        //String baseName = "T" + themeCode + "-S" + (Int32)m_tileScale + "-Z" + currentZone + "-X" + xx + "-Y" + (yy - 1);

                        if(!m_retilingSpecial)
                        {
                            // adding to snap lists prepares them for calculating snap points:
                            snapLat.Add(tllat);
                            snapLat.Add(brlat);
                            snapLng.Add(tllng);
                            snapLng.Add(brlng);
                        }

                        m_tiles[vvv, hhh] = new TileTerra(this, m_tileScale, tileTopLeft, tileBottomRight);
                        m_tiles[vvv, hhh].baseName = baseName;
                        m_tiles[vvv, hhh].init();		// gets backdrop, or starts the process of loading backdrop

            #if DEBUG
                        //LibSys.StatusBar.Trace("[" + vvv + "," + hhh + "]  " + baseName);
                        //LibSys.StatusBar.Trace("        -- topLeft=" + tileTopLeft + " bottomRight=" + tileBottomRight);
            #endif
                        yy--;
                    }
                    xx++;
                }

                // snap to the grid. If special retiling, distortion is ok:
                for(int vvv=0; !m_retilingSpecial && vvv < m_vCount ;vvv++)
                {
                    for(int hhh=0; hhh < m_hCount ;hhh++)
                    {
                        TileTerra tile = m_tiles[vvv, hhh];
                        // snap the tile's corners to grid:
                        tile.getBottomRight().X = snapLng.snap(tile.getBottomRight().X);
                        tile.getBottomRight().Y = snapLat.snap(tile.getBottomRight().Y);
                        tile.getTopLeft().X = snapLng.snap(tile.getTopLeft().X);
                        tile.getTopLeft().Y = snapLat.snap(tile.getTopLeft().Y);
                    }
                }

                // we need topleft tile for Projection:
                m_topLeftTile = m_tiles[0, 0];

                calcRatios();

                // compute resolution to display, meters per pixel, with overzoom indicator:
                double ratio = (m_ratioX + m_ratioY) / 2.0d;
                string overzoom = ("1m".Equals(m_tileScaleName) && ratio > 1.1d) ? " (overzoom)" : "";

                hasRenderedTiles = true;

                m_placeDescription = "[" + abbMessage + "]";
                m_formText = Project.PROGRAM_NAME_HUMAN + " - " + m_placeDescription + "   " + m_tileScaleName + "/pixel * " + ratio + overzoom; // + " (" + m_tileScale + ")";

            }	// end lock

            #region old code relying on Tiles DB in TerraserverCache
            /*
            int iTheme = (int)m_curTheme;
            string where = "theme = " + iTheme + " AND scale = " + iScale + " AND name LIKE '%-Z" + currentZone + "-%'"
                + " AND brlng > " + covTL_Lng + " AND tllng <" + covBR_Lng
                + " AND brlat < " + covTL_Lat + " AND tllat > " + covBR_Lat;

            #if DEBUG
            LibSys.StatusBar.Trace("WHERE " + where);
            #endif

            // sort by name gives us rows sorted from bottom left up to top left (per line scan) all the way to top right -
            // like a TV scanning, turned on the left side. The Y coord axis goes up, the X - to the right.
            string sort = "name";

            DataRow[] rows = TerraserverCache.TilesDS.Tables[0].Select(where, sort);

            // not all tiles may be present in the grid. Restore the grid structure:

            if(rows != null && rows.Length > 0)
            {
                // use the first tile for grid evaluation:
                int tileScale = (int)rows[0]["scale"];
                double tllng = (double)rows[0]["tllng"];
                double tllat = (double)rows[0]["tllat"];
                double brlng = (double)rows[0]["brlng"];
                double brlat = (double)rows[0]["brlat"];

                m_tileResolutionDegreesH = Math.Abs(brlng - tllng);
                m_tileResolutionDegreesV = Math.Abs(brlat - tllat);

            #if DEBUG
                LibSys.StatusBar.Trace("tl=" + tllng + "," + tllat + " br=" + brlng + "," + brlat);
                LibSys.StatusBar.Trace("m_tileResolutionDegreesH=" + m_tileResolutionDegreesH + " m_tileResolutionDegreesV=" + m_tileResolutionDegreesV);
                LibSys.StatusBar.Trace("tile 0 -- topLeft=" + (new GeoCoord(tllng,tllat)) + " bottomRight=" + (new GeoCoord(brlng,brlat)));
            #endif
                // evaluate dimensions of tile matrix and corners of the tile-covered frame:
                double d;
                int hCount = 0;
                for (d=tllng; d > covTL.Lng ;d -= m_tileResolutionDegreesH)
                {
                    //LibSys.StatusBar.Trace("working left -- topLeft=" + (new GeoCoord(d,tllat)));
                    hCount++;
                }
                double topLeftLng = d;
                for (d=tllng; d < covBR.Lng ;d += m_tileResolutionDegreesH)
                {
                    //LibSys.StatusBar.Trace("working right -- topLeft=" + (new GeoCoord(d,tllat)));
                    hCount++;
                }
                double bottomRightLng = d;

                int vCount = 0;
                for (d=tllat; d < covTL.Lat ;d += m_tileResolutionDegreesV)
                {
                    //LibSys.StatusBar.Trace("working up -- topLeft=" + (new GeoCoord(tllng, d)));
                    vCount++;
                }
                double topLeftLat = d;
                for (d=tllat; d > covBR.Lat ;d -= m_tileResolutionDegreesV)
                {
                    //LibSys.StatusBar.Trace("working down -- topLeft=" + (new GeoCoord(tllng, d)));
                    vCount++;
                }
                double bottomRightLat = d;

            #if DEBUG
                LibSys.StatusBar.Trace("hCount=" + hCount + " vCount=" + vCount);
                LibSys.StatusBar.Trace("topLeft=" + topLeftLng + "," + topLeftLat + " bottomRight=" + bottomRightLng + "," + bottomRightLat);
                LibSys.StatusBar.Trace("topLeft=" + (new GeoCoord(topLeftLng,topLeftLat)) + " bottomRight=" + (new GeoCoord(bottomRightLng,bottomRightLat)));
            #endif

                cleanTiles();			// dispose of previous tile array, if any

                m_vCount = vCount+2;	// make more cells for inperfections in tile corners.
                m_hCount = hCount+2;	// extra tiles will be initialized as "empty". The order of the tiles is random.

                lock(tilesLock)
                {
                    m_tiles = new TileTerra[m_vCount, m_hCount];

                    SnapList snapLat = new SnapList(m_tileResolutionDegreesV, true);
                    SnapList snapLng = new SnapList(m_tileResolutionDegreesH, true);

                    int vv = 0;
                    int hh = 0;

                    int rowCount = 0;
                    foreach(DataRow row in rows)
                    {
                        string basename = (string)row["name"];
                        tileScale = (int)row["scale"];
                        tllng = (double)row["tllng"];
                        tllat = (double)row["tllat"];
                        brlng = (double)row["brlng"];
                        brlat = (double)row["brlat"];

                        // adding to snap lists prepares them for calculating snap points:
                        snapLat.Add(tllat);
                        snapLat.Add(brlat);
                        snapLng.Add(tllng);
                        snapLng.Add(brlng);

                        // find the right position for the tile:
                        // (turns out that order of tiles does not matter)

                        // place the tile:
                        GeoCoord tileTopLeft = new GeoCoord(tllng, tllat, 0.0d);
                        GeoCoord tileBottomRight = new GeoCoord(brlng, brlat, 0.0d);
                        m_tiles[vv, hh] = new TileTerra(this, (Scale)tileScale, tileTopLeft, tileBottomRight);
            #if DEBUG
                        LibSys.StatusBar.Trace("    ----- tile: " + basename + " --- tl=" + tllng + "," + tllat + " br=" + brlng + "," + brlat);
            #endif
                        m_tiles[vv, hh].baseName = basename;
                        m_tiles[vv, hh].init();		// gets backdrop, or starts the process of loading backdrop

                        if(++rowCount >= m_hCount * m_vCount)
                        {
                            // no matter what, we don't want to overflow the array and get an exception. Shouldn't happen though.
                            LibSys.StatusBar.Error("too many tiles in rowset");
                            break;
                        }

                        hh++;
                        if(hh >= m_hCount)
                        {
                            hh = 0;
                            vv++;
                        }

                        // adjust frame corners to eliminate rounding errors, if possible:
                        topLeftLng = Math.Min(topLeftLng, tllng);
                        topLeftLat = Math.Max(topLeftLat, tllat);
                        bottomRightLng = Math.Max(bottomRightLng, brlng);
                        bottomRightLat = Math.Min(bottomRightLat, brlat);
                        //break;
                    }
                    m_cameraManager.terraTopLeft = new GeoCoord(topLeftLng, topLeftLat);
                    m_cameraManager.terraBottomRight = new GeoCoord(bottomRightLng, bottomRightLat);

                    // make sure there are no null tiles in the array:
                    tllng = topLeftLng;
                    tllat = topLeftLat;
                    brlng = tllng + m_tileResolutionDegreesH;
                    brlat = tllat - m_tileResolutionDegreesV;
                    for(int vvv=0; vvv < m_vCount ;vvv++)
                    {
                        for(int hhh=0; hhh < m_hCount ;hhh++)
                        {
                            TileTerra tile = m_tiles[vvv, hhh];
                            if(tile == null)
                            {
                                GeoCoord tileTopLeft = new GeoCoord(snapLng.snap(tllng), snapLat.snap(tllat), 0.0d);
                                GeoCoord tileBottomRight = new GeoCoord(snapLng.snap(brlng), snapLat.snap(brlat), 0.0d);
                                m_tiles[vvv, hhh] = new TileTerra(this, (Scale)tileScale, tileTopLeft, tileBottomRight);
                                m_tiles[vvv, hhh].baseName = "empty";
                                tile = m_tiles[vvv, hhh];
                                //m_tiles[vvv, hhh].init();		// gets backdrop, or starts the process of loading backdrop
                            }
                            else
                            {
                                // snap the tile's corners to grid:
                                tile.getBottomRight().X = snapLng.snap(tile.getBottomRight().X);
                                tile.getBottomRight().Y = snapLat.snap(tile.getBottomRight().Y);
                                tile.getTopLeft().X = snapLng.snap(tile.getTopLeft().X);
                                tile.getTopLeft().Y = snapLat.snap(tile.getTopLeft().Y);
                            }
                            // we need topleft tile for Projection:
                            if(m_topLeftTile == null || tile.getTopLeft().X <= m_topLeftTile.getTopLeft().X
                                && tile.getTopLeft().Y >= m_topLeftTile.getTopLeft().Y)
                            {
                                m_topLeftTile = tile;
                            }
                            tllng += m_tileResolutionDegreesH;
                            brlng += m_tileResolutionDegreesH;
                        }
                        tllat -= m_tileResolutionDegreesV;
                        brlat -= m_tileResolutionDegreesV;
                    }
                }	// end lock

                // compute parameters for Projection:
                Rectangle tileRect = m_topLeftTile.getFrameRectangle();
                m_ratioX = ((double)tileRect.Width - 1.5d) / 200.0d;		// -1.5 corrects added 1 in getFrameRectangle(), and probability of rounding
                m_ratioY = ((double)tileRect.Height - 1.5d) / 200.0d;
                m_offsetX = tileRect.X;
                m_offsetY = tileRect.Y;

                // compute resolution to display, meters per pixel, with overzoom indicator:
                double ratio = (m_ratioX + m_ratioY) / 2.0d;
                string overzoom = ("1m".Equals(m_tileScaleName) && ratio > 1.1d) ? " (overzoom)" : "";

                try
                {
                    // compute UTMP reference values for Projection operation:
                    screenUtmZone = currentZone;
                    m_scale = (Scale)m_tileScale;
                    m_metersPerPixel = (1 << ((Int32) m_scale - 10));
                    // we have to parse tile name here - something like T1-S16-Z17-X57-Y368
                    char[]   sep = new Char[1] { '-' };
                    string[] split = m_topLeftTile.baseName.Split(sep);

                    int utmX = Convert.ToInt32(split[3].Substring(1));
                    int utmY = Convert.ToInt32(split[4].Substring(1));
                    screenUtmX = (utmX * 200 * m_metersPerPixel);
                    screenUtmY = (utmY * 200 * m_metersPerPixel);

                    hasRenderedTiles = true;
                }
                catch {}

                m_placeDescription = "[" + abbMessage + "]";
                m_formText = Project.PROGRAM_NAME_HUMAN + " - " + m_placeDescription + "   " + m_tileScaleName + "/pixel * " + ratio + overzoom; // + " (" + m_tileScale + ")";
            }
            else
            {
                // there are no tiles for this scale, but if we zoomed in the existing tiles may work. Make sure distortion is taken care of.
                try
                {
                    // find which tile is now top-left (screen corner contained in this tile):
                    Rectangle tileRect = new Rectangle(0, 0, 0, 0);

                    for(int vvv=0; vvv < m_vCount ;vvv++)
                    {
                        for(int hhh=0; hhh < m_hCount ;hhh++)
                        {
                            TileTerra tile = m_tiles[vvv, hhh];
                            tileRect = tile.getFrameRectangle();
                            if(tileRect.Contains(0, 0))
                            {
                                m_topLeftTile = tile;
                                goto found;
                            }
                        }
                    }
                    goto notFound;

                found:
                    // compute parameters for Projection:
                    m_ratioX = ((double)tileRect.Width - 1.5d) / 200.0d;		// -1.5 corrects added 1 in getFrameRectangle(), and probability of rounding
                    m_ratioY = ((double)tileRect.Height - 1.5d) / 200.0d;
                    m_offsetX = tileRect.X;
                    m_offsetY = tileRect.Y;

                    // compute resolution to display, meters per pixel, with overzoom indicator:
                    double ratio = (m_ratioX + m_ratioY) / 2.0d;
                    string overzoom = " (overzoom)";

                    // compute UTMP reference values for Projection operation:
                    screenUtmZone = currentZone;
                    m_metersPerPixel = (1 << ((Int32) m_scale - 10));
                    // we have to parse tile name here - something like T1-S16-Z17-X57-Y368
                    char[]   sep = new Char[1] { '-' };
                    string[] split = m_topLeftTile.baseName.Split(sep);

                    m_tileScale = (Scale)Convert.ToInt32(split[1].Substring(1));
                    m_scale = (Scale)m_tileScale;
                    m_tileScaleName = scaleName(m_scale);
                    int utmX = Convert.ToInt32(split[3].Substring(1));
                    int utmY = Convert.ToInt32(split[4].Substring(1));
                    screenUtmX = (utmX * 200 * m_metersPerPixel);
                    screenUtmY = (utmY * 200 * m_metersPerPixel);

                    hasRenderedTiles = true;

                    m_placeDescription = "[" + abbMessage + "]";
                    m_formText = Project.PROGRAM_NAME_HUMAN + " - " + m_placeDescription + "   " + m_tileScaleName + "/pixel * " + ratio + overzoom; // + " (" + m_tileScale + ")";

                notFound:
                    ;
                }
                catch {}
            }
            */
            #endregion

            // Landmarks array was cleaned in the beginning of ReTile().
            // now fill the landmarks from the database:
            string where = "lng > " + covTL_Lng + " AND lng <" + covBR_Lng
                + " AND lat < " + covTL_Lat + " AND lat > " + covBR_Lat;

            DataRow[] rows = TerraserverCache.LandmarksDS.Tables["lm"].Select(where);

            if(rows != null && rows.Length > 0)
            {
                int numLandmarks = rows.Length;
                if(numLandmarks > 0)
                {
                    foreach(DataRow row in rows)
                    {
                        string name = (string)row["name"];
                        string type = (string)row["type"];
                        double lat =  (double)row["lat"];
                        double lng =  (double)row["lng"];
                        Landmark lm = new Landmark(name, new GeoCoord(lng, lat, 0.0d), type);
                        TerraserverCache.AddLandmark(lm);
                    }
                }
            }
        }
Beispiel #3
0
 // goes to terraserver for UTM to LonLat conversion -- not any more:
 private LonLatPt getBottomRightByTileId(TileId tid)
 {
     UtmPt utm = new UtmPt();
     utm.Zone = tid.Scene;
     int metersPerPixel = (1 << ((int) tid.Scale - 10));
     // lower right:
     utm.X = (tid.X + 1) * 200 * metersPerPixel - 1;
     utm.Y = tid.Y * 200 * metersPerPixel;
     LonLatPt llpt = Projection.UtmNad83PtToLonLatPt(utm); //TerraserverCache.ts.ConvertUtmPtToLonLatPt(utm);
     return llpt;
 }
Beispiel #4
0
        // goes to terraserver for UTM to LonLat conversion -- not any more:
        private LonLatPt getTopLeftByTileId(TileId tid)
        {
            // from http://terraserver.microsoft.net/about.aspx?n=AboutTerraServiceOverview (select Data Structures link):
            // Most TerraServer image tiles are in the UTM NAD 83 projection system.
            // The Scale, Scene, X, and Y fields can be used to compute the UTM NAD 83 coordinates
            // for the lower left hand pixel in the TerraServer tile (XOffset=0 and YOffset=200).
            // The following formulas are required to compute the UTM NAD 83 for the lower left hand pixel:
            //		Int32 UtmZone = Scene;
            //		Int32 metersPerPixel = (1 << ((Int32) Scale - 10));
            //		Int32 UtmEasting = X * 200 * metersPerPixel;
            //		Int32 UtmNorthing = Y * 200 * metersPerPixel;

            UtmPt utm = new UtmPt();
            utm.Zone = tid.Scene;
            int metersPerPixel = (1 << ((int) tid.Scale - 10));
            // top left:
            utm.X = tid.X * 200 * metersPerPixel;
            utm.Y = (tid.Y + 1) * 200 * metersPerPixel - 1;
            LonLatPt llpt = Projection.UtmNad83PtToLonLatPt(utm); //TerraserverCache.ts.ConvertUtmPtToLonLatPt(utm);
            return llpt;
        }
        /// <summary>
        /// this is complete cut-and-paste from the above - keep them in sync
        /// </summary>
        /// <param name="obj"></param>
        private void listQueryDisconnected(Hashtable list)
        {
            int xStart = 0;
            int yStart = 0;
            int xEnd = 0;
            int yEnd = 0;
            int m_lastFactor = 0;

            GeoCoord covTL = m_coverageTopLeft;
            GeoCoord covBR = m_coverageBottomRight;

            double marginY = 0.0d;
            double marginX = 0.0d;

            double covTL_Lng = covTL.Lng - marginX;
            double covTL_Lat = covTL.Lat + marginY;
            double covBR_Lng = covBR.Lng + marginX;
            double covBR_Lat = covBR.Lat - marginY;

            int currentZone = TileSetTerra.getZone(m_coverageCenter);

            LonLatPt lonlat = new LonLatPt();
            lonlat.Lat = covTL_Lat;
            lonlat.Lon = covTL_Lng;

            UtmPt utmptTL = Projection.LonLatPtToUtmNad83Pt(lonlat);		// can be in other than currentZone

            lonlat.Lat = covBR_Lat;
            lonlat.Lon = covBR_Lng;

            UtmPt utmptBR = Projection.LonLatPtToUtmNad83Pt(lonlat);		// can be in other than currentZone

            if(utmptTL.Zone != currentZone)
            {
                lonlat.Lat = m_coverageCenter.Lat;
                lonlat.Lon = m_coverageCenter.Lng;

                UtmPt utmptCam = Projection.LonLatPtToUtmNad83Pt(lonlat);	// can be in other than currentZone

                double dX = utmptBR.X - utmptCam.X;
                utmptTL.X = utmptCam.X - dX;
                utmptTL.Zone = currentZone;
            }
            else if(utmptBR.Zone != currentZone)
            {
                lonlat.Lat = m_coverageCenter.Lat;
                lonlat.Lon = m_coverageCenter.Lng;

                UtmPt utmptCam = Projection.LonLatPtToUtmNad83Pt(lonlat);	// can be in other than currentZone

                double dX = utmptCam.X - utmptTL.X;
                utmptBR.X = utmptCam.X + dX;
                utmptBR.Zone = currentZone;
            }

            int iScale = (int)m_tileScale;
            int metersPerPixel = (1 << ((int) iScale - 10));
            int factor = 200 * metersPerPixel;

            if(xEnd - xStart == 0 || m_lastFactor == 0)
            {
                xStart =  (int)Math.Floor(utmptTL.X / factor);
                yStart =  (int)Math.Ceiling(utmptTL.Y / factor);

                xEnd =  (int)Math.Ceiling(utmptBR.X / factor);
                yEnd =  (int)Math.Floor(utmptBR.Y / factor);

                m_lastFactor = factor;
            }
            else
            {
                xStart =  xStart * m_lastFactor / factor;
                yStart =  yStart * m_lastFactor / factor;

                xEnd =  xEnd * m_lastFactor / factor;
                yEnd =  yEnd * m_lastFactor / factor;
            }

            int numTilesX = xEnd - xStart;
            int numTilesY = yStart - yEnd;

            int hCount = numTilesX;
            int vCount = numTilesY;

            UtmPt utmpt = new UtmPt();
            utmpt.X = xStart * factor;
            utmpt.Y = yStart * factor;
            utmpt.Zone = currentZone;

            lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

            double topLeftLat = lonlat.Lat;
            double topLeftLng = lonlat.Lon;

            utmpt.X = (xStart + numTilesX) * factor;
            utmpt.Y = (yStart - numTilesY) * factor;

            lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

            double bottomRightLat = lonlat.Lat;
            double bottomRightLng = lonlat.Lon;

            int themeCode = getThemeCode();

            int xx = (int)xStart;

            for(int hhh=0; hhh < hCount ;hhh++)
            {
                int yy = (int)yStart;

                for(int vvv=0; vvv < vCount ;vvv++)
                {
                    utmpt.X = xx * factor;
                    utmpt.Y = (yy) * factor;
                    utmpt.Zone = currentZone;

                    lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

                    double tllat = lonlat.Lat;
                    double tllng = lonlat.Lon;

                    utmpt.X = (xx + 1) * factor;
                    utmpt.Y = (yy - 1) * factor;

                    lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

                    double brlat = lonlat.Lat;
                    double brlng = lonlat.Lon;

                    GeoCoord tileTopLeft = new GeoCoord(tllng, tllat);
                    GeoCoord tileBottomRight = new GeoCoord(brlng, brlat);

                    String baseName = String.Format("T{0}-S{1}-Z{2}-X{3}-Y{4}", themeCode, (Int32)m_tileScale, currentZone, xx, (yy - 1));

                    if(!list.ContainsKey(baseName))
                    {
                        list.Add(baseName, null);
                    }
            #if DEBUG
                    //LibSys.StatusBar.Trace("[" + vvv + "," + hhh + "]  " + baseName);
                    //LibSys.StatusBar.Trace("        -- topLeft=" + tileTopLeft + " bottomRight=" + tileBottomRight);
            #endif
                    yy--;
                }
                xx++;
            }
        }
        /// <summary>
        /// this is somewhat cut-and-paste from its namesake from the TileSetTerra.cs keep them in sync
        /// </summary>
        /// <param name="obj"></param>
        private void _queryDisconnected(object obj)
        {
            int xStart = 0;
            int yStart = 0;
            int xEnd = 0;
            int yEnd = 0;
            int m_lastFactor = 0;

            GeoCoord covTL = m_coverageTopLeft;
            GeoCoord covBR = m_coverageBottomRight;

            double marginY = 0.0d;
            double marginX = 0.0d;

            double covTL_Lng = covTL.Lng - marginX;
            double covTL_Lat = covTL.Lat + marginY;
            double covBR_Lng = covBR.Lng + marginX;
            double covBR_Lat = covBR.Lat - marginY;

            int currentZone = TileSetTerra.getZone(m_coverageCenter);

            LonLatPt lonlat = new LonLatPt();
            lonlat.Lat = covTL_Lat;
            lonlat.Lon = covTL_Lng;

            UtmPt utmptTL = Projection.LonLatPtToUtmNad83Pt(lonlat);		// can be in other than currentZone

            lonlat.Lat = covBR_Lat;
            lonlat.Lon = covBR_Lng;

            UtmPt utmptBR = Projection.LonLatPtToUtmNad83Pt(lonlat);		// can be in other than currentZone

            if(utmptTL.Zone != currentZone)
            {
                lonlat.Lat = m_coverageCenter.Lat;
                lonlat.Lon = m_coverageCenter.Lng;

                UtmPt utmptCam = Projection.LonLatPtToUtmNad83Pt(lonlat);	// can be in other than currentZone

                double dX = utmptBR.X - utmptCam.X;
                utmptTL.X = utmptCam.X - dX;
                utmptTL.Zone = currentZone;
            }
            else if(utmptBR.Zone != currentZone)
            {
                lonlat.Lat = m_coverageCenter.Lat;
                lonlat.Lon = m_coverageCenter.Lng;

                UtmPt utmptCam = Projection.LonLatPtToUtmNad83Pt(lonlat);	// can be in other than currentZone

                double dX = utmptCam.X - utmptTL.X;
                utmptBR.X = utmptCam.X + dX;
                utmptBR.Zone = currentZone;
            }

            int iScale = (int)m_tileScale;
            int metersPerPixel = (1 << ((int) iScale - 10));
            int factor = 200 * metersPerPixel;

            if(xEnd - xStart == 0 || m_lastFactor == 0)
            {
                xStart =  (int)Math.Floor(utmptTL.X / factor);
                yStart =  (int)Math.Ceiling(utmptTL.Y / factor);

                xEnd =  (int)Math.Ceiling(utmptBR.X / factor);
                yEnd =  (int)Math.Floor(utmptBR.Y / factor);

                m_lastFactor = factor;
            }
            else
            {
                xStart =  xStart * m_lastFactor / factor;
                yStart =  yStart * m_lastFactor / factor;

                xEnd =  xEnd * m_lastFactor / factor;
                yEnd =  yEnd * m_lastFactor / factor;
            }

            int numTilesX = xEnd - xStart;
            int numTilesY = yStart - yEnd;

            int hCount = numTilesX;
            int vCount = numTilesY;

            UtmPt utmpt = new UtmPt();
            utmpt.X = xStart * factor;
            utmpt.Y = yStart * factor;
            utmpt.Zone = currentZone;

            lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

            double topLeftLat = lonlat.Lat;
            double topLeftLng = lonlat.Lon;

            utmpt.X = (xStart + numTilesX) * factor;
            utmpt.Y = (yStart - numTilesY) * factor;

            lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

            double bottomRightLat = lonlat.Lat;
            double bottomRightLng = lonlat.Lon;

            int themeCode = getThemeCode();

            int xx = (int)xStart;

            for(int hhh=0; hhh < hCount ;hhh++)
            {
                int yy = (int)yStart;

                for(int vvv=0; vvv < vCount ;vvv++)
                {
                    utmpt.X = xx * factor;
                    utmpt.Y = (yy) * factor;
                    utmpt.Zone = currentZone;

                    lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

                    double tllat = lonlat.Lat;
                    double tllng = lonlat.Lon;

                    utmpt.X = (xx + 1) * factor;
                    utmpt.Y = (yy - 1) * factor;

                    lonlat = Projection.UtmNad83PtToLonLatPt(utmpt);

                    double brlat = lonlat.Lat;
                    double brlng = lonlat.Lon;

                    GeoCoord tileTopLeft = new GeoCoord(tllng, tllat);
                    GeoCoord tileBottomRight = new GeoCoord(brlng, brlat);

                    String baseName = String.Format("T{0}-S{1}-Z{2}-X{3}-Y{4}", themeCode, (Int32)m_tileScale, currentZone, xx, (yy - 1));

                    if(TerraserverCache.TileNamesCollection != null)
                    {
                        if(!TerraserverCache.TileNamesCollection.ContainsKey(baseName))
                        {
                            TerraserverCache.TileNamesCollection.Add(baseName, null);
                        }
                    }

                    lock(m_duplicates)
                    {
                        if(!m_duplicates.ContainsKey(baseName))
                        {
                            TerraserverCache.downloadIfMissing(baseName);
                            m_duplicates.Add(baseName, null);
                        }
                    }
            #if DEBUG
                    //LibSys.StatusBar.Trace("[" + vvv + "," + hhh + "]  " + baseName);
                    //LibSys.StatusBar.Trace("        -- topLeft=" + tileTopLeft + " bottomRight=" + tileBottomRight);
            #endif
                    yy--;
                }
                xx++;
            }

            int totalCount = TileSetTerraLayout.DuplicatesCount;
            int newCount = ThreadPool2.WaitingCallbacks;

            if(newCount == 0)
            {
                LibSys.StatusBar.Trace("*Preload tiles: nothing to download - all " + totalCount + " tiles already in cache.");
            }
            else
            {
                if(newCount <= totalCount)
                {
                    LibSys.StatusBar.Trace("*Preload tiles: trying to download " + newCount + " new of total " + totalCount + " tiles");
                }
                else
                {
                    LibSys.StatusBar.Trace("*Preload tiles: trying to download " + newCount + " new tiles");
                }
            }
        }
Beispiel #7
0
 /// <remarks/>
 public void ConvertUtmPtToLonLatPtAsync(UtmPt utm, object userState) {
     if ((this.ConvertUtmPtToLonLatPtOperationCompleted == null)) {
         this.ConvertUtmPtToLonLatPtOperationCompleted = new System.Threading.SendOrPostCallback(this.OnConvertUtmPtToLonLatPtOperationCompleted);
     }
     this.InvokeAsync("ConvertUtmPtToLonLatPt", new object[] {
                 utm}, this.ConvertUtmPtToLonLatPtOperationCompleted, userState);
 }
Beispiel #8
0
 /// <remarks/>
 public void ConvertUtmPtToLonLatPtAsync(UtmPt utm) {
     this.ConvertUtmPtToLonLatPtAsync(utm, null);
 }
Beispiel #9
0
 /// <remarks/>
 public System.IAsyncResult BeginConvertUtmPtToLonLatPt(UtmPt utm, System.AsyncCallback callback, object asyncState) {
     return this.BeginInvoke("ConvertUtmPtToLonLatPt", new object[] {
                 utm}, callback, asyncState);
 }
Beispiel #10
0
 public LonLatPt ConvertUtmPtToLonLatPt(UtmPt utm) {
     object[] results = this.Invoke("ConvertUtmPtToLonLatPt", new object[] {
                 utm});
     return ((LonLatPt)(results[0]));
 }
Beispiel #11
0
        // IMainCommand implementation:
        public bool fromUtmString(string text, out double lng, out double lat)
        {
            bool ret = false;
            lng = 0.0d;
            lat = 0.0d;

            try
            {
                // UTM = 11S E433603 N3778359
                char[] sep = new Char[] { ' ' };
                string[] split = text.Split(sep);
                string sZ = split[0];
                string sE = split[1];
                string sN = split[2];

                if(sZ.ToUpper().EndsWith("S"))
                {
                    sZ = sZ.Substring(0, sZ.Length - 1);
                }

                if(sE.ToUpper().EndsWith("E"))
                {
                    sE = sE.Substring(0, sE.Length - 1);
                }

                if(sN.ToUpper().EndsWith("N"))
                {
                    sN = sN.Substring(0, sN.Length - 1);
                }

                UtmPt utmpt = new UtmPt();
                utmpt.Zone = Convert.ToInt32(sZ);
                utmpt.X = Convert.ToDouble(sE);
                utmpt.Y = Convert.ToDouble(sN);

                LonLatPt pt = Projection.UtmNad83PtToLonLatPt(utmpt);

                lat = pt.Lat;
                lng = pt.Lon;

                ret = true;
            }
            catch {}

            return ret;
        }