コード例 #1
0
        private MemoryRasterHeader GetHeader(ISpatialReference spatialRef, CoordEnvelope coordEnvelope)
        {
            MemoryRasterHeader header = new MemoryRasterHeader();

            header.Identify = MemoryRasterDriver.FileIdentify;
            //
            if (spatialRef != null)
            {
                Datum datum = spatialRef.GeographicsCoordSystem.Datum ?? new Datum();
                if (spatialRef.ProjectionCoordSystem != null)
                {
                    header.PrjId = int.Parse(spatialRef.ProjectionCoordSystem.Name.ENVIName);
                    header.A     = (float)datum.Spheroid.SemimajorAxis;
                    header.B     = (float)datum.Spheroid.SemiminorAxis;
                    header.K0    = (float)datum.Spheroid.InverseFlattening;
                    IProjectionCoordSystem prjCoordSystem = spatialRef.ProjectionCoordSystem;
                    header.SP1  = GetPrjParaValue(prjCoordSystem, "sp1");
                    header.SP2  = GetPrjParaValue(prjCoordSystem, "sp2");
                    header.Lat0 = GetPrjParaValue(prjCoordSystem, "lat0");
                    header.Lon0 = GetPrjParaValue(prjCoordSystem, "lon0");
                    header.X0   = GetPrjParaValue(prjCoordSystem, "x0");
                    header.Y0   = GetPrjParaValue(prjCoordSystem, "y0");
                }
            }
            //
            if (coordEnvelope != null)
            {
                header.MinX = (float)coordEnvelope.MinX;
                header.MaxX = (float)coordEnvelope.MaxX;
                header.MinY = (float)coordEnvelope.MinY;
                header.MaxY = (float)coordEnvelope.MaxY;
            }
            return(header);
        }
コード例 #2
0
 private ISpatialReference GetSpatialRef(MemoryRasterHeader header)
 {
     using (SpatialReferenceBuilder b = new SpatialReferenceBuilder())
     {
         return(b.GetSpatialRef(header.PrjId, header.SP1,
                                header.SP2, header.Lat0, header.Lon0,
                                header.X0, header.Y0, header.K0));
     }
 }
コード例 #3
0
 private void SetFieldsByHeader(MemoryRasterHeader header)
 {
     _bandCount    = header.BandCount;
     _width        = header.Width;
     _height       = header.Height;
     _dataType     = (enumDataType)header.DataType;
     _dataTypeSize = DataTypeHelper.SizeOf(_dataType);
     _spatialRef   = GetSpatialRef(header);
     SetCoordType(_spatialRef);
     _headerSize = Marshal.SizeOf(header) + header.ExtendHeaderLength;
     TryCreateCoordTransform(header);
 }
コード例 #4
0
 private void TryCreateCoordTransform(MemoryRasterHeader header)
 {
     if (_spatialRef == null)
     {
         _coordTransform = CoordTransoformFactory.GetCoordTransform(null, null, _width, _height);
     }
     else
     {
         _coordTransform = CoordTransoformFactory.GetCoordTransform(
             new Point(0, 0),
             new Point(_width, _height),
             new double[] { double.Parse(header.MinX.ToString()), double.Parse(header.MaxY.ToString()) },
             new double[] { double.Parse(header.MaxX.ToString()), double.Parse(header.MinY.ToString()) });
     }
 }
コード例 #5
0
        public override IRasterDataProvider Create(string fileName, int xSize, int ySize, int bandCount, enumDataType dataType, params object[] options)
        {
            ISpatialReference spatialRef;
            CoordEnvelope     coordEnvelope;
            bool       isWithHdr;
            int        extHeaderSize = 0;
            HdrMapInfo mapInfo;

            ParseOptions(xSize, ySize, options, out spatialRef, out coordEnvelope, out mapInfo, out isWithHdr, out extHeaderSize);
            MemoryRasterHeader h = GetHeader(spatialRef, coordEnvelope);

            h.BandCount          = bandCount;
            h.DataType           = (int)dataType;
            h.Width              = xSize;
            h.Height             = ySize;
            h.ExtendHeaderLength = extHeaderSize;
            byte[] headerBytes = new byte[1024];
            using (FileStream fs = new FileStream(fileName, FileMode.Create))
            {
                int      headerSize = Marshal.SizeOf(typeof(MemoryRasterHeader));
                byte[]   buffer     = new byte[headerSize];
                GCHandle handle     = GCHandle.Alloc(buffer, GCHandleType.Pinned);
                Marshal.StructureToPtr((object)h, handle.AddrOfPinnedObject(), true);
                handle.Free();
                fs.SetLength(headerSize + extHeaderSize + (long)xSize * (long)ySize * (long)bandCount * (long)DataTypeHelper.SizeOf(dataType));
                fs.Write(buffer, 0, buffer.Length);
                fs.Seek(0, SeekOrigin.Begin);
                fs.Read(headerBytes, 0, (int)Math.Min(headerBytes.Length, fs.Length));
            }

            HdrFile hdrFile = h.ToHdrFile();

            if (spatialRef != null)
            {
                hdrFile.HdrProjectionInfo = GetHdrProjectionInfo(spatialRef);
            }
            if (mapInfo != null)
            {
                hdrFile.MapInfo = mapInfo;
            }

            hdrFile.SaveTo(HdrFile.GetHdrFileName(fileName));
            IGeoDataProvider provider = BuildDataProvider(fileName, headerBytes, enumDataProviderAccess.Update, options);

            return(provider as IRasterDataProvider);
        }
コード例 #6
0
        public MemoryRasterDataProvider(string mmfName, string fname, enumDataProviderAccess access, IGeoDataDriver driver)
            : base(fname, driver)
        {
            _mmfName  = GetMmfName(mmfName);
            _fileName = fname;
            _access   = access == enumDataProviderAccess.ReadOnly ? MemoryMappedFileAccess.Read : MemoryMappedFileAccess.ReadWrite;
            string hdrfile = HdrFile.GetHdrFileName(_fileName);

            if (File.Exists(hdrfile))
            {
                _filelist = new string[] { _fileName, hdrfile }
            }
            ;
            else
            {
                _filelist = new string[] { _fileName }
            };
            _header = GetHeader(fname);
            SetFieldsByHeader(_header);
            TrySetEnvelopeAndResolutions();
            LoadBands();
        }