public void RasterMapperConstructorTest()
{
RasterMapper mapper = new RasterMapper(RasterMapMode.ValueIsArea, MatrixFactory.CreateIdentity(4));
Assert.AreEqual(RasterMapMode.ValueIsArea, mapper.Mode);
Assert.AreEqual(MatrixFactory.CreateIdentity(4), mapper.RasterTransformation);
Assert.AreEqual(MatrixFactory.CreateIdentity(4), mapper.GeometryTransformation);
Assert.AreEqual(1, mapper.ColumnSize);
Assert.AreEqual(1, mapper.RowSize);
Assert.AreEqual(new CoordinateVector(1, 0), mapper.ColumnVector);
Assert.AreEqual(new CoordinateVector(0, 1), mapper.RowVector);
Assert.AreEqual(new CoordinateVector(1, 1, 1), mapper.Scale);
Assert.AreEqual(Coordinate.Empty, mapper.Translation);
// exceptions
Assert.Throws <ArgumentNullException>(() => new RasterMapper(RasterMapMode.ValueIsArea, null));
Assert.Throws <ArgumentException>(() => new RasterMapper(RasterMapMode.ValueIsArea, new Matrix(1, 4)));
Assert.Throws <ArgumentException>(() => new RasterMapper(RasterMapMode.ValueIsArea, new Matrix(4, 1)));
Assert.Throws <ArgumentException>(() => new RasterMapper(RasterMapMode.ValueIsArea, new Matrix(4, 4, Double.NaN)));
Assert.Throws <ArgumentException>(() => new RasterMapper(RasterMapMode.ValueIsArea, new Matrix(4, 4)));
Assert.Throws <ArgumentException>(() =>
{
Matrix matrix = new Matrix(4, 4);
matrix[3, 0] = matrix[3, 1] = matrix[3, 2] = matrix[3, 3] = 1;
new RasterMapper(RasterMapMode.ValueIsArea, matrix);
});
Assert.Throws <NotSupportedException>(() => new RasterMapper(RasterMapMode.ValueIsArea, MatrixFactory.CreateDiagonal(0, 0, 0, 1)));
}
public void ProxyRasterGetValuesTest()
{
// index based
ProxyRaster raster = new ProxyRaster(_factory.Object, _service.Object, null);
for (Int32 j = 0; j < raster.NumberOfRows; j += 5)
{
for (Int32 k = 0; k < raster.NumberOfColumns; k += 5)
{
Assert.IsTrue(_service.Object.ReadValueSequence(j, k, 0, 3).SequenceEqual(raster.GetValues(j, k)));
Assert.IsTrue(_service.Object.ReadValueSequence(j, k, 0, 3).SequenceEqual(raster[j, k]));
}
}
// coordinate based
RasterMapper mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsCoordinate, 1000, 1000, 0, 10, 10, 1);
raster = new ProxyRaster(_factory.Object, _service.Object, mapper);
for (Int32 x = 1000; x < 1000 + 10 * _service.Object.Dimensions.NumberOfColumns; x += 100)
{
for (Int32 y = 1000; y < 1000 + 10 * _service.Object.Dimensions.NumberOfRows; y += 100)
{
Assert.IsTrue(_service.Object.ReadValueSequence((x - 1000) / 10, (y - 1000) / 10, 0, 3).SequenceEqual(raster.GetValues(new Coordinate(x, y))));
Assert.IsTrue(_service.Object.ReadValueSequence((x - 1000) / 10, (y - 1000) / 10, 0, 3).SequenceEqual(raster[new Coordinate(x, y)]));
}
}
}
public void ProxyRasterConstructorTest()
{
// successful construction without spectral ranges and mapping
ProxyRaster raster = new ProxyRaster(_factory.Object, _service.Object, null);
Assert.IsFalse(raster.IsMapped);
Assert.IsNull(raster.Mapper);
Assert.IsTrue(raster.Coordinates.All(coordinate => !coordinate.IsValid));
Assert.AreEqual(_service.Object.IsReadable, raster.IsReadable);
Assert.AreEqual(_service.Object.IsWritable, raster.IsWritable);
Assert.AreEqual(_service.Object.Dimensions, raster.Dimensions);
Assert.AreEqual(_service.Object.Format, raster.Format);
Assert.AreEqual(_service.Object.Dimensions.NumberOfBands, raster.NumberOfBands);
Assert.AreEqual(_service.Object.Dimensions.NumberOfBands, raster.Bands.Count);
Assert.AreEqual(_factory.Object, raster.Factory);
// successful construction with mapping
RasterMapper mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, 1000, 1000, 0, 10, 10, 1);
raster = new ProxyRaster(_factory.Object, _service.Object, mapper);
Assert.IsTrue(raster.IsMapped);
Assert.AreEqual(mapper, raster.Mapper);
Assert.AreEqual(new Coordinate(1000, 1200), raster.Coordinates[0]);
Assert.AreEqual(new Coordinate(1150, 1200), raster.Coordinates[1]);
Assert.AreEqual(new Coordinate(1150, 1000), raster.Coordinates[2]);
Assert.AreEqual(new Coordinate(1000, 1000), raster.Coordinates[3]);
// argument null exception
Assert.Throws <ArgumentNullException>(() => { raster = new ProxyRaster(_factory.Object, null, null); });
}
public void ProxyRasterSetValuesTest()
{
_service.Setup(entity => entity.WriteValueSequence(It.IsInRange(0, 19, Moq.Range.Inclusive),
It.IsInRange(0, 14, Moq.Range.Inclusive),
It.IsInRange(0, 2, Moq.Range.Inclusive), It.IsAny <UInt32[]>()))
.Callback(new Action <Int32, Int32, Int32, UInt32[]>((rowIndex, columnIndex, bandIndex, values) => Assert.IsTrue(values.SequenceEqual(new UInt32[] { 0, 1, 2 }))));
// test case 1: index based
ProxyRaster raster = new ProxyRaster(_factory.Object, _service.Object, null);
for (Int32 j = 0; j < raster.NumberOfRows; j += 5)
{
for (Int32 k = 0; k < raster.NumberOfColumns; k += 5)
{
raster.SetValues(j, k, new UInt32[] { 0, 1, 2 });
}
}
// test case 2: coordinate based
RasterMapper mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsCoordinate, 1000, 1000, 0, 10, 10, 1);
raster = new ProxyRaster(_factory.Object, _service.Object, mapper);
for (Int32 x = 1000; x < 1000 + 10 * _service.Object.Dimensions.NumberOfColumns; x += 100)
{
for (Int32 y = 1000; y < 1000 + 10 * _service.Object.Dimensions.NumberOfRows; y += 100)
{
raster.SetValues(new Coordinate(x, y), new UInt32[] { 0, 1, 2 });
raster[new Coordinate(x, y)] = new UInt32[] { 0, 1, 2 };
}
}
}
/// <summary>
/// Computes the raster mapper.
/// </summary>
/// <returns>The raster mapper.</returns>
protected override RasterMapper ComputeRasterMapper()
{
RasterMapper mapper = null;
// try to read from file content
try
{
mapper = ComputeRasterToModelSpaceMapping();
}
catch { }
if (mapper != null)
{
return(mapper);
}
// try to read from metafile
if (_metafileReader != null)
{
try
{
mapper = _metafileReader.ReadMapping();
}
catch { }
}
if (mapper != null)
{
return(mapper);
}
// use default mapping
return(RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, Coordinate.Empty, new CoordinateVector(1, 1, 0)));
}
/// <summary>
/// Sets the parameters of the format.
/// </summary>
/// <param name="parameters">The parameters.</param>
private void SetParameters(IDictionary <GeometryStreamParameter, Object> parameters)
{
_layout = ResolveParameter <RawImageLayout>(SpectralGeometryStreamParameters.Layout);
_numberOfRows = ResolveParameter <Int32>(SpectralGeometryStreamParameters.NumerOfRows);
_numberOfColumns = ResolveParameter <Int32>(SpectralGeometryStreamParameters.NumberOfColumns);
_numberOfBands = ResolveParameter <Int32>(SpectralGeometryStreamParameters.SpectralResolution);
_radiometricResolution = ResolveParameter <Int32>(SpectralGeometryStreamParameters.RadiometricResolution);
_byteOrder = ResolveParameter <ByteOrder>(SpectralGeometryStreamParameters.SpectralResolution);
_bytesGapPerBand = ResolveParameter <Int32>(SpectralGeometryStreamParameters.BytesGapPerBand);
_bytesPerBandRow = IsProvidedParameter(SpectralGeometryStreamParameters.BytesPerBandRow) ?
ResolveParameter <Int32>(SpectralGeometryStreamParameters.BytesPerBandRow) :
Convert.ToInt32(Math.Ceiling(_numberOfColumns * _radiometricResolution / 8.0));
_bytesPerRow = IsProvidedParameter(SpectralGeometryStreamParameters.BytesPerRow) ?
ResolveParameter <Int32>(SpectralGeometryStreamParameters.BytesPerRow) :
(_layout == RawImageLayout.BandInterlevedByLine ? _numberOfBands * _bytesGapPerBand : (Int32)Math.Ceiling(_numberOfRows * _numberOfColumns * _radiometricResolution / 8.0));
_bytesSkipped = ResolveParameter <Int32>(SpectralGeometryStreamParameters.BytesSkipped);
// set raster mapping if all parameters are available
if (parameters.ContainsKey(SpectralGeometryStreamParameters.TieCoordinate) && parameters.ContainsKey(SpectralGeometryStreamParameters.ColumnDimension) && parameters.ContainsKey(SpectralGeometryStreamParameters.RowDimension))
{
_mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsCoordinate,
ResolveParameter <Coordinate>(SpectralGeometryStreamParameters.TieCoordinate).X,
ResolveParameter <Coordinate>(SpectralGeometryStreamParameters.TieCoordinate).Y,
0,
ResolveParameter <Double>(SpectralGeometryStreamParameters.ColumnDimension),
ResolveParameter <Double>(SpectralGeometryStreamParameters.RowDimension),
1);
}
}
public void SetUp()
{
List <Coordinate> coordinates = new List <Coordinate>
{
new Coordinate(0, 0),
new Coordinate(0, 4),
new Coordinate(4, 0),
new Coordinate(4, 4)
};
RasterMapper mapper = RasterMapper.FromCoordinates(RasterMapMode.ValueIsArea,
new RasterCoordinate(0, 0, 0, 0),
new RasterCoordinate(4, 0, 0, 4),
new RasterCoordinate(4, 4, 4, 4),
new RasterCoordinate(0, 4, 4, 0));
_sourceRasterMock = new Mock <IRaster>(MockBehavior.Strict);
_sourceRasterMock.Setup(raster => raster.Factory).Returns(new RasterFactory());
_sourceRasterMock.Setup(raster => raster.Coordinates).Returns(coordinates);
_sourceRasterMock.Setup(raster => raster.IsReadable).Returns(true);
_sourceRasterMock.Setup(raster => raster.Dimensions).Returns(new RasterDimensions(4, 4, 1, 8));
_sourceRasterMock.Setup(raster => raster.NumberOfRows).Returns(4);
_sourceRasterMock.Setup(raster => raster.NumberOfColumns).Returns(4);
_sourceRasterMock.Setup(raster => raster.NumberOfBands).Returns(1);
_sourceRasterMock.Setup(raster => raster.RadiometricResolution).Returns(8);
_sourceRasterMock.Setup(raster => raster.Mapper).Returns(mapper);
_sourceRasterMock.Setup(raster => raster.Format).Returns(RasterFormat.Integer);
_sourceRasterMock.Setup(raster => raster.IsMapped).Returns(true);
_sourceRasterMock.Setup(raster => raster.GetValue(It.IsInRange(0, 4, Moq.Range.Inclusive), It.IsInRange(0, 4, Moq.Range.Inclusive), It.IsInRange(0, 3, Moq.Range.Inclusive))).Returns(4);
_referenceRasterMock = new Mock <IRaster>(MockBehavior.Strict);
_referenceRasterMock.Setup(raster => raster.Factory).Returns(new RasterFactory());
_referenceRasterMock.Setup(raster => raster.Coordinates).Returns(coordinates);
_referenceRasterMock.Setup(raster => raster.IsReadable).Returns(true);
_referenceRasterMock.Setup(raster => raster.Dimensions).Returns(new RasterDimensions(4, 4, 1, 8));
_referenceRasterMock.Setup(raster => raster.NumberOfRows).Returns(4);
_referenceRasterMock.Setup(raster => raster.NumberOfColumns).Returns(4);
_referenceRasterMock.Setup(raster => raster.NumberOfBands).Returns(1);
_referenceRasterMock.Setup(raster => raster.RadiometricResolution).Returns(8);
_referenceRasterMock.Setup(raster => raster.Mapper).Returns(mapper);
_referenceRasterMock.Setup(raster => raster.Format).Returns(RasterFormat.Integer);
_referenceRasterMock.Setup(raster => raster.IsMapped).Returns(true);
for (Int32 i = 0; i < 4; i++)
{
for (Int32 j = 0; j < 4; j++)
{
if (i == 0 && j == 0)
{
_referenceRasterMock.Setup(raster => raster.GetValue(0, 0, It.IsInRange(0, 3, Moq.Range.Inclusive))).Returns(10);
}
else
{
_referenceRasterMock.Setup(raster => raster.GetValue(i, j, It.IsInRange(0, 3, Moq.Range.Inclusive))).Returns(4);
}
}
}
}
public void RasterMapperFromMapperTest()
{
// matrix from identity
RasterMapper sourceMapper = new RasterMapper(RasterMapMode.ValueIsArea, MatrixFactory.CreateIdentity(4));
RasterMapper mapper = RasterMapper.FromMapper(sourceMapper, MatrixFactory.CreateIdentity(4));
Assert.AreEqual(RasterMapMode.ValueIsArea, mapper.Mode);
Assert.AreEqual(MatrixFactory.CreateIdentity(4), mapper.GeometryTransformation);
// coordinate and vector from identity
mapper = RasterMapper.FromMapper(sourceMapper, new Coordinate(300, 1000, 0), new CoordinateVector(10, 3));
Assert.AreEqual(RasterMapMode.ValueIsArea, mapper.Mode);
Assert.AreEqual(new CoordinateVector(10, 0), mapper.ColumnVector);
Assert.AreEqual(new CoordinateVector(0, 3), mapper.RowVector);
Assert.AreEqual(new Coordinate(300, 1000), mapper.Translation);
// all values from identity
mapper = RasterMapper.FromMapper(sourceMapper, 300, 1000, 0, 10, 3, 0);
Assert.AreEqual(RasterMapMode.ValueIsArea, mapper.Mode);
Assert.AreEqual(new CoordinateVector(10, 0), mapper.ColumnVector);
Assert.AreEqual(new CoordinateVector(0, 3), mapper.RowVector);
Assert.AreEqual(new Coordinate(300, 1000), mapper.Translation);
// exceptions
Assert.Throws <ArgumentNullException>(() => RasterMapper.FromMapper(mapper, null));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, new Matrix(1, 4)));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, new Matrix(4, 1)));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, new Matrix(4, 4, Double.NaN)));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, new Matrix(4, 4)));
Assert.Throws <ArgumentException>(() =>
{
Matrix matrix = new Matrix(4, 4);
matrix[3, 0] = matrix[3, 1] = matrix[3, 2] = matrix[3, 3] = 1;
RasterMapper.FromMapper(mapper, matrix);
});
Assert.Throws <NotSupportedException>(() => RasterMapper.FromMapper(mapper, MatrixFactory.CreateDiagonal(0, 0, 0, 1)));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, Coordinate.Undefined, new CoordinateVector(0, 1, 0)));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, Coordinate.Empty, new CoordinateVector(Double.NaN, Double.NaN, Double.NaN)));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, Coordinate.Empty, new CoordinateVector(0, 1, 0)));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, Coordinate.Empty, new CoordinateVector(1, 0, 0)));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, Double.NaN, 0, 0, 1, 0, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, 0, Double.NaN, 0, 1, 0, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, 0, 0, Double.NaN, 1, 0, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, 0, 0, 0, 1, 0, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, 0, 0, 0, 0, 1, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, 0, 0, 0, Double.NaN, 1, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, 0, 0, 0, 1, Double.NaN, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromMapper(mapper, 0, 0, 0, 1, 1, Double.NaN));
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyRaster" /> class.
/// </summary>
/// <param name="factory">The raster factory.</param>
/// <param name="service">The raster service.</param>
/// <param name="mapper">The raster mapper.</param>
/// <exception cref="System.ArgumentNullException">The service is null.</exception>
public ProxyRaster(IRasterFactory factory, IRasterService service, RasterMapper mapper)
: base(factory, service?.Dimensions, mapper)
{
if (service == null)
{
throw new ArgumentNullException("service", "The service is null.");
}
_service = service;
_isSequentialService = _service.DataOrder == RasterDataOrder.RowColumnBand;
_histogramValues = Enumerable.Repeat <Int32[]>(null, NumberOfRows).ToArray();
}
public void RasterMapperFromTransformationTest()
{
// matrix
RasterMapper mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, MatrixFactory.CreateIdentity(4));
Assert.AreEqual(RasterMapMode.ValueIsArea, mapper.Mode);
Assert.AreEqual(MatrixFactory.CreateIdentity(4), mapper.GeometryTransformation);
// coordinate and vector
mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, new Coordinate(300, 1000, 0), new CoordinateVector(10, 3));
Assert.AreEqual(new Coordinate(300, 1000), mapper.Translation);
Assert.AreEqual(RasterMapMode.ValueIsArea, mapper.Mode);
Assert.AreEqual(10, mapper.ColumnSize);
Assert.AreEqual(3, mapper.RowSize);
Assert.AreEqual(new CoordinateVector(10, 0), mapper.ColumnVector);
Assert.AreEqual(new CoordinateVector(0, 3), mapper.RowVector);
// all values
mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, 300, 1000, 0, 10, 3, 0);
Assert.AreEqual(new Coordinate(300, 1000), mapper.Translation);
Assert.AreEqual(RasterMapMode.ValueIsArea, mapper.Mode);
Assert.AreEqual(10, mapper.ColumnSize);
Assert.AreEqual(3, mapper.RowSize);
Assert.AreEqual(new CoordinateVector(10, 0), mapper.ColumnVector);
Assert.AreEqual(new CoordinateVector(0, 3), mapper.RowVector);
// exceptions
Assert.Throws <ArgumentException>(() => RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, Coordinate.Undefined, new CoordinateVector(0, 1, 0)));
Assert.Throws <ArgumentException>(() => RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, Coordinate.Empty, new CoordinateVector(Double.NaN, Double.NaN, Double.NaN)));
Assert.Throws <ArgumentException>(() => RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, Coordinate.Empty, new CoordinateVector(0, 1, 0)));
Assert.Throws <ArgumentException>(() => RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, Coordinate.Empty, new CoordinateVector(1, 0, 0)));
Assert.Throws <ArgumentException>(() => RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, Double.NaN, 0, 0, 1, 0, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, 0, Double.NaN, 0, 1, 0, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, 0, 0, Double.NaN, 1, 0, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, 0, 0, 0, 1, 0, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, 0, 0, 0, 0, 1, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, 0, 0, 0, Double.NaN, 1, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, 0, 0, 0, 1, Double.NaN, 0));
Assert.Throws <ArgumentException>(() => RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, 0, 0, 0, 1, 1, Double.NaN));
}
/// <summary>
/// Sets the properties of the result.
/// </summary>
/// <param name="format">The raster format.</param>
/// <param name="numberOfBands">The number of bands.</param>
/// <param name="numberOfRows">The number of rows.</param>
/// <param name="numberOfColumns">The number of columns.</param>
/// <param name="radiometricResolution">The radiometric resolution.</param>
/// <param name="mapper">The mapper.</param>
/// <param name="presentation">The raster presentation.</param>
/// <param name="imaging">The raster imaging.</param>
protected void SetResultProperties(RasterFormat format, Int32 numberOfBands, Int32 numberOfRows, Int32 numberOfColumns, Int32 radiometricResolution, RasterMapper mapper, RasterPresentation presentation, RasterImaging imaging)
{
if (_resultPropertiesSet)
{
return;
}
_resultFormat = format;
_resultDimensions = new RasterDimensions(numberOfBands, numberOfRows, numberOfColumns, radiometricResolution);
_resultMapper = mapper;
_resultPresentation = presentation;
_resultImaging = imaging;
_resultPropertiesSet = true;
}
/// <summary>
/// Sets the properties of the result.
/// </summary>
/// <param name="numberOfBands">The number of bands.</param>
/// <param name="numberOfRows">The number of rows.</param>
/// <param name="numberOfColumns">The number of columns.</param>
/// <param name="radiometricResolution">The radiometric resolution.</param>
protected void SetResultProperties(Int32 numberOfBands, Int32 numberOfRows, Int32 numberOfColumns, Int32 radiometricResolution)
{
if (_resultPropertiesSet)
{
return;
}
_resultFormat = Source.Raster.Format;
_resultDimensions = new RasterDimensions(numberOfBands, numberOfRows, numberOfColumns, radiometricResolution);
_resultMapper = Source.Raster.Mapper;
_resultPresentation = Source.Presentation;
_resultImaging = Source.Imaging;
_resultPropertiesSet = true;
}
/// <summary>
/// Sets the properties of the result.
/// </summary>
/// <param name="format">The raster format.</param>
/// <param name="dimensions">The raster dimensions.</param>
protected void SetResultProperties(RasterFormat format, RasterDimensions dimensions)
{
if (_resultPropertiesSet)
{
return;
}
_resultFormat = format;
_resultDimensions = dimensions ?? Source.Raster.Dimensions;
_resultMapper = Source.Raster.Mapper;
_resultPresentation = Source.Presentation;
_resultImaging = Source.Imaging;
_resultPropertiesSet = true;
}
public void RasterMapperGetHashCodeTest()
{
RasterMapper mapper1 = new RasterMapper(RasterMapMode.ValueIsArea, MatrixFactory.CreateIdentity(4));
RasterMapper mapper2 = new RasterMapper(RasterMapMode.ValueIsArea, MatrixFactory.CreateIdentity(4));
Assert.AreEqual(mapper1.GetHashCode(), mapper2.GetHashCode());
mapper2 = new RasterMapper(RasterMapMode.ValueIsCoordinate, MatrixFactory.CreateIdentity(4));
Assert.AreNotEqual(mapper1.GetHashCode(), mapper2.GetHashCode());
mapper2 = RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, new Coordinate(300, 1000, 0), new CoordinateVector(10, 3));
Assert.AreNotEqual(mapper1.GetHashCode(), mapper2.GetHashCode());
}
/// <summary>
/// Sets the properties of the result.
/// </summary>
/// <param name="format">The raster format.</param>
/// <param name="dimensions">The raster dimensions.</param>
/// <param name="mapper">The mapper.</param>
/// <param name="presentation">The raster presentation.</param>
/// <param name="imaging">The raster imaging.</param>
protected void SetResultProperties(RasterFormat format, RasterDimensions dimensions, RasterMapper mapper, RasterPresentation presentation, RasterImaging imaging)
{
if (_resultPropertiesSet)
{
return;
}
_resultFormat = format;
_resultDimensions = dimensions ?? Source.Raster.Dimensions;
_resultMapper = mapper;
_resultPresentation = presentation;
_resultImaging = imaging;
_resultPropertiesSet = true;
}
/// <summary>
/// Sets the properties of the result.
/// </summary>
/// <param name="geometry">The geometry.</param>
/// <param name="format">The raster format.</param>
/// <param name="numberOfBands">The number of bands.</param>
/// <param name="radiometricResolution">The radiometric resolution.</param>
/// <param name="presentation">The raster presentation.</param>
protected void SetResultProperties(ISpectralGeometry geometry, RasterFormat format, Int32 numberOfBands, Int32 radiometricResolution, RasterPresentation presentation)
{
if (_resultPropertiesSet)
{
return;
}
_resultGeometry = geometry;
_resultFormat = format;
_resultDimensions = new RasterDimensions(numberOfBands, Source.Raster.NumberOfRows, Source.Raster.NumberOfColumns, radiometricResolution);
_resultMapper = Source.Raster.Mapper;
_resultPresentation = presentation;
_resultImaging = Source.Imaging;
_resultPropertiesSet = true;
}
/// <summary>
/// Computes the raster mapper of the mask.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="rowStart">The starting row index of a mask.</param>
/// <param name="columnStart">The starting column index of a mask.</param>
/// <param name="numberOfRows">The number of rows in the mask.</param>
/// <param name="numberOfColumns">The number of columns in the mask.</param>
/// <returns>The raster mapper of the specified source.</returns>
/// <exception cref="System.ArgumentNullException">The source is null.</exception>
private static RasterMapper ComputeMapper(IRaster source, Int32 rowStart, Int32 columnStart)
{
if (source == null)
{
throw new ArgumentNullException("source", "The source is null.");
}
if (source.Mapper == null)
{
return(null);
}
else
{
// the mask is a translation of the source
return(RasterMapper.FromMapper(source.Mapper, (Coordinate)(source.Mapper.MapCoordinate(rowStart, columnStart) - source.Mapper.MapCoordinate(0, 0)), new CoordinateVector(1, 1, 1)));
}
}
/// <summary>
/// Reads the raster mapping stored in the metafile stream.
/// </summary>
/// <returns>The raster mapping.</returns>
protected override RasterMapper ReadMappingInternal()
{
List <RasterCoordinate> coordinates = new List <RasterCoordinate>(4);
foreach (XElement vertexElement in _document.Element("Dimap_Document").Element("Dataset_Frame").Elements("Vertex"))
{
RasterCoordinate coordinate = new RasterCoordinate(
Int32.Parse(vertexElement.Element("FRAME_ROW").Value, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat),
Int32.Parse(vertexElement.Element("FRAME_COL").Value, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat),
Double.Parse(vertexElement.Element("FRAME_LAT").Value, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat),
Double.Parse(vertexElement.Element("FRAME_LON").Value, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat)
);
coordinates.Add(coordinate);
}
return(RasterMapper.FromCoordinates(RasterMapMode.ValueIsArea, coordinates));
}
public void ProxyRasterSetValueTest()
{
for (Int32 i = 0; i < 3; i++)
{
_service.Setup(entity => entity.WriteValue(It.IsInRange(0, 19, Moq.Range.Inclusive),
It.IsInRange(0, 14, Moq.Range.Inclusive),
i, It.IsAny <UInt32>()))
.Callback(new Action <Int32, Int32, Int32, UInt32>((rowIndex, columnIndex, bandIndex, value) => Assert.AreEqual(bandIndex, value, 0)));
}
// test case 1: index based
ProxyRaster raster = new ProxyRaster(_factory.Object, _service.Object, null);
for (Int32 i = 0; i < raster.NumberOfBands; i++)
{
for (Int32 j = 0; j < raster.NumberOfRows; j += 5)
{
for (Int32 k = 0; k < raster.NumberOfColumns; k += 5)
{
raster.SetValue(j, k, i, (UInt32)i);
raster[j, k, i] = (UInt32)i;
}
}
}
// test case 2: coordinate based
RasterMapper mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsCoordinate, 1000, 1000, 0, 10, 10, 1);
raster = new ProxyRaster(_factory.Object, _service.Object, mapper);
for (Int32 i = 0; i < raster.NumberOfBands; i++)
{
for (Int32 x = 1000; x < 1000 + 10 * _service.Object.Dimensions.NumberOfColumns; x += 100)
{
for (Int32 y = 1000; y < 1000 + 10 * _service.Object.Dimensions.NumberOfRows; y += 100)
{
raster.SetValue(new Coordinate(x, y), i, (UInt32)i);
raster[new Coordinate(x, y), i] = (UInt32)i;
}
}
}
}
public void ProxyRasterGetValueTest()
{
// index based
ProxyRaster raster = new ProxyRaster(_factory.Object, _service.Object, null);
for (Int32 i = -1; i <= raster.NumberOfBands; i++)
{
for (Int32 j = -1; j <= raster.NumberOfRows + 5; j += 5)
{
for (Int32 k = -1; k <= raster.NumberOfColumns + 5; k += 5)
{
try
{
Assert.AreEqual(_service.Object.ReadValue(j, k, i), raster.GetValue(j, k, i));
Assert.AreEqual(_service.Object.ReadValue(j, k, i), raster[j, k, i]);
}
catch (ArgumentOutOfRangeException)
{
Assert.IsTrue(i < 0 || i >= raster.NumberOfBands ||
j < 0 || j >= raster.NumberOfRows ||
k < 0 || k >= raster.NumberOfColumns);
}
}
}
}
// coordinate based
RasterMapper mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsCoordinate, 1000, 1000, 0, 10, 10, 1);
raster = new ProxyRaster(_factory.Object, _service.Object, mapper);
for (Int32 x = 1000; x < 1000 + 10 * _service.Object.Dimensions.NumberOfColumns; x += 100)
{
for (Int32 y = 1000; y < 1000 + 10 * _service.Object.Dimensions.NumberOfRows; y += 100)
{
Assert.AreEqual(_service.Object.ReadValue((x - 1000) / 10, (y - 1000) / 10, 0), raster.GetValue(new Coordinate(x, y), 0));
Assert.AreEqual(_service.Object.ReadValue((x - 1000) / 10, (y - 1000) / 10, 0), raster[new Coordinate(x, y), 0]);
}
}
}
/// <summary>
/// Prepares the result of the operation.
/// </summary>
/// <returns>The resulting geometry.</returns>
protected override ISpectralGeometry PrepareResult()
{
// compute the mapper
RasterMapper mapper = null;
IPolygon polygon = null;
if (Source.Raster.IsMapped)
{
mapper = RasterMapper.FromMapper(Source.Raster.Mapper,
(Coordinate)(Source.Raster.Mapper.MapCoordinate(SourceRowOffset, SourceColumnOffset) - Source.Raster.Mapper.MapCoordinate(0, 0)),
new CoordinateVector(SourceRowCount / _targetNumberOfRows, SourceColumnCount / _targetNumberOfColumns));
if (mapper.Mode == RasterMapMode.ValueIsArea)
{
polygon = Source.Factory.CreatePolygon(mapper.MapCoordinate(0, 0),
mapper.MapCoordinate(_targetNumberOfRows - 1, 0),
mapper.MapCoordinate(_targetNumberOfRows - 1, _targetNumberOfColumns - 1),
mapper.MapCoordinate(0, _targetNumberOfColumns - 1));
}
else
{
polygon = Source.Factory.CreatePolygon(mapper.MapCoordinate(0, 0),
mapper.MapCoordinate(_targetNumberOfRows, 0),
mapper.MapCoordinate(_targetNumberOfRows, _targetNumberOfColumns),
mapper.MapCoordinate(0, _targetNumberOfColumns));
}
}
else
{
polygon = Source.Factory.CreatePolygon(new Coordinate(0, 0),
new Coordinate(_targetNumberOfRows, 0),
new Coordinate(_targetNumberOfRows, _targetNumberOfColumns),
new Coordinate(0, _targetNumberOfColumns));
}
SetResultProperties(Source.Raster.Format, Source.Raster.NumberOfBands, _targetNumberOfRows, _targetNumberOfColumns, Source.Raster.RadiometricResolution, mapper);
return(base.PrepareResult());
}
public void RasterMapperEqualsTest()
{
RasterMapper mapper1 = new RasterMapper(RasterMapMode.ValueIsArea, MatrixFactory.CreateIdentity(4));
RasterMapper mapper2 = new RasterMapper(RasterMapMode.ValueIsArea, MatrixFactory.CreateIdentity(4));
Assert.IsTrue(mapper1.Equals(mapper1));
Assert.IsFalse(mapper1.Equals(null));
Assert.IsTrue(mapper1.Equals(mapper2));
Assert.IsTrue(mapper1.Equals((Object)mapper1));
Assert.IsFalse(mapper1.Equals((Object)null));
Assert.IsTrue(mapper1.Equals((Object)mapper2));
mapper2 = new RasterMapper(RasterMapMode.ValueIsCoordinate, MatrixFactory.CreateIdentity(4));
Assert.IsFalse(mapper1.Equals(mapper2));
Assert.IsFalse(mapper1.Equals((Object)mapper2));
mapper2 = RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, new Coordinate(300, 1000, 0), new CoordinateVector(10, 3));
Assert.IsFalse(mapper1.Equals(mapper2));
Assert.IsFalse(mapper1.Equals((Object)mapper2));
}
public void ProxyRasterNearestValueTest()
{
// test case 1: index based
ProxyRaster raster = new ProxyRaster(_factory.Object, _service.Object, null);
for (Int32 i = 0; i < raster.NumberOfBands; i++)
{
for (Int32 j = -1; j <= raster.NumberOfRows + 5; j += 5)
{
for (Int32 k = -1; k <= raster.NumberOfColumns + 5; k += 5)
{
Assert.AreEqual(_service.Object.ReadValue(Math.Max(0, Math.Min(j, _service.Object.Dimensions.NumberOfRows - 1)),
Math.Max(0, Math.Min(j, _service.Object.Dimensions.NumberOfColumns - 1)), i),
raster.GetNearestValue(j, k, i));
}
}
}
// test case 2: coordinate based
RasterMapper mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsCoordinate, 1000, 1000, 0, 10, 10, 1);
raster = new ProxyRaster(_factory.Object, _service.Object, mapper);
for (Int32 i = 0; i < raster.NumberOfBands; i++)
{
for (Int32 x = 1000; x < 1000 + 10 * _service.Object.Dimensions.NumberOfColumns; x += 100)
{
for (Int32 y = 1000; y < 1000 + 10 * _service.Object.Dimensions.NumberOfRows; y += 100)
{
Assert.AreEqual(_service.Object.ReadValue(Math.Max(0, Math.Min((x - 1000) / 10, _service.Object.Dimensions.NumberOfRows - 1)),
Math.Max(0, Math.Min((y - 1000) / 10, _service.Object.Dimensions.NumberOfColumns - 1)), i),
raster.GetNearestValue(new Coordinate(x, y), i));
}
}
}
}
public void RasterMapperFromCoordinatesTest()
{
RasterMapper sourceMapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsCoordinate, new Coordinate(300, 1000, 0), new CoordinateVector(10, 3));
RasterMapper mapper = RasterMapper.FromCoordinates(RasterMapMode.ValueIsCoordinate,
new RasterCoordinate(0, 0, sourceMapper.MapCoordinate(0, 0)),
new RasterCoordinate(100, 0, sourceMapper.MapCoordinate(100, 0)),
new RasterCoordinate(100, 100, sourceMapper.MapCoordinate(100, 100)),
new RasterCoordinate(0, 100, sourceMapper.MapCoordinate(0, 100))
);
Assert.AreEqual(RasterMapMode.ValueIsCoordinate, mapper.Mode);
Assert.AreEqual(sourceMapper.ColumnVector, mapper.ColumnVector);
Assert.AreEqual(sourceMapper.RowVector, mapper.RowVector);
Assert.AreEqual(sourceMapper.Translation.X, mapper.Translation.X, 0.000001);
Assert.AreEqual(sourceMapper.Translation.Y, mapper.Translation.Y, 0.000001);
Assert.AreEqual(sourceMapper.Translation.Z, mapper.Translation.Z, 0.000001);
// exceptions
Assert.Throws <ArgumentNullException>(() => RasterMapper.FromCoordinates(RasterMapMode.ValueIsCoordinate, null));
Assert.Throws <ArgumentException>(() => RasterMapper.FromCoordinates(RasterMapMode.ValueIsCoordinate, new RasterCoordinate(0, 0, sourceMapper.MapCoordinate(0, 0)), new RasterCoordinate(0, 100, sourceMapper.MapCoordinate(0, 100))));
Assert.Throws <ArgumentException>(() => RasterMapper.FromCoordinates(RasterMapMode.ValueIsCoordinate, new RasterCoordinate(0, 0, sourceMapper.MapCoordinate(0, 0)), new RasterCoordinate(100, 0, sourceMapper.MapCoordinate(100, 0))));
}
public void RasterMapperMapRasterTest()
{
// value is coordinate
RasterMapper mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsCoordinate, 300, 1000, 0, 10, 3, 1);
for (Int32 i = -100; i < 100; i += 3)
{
for (Int32 j = -100; j < 100; j += 3)
{
Int32 rowIndex, columnIndex;
mapper.MapRaster(new Coordinate(300 + i * 10, 1000 + j * 3), out rowIndex, out columnIndex);
Assert.AreEqual(i, columnIndex);
Assert.AreEqual(j, rowIndex);
Double floatRowIndex, floatColumnIndex;
mapper.MapRaster(new Coordinate(300 + i * 10, 1000 + j * 3), out floatRowIndex, out floatColumnIndex);
Assert.AreEqual(i, floatColumnIndex);
Assert.AreEqual(j, floatRowIndex);
mapper.MapRaster(new Coordinate(300 + i * 10, 1000 + j * 3), RasterMapMode.ValueIsCoordinate, out floatRowIndex, out floatColumnIndex);
Assert.AreEqual(i, floatColumnIndex);
Assert.AreEqual(j, floatRowIndex);
mapper.MapRaster(new Coordinate(295 + i * 10, 998.5 + j * 3), RasterMapMode.ValueIsArea, out floatRowIndex, out floatColumnIndex);
Assert.AreEqual(i, floatColumnIndex);
Assert.AreEqual(j, floatRowIndex);
}
}
// value is area
mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsArea, 300, 1000, 0, 10, 3, 1);
for (Int32 i = -100; i < 100; i += 3)
{
for (Int32 j = -100; j < 100; j += 3)
{
Int32 rowIndex, columnIndex;
mapper.MapRaster(new Coordinate(300 + i * 10, 1000 + j * 3), out rowIndex, out columnIndex);
Assert.AreEqual(i, columnIndex);
Assert.AreEqual(j, rowIndex);
Double floatRowIndex, floatColumnIndex;
mapper.MapRaster(new Coordinate(300 + i * 10, 1000 + j * 3), out floatRowIndex, out floatColumnIndex);
Assert.AreEqual(i, floatColumnIndex);
Assert.AreEqual(j, floatRowIndex);
mapper.MapRaster(new Coordinate(305 + i * 10, 1001.5 + j * 3), RasterMapMode.ValueIsCoordinate, out floatRowIndex, out floatColumnIndex);
Assert.AreEqual(i, floatColumnIndex);
Assert.AreEqual(j, floatRowIndex);
mapper.MapRaster(new Coordinate(300 + i * 10, 1000 + j * 3), RasterMapMode.ValueIsArea, out floatRowIndex, out floatColumnIndex);
Assert.AreEqual(i, floatColumnIndex);
Assert.AreEqual(j, floatRowIndex);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Raster16" /> class.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="spectralValues">The array of spectral values.</param>
/// <param name="dimensions">The dimensions of the raster.</param>
/// <param name="mapper">The mapper.</param>
private Raster16(IRasterFactory factory, UInt16[][] spectralValues, RasterDimensions dimensions, RasterMapper mapper)
: base(factory, dimensions, mapper)
{
// copy values for all bands
for (Int32 bandIndex = 0; bandIndex < spectralValues.Length; bandIndex++)
{
_values[bandIndex] = new UInt16[spectralValues[bandIndex].Length];
Array.Copy(spectralValues[bandIndex], _values[bandIndex], spectralValues[bandIndex].Length);
}
_histogramValues = Enumerable.Repeat <Int32[]>(null, spectralValues.Length).ToArray();
}
/// <summary>
/// Initializes a new instance of the <see cref="Raster16" /> class.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="numberOfBands">The number of bands.</param>
/// <param name="numberOfRows">The number of rows.</param>
/// <param name="numberOfColumns">The number of columns.</param>
/// <param name="radiometricResolution">The radiometric resolution.</param>
/// <param name="mapper">The mapper.</param>
/// <exception cref="System.ArgumentOutOfRangeException">
/// The number of bands is less than 1.
/// or
/// The number of rows is less than 0.
/// or
/// The number of columns is less than 0.
/// or
/// The radiometric resolution is less than 1.
/// or
/// The radiometric resolution is greater than 64.
/// </exception>
public Raster16(IRasterFactory factory, Int32 numberOfBands, Int32 numberOfRows, Int32 numberOfColumns, Int32 radiometricResolution, RasterMapper mapper)
: base(factory, numberOfBands, numberOfRows, numberOfColumns, radiometricResolution, mapper)
{
// generate empty values for all bands
_values = Enumerable.Repeat <UInt16[]>(null, numberOfBands).ToArray();
_histogramValues = Enumerable.Repeat <Int32[]>(null, numberOfBands).ToArray();
for (Int32 bandIndex = 0; bandIndex < _values.Length; bandIndex++)
{
_values[bandIndex] = new UInt16[NumberOfRows * NumberOfColumns];
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RasterFloat32" /> class.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="spectralValues">The array of spectral values.</param>
/// <param name="dimensions">The dimensions of the raster.</param>
/// <param name="mapper">The mapper.</param>
private RasterFloat32(IRasterFactory factory, Single[][] spectralValues, RasterDimensions dimensions, RasterMapper mapper)
: base(factory, dimensions, mapper)
{
// copy values for all bands
for (Int32 bandIndex = 0; bandIndex < spectralValues.Length; bandIndex++)
{
_values[bandIndex] = new Single[spectralValues[bandIndex].Length];
Array.Copy(spectralValues[bandIndex], _values[bandIndex], spectralValues[bandIndex].Length);
}
}
/// <summary>
/// Reads the mapping from model space to raster space.
/// </summary>
/// <returns>The mapping from model space to raster space.</returns>
protected RasterMapper ComputeRasterToModelSpaceMapping()
{
if (!_currentGeoKeys.ContainsKey(GeoKey.RasterType))
{
return(null);
}
RasterMapMode mode = Convert.ToInt16(_currentGeoKeys[GeoKey.RasterType]) == 1 ? RasterMapMode.ValueIsArea : RasterMapMode.ValueIsCoordinate;
Double[] modelTiePointsArray = null;
Double[] modelPixelScaleArray = null;
Double[] modelTransformationArray = null;
// gather information from tags
if (_imageFileDirectories[_currentImageIndex].ContainsKey(TiffTag.ModelTiepointTag))
{
modelTiePointsArray = _imageFileDirectories[_currentImageIndex][TiffTag.ModelTiepointTag].Select(value => Convert.ToDouble(value)).ToArray();
}
if (_imageFileDirectories[_currentImageIndex].ContainsKey(TiffTag.ModelPixelScaleTag))
{
modelPixelScaleArray = _imageFileDirectories[_currentImageIndex][TiffTag.ModelPixelScaleTag].Select(value => Convert.ToDouble(value)).ToArray();
}
if (_imageFileDirectories[_currentImageIndex].ContainsKey(TiffTag.ModelTransformationTag))
{
modelTransformationArray = _imageFileDirectories[_currentImageIndex][TiffTag.ModelTransformationTag].Select(value => Convert.ToDouble(value)).ToArray();
}
// for GeoTIFF 0.2, IntergraphMatrixTag (33920) may contain the transformation values
if (modelTransformationArray == null && _imageFileDirectories[_currentImageIndex].ContainsKey(TiffTag.IntergraphMatrixTag))
{
modelTransformationArray = _imageFileDirectories[_currentImageIndex][TiffTag.IntergraphMatrixTag].Select(value => Convert.ToDouble(value)).ToArray();
}
// compute with model tie points
if (modelTiePointsArray != null && (modelTiePointsArray.Length > 6 || (modelTiePointsArray.Length == 6 && modelPixelScaleArray.Length == 3)))
{
if (modelTiePointsArray.Length > 6) // transformation is specified by tie points
{
RasterCoordinate[] coordinates = new RasterCoordinate[modelTiePointsArray.Length / 6];
for (Int32 i = 0; i < modelTiePointsArray.Length; i += 6)
{
coordinates[i / 6] = new RasterCoordinate(Convert.ToInt32(modelTiePointsArray[i]), Convert.ToInt32(modelTiePointsArray[i + 1]), new Coordinate(modelTiePointsArray[i + 3], modelTiePointsArray[i + 4], modelTiePointsArray[i + 5]));
}
return(RasterMapper.FromCoordinates(mode, coordinates));
}
else // transformation is specified by single tie point and scale
{
Coordinate rasterSpaceCoordinate = new Coordinate(modelTiePointsArray[0], modelTiePointsArray[1], modelTiePointsArray[2]);
Coordinate modelSpaceCoordinate = new Coordinate(modelTiePointsArray[3], modelTiePointsArray[4], modelTiePointsArray[5]);
Double scaleX = modelPixelScaleArray[0];
Double scaleY = -modelPixelScaleArray[1];
Double scaleZ = modelPixelScaleArray[2];
return(RasterMapper.FromTransformation(mode,
modelSpaceCoordinate.X - rasterSpaceCoordinate.X * scaleX,
modelSpaceCoordinate.Y + rasterSpaceCoordinate.Y * scaleY,
modelSpaceCoordinate.Z - rasterSpaceCoordinate.Z * scaleZ,
scaleX, scaleY, scaleZ));
}
}
// compute with transformation values
if (modelTransformationArray != null)
{
Matrix transformation = new Matrix(4, 4);
for (Int32 i = 0; i < 4; i++)
{
for (Int32 j = 0; j < 4; j++)
{
transformation[i, j] = modelTransformationArray[i * 4 + j];
}
}
return(RasterMapper.FromTransformation(mode, transformation));
}
// nothing is available
return(null);
}
/// <summary>
/// Reads the header file.
/// </summary>
/// <exception cref="System.IO.FileNotFoundException">The header file is not available.</exception>
private void ReadHeader()
{
String headerFileName;
if (_fileSystem.Exists(_basePath + _fileSystem.DirectorySeparator + _baseFileName + ".hdr"))
{
headerFileName = _basePath + _fileSystem.DirectorySeparator + _baseFileName + ".hdr";
}
else if (_fileSystem.Exists(_basePath + _fileSystem.DirectorySeparator + _baseFileName + ".HDR"))
{
headerFileName = _basePath + _fileSystem.DirectorySeparator + _baseFileName + ".HDR";
}
else
{
throw new FileNotFoundException("The header file is not available.", _basePath + _fileSystem.DirectorySeparator + _baseFileName + ".hdr");
}
using (StreamReader reader = new StreamReader(headerFileName))
{
Double upperLeftX = 0, upperLeftY = 0, vectorX = 0, vectorY = 0;
Regex regex = new Regex(@"\s");
while (!reader.EndOfStream)
{
String line = reader.ReadLine();
if (String.IsNullOrEmpty(line) || line[0] == '#')
{
continue;
}
String[] lineParts = regex.Split(line.ToUpper()).Where(linePart => !String.IsNullOrEmpty(linePart)).ToArray();
if (lineParts.Length >= 2)
{
switch (lineParts[0])
{
case "BYTEORDER":
_byteOrder = (lineParts[1].Equals("I")) ? ByteOrder.LittleEndian : ByteOrder.BigEndian;
break;
case "LAYOUT":
switch (lineParts[1])
{
case "BIP":
_layout = RawImageLayout.BandInterlevedByPixel;
break;
case "BIL":
_layout = RawImageLayout.BandInterlevedByLine;
break;
case "BSQ":
_layout = RawImageLayout.BandSequential;
break;
}
break;
case "NROWS":
_numberOfRows = Int32.Parse(lineParts[1]);
break;
case "NCOLS":
_numberOfColumns = Int32.Parse(lineParts[1]);
break;
case "NBANDS":
_numberOfBands = Int32.Parse(lineParts[1]);
break;
case "NBITS":
_radiometricResolution = Int32.Parse(lineParts[1]);
break;
case "ULXMAP":
upperLeftX = Double.Parse(lineParts[1], CultureInfo.InvariantCulture);
break;
case "ULYMAP":
upperLeftY = Double.Parse(lineParts[1], CultureInfo.InvariantCulture);
break;
case "XDIM":
vectorX = Double.Parse(lineParts[1], CultureInfo.InvariantCulture);
break;
case "YDIM":
vectorY = Double.Parse(lineParts[1], CultureInfo.InvariantCulture);
break;
}
}
}
_bytesGapPerBand = 0;
_bytesPerBandRow = (Int32)Math.Ceiling(_numberOfColumns * _radiometricResolution / 8.0);
_bytesPerRow = (Int32)Math.Ceiling(_numberOfRows * _numberOfColumns * _radiometricResolution / 8.0);
_bytesSkipped = 0;
if (vectorX != 0 && vectorY != 0)
{
_mapper = RasterMapper.FromTransformation(RasterMapMode.ValueIsCoordinate, upperLeftX, upperLeftY, 0, vectorX, vectorY, 0);
}
}
}
