Esempio n. 1
0
        /**
         *
         */
        private HGTReader PrepReader(int res, int row, int col)
        {
            if (row >= readers.Length)
            {
                //log.error("invalid array index for row", row);
                return(null);
            }
            if (col >= readers[row].Length)
            {
                //log.error("invalid array index for col", row);
                return(null);
            }
            HGTReader rdr = readers[row][col];

            if (rdr == null)
            {
                //statRdrNull++;
                return(null);
            }

            // do not use if different resolution
            if (res != rdr.GetRes())
            {
                //statRdrRes++;
                return(null);
            }

            rdr.PrepRead();
            if (row > lastRow)
            {
                lastRow = row;
            }

            return(rdr);
        }
Esempio n. 2
0
        /**
         * Fill 16 values of HGT near required coordinates
         * can use HGTreaders near the current one
         */
        private bool FillArray(HGTReader rdr, int row, int col, int xLeft, int yBottom)
        {
            int  res    = rdr.GetRes();
            int  minX   = 0;
            int  minY   = 0;
            int  maxX   = 3;
            int  maxY   = 3;
            bool inside = true;

            // check borders
            if (xLeft == 0)
            {
                if (col <= 0)
                {
                    return(false);
                }

                minX   = 1;
                inside = false;
            }
            else if (xLeft == res - 1)
            {
                if (col + 1 >= readers[0].Length)
                {
                    return(false);
                }

                maxX   = 2;
                inside = false;
            }
            if (yBottom == 0)
            {
                if (row <= 0)
                {
                    return(false);
                }

                minY   = 1;
                inside = false;
            }
            else if (yBottom == res - 1)
            {
                if (row + 1 >= readers.Length)
                {
                    return(false);
                }

                maxY   = 2;
                inside = false;
            }

            // fill data from current reader
            short h;

            for (int x = minX; x <= maxX; x++)
            {
                for (int y = minY; y <= maxY; y++)
                {
                    h = rdr.Ele(xLeft + x - 1, yBottom + y - 1);
                    if (h == HGTReader.UNDEF)
                    {
                        return(false);
                    }

                    eleArray[x][y] = h;
                    maxhöhe        = Math.Max(maxhöhe, h);
                    minhöhe        = Math.Min(minhöhe, h);
                }
            }

            if (inside) // no need to check borders again
            {
                return(true);
            }

            // fill data from adjacent readers, down and up
            if (xLeft > 0 && xLeft < res - 1)
            {
                if (yBottom == 0)
                { // bottom edge
                    HGTReader rdrBB = PrepReader(res, row - 1, col);
                    if (rdrBB == null)
                    {
                        return(false);
                    }

                    for (int x = 0; x <= 3; x++)
                    {
                        h = rdrBB.Ele(xLeft + x - 1, res - 1);
                        if (h == HGTReader.UNDEF)
                        {
                            return(false);
                        }

                        eleArray[x][0] = h;
                    }
                }
                else if (yBottom == res - 1)
                { // top edge
                    HGTReader rdrTT = PrepReader(res, row + 1, col);
                    if (rdrTT == null)
                    {
                        return(false);
                    }

                    for (int x = 0; x <= 3; x++)
                    {
                        h = rdrTT.Ele(xLeft + x - 1, 1);
                        if (h == HGTReader.UNDEF)
                        {
                            return(false);
                        }

                        eleArray[x][3] = h;
                    }
                }
            }

            // fill data from adjacent readers, left and right
            if (yBottom > 0 && yBottom < res - 1)
            {
                if (xLeft == 0)
                { // left edgge
                    HGTReader rdrLL = PrepReader(res, row, col - 1);
                    if (rdrLL == null)
                    {
                        return(false);
                    }

                    for (int y = 0; y <= 3; y++)
                    {
                        h = rdrLL.Ele(res - 1, yBottom + y - 1);
                        if (h == HGTReader.UNDEF)
                        {
                            return(false);
                        }

                        eleArray[0][y] = h;
                    }
                }
                else if (xLeft == res - 1)
                { // right edge
                    HGTReader rdrRR = PrepReader(res, row, col + 1);
                    if (rdrRR == null)
                    {
                        return(false);
                    }

                    for (int y = 0; y <= 3; y++)
                    {
                        h = rdrRR.Ele(1, yBottom + y - 1);
                        if (h == HGTReader.UNDEF)
                        {
                            return(false);
                        }

                        eleArray[3][y] = h;
                    }
                }
            }

            // fill data from adjacent readers, corners
            if (xLeft == 0)
            {
                if (yBottom == 0)
                { // left bottom corner
                    HGTReader rdrLL = PrepReader(res, row, col - 1);
                    if (rdrLL == null)
                    {
                        return(false);
                    }

                    for (int y = 1; y <= 3; y++)
                    {
                        h = rdrLL.Ele(res - 1, yBottom + y - 1);
                        if (h == HGTReader.UNDEF)
                        {
                            return(false);
                        }

                        eleArray[0][y] = h;
                    }

                    HGTReader rdrBB = PrepReader(res, row - 1, col);
                    if (rdrBB == null)
                    {
                        return(false);
                    }

                    for (int x = 1; x <= 3; x++)
                    {
                        h = rdrBB.Ele(xLeft + x - 1, res - 1);
                        if (h == HGTReader.UNDEF)
                        {
                            return(false);
                        }

                        eleArray[x][0] = h;
                    }

                    HGTReader rdrLB = PrepReader(res, row - 1, col - 1);
                    if (rdrLB == null)
                    {
                        return(false);
                    }

                    h = rdrLB.Ele(res - 1, res - 1);
                    if (h == HGTReader.UNDEF)
                    {
                        return(false);
                    }

                    eleArray[0][0] = h;
                }
                else if (yBottom == res - 1)
                { // left top corner
                    HGTReader rdrLL = PrepReader(res, row, col - 1);
                    if (rdrLL == null)
                    {
                        return(false);
                    }

                    for (int y = 0; y <= 2; y++)
                    {
                        h = rdrLL.Ele(res - 1, yBottom + y - 1);
                        if (h == HGTReader.UNDEF)
                        {
                            return(false);
                        }

                        eleArray[0][y] = h;
                    }

                    HGTReader rdrTT = PrepReader(res, row + 1, col);
                    if (rdrTT == null)
                    {
                        return(false);
                    }

                    for (int x = 1; x <= 3; x++)
                    {
                        h = rdrTT.Ele(xLeft + x - 1, 1);
                        if (h == HGTReader.UNDEF)
                        {
                            return(false);
                        }

                        eleArray[x][3] = h;
                    }

                    HGTReader rdrLT = PrepReader(res, row + 1, col - 1);
                    if (rdrLT == null)
                    {
                        return(false);
                    }

                    h = rdrLT.Ele(res - 1, 1);
                    if (h == HGTReader.UNDEF)
                    {
                        return(false);
                    }

                    eleArray[0][3] = h;
                }
            }
            else if (xLeft == res - 1)
            {
                if (yBottom == 0)
                { // right bottom corner
                    HGTReader rdrRR = PrepReader(res, row, col + 1);
                    if (rdrRR == null)
                    {
                        return(false);
                    }

                    for (int y = 1; y <= 3; y++)
                    {
                        h = rdrRR.Ele(1, yBottom + y - 1);
                        if (h == HGTReader.UNDEF)
                        {
                            return(false);
                        }

                        eleArray[3][y] = h;
                    }

                    HGTReader rdrBB = PrepReader(res, row - 1, col);
                    if (rdrBB == null)
                    {
                        return(false);
                    }

                    for (int x = 0; x <= 2; x++)
                    {
                        h = rdrBB.Ele(xLeft + x - 1, res - 1);
                        if (h == HGTReader.UNDEF)
                        {
                            return(false);
                        }

                        eleArray[x][0] = h;
                    }

                    HGTReader rdrRB = PrepReader(res, row - 1, col + 1);
                    if (rdrRB == null)
                    {
                        return(false);
                    }

                    h = rdrRB.Ele(1, res - 1);
                    if (h == HGTReader.UNDEF)
                    {
                        return(false);
                    }

                    eleArray[3][0] = h;
                }
                else if (yBottom == res - 1)
                { // right top corner
                    HGTReader rdrRR = PrepReader(res, row, col + 1);
                    if (rdrRR == null)
                    {
                        return(false);
                    }

                    for (int y = 0; y <= 2; y++)
                    {
                        h = rdrRR.Ele(1, yBottom + y - 1);
                        if (h == HGTReader.UNDEF)
                        {
                            return(false);
                        }

                        eleArray[3][y] = h;
                    }

                    HGTReader rdrTT = PrepReader(res, row + 1, col);
                    if (rdrTT == null)
                    {
                        return(false);
                    }

                    for (int x = 0; x <= 2; x++)
                    {
                        h = rdrTT.Ele(xLeft + x - 1, 1);
                        if (h == HGTReader.UNDEF)
                        {
                            return(false);
                        }

                        eleArray[x][3] = h;
                    }

                    HGTReader rdrRT = PrepReader(res, row + 1, col + 1);
                    if (rdrRT == null)
                    {
                        return(false);
                    }

                    h = rdrRT.Ele(1, 1);
                    if (h == HGTReader.UNDEF)
                    {
                        return(false);
                    }

                    eleArray[3][3] = h;
                }
            }

            // all 16 values present
            return(true);
        }
Esempio n. 3
0
        /**
         * Class to extract elevation information from SRTM files in hgt format.
         * @param path a comma separated list of directories which may contain *.hgt files.
         * @param bbox the bounding box of the tile for which the DEM information is needed.
         * @param demPolygonMapUnits optional bounding polygon which describes the area for
         * which elevation should be read from hgt files.
         * @param interpolationMethod
         */
        public HGTConverter(string hgtpath, string[] directorys, GeoPunkt linksunten, GeoPunkt rechtsoben)
        {
            // make bigger box for interpolation or aligning of areas
            int minLat = (int)Math.Floor(linksunten.Lat);
            int minLon = (int)Math.Floor(linksunten.Lon);
            int maxLat = (int)Math.Ceiling(rechtsoben.Lat);
            int maxLon = (int)Math.Ceiling(rechtsoben.Lon);

            eleArray = new double[4][];
            for (int i = 0; i < eleArray.Length; i++)
            {
                eleArray[i] = new double[4];
            }

            if (minLat < -90)
            {
                minLat = -90;
            }

            if (maxLat > 90)
            {
                maxLat = 90;
            }

            if (minLon < -180)
            {
                minLon += 360;
            }

            if (maxLon > 180)
            {
                maxLon -= 360;
            }
            if (minLon > maxLon)
            {
                maxLon += 360;
            }

            minLat32 = ToMapUnit(minLat) * 256;
            minLon32 = ToMapUnit(minLon) * 256;
            // create matrix of readers
            int dimLat = maxLat - minLat;
            int dimLon = maxLon - minLon;

            readers = new HGTReader[dimLat][];
            for (int i = 0; i < dimLat; i++)
            {
                readers[i] = new HGTReader[dimLon];
            }

            //demArea = demPolygonMapUnits;
            int maxRes = -1;

            for (int row = 0; row < dimLat; row++)
            {
                int lat = row + minLat;
                for (int col = 0; col < dimLon; col++)
                {
                    int lon = col + minLon;
                    //Area rdrBbox = new Area(lat, lon, lat + 1.0, lon + 1.0);
                    //int testMode = intersectsPoly(rdrBbox);
                    //if (testMode != 0)
                    //{
                    HGTReader rdr = new HGTReader(lat, lon, hgtpath, directorys);
                    readers[row][col] = rdr;
                    maxRes            = Math.Max(maxRes, rdr.GetRes());
                    //}
                }
            }
            res = maxRes; // we use the highest available res
            return;
        }
Esempio n. 4
0
        protected double GetElevation(int lat32, int lon32)
        {
            int row = (int)((lat32 - minLat32) * FACTOR);
            int col = (int)((lon32 - minLon32) * FACTOR);

            HGTReader rdr = readers[row][col];

            if (rdr == null)
            {
                // no reader : ocean or missing file
                return(outsidePolygonHeight);
            }
            int res = rdr.GetRes();

            rdr.PrepRead();
            if (res <= 0)
            {
                return(0); // assumed to be an area in the ocean
            }

            lastRow = row;

            double scale = res * FACTOR;

            double y1      = (lat32 - minLat32) * scale - row * res;
            double x1      = (lon32 - minLon32) * scale - col * res;
            int    xLeft   = (int)x1;
            int    yBottom = (int)y1;
            double qx      = x1 - xLeft;
            double qy      = y1 - yBottom;


            //statPoints++;
            if (useComplexInterpolation)
            {
                // bicubic (Catmull-Rom) interpolation with 16 points
                bool filled = FillArray(rdr, row, col, xLeft, yBottom);
                if (filled)
                {
                    h = BicubicInterpolation(eleArray, qx, qy);
                    //statBicubic++;
                }
            }

            if (h == HGTReader.UNDEF || !useComplexInterpolation)
            {
                // use bilinear interpolation if bicubic not available
                int xRight = xLeft + 1;
                int yTop   = yBottom + 1;

                int hLT = rdr.Ele(xLeft, yTop);
                maxhöhe = Math.Max(maxhöhe, hLT);
                minhöhe = Math.Min(minhöhe, hLT);
                int hRT = rdr.Ele(xRight, yTop);
                maxhöhe = Math.Max(maxhöhe, hRT);
                minhöhe = Math.Min(minhöhe, hRT);
                int hLB = rdr.Ele(xLeft, yBottom);
                maxhöhe = Math.Max(maxhöhe, hLB);
                minhöhe = Math.Min(minhöhe, hLB);
                int hRB = rdr.Ele(xRight, yBottom);
                maxhöhe = Math.Max(maxhöhe, hRB);
                minhöhe = Math.Min(minhöhe, hRB);


                h = InterpolatedHeight(qx, qy, hLT, hRT, hRB, hLB);
                //statBilinear++;
                //if (h == HGTReader.UNDEF) statVoid++;
            }

            //if (h == HGTReader.UNDEF && log.isLoggable(Level.WARNING))
            //{
            //    double lon = lon32 * FACTOR;
            //    double lat = lat32 * FACTOR;
            //    Coord c = new Coord(lat, lon);
            //    log.warn("height interpolation returns void at", c.toDegreeString());
            //}
            return(h);
        }