private void WriteAboutFile(string dstFilename)
{
//写出dat文件的相关信息
IRasterDataProvider rd = GeoDataDriver.Open(dstFilename) as IRasterDataProvider;
try
{
if (rd != null)
{
MemoryRasterDataProvider mrd = rd as MemoryRasterDataProvider;
if (mrd == null)
{
return;
}
HdrFile hdr = mrd.ToHdrFile();
if (hdr != null)
{
string hdrfile = Path.Combine(Path.GetDirectoryName(dstFilename), Path.GetFileNameWithoutExtension(dstFilename) + ".hdr");
HdrFile.SaveTo(hdrfile, hdr);
}
}
}
finally
{
if (rd != null)
{
rd.Dispose();
}
}
}
//以下为一些辅助帮助类
public static IRasterDataProvider CreateRaster(string outFileName, CoordEnvelope env, float resolutionX, float resolutionY, int bandCount,
IRasterDataProvider referProvider)
{
//int bandCount = referProvider.BandCount;
//CoordEnvelope outEnv = referProvider.CoordEnvelope;
//float resX = referProvider.ResolutionX;
//float resY = referProvider.ResolutionY;
int width = (int)(Math.Round(env.Width / resolutionX));
int height = (int)(Math.Round(env.Height / resolutionY));
Project.ISpatialReference spatialRef = referProvider.SpatialRef;
enumDataType datatype = referProvider.DataType;
List <string> options = new List <string>();
options.Add("INTERLEAVE=BSQ");
options.Add("VERSION=LDF");
options.Add("WITHHDR=TRUE");
options.Add("SPATIALREF=" + spatialRef.ToProj4String());
options.Add("MAPINFO={" + 1 + "," + 1 + "}:{" + env.MinX + "," + env.MaxY + "}:{" + resolutionX + "," + resolutionY + "}"); //=env.ToMapInfoString(new Size(width, height));
string hdrfile = HdrFile.GetHdrFileName(referProvider.fileName);
if (!string.IsNullOrWhiteSpace(hdrfile) && File.Exists(hdrfile))
{
HdrFile hdr = HdrFile.LoadFrom(hdrfile);
if (hdr != null && hdr.BandNames != null)
{
options.Add("BANDNAMES=" + string.Join(",", hdr.BandNames));
}
}
CheckAndCreateDir(Path.GetDirectoryName(outFileName));
IRasterDataDriver raster = RasterDataDriver.GetDriverByName("LDF") as IRasterDataDriver;
RasterDataProvider outRaster = raster.Create(outFileName, width, height, bandCount, datatype, options.ToArray()) as RasterDataProvider;
return(outRaster);
}
public void Update(CoordEnvelope coordEnvelope)
{
_isNeedUpdateHeader = false;
if (coordEnvelope != null)
{
_coordEnvelope = coordEnvelope.Clone();
_header.MinX = (float)_coordEnvelope.MinX;
_header.MaxX = (float)_coordEnvelope.MaxX;
_header.MinY = (float)_coordEnvelope.MinY;
_header.MaxY = (float)_coordEnvelope.MaxY;
if (_access == MemoryMappedFileAccess.ReadWrite)
{
//MemoryRasterHeader header = GetExtHeader<MemoryRasterHeader>();
SetExtHeader <MemoryRasterHeader>(_header);
string hdr = HdrFile.GetHdrFileName(_fileName);
if (File.Exists(hdr))
{
File.Delete(hdr);
}
}
else
{
_isNeedUpdateHeader = true;
}
}
}
public static IRasterDataProvider CreateRaster(string outFileName, IRasterDataProvider referProvider, string fname)
{
int width = referProvider.Width;
int height = referProvider.Height;
Project.ISpatialReference spatialRef = referProvider.SpatialRef;
enumDataType datatype = referProvider.DataType;
List <string> options = new List <string>();
options.Add("INTERLEAVE=BSQ");
options.Add("VERSION=LDF");
options.Add("WITHHDR=TRUE");
options.Add("SPATIALREF=" + spatialRef.ToProj4String());
options.Add("MAPINFO={" + 1 + "," + 1 + "}:{" + referProvider.CoordEnvelope.MinX + "," + referProvider.CoordEnvelope.MaxY + "}:{" + referProvider.ResolutionX + "," + referProvider.ResolutionY + "}"); //=env.ToMapInfoString(new Size(width, height));
string hdrfile = HdrFile.GetHdrFileName(Path.ChangeExtension(fname, ".hdr"));
if (!string.IsNullOrWhiteSpace(hdrfile) && File.Exists(hdrfile))
{
HdrFile hdr = HdrFile.LoadFrom(hdrfile);
if (hdr != null && hdr.BandNames != null)
{
options.Add("BANDNAMES=" + string.Join(",", hdr.BandNames));
}
}
if (!Directory.Exists(Path.GetDirectoryName(outFileName)))
{
Directory.CreateDirectory(Path.GetDirectoryName(outFileName));
}
IRasterDataDriver raster = RasterDataDriver.GetDriverByName("LDF") as IRasterDataDriver;
RasterDataProvider outRaster = raster.Create(outFileName, width, height, 1, datatype, options.ToArray()) as RasterDataProvider;
return(outRaster);
}
//适用于打开文件的情况
public MvgDataProvider(string fileName, IGeoDataDriver dataDriver, bool isReadOnly)
: base(fileName, dataDriver)
{
_driver = dataDriver;
_fileName = fileName;
string hdrfile = HdrFile.GetHdrFileName(_fileName);
if (File.Exists(hdrfile))
{
_filelist = new string[] { _fileName, hdrfile }
}
;
else
{
_filelist = new string[] { _fileName }
};
_header = new MvgHeader(fileName);
FillProviderAttributes();
_fsStream = new FileStream(_fileName, FileMode.Open, isReadOnly ? FileAccess.Read : FileAccess.ReadWrite);
if (!isReadOnly)
{
_binaryWriter = new BinaryWriter(_fsStream);
}
_binaryReader = new BinaryReader(_fsStream);
LoadBands();
}
/// <summary>
/// 调用GDAL前生成.hdr文件
/// </summary>
protected override void CallGDALBefore()
{
base.CallGDALBefore();
_d1bdHeader = SetFileHeader.Set1BDHeader(fileName);
//generate hdr file
using (FileStream fs = new FileStream(fileName, FileMode.Open))
{
long len = fs.Length;
_factOfLine = (int)(len / _sizeOfLine - 1);
this._hdr = new HdrFile();
_hdr.Lines = _factOfLine;
_hdr.BandNames = TryGetBandNames();
_hdr.Bands = _hdr.BandNames.Count();
_hdr.Samples = _samples;
_hdr.HeaderOffset = _offset;
if (_d1bdHeader.IsBigEndian)
{
_hdr.ByteOrder = enumHdrByteOder.Network_IEEE;
}
else
{
_hdr.ByteOrder = enumHdrByteOder.Host_intel;
}
_hdr.MajorFrameOffsets[0] = _maxFrameOffset;
_hdr.MajorFrameOffsets[1] = _minFrameOffset;
string fname = HdrFile.GetHdrFileName(this._fileName);
_hdr.SaveTo(fname);
}
}
/*
* VALUECOUNT = 2 //default:0
* VALUES = "{0,1}" //
* VALUENAMES //
* SPATIALREF=Proj4 //default:wgs-84
* MAPINFO={X,Y}:{Col,Row}:{ResolutionX,ResolutionY} //default:null
* WITHHDR=[TRUE|FALSE] //default:true
*/
public override IRasterDataProvider Create(string fileName, int xSize, int ySize, int bandCount, enumDataType dataType, params object[] options)
{
ISpatialReference spatialRef;
MvgHeader mvgHeader;
HdrMapInfo mapInfo = null;
bool isWithHdr = true;
Int16 valueCount = 0;
Int16[] values = null;
string[] valueNames = null;
using (FileStream fileStream = new FileStream(fileName, FileMode.Create))
{
ParserMvgHeaderParams(options, out spatialRef, out mapInfo, out isWithHdr, out valueCount, out values, out valueNames);
mvgHeader = CreateMvgHeader(xSize, ySize, spatialRef, mapInfo, valueCount, values, valueNames);
int headerSize = mvgHeader.HeaderSize;
int fileLength = mvgHeader.HeaderSize + xSize * ySize * bandCount * DataTypeHelper.SizeOf(enumDataType.Int16);
fileStream.SetLength(fileLength);
fileStream.Write(mvgHeader.ToBytes(), 0, headerSize);
}
if (isWithHdr)
{
mvgHeader.ToHdrFile().SaveTo(HdrFile.GetHdrFileName(fileName));
}
IGeoDataProvider provider = BuildDataProviderByArgs(fileName, enumDataProviderAccess.Update, mvgHeader);
return(provider as IRasterDataProvider);
}
public override void Write(HdrFile hdr, RasterIdentify id)
{
base.Write(hdr, id);
BytesPerPixel = GetBytesPerPixel(hdr.DataType);
BeginTimeYear = (short)id.OrbitDateTime.Year;
BeginTimeMonth = (short)id.OrbitDateTime.Month;
BeginTimeDay = (short)id.OrbitDateTime.Day;
BeginTimeHour = (short)id.OrbitDateTime.Hour;
BeginTimeMinute = (short)id.OrbitDateTime.Minute;
EndTimeYear = (short)id.OrbitDateTime.Year;
EndTimeMonth = (short)id.OrbitDateTime.Month;
EndTimeDay = (short)id.OrbitDateTime.Day;
EndTimeHour = (short)id.OrbitDateTime.Hour;
EndTimeMinute = (short)id.OrbitDateTime.Minute;
if (hdr.BandNums.Length == 3)
{
ChannelNumber = 0;
RChannelNumber = (short)hdr.BandNums[0];
GChannelNumber = (short)hdr.BandNums[1];
BChannelNumber = (short)hdr.BandNums[2];
}
else if (hdr.BandNums.Length == 1)
{
ChannelNumber = 6;
}
}
public HdrFile ToHdrFile()
{
HdrFile hdrContent = _header.ToHdrFile();
hdrContent.HdrProjectionInfo = GetHdrProjectionInfo();
hdrContent.MapInfo = GetHdrMapInfo();
return(hdrContent);
}
public override void Write(HdrFile hdr)
{
base.Write(hdr);
Level2HeaderLength = 88;
PaddingLength = (short)(hdr.Samples - Level1HeaderLength - Level2HeaderLength);
FileHeaderOccupyRecordCount = 1;
ProductType = 2;
}
public void CreateEmptyLdfFile()
{
Assert.That(_newFileName != null);
IGeoDataDriver driver = GeoDataDriver.GetDriverByName("LDF");
Assert.NotNull(driver);
ILdfDriver drv = driver as ILdfDriver;
Assert.NotNull(drv);
int width = 2048;
int height = 3390;
int bandCount = 10;
enumDataType dataType = enumDataType.UInt16;
enumInterleave interleave = enumInterleave.BSQ;
string version = "LDF";
//string proj4 = "+proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +a=6378137 +b=6378137";
string mapInfo = "{1,1}:{110,35}:{0.01,0.01}";
bool withHdr = true;
ILdfDataProvider prd = drv.Create(_newFileName, width, height, bandCount, dataType,
"INTERLEAVE=" + interleave.ToString(),
"VERSION=" + version,
//"SPATIALREF=" + proj4,
"MAPINFO=" + mapInfo, "WITHHDR=" + withHdr.ToString()) as ILdfDataProvider;
Assert.NotNull(prd);
Assert.That(prd.Width == width && prd.Height == height);
Assert.That(prd.BandCount == bandCount);
Assert.That(prd.DataType == dataType);
ILdfHeader header = prd.Header;
Assert.NotNull(header);
HdrFile hdr = header.ToHdrFile();
PrintHdrInfo(hdr);
Ldf1Header ldfheader = header as Ldf1Header;
Assert.NotNull(ldfheader);
Assert.That(ldfheader._width == width && ldfheader._height == height);
Assert.That(ldfheader.DataType == dataType);
Assert.NotNull(prd.SpatialRef);
for (int i = 0; i < bandCount; i++)
{
IRasterBand band = prd.GetRasterBand(i + 1);
Assert.NotNull(band);
Assert.That(band.Width == width && band.Height == height);
Assert.That(band.DataType == dataType);
}
prd.Dispose();
drv.Dispose();
Assert.True(File.Exists(_newFileName));
FileInfo fInfo = new FileInfo(_newFileName);
Assert.True(width * height * bandCount * 2 + header.HeaderSize == fInfo.Length);
ISpatialReference spatialRef = prd.SpatialRef;
Assert.NotNull(spatialRef);
Console.Out.WriteLine(spatialRef.ToString());
}
private void CreatHdrFileByLdfFile(string ldfFileName)
{
string hdrFileName = HdrFile.GetHdrFileName(ldfFileName);
if (!File.Exists(hdrFileName))
{
CreatHdrFile(HdrFile.GetHdrFileName(ldfFileName));
}
}
public void ParseFromFile(string infile)
{
string outfile = Path.Combine(Path.GetDirectoryName(infile), Path.GetFileNameWithoutExtension(infile) + "_COPY.hdr");
HdrFile hdr = HdrFile.LoadFrom(infile);
Assert.NotNull(hdr);
hdr.SaveTo(outfile);
Console.Write(File.ReadAllText(outfile));
//FileAssert.AreEqual(infile, outfile);
}
private void WritePolarAWX(string hdr, string dat, RasterIdentify id)
{
HdrFile hdrObj = HdrFile.LoadFrom(hdr);
L1Header = new AWXLevel1HeaderImagePolarOrbit();
L1Header.Write(hdrObj);
L2Header = new AWXLevel2HeaderImagePolarOrbit();
if (hdrObj.MapInfo.Name == "Geographic Lat/Lon")
{
L2Header.ProjectMode = 4;
}
using (IRasterDataProvider dataprd = GeoDataDriver.Open(dat) as IRasterDataProvider)
{
if (dataprd != null && dataprd.BandCount != 0)
{
L2Header.GeographicalScopeNorthLatitude = (short)(dataprd.CoordEnvelope.MaxY * 100);
L2Header.GeographicalScopeSouthLatitude = (short)(dataprd.CoordEnvelope.MinY * 100);
L2Header.GeographicalScopeWestLongitude = (short)(dataprd.CoordEnvelope.MinX * 100);
L2Header.GeographicalScopeEastLongitude = (short)(dataprd.CoordEnvelope.MaxX * 100);
L2Header.ProjectCenterLatitude = (short)((L2Header.GeographicalScopeNorthLatitude + L2Header.GeographicalScopeSouthLatitude) / 2);
L2Header.ProjectCenterLongitude = (short)((L2Header.GeographicalScopeEastLongitude + L2Header.GeographicalScopeWestLongitude) / 2);
L2Header.ProjectHorizontalResolution = (short)(dataprd.ResolutionX * 100 * 100);
L2Header.ProjectVerticalResolution = (short)(dataprd.ResolutionY * 100 * 100);
}
}
L2Header.Write(hdrObj, id);
Padding = new byte[L1Header.RecordLength - L1Header.Level1HeaderLength - L1Header.Level2HeaderLength];
L1Header.WriteFile(hdr);
L2Header.WriteFile(hdr);
using (FileStream stream = new FileStream(Path.ChangeExtension(hdr, "AWX"), FileMode.Append))
{
using (BinaryWriter bw = new BinaryWriter(stream))
{
bw.Write(Padding);
}
}
using (FileStream stream = new FileStream(dat, FileMode.Open))
{
stream.Seek(hdrObj.HeaderOffset, SeekOrigin.Begin);
using (BinaryReader br = new BinaryReader(stream))
{
byte[] awxProductBytes = br.ReadBytes(Convert.ToInt32(stream.Length - stream.Position));
Product = new AWXProduct();
Product.Read(new MemoryStream(awxProductBytes));
}
}
using (FileStream stream = new FileStream(Path.ChangeExtension(hdr, "AWX"), FileMode.Append))
{
using (BinaryWriter bw = new BinaryWriter(stream))
{
bw.Write(Product.Data);
}
}
}
public HdrFile ToHdrFile()
{
HdrFile hdr = new HdrFile();
hdr.Bands = BandCount;
hdr.Samples = Width;
hdr.Lines = Height;
hdr.DataType = HdrFile.DataTypeToIntValue(DataTypeHelper.Enum2DataType((enumDataType)DataType));
hdr.HeaderOffset = Marshal.SizeOf(typeof(MemoryRasterHeader)) + ExtendHeaderLength;
return(hdr);
}
public virtual void Write(HdrFile hdr)
{
Sat96Filename = new string(new char[12] {
'1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c'
}); //
Endian = (hdr.ByteOrder == enumHdrByteOder.Host_intel) ? (short)0 : (short)1;
Level1HeaderLength = 40;
Format = new string(new char[8] {
'S', 'A', 'T', '2', '0', '0', '4', '\0'
}); //
}
private Core.DrawEngine.CoordEnvelope CoordEnvelopeFromHdr(HdrFile hdrFile)
{
double w = hdrFile.Samples * hdrFile.MapInfo.XYResolution.Longitude;
double h = hdrFile.Lines * hdrFile.MapInfo.XYResolution.Latitude;
double minX = hdrFile.MapInfo.BaseMapCoordinateXY.Longitude - (hdrFile.MapInfo.BaseRowColNumber.X - 1) * hdrFile.MapInfo.XYResolution.Longitude;
double maxX = w + minX;
double maxY = hdrFile.MapInfo.BaseMapCoordinateXY.Latitude + (hdrFile.MapInfo.BaseRowColNumber.Y - 1) * hdrFile.MapInfo.XYResolution.Latitude;
double minY = maxY - h;
return(new Core.DrawEngine.CoordEnvelope(minX, maxX, minY, maxY));
}
protected override void CallGDALBefore()
{
base.CallGDALBefore();
AWXFile awxFile = new AWXFile();
awxFile.Read(fileName);
if (awxFile.L1Header.ProductType == 1 || awxFile.L1Header.ProductType == 2)
{
AWXLevel2HeaderImage l2HI = awxFile.L2Header as AWXLevel2HeaderImage;
HdrFile hdr = new HdrFile();
hdr.DataType = 0;
if (l2HI.Reserve != 0)
{
hdr.DataType = l2HI.Reserve;
}
if (awxFile.L1Header.ProductType == 2)
{
AWXLevel2HeaderImagePolarOrbit l2HIP = awxFile.L2Header as AWXLevel2HeaderImagePolarOrbit;
if (hdr.DataType == 0)
{
if (l2HIP.BytesPerPixel == 2)
{
hdr.DataType = 2;
}
else
{
hdr.DataType = 1;
}
}
}
else
{
l2HI = awxFile.L2Header as AWXLevel2HeaderImageGeostationary;
//if(hdr.DataType==0)
hdr.DataType = 1;
}
hdr.Lines = l2HI.ImageHeight;
string[] bandNames;
hdr.Bands = CheckBands(awxFile.L1Header, l2HI, out bandNames);//需根据静止或极轨数据进行区分；
hdr.BandNames = bandNames;
hdr.Samples = l2HI.ImageWidth;
hdr.HeaderOffset = awxFile.L1Header.RecordLength;
hdr.Intertleave = enumInterleave.BSQ;
hdr.ByteOrder = (awxFile.L1Header.Endian == 0) ? enumHdrByteOder.Host_intel : enumHdrByteOder.Network_IEEE;
//TryCreateSpatialRefByHeader(l2HI);
//hdr.HdrProjectionInfo = GetHdrProjectionInfo();
hdr.MapInfo = GetHdrMapInfo(l2HI);
//hdr.GeoPoints = GetHdrGeoPoints(l2HI);
hdr.SaveTo(Path.ChangeExtension(fileName, "hdr"));
}
}
public void OpenFile()
{
IGeoDataDriver drv = GeoDataDriver.GetDriverByName("MVG");
IRasterDataProvider prd = drv.Open(_fileName, enumDataProviderAccess.ReadOnly) as IRasterDataProvider;
Assert.IsNotNull(prd);
MvgHeader header = (prd as IMvgDataProvider).Header as MvgHeader;
Assert.IsNotNull(header);
Console.WriteLine("header.Width=" + header.Width);
Console.WriteLine("header.Height=" + header.Height);
HdrFile hdr = header.ToHdrFile();
PrintHdrInfo(hdr);
}
/// <summary>
/// 调用GDAL前生成.hdr文件
/// </summary>
protected override void CallGDALBefore()
{
base.CallGDALBefore();
string[] filenames = null;
_infoDic = HJXML.ReadXMLFile(fileName, out filenames, out _existBands, out _lines, out _sample);
//generate hdr file
this._hdr = new HdrFile();
_hdr.Lines = _lines;
_hdr.BandNames = TryGetBandNames();
_hdr.Bands = _existBands.Count;
_hdr.Samples = _sample;
_hdr.HeaderOffset = 0;
string fname = HdrFile.GetHdrFileName(this._fileName);
_hdr.SaveTo(fname);
}
private void TryUpdateHeader()
{
using (FileStream fs = new FileStream(_fileName, FileMode.Open, FileAccess.Write))
{
SetExtHeader <MemoryRasterHeader>(fs, _header);
string hdr = HdrFile.GetHdrFileName(_fileName);
if (File.Exists(hdr))
{
//HdrFile hdrfile = HdrFile.LoadFrom(hdr);
//hdrfile.MapInfo.BaseMapCoordinateXY = new HdrGeoPointCoord(_header.MinX, _header.MaxY);
//hdrfile.MapInfo.BaseRowColNumber = new Point(1, 1);
//hdrfile.SaveTo(hdr);
File.Delete(hdr);
}
}
}
public HdrFile ToHdrFile()
{
HdrFile hdr = new HdrFile();
hdr.Samples = _width;
hdr.Lines = _height;
hdr.DataType = HdrFile.DataTypeToIntValue(typeof(Int16));
hdr.Intertleave = enumInterleave.BSQ;
hdr.Bands = 1;
hdr.HeaderOffset = HeaderSize;
hdr.ByteOrder = enumHdrByteOder.Host_intel;
hdr.HdrProjectionInfo = GetHdrProjectionInfo();
hdr.MapInfo = GetHdrMapInfo();
hdr.GeoPoints = null;
return(hdr);
}
private void PrintHdrInfo(HdrFile hdr)
{
Console.WriteLine("Hdr File:");
Console.WriteLine(hdr.Samples.ToString());
Console.WriteLine(hdr.Lines.ToString());
Console.WriteLine(hdr.Bands.ToString());
Console.WriteLine(hdr.Intertleave.ToString());
Console.WriteLine(hdr.DataType.ToString());
Console.WriteLine(hdr.ByteOrder.ToString());
Console.WriteLine(hdr.HeaderOffset.ToString());
Console.WriteLine("////");
hdr.SaveTo(HdrFile.GetHdrFileName(_newFileName));
Console.WriteLine("LOAD HDR FILE:");
Console.Write(File.ReadAllText(HdrFile.GetHdrFileName(_newFileName)));
Console.WriteLine("////END LOAD HDR FILE");
}
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);
}
public unsafe LandRasterDictionaryTemplate(string rasterFile, string codeFile)
{
using (IRasterDataProvider prd = GeoDataDriver.Open(rasterFile) as IRasterDataProvider)
{
_pixelValues = new byte[prd.Width * prd.Height];
fixed(byte *buffer = _pixelValues)
{
IntPtr ptr = new IntPtr(buffer);
prd.GetRasterBand(1).Read(0, 0, prd.Width, prd.Height, ptr, enumDataType.Byte, prd.Width, prd.Height);
}
_hdrInfo = HdrFile.LoadFrom(HdrFile.GetHdrFileName(rasterFile));
_pixelNames = ParsePixelNames(codeFile);
ExtractFieldsFromHdr();
}
}
private void CreatHdrFile(string fileName)
{
HdrFile hdr;
string fname = HdrFile.GetHdrFileName(fileName);
if (File.Exists(fname))
{
return;
}
else
{
hdr = _header.ToHdrFile();
if (hdr != null)
{
hdr.SaveTo(fname);
}
}
}
public override void Delete(string fileName)
{
string hdrFile = HdrFile.GetHdrFileName(fileName);
string[] files = null;
if (File.Exists(hdrFile))
{
files = new string[] { fileName, hdrFile }
}
;
else
{
files = new string[] { fileName }
};
foreach (string f in files)
{
File.Delete(f);
}
}
private void AddOverView(string pngfilename)
{
if (!File.Exists(pngfilename))
{
return;
}
string hdrfilename = pngfilename.Replace(".overview.png", ".hdr");
if (!File.Exists(hdrfilename))
{
return;
}
HdrFile hdrFile = HdrFile.LoadFrom(hdrfilename);
Core.DrawEngine.CoordEnvelope env = CoordEnvelopeFromHdr(hdrFile);
Bitmap bmp = LoadImage(pngfilename);
_simpleMapControl.AddImageLayer(pngfilename, bmp, env, true);
_simpleMapControl.Render();
}
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();
}
public override void Write(HdrFile hdr, RasterIdentify id)
{
char[] satchar = new char[8];
char[] arr = id.Satellite.ToCharArray();
if (arr.Length <= 8)
{
for (int i = 0; i < arr.Length; i++)
{
satchar[i] = arr[i];
}
}
else
{
for (int i = 0; i < 8; i++)
{
satchar[i] = arr[i];
}
}
Satellite = new string(satchar);//id.Satellite.ToCharArray()//string.Format("{0, -8}",id.Satellite.ToString())
ImageWidth = (short)hdr.Samples;
ImageHeight = (short)hdr.Lines;
Reserve = (short)hdr.DataType;
}
