Example #1
0
        /// <summary>
        /// Union this rectangle with another
        /// </summary>
        /// <param name="rect"></param>
        /// <returns></returns>
        public ExtentRectangle Union(ExtentRectangle rect)
        {
            decimal newright, newleft, newtop, newbottom;

            if (CellHeight > 0)
            {
                newtop    = Math.Min(Top, rect.Top);
                newbottom = Math.Max(Bottom, rect.Bottom);
            }
            else
            {
                newtop    = Math.Max(Top, rect.Top);
                newbottom = Math.Min(Bottom, rect.Bottom);
            }
            if (CellWidth > 0)
            {
                newleft  = Math.Min(Left, rect.Left);
                newright = Math.Max(Right, rect.Right);
            }
            else
            {
                newleft  = Math.Max(Left, rect.Left);
                newright = Math.Min(Right, rect.Right);
            }

            int newcols = (int)((newright - newleft) / Math.Abs(CellWidth));
            int newrows = (int)((newtop - newbottom) / Math.Abs(CellHeight));

            return(new ExtentRectangle(newtop, newleft, CellHeight, CellWidth, newrows, newcols));
        }
Example #2
0
        /// <summary>
        /// Create from existing rectangle but apply new cell size
        /// </summary>
        /// <param name="orig"></param>
        public ExtentRectangle(ExtentRectangle orig, decimal mCellHeight, decimal mCellWidth)
        {
            int newRows = Convert.ToInt32(Math.Ceiling(orig.Height / Math.Abs(mCellHeight)));
            int newCols = Convert.ToInt32(Math.Floor(orig.Width / Math.Abs(mCellWidth)));

            _Init(orig.Top, orig.Left, mCellHeight, mCellWidth, newRows, newCols);
        }
Example #3
0
        /// <summary>
        /// We just want a list of keys back
        /// </summary>
        /// <param name="ext"></param>
        /// <returns></returns>
        public List <long> FIDIntersectExtent(ExtentRectangle ext)
        {
            Open();
            List <long> retVal = new List <long>();

            Geometry ring = new Geometry(wkbGeometryType.wkbLinearRing);

            ring.AddPoint((double)ext.Left, (double)ext.Top, 0);
            ring.AddPoint((double)ext.Right, (double)ext.Top, 0);
            ring.AddPoint((double)ext.Right, (double)ext.Bottom, 0);
            ring.AddPoint((double)ext.Left, (double)ext.Bottom, 0);
            ring.AddPoint((double)ext.Left, (double)ext.Top, 0);

            Geometry extrect = new Geometry(wkbGeometryType.wkbPolygon);

            extrect.AddGeometry(ring);

            foreach (KeyValuePair <long, VectorFeature> kvp in Features)
            {
                Geometry geo = kvp.Value.Feat.GetGeometryRef();
                if (geo != null && extrect.Intersects(geo))
                {
                    retVal.Add(kvp.Key);
                }
            }
            return(retVal);
        }
Example #4
0
 /// <summary>
 /// This is a create constructor
 /// </summary>
 /// <param name="rTemplate"></param>
 /// <param name="rExtent"></param>
 /// <param name="sFilename"></param>
 /// <param name="leaveopen"></param>
 public Raster(Raster rTemplate, ExtentRectangle rExtent, FileInfo sFilename, bool leaveopen = false) : base(sFilename)
 {
     _Init(rTemplate.driver, rTemplate.VerticalUnits, rTemplate.Proj, rTemplate.Datatype, rExtent, rTemplate.origNodataVal);
     if (!leaveopen)
     {
         UnloadDS();
     }
 }
Example #5
0
        /// <summary>
        /// Temporary file constructor
        /// </summary>
        /// <param name="rTemplate"></param>
        /// <param name="sFilename"></param>
        /// <param name="leaveopen"></param>
        public Raster(Raster rTemplate, Projection proj) : base(TempRasterFileInfo())
        {
            _temporary = true;
            ExtentRectangle theExtent = new ExtentRectangle(rTemplate.Extent);

            _Init(RasterDriver.GTiff, rTemplate.VerticalUnits, proj, rTemplate.Datatype, theExtent, rTemplate.origNodataVal);
            Create();
        }
Example #6
0
 /// <summary>
 /// Is this raster concurrent with another?
 /// </summary>
 /// <param name="otherExtent"></param>
 /// <returns></returns>
 public bool IsConcurrent(ExtentRectangle otherExtent)
 {
     return(CellWidth == otherExtent.CellWidth &&
            CellHeight == otherExtent.CellHeight &&
            Left == otherExtent.Left &&
            Right == otherExtent.Right &&
            Top == otherExtent.Top &&
            Bottom == otherExtent.Bottom);
 }
Example #7
0
        /// <summary>
        /// Return (x,y) integer typle representing how shifted one rectangle is relative to this one
        /// </summary>
        /// <param name="rect"></param>
        /// <returns>Tuple (x,y)</returns>
        public int[] GetTranslation(ExtentRectangle rect)
        {
            int ydiff = (int)(rect.Top - Top / Math.Abs(CellHeight));
            int xdiff = (int)(rect.Left - Left / Math.Abs(CellWidth));

            return(new int[2] {
                xdiff, ydiff
            });
        }
Example #8
0
        /// <summary>
        /// Get a tuple representing row translation between two Extentrectangles
        /// </summary>
        /// <param name="rExtent1"></param>
        /// <param name="rExtent2"></param>
        /// <returns>(colT, rowT)</returns>
        public int[] GetTopCornerTranslationRowCol(ExtentRectangle rExtent2)
        {
            int colT = (int)((Left - rExtent2.Left) / CellWidth);
            int rowT = (int)((Top - rExtent2.Top) / CellHeight);

            return(new int[2] {
                rowT, colT
            });
        }
Example #9
0
        /// <summary>
        /// Determine if two extents overlap
        /// </summary>
        /// <param name="otherExtent"></param>
        /// <returns></returns>
        public bool HasOverlap(ExtentRectangle otherExtent)
        {
            // TODO: TEST THIS THOROUGHLY, ESPECIALLY -/+ widht heights
            decimal ulx = Math.Max(Left, otherExtent.Left);
            decimal uly = Math.Max(Bottom, otherExtent.Bottom);
            decimal lrx = Math.Min(Right, otherExtent.Right);
            decimal lry = Math.Min(Top, otherExtent.Top);

            return(ulx <= lrx && uly <= lry);
        }
Example #10
0
        /// <summary>
        /// Pass in a list of rasters to extend the extent of this raster
        /// </summary>
        /// <param name="rasters"></param>
        /// <returns></returns>
        public static ExtentRectangle RasterExtentExpand(List <Raster> rasters)
        {
            ExtentRectangle newExtent = rasters[0].Extent;

            foreach (Raster raster in rasters)
            {
                newExtent.Union(raster.Extent);
            }

            return(newExtent);
        }
Example #11
0
        // This is mainly for testing purposes
        public Raster(Raster rTemplate, bool leaveopen = false) : base()
        {
            _temporary = false;
            ExtentRectangle theExtent = new ExtentRectangle(rTemplate.Extent);

            _Init(RasterDriver.GTiff, rTemplate.VerticalUnits, rTemplate.Proj, rTemplate.Datatype, theExtent, rTemplate.origNodataVal);
            if (!leaveopen)
            {
                UnloadDS();
            }
        }
Example #12
0
 /// <summary>
 /// Initialization function
 /// </summary>
 protected void _Init(RasterDriver rdDriver, LengthUnit lUnits, Projection proj, GdalDataType dType,
                      ExtentRectangle theExtent, double?ndv)
 {
     _writepermission = false;
     origNodataVal    = ndv;
     Datatype         = dType;
     Extent           = theExtent;
     Proj             = proj;
     VerticalUnits    = lUnits;
     driver           = rdDriver;
 }
Example #13
0
        /// <summary>
        /// Explicit Constructor to create a new raster
        /// </summary>
        /// <param name="fTop"></param>
        /// <param name="fLeft"></param>
        /// <param name="dCellHeight"></param>
        /// <param name="dCellWidth"></param>
        /// <param name="nRows"></param>
        /// <param name="nCols"></param>
        /// <param name="dNoData"></param>
        /// <param name="psDriver"></param>
        /// <param name="eDataType"></param>
        /// <param name="psProjection"></param>
        /// <param name="psUnit"></param>
        public Raster(decimal fTop, decimal fLeft, decimal dCellHeight, decimal dCellWidth, int nRows, int nCols,
                      double?dNoData, RasterDriver psDriver, GdalDataType dType,
                      string psProjection, string psUnit, bool leaveopen = false) : base()
        {
            _temporary = false;
            ExtentRectangle theExtent = new ExtentRectangle(fTop, fLeft, dCellHeight, dCellWidth, nRows, nCols);

            _Init(psDriver, UnitFromString(psUnit), new Projection(psProjection), dType, theExtent, dNoData);
            if (!leaveopen)
            {
                UnloadDS();
            }
        }
Example #14
0
        /// <summary>
        /// Translate the 1D array index into another rectangle's 1D array index
        /// </summary>
        /// <param name="origid"></param>
        /// <param name="otherExtent"></param>
        /// <returns>the transformed ID, -1 if it's not valid</returns>
        public int RelativeId(int origid, ExtentRectangle otherExtent)
        {
            int[] origRowCol   = Id2RowCol(origid);
            int[] offsetRowCol = GetTopCornerTranslationRowCol(otherExtent);
            int   newInd;
            int   newRow = origRowCol[0] + offsetRowCol[0];
            int   newCol = origRowCol[1] + offsetRowCol[1];

            if (newCol <= 0 || newRow <= 0 || newCol > otherExtent.Cols || newRow > otherExtent.Rows)
            {
                newInd = -1;
            }
            else
            {
                newInd = (newRow - 1) * otherExtent.Cols + (newCol) - 1;
            }

            return(newInd);
        }
Example #15
0
        /// <summary>
        /// Transform a cell into a rectangle geometry
        /// </summary>
        /// <param name="row"></param>
        /// <param name="col"></param>
        /// <param name="ext"></param>
        /// <returns></returns>
        public static Geometry CellToRect(int row, int col, ExtentRectangle ext)
        {
            double l = (double)(ext.Left + ((col - 1) * ext.CellWidth));
            double r = l + (double)ext.CellWidth;
            double t = (double)(ext.Top + ((row - 1) * ext.CellHeight));
            double b = t + (double)ext.CellWidth;

            Geometry ring = new Geometry(wkbGeometryType.wkbLinearRing);

            ring.AddPoint(l, t, 0);
            ring.AddPoint(r, t, 0);
            ring.AddPoint(r, b, 0);
            ring.AddPoint(l, b, 0);
            ring.AddPoint(l, t, 0);

            Geometry extrect = new Geometry(wkbGeometryType.wkbPolygon);

            extrect.AddGeometry(ring);
            return(extrect);
        }
Example #16
0
        public void CreateDS(Raster.RasterDriver driver, FileInfo finfo, ExtentRectangle theExtent, Projection proj, GdalDataType theType)
        {
            List <string> creationOpts = new List <string>();

            switch (driver)
            {
            case Raster.RasterDriver.GTiff:
                creationOpts.Add("COMPRESS=LZW");
                break;

            case Raster.RasterDriver.HFA:
                creationOpts.Add("COMPRESS=PACKBITS");
                break;
            }
            Driver driverobj = Gdal.GetDriverByName(Enum.GetName(typeof(Raster.RasterDriver), driver));

            _ds = driverobj.Create(finfo.FullName, theExtent.Cols, theExtent.Rows, 1, theType._origType, creationOpts.ToArray());
            _ds.SetGeoTransform(theExtent.Transform);
            _ds.SetProjection(proj.OriginalString);

            SetNoData((double)origNodataVal);
        }
Example #17
0
        /// <summary>
        /// Load all relevant settings from a file
        /// </summary>
        protected override void _initfromfile()
        {
            bool leaveOpen = IsOpen;

            Open();

            Band         rBand1 = _ds.GetRasterBand(1);
            GdalDataType dType  = new GdalDataType(rBand1.DataType);

            string          sDriver   = _ds.GetDriver().ShortName;
            ExtentRectangle theExtent = new ExtentRectangle(_ds);

            _Init(_str2driver(sDriver),
                  UnitFromString(rBand1.GetUnitType()),
                  new Projection(_ds.GetProjection()),
                  dType, theExtent, GetNodataVal());

            if (!leaveOpen)
            {
                UnloadDS();
            }
        }
Example #18
0
 /// <summary>
 /// Othoganility check for this rectangle
 /// </summary>
 /// <param name="otherExtent"></param>
 /// <returns></returns>
 public bool IsOrthogonal(ExtentRectangle otherExtent)
 {
     return(IsDivisible() && otherExtent.IsDivisible());
 }
Example #19
0
 public bool Equals(ExtentRectangle other)
 {
     return(IsConcurrent(other));
 }
Example #20
0
 /// <summary>
 /// Copy constructor
 /// </summary>
 /// <param name="orig"></param>
 public ExtentRectangle(ExtentRectangle orig)
 {
     _Init(orig.Top, orig.Left, orig.CellHeight, orig.CellWidth, orig.Rows, orig.Cols);
 }
Example #21
0
        public List <Geometry> GeometriesIntersectExtent(ExtentRectangle ext)
        {
            List <VectorFeature> feats = FeaturesIntersectExtent(ext).Values.ToList();

            return(feats.Select(x => x.Feat.GetGeometryRef()).ToList());
        }