/// <summary>
/// Computes the specified spectral value.
/// </summary>
/// <param name="rowIndex">The zero-based row index of the value.</param>
/// <param name="columnIndex">The zero-based column index of the value.</param>
/// <param name="bandIndex">The zero-based band index of the value.</param>
/// <returns>The spectral value at the specified index.</returns>
protected override UInt32 Compute(Int32 rowIndex, Int32 columnIndex, Int32 bandIndex)
{
// if threshold is specified, the magnitude of the gradient is computed
if (_threshold > 0)
{
Double gradientRow = -Source.Raster.GetNearestValue(rowIndex - 1, columnIndex, bandIndex) + Source.Raster.GetNearestValue(rowIndex + 1, columnIndex, bandIndex);
Double gradientColumn = -Source.Raster.GetNearestValue(rowIndex, columnIndex - 1, bandIndex) + Source.Raster.GetNearestValue(rowIndex, columnIndex + 1, bandIndex);
// if the threshold is not reached, the original value is returned
if (Math.Sqrt(gradientRow * gradientRow + gradientColumn * gradientColumn) < _threshold)
{
return(Source.Raster.GetValue(rowIndex, columnIndex, bandIndex));
}
}
Double filteredValue = 0;
for (Int32 filterRowIndex = -_unsharpFilter.Radius; filterRowIndex <= _unsharpFilter.Radius; filterRowIndex++)
{
for (Int32 filterColumnIndex = -_unsharpFilter.Radius; filterColumnIndex <= _unsharpFilter.Radius; filterColumnIndex++)
{
filteredValue += Source.Raster.GetNearestValue(rowIndex + filterRowIndex, columnIndex + filterColumnIndex, bandIndex) * _unsharpFilter.Kernel[filterRowIndex + _unsharpFilter.Radius, filterColumnIndex + _unsharpFilter.Radius];
}
}
filteredValue = filteredValue / _unsharpFilter.Factor + _unsharpFilter.Offset;
return(RasterAlgorithms.Restrict((1 + _amount) * Source.Raster.GetValue(rowIndex, columnIndex, bandIndex) - _amount * filteredValue, Source.Raster.RadiometricResolution));
}
/// <summary>
/// Computes the specified spectral value.
/// </summary>
/// <param name="rowIndex">The zero-based row index of the value.</param>
/// <param name="columnIndex">The zero-based column index of the value.</param>
/// <param name="bandIndex">The zero-based band index of the value.</param>
/// <returns>The spectral value at the specified index.</returns>
protected override UInt32 Compute(Int32 rowIndex, Int32 columnIndex, Int32 bandIndex)
{
if (_multipliers[bandIndex] == 0)
{
return(RasterAlgorithms.RadiometricResolutionMax(Source.Raster.RadiometricResolution) / 2 + 1);
}
return(RasterAlgorithms.Restrict(_multipliers[bandIndex] * Source.Raster.GetValue(rowIndex, columnIndex, bandIndex), Source.Raster.RadiometricResolution));
}
/// <summary>
/// Computes the specified spectral value.
/// </summary>
/// <param name="rowIndex">The zero-based row index of the value.</param>
/// <param name="columnIndex">The zero-based column index of the value.</param>
/// <returns>The array containing the spectral values for each band at the specified index.</returns>
public virtual UInt32[] Compute(Double rowIndex, Double columnIndex)
{
Double[] resultFloat = ComputeFloat(rowIndex, columnIndex);
UInt32[] result = new UInt32[_raster.NumberOfBands];
for (Int32 bandIndex = 0; bandIndex < _raster.NumberOfBands; bandIndex++)
{
result[bandIndex] = RasterAlgorithms.Restrict(resultFloat[bandIndex], _raster.RadiometricResolution);
}
return(result);
}
/// <summary>
/// Computes the specified spectral value.
/// </summary>
/// <param name="rowIndex">The zero-based row index of the value.</param>
/// <param name="columnIndex">The zero-based column index of the value.</param>
/// <param name="bandIndex">The zero-based band index of the value.</param>
/// <returns>The spectral value at the specified index.</returns>
protected override UInt32 Compute(Int32 rowIndex, Int32 columnIndex, Int32 bandIndex)
{
Double[] filteredValues = new Double[_filter.Radius * _filter.Radius];
Int32 rowBase = rowIndex - _filter.Radius / 2;
Int32 columnBase = columnIndex - _filter.Radius / 2;
Int32 index = 0;
for (Int32 k = 0; k < _filter.Radius; k++)
{
for (Int32 l = 0; l < _filter.Radius; l++)
{
filteredValues[index] += _filter.Kernel[k, l] * Source.Raster.GetNearestValue(rowBase + k, columnBase + l, bandIndex);
index++;
}
}
Array.Sort(filteredValues);
return(RasterAlgorithms.Restrict(filteredValues[_filter.Radius * _filter.Radius / 2], Source.Raster.RadiometricResolution));
}
/// <summary>
/// Computes the specified spectral value.
/// </summary>
/// <param name="rowIndex">The zero-based row index of the value.</param>
/// <param name="columnIndex">The zero-based column index of the value.</param>
/// <param name="bandIndex">The zero-based band index of the value.</param>
/// <returns>The spectral value at the specified index.</returns>
protected override UInt32 Compute(Int32 rowIndex, Int32 columnIndex, Int32 bandIndex)
{
if (_filters.Count == 0)
{
return(Source.Raster.GetValue(rowIndex, columnIndex, bandIndex));
}
if (_filters.Count == 1)
{
Double filteredValue = 0;
for (Int32 filterRowIndex = -_filters[0].Radius; filterRowIndex <= _filters[0].Radius; filterRowIndex++)
{
for (Int32 filterColumnIndex = -_filters[0].Radius; filterColumnIndex <= _filters[0].Radius; filterColumnIndex++)
{
filteredValue += Source.Raster.GetNearestValue(rowIndex + filterRowIndex, columnIndex + filterColumnIndex, bandIndex) * _filters[0].Kernel[filterRowIndex + _filters[0].Radius, filterColumnIndex + _filters[0].Radius];
}
}
return(RasterAlgorithms.Restrict(filteredValue / _filters[0].Factor + _filters[0].Offset, Source.Raster.RadiometricResolution));
}
Double[] filteredValues = new Double[_filters.Count];
for (Int32 filterIndex = 0; filterIndex < _filters.Count; filterIndex++)
{
for (Int32 filterRowIndex = -_filters[filterIndex].Radius; filterRowIndex <= _filters[filterIndex].Radius; filterRowIndex++)
{
for (Int32 filterColumnIndex = -_filters[filterIndex].Radius; filterColumnIndex <= _filters[filterIndex].Radius; filterColumnIndex++)
{
filteredValues[filterIndex] += Source.Raster.GetNearestValue(rowIndex + filterRowIndex, columnIndex + filterColumnIndex, bandIndex) * _filters[filterIndex].Kernel[filterRowIndex + _filters[filterIndex].Radius, filterColumnIndex + _filters[filterIndex].Radius];
}
}
filteredValues[filterIndex] = filteredValues[filterIndex] / _filters[filterIndex].Factor + _filters[filterIndex].Offset;
}
return(RasterAlgorithms.Restrict(CombineValues(filteredValues), Source.Raster.RadiometricResolution));
}
/// <summary>
/// Computes the specified spectral value.
/// </summary>
/// <param name="rowIndex">The zero-based row index of the value.</param>
/// <param name="columnIndex">The zero-based column index of the value.</param>
/// <param name="bandIndex">The zero-based band index of the value.</param>
/// <returns>
/// The spectral value at the specified index.
/// </returns>
protected override UInt32 Compute(Int32 rowIndex, Int32 columnIndex, Int32 bandIndex)
{
Int32 rowCenter = (_structuringElement.NumberOfRows - 1) / 2;
Int32 columnCenter = (_structuringElement.NumberOfColumns - 1) / 2;
Int32 firstRowIndex = rowIndex - rowCenter;
Int32 firstColumnIndex = columnIndex - columnCenter;
Double result = 0;
for (Int32 row = 0; row < _structuringElement.NumberOfRows; row++)
{
for (Int32 column = 0; column < _structuringElement.NumberOfColumns; column++)
{
Double value = Source.Raster.GetNearestValue(firstRowIndex + row, firstColumnIndex + column, bandIndex) + _structuringElement[row, column];
if (value > result)
{
result = value;
}
}
}
return(RasterAlgorithms.Restrict(result, Source.Raster.RadiometricResolution));
}
/// <summary>
/// Computes the specified spectral value.
/// </summary>
/// <param name="rowIndex">The zero-based row index of the value.</param>
/// <param name="columnIndex">The zero-based column index of the value.</param>
/// <param name="bandIndex">The zero-based band index of the value.</param>
/// <returns>The spectral value at the specified index.</returns>
protected override UInt32 Compute(Int32 rowIndex, Int32 columnIndex, Int32 bandIndex)
{
return(RasterAlgorithms.Restrict(Source.Raster.GetValue(rowIndex, columnIndex, bandIndex) * _factor[bandIndex] + _offset[bandIndex], Source.Raster.RadiometricResolution));
}
/// <summary>
/// Computes the specified spectral value.
/// </summary>
/// <param name="rowIndex">The zero-based row index of the value.</param>
/// <param name="columnIndex">The zero-based column index of the value.</param>
/// <param name="bandIndex">The zero-based band index of the value.</param>
/// <returns>The spectral value at the specified index.</returns>
protected override UInt32 Compute(Int32 rowIndex, Int32 columnIndex, Int32 bandIndex)
{
return(RasterAlgorithms.Restrict(Math.Log(Source.Raster.GetFloatValue(rowIndex, columnIndex, bandIndex)), Source.Raster.RadiometricResolution));
}
/// <summary>
/// Computes the specified spectral value.
/// </summary>
/// <param name="rowIndex">The zero-based row index of the value.</param>
/// <param name="columnIndex">The zero-based column index of the value.</param>
/// <param name="bandIndex">The zero-based band index of the value.</param>
/// <returns>The spectral value at the specified index.</returns>
public virtual UInt32 Compute(Double rowIndex, Double columnIndex, Int32 bandIndex)
{
return(RasterAlgorithms.Restrict(ComputeFloat(rowIndex, columnIndex, bandIndex), _raster.RadiometricResolution));
}
/// <summary>
/// Computes the specified spectral value.
/// </summary>
/// <param name="rowIndex">The zero-based row index of the value.</param>
/// <param name="columnIndex">The zero-based column index of the value.</param>
/// <param name="bandIndex">The zero-based band index of the value.</param>
/// <returns>The spectral value at the specified index.</returns>
protected override UInt32 Compute(Int32 rowIndex, Int32 columnIndex, Int32 bandIndex)
{
// determining which four tiles are the closest to the actual pixel
// upper left tile's tile-row index in the array of tiles
Int32 upperLeftTileRowIndex = (_numberOfPixelRowsOfNormalTile % 2 == 0) ? (rowIndex + _numberOfPixelRowsOfNormalTile / 2 - 1) / _numberOfPixelRowsOfNormalTile - 1 : (rowIndex + _numberOfPixelRowsOfNormalTile / 2) / _numberOfPixelRowsOfNormalTile - 1;
// upper left tile's tile-column index in the array of tiles
Int32 upperLeftTileColumnIndex = (_numberOfPixelColumnsOfNormalTile % 2 == 0) ? (columnIndex + _numberOfPixelColumnsOfNormalTile / 2 - 1) / _numberOfPixelColumnsOfNormalTile - 1 : (columnIndex + _numberOfPixelColumnsOfNormalTile / 2) / _numberOfPixelColumnsOfNormalTile - 1;
Int32 upperRightTileRowIndex = upperLeftTileRowIndex; // upper right tile's tile-row index in the array of tiles
Int32 upperRightTileColumnIndex = upperLeftTileColumnIndex + 1; // upper right tile's tile-column index in the array of tiles
Int32 lowerLeftTileRowIndex = upperLeftTileRowIndex + 1; // lower left tile's tile-row index in the array of tiles
Int32 lowerLeftTileColumnIndex = upperLeftTileColumnIndex; // lower left tile's tile-column index in the array of tiles
Int32 lowerRightTileRowIndex = upperLeftTileRowIndex + 1; // lower right tile's tile-row index in the array of tiles
Int32 lowerRightTileColumnIndex = upperLeftTileColumnIndex + 1; // lower right tile's tile-column index in the array of tiles
// the four values to be bilinearly interpolated, computed using the four used tiles' transformation formula
// for the corresponding tile's (not adaptive!) histogram equalization
Double upperLeftValue = 0;
Double upperRightValue = 0;
Double lowerLeftValue = 0;
Double lowerRightValue = 0;
if (!(upperLeftTileRowIndex == -1 || upperLeftTileColumnIndex == -1))
{
upperLeftValue = PixelValueTransformation(Source.Raster.GetValue(rowIndex, columnIndex, bandIndex), bandIndex, _allTilesParameters[upperLeftTileRowIndex, upperLeftTileColumnIndex]);
}
if (!(upperRightTileRowIndex == -1 || upperRightTileColumnIndex == _tileNumberHorizontally))
{
upperRightValue = PixelValueTransformation(Source.Raster.GetValue(rowIndex, columnIndex, bandIndex), bandIndex, _allTilesParameters[upperRightTileRowIndex, upperRightTileColumnIndex]);
}
if (!(lowerLeftTileRowIndex == _tileNumberVertically || lowerLeftTileColumnIndex == -1))
{
lowerLeftValue = PixelValueTransformation(Source.Raster.GetValue(rowIndex, columnIndex, bandIndex), bandIndex, _allTilesParameters[lowerLeftTileRowIndex, lowerLeftTileColumnIndex]);
}
if (!(lowerRightTileRowIndex == _tileNumberVertically || lowerRightTileColumnIndex == _tileNumberHorizontally))
{
lowerRightValue = PixelValueTransformation(Source.Raster.GetValue(rowIndex, columnIndex, bandIndex), bandIndex, _allTilesParameters[lowerRightTileRowIndex, lowerRightTileColumnIndex]);
}
// the weights of the upper tiles and the left tiles
Double upperWeight = ((lowerLeftTileRowIndex * _numberOfPixelRowsOfNormalTile + _numberOfPixelRowsOfNormalTile / 2) - rowIndex) / (Double)((lowerLeftTileRowIndex * _numberOfPixelRowsOfNormalTile + _numberOfPixelRowsOfNormalTile / 2) - (upperLeftTileRowIndex * _numberOfPixelRowsOfNormalTile + _numberOfPixelRowsOfNormalTile / 2));
Double leftWeight = ((upperRightTileColumnIndex * _numberOfPixelColumnsOfNormalTile + _numberOfPixelColumnsOfNormalTile / 2) - columnIndex) / (Double)((upperRightTileColumnIndex * _numberOfPixelColumnsOfNormalTile + _numberOfPixelColumnsOfNormalTile / 2) - (upperLeftTileColumnIndex * _numberOfPixelColumnsOfNormalTile + _numberOfPixelColumnsOfNormalTile / 2));
Double value;
if (upperLeftTileRowIndex == -1)
{
if (upperLeftTileColumnIndex == -1)
{
value = lowerRightValue;
}
else if (upperLeftTileColumnIndex >= 0 && upperLeftTileColumnIndex <= (_tileNumberHorizontally - 2))
{
value = LinearInterpolation(lowerLeftValue, lowerRightValue, leftWeight);
}
else
{
value = lowerLeftValue;
}
}
else if (upperLeftTileRowIndex >= 0 && upperLeftTileRowIndex <= (_tileNumberVertically - 2))
{
if (upperLeftTileColumnIndex == -1)
{
value = LinearInterpolation(upperRightValue, lowerRightValue, upperWeight);
}
else if (upperLeftTileColumnIndex >= 0 && upperLeftTileColumnIndex <= (_tileNumberHorizontally - 2))
{
value = BilinearInterpolation(upperLeftValue, lowerLeftValue, upperRightValue, lowerRightValue, upperWeight, leftWeight);
}
else
{
value = LinearInterpolation(upperLeftValue, lowerLeftValue, upperWeight);
}
}
else
{
if (upperLeftTileColumnIndex == -1)
{
value = upperRightValue;
}
else if (upperLeftTileColumnIndex >= 0 && upperLeftTileColumnIndex <= (_tileNumberHorizontally - 2))
{
value = LinearInterpolation(upperLeftValue, upperRightValue, leftWeight);
}
else
{
value = upperLeftValue;
}
}
return(RasterAlgorithms.Restrict(value, Source.Raster.RadiometricResolution));
}
