public IRaster Surface(IRaster raster)
{
int nr = raster.NumRows;
int nc = raster.NumColumns;
for (int row = 0; row < nr; row++)
{
for (int col = 0; col < nc; col++)
{
raster.Value[row, col] = data[col, row];
}
}
raster.Save();
raster.Close();
return raster;
}
public bool RasterMath(IRaster input1, IRaster input2, IRaster output, ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (input1 == null || input2 == null || output == null)
{
return false;
}
Extent envelope = UnionEnvelope(input1, input2);
// Figures out which raster has smaller cells
IRaster smallestCellRaster = input1.CellWidth < input2.CellWidth ? input1 : input2;
// Given the envelope of the two rasters we calculate the number of columns / rows
int noOfCol = Convert.ToInt32(Math.Abs(envelope.Width / smallestCellRaster.CellWidth));
int noOfRow = Convert.ToInt32(Math.Abs(envelope.Height / smallestCellRaster.CellHeight));
// create output raster
output = Raster.CreateRaster(
output.Filename, string.Empty, noOfCol, noOfRow, 1, typeof(int), new[] { string.Empty });
RasterBounds bound = new RasterBounds(noOfRow, noOfCol, envelope);
output.Bounds = bound;
output.NoDataValue = input1.NoDataValue;
RcIndex v1;
RcIndex v2;
int previous = 0;
int max = output.Bounds.NumRows + 1;
for (int i = 0; i < output.Bounds.NumRows; i++)
{
for (int j = 0; j < output.Bounds.NumColumns; j++)
{
Coordinate cellCenter = output.CellToProj(i, j);
v1 = input1.ProjToCell(cellCenter);
double val1;
if (v1.Row <= input1.EndRow && v1.Column <= input1.EndColumn && v1.Row > -1 && v1.Column > -1)
{
val1 = input1.Value[v1.Row, v1.Column];
}
else
{
val1 = input1.NoDataValue;
}
v2 = input2.ProjToCell(cellCenter);
double val2;
if (v2.Row <= input2.EndRow && v2.Column <= input2.EndColumn && v2.Row > -1 && v2.Column > -1)
{
val2 = input2.Value[v2.Row, v2.Column];
}
else
{
val2 = input2.NoDataValue;
}
if (val1 == input1.NoDataValue && val2 == input2.NoDataValue)
{
output.Value[i, j] = output.NoDataValue;
}
else if (val1 != input1.NoDataValue && val2 == input2.NoDataValue)
{
output.Value[i, j] = output.NoDataValue;
}
else if (val1 == input1.NoDataValue && val2 != input2.NoDataValue)
{
output.Value[i, j] = output.NoDataValue;
}
else
{
output.Value[i, j] = Operation(val1, val2);
}
if (cancelProgressHandler.Cancel)
{
return false;
}
}
int current = Convert.ToInt32(Math.Round(i * 100D / max));
// only update when increment in persentage
if (current > previous)
{
cancelProgressHandler.Progress(string.Empty, current, current + TextStrings.progresscompleted);
}
previous = current;
}
// output = Temp;
output.Save();
return true;
}
/// <summary>
/// Executes the ReSample Opaeration tool programaticaly
/// Ping deleted the static property for external testing
/// </summary>
/// <param name="input1">The input raster</param>
/// <param name="oldCellSize">The size of the cells Hight</param>
/// <param name="newCellSize">The size of the cells Width</param>
/// <param name="output">The output raster</param>
/// <param name="cancelProgressHandler">The progress handler</param>
/// <returns></returns>
public bool Execute(IRaster input1, double newCellHeight, double newCellWidth, IRaster output, ICancelProgressHandler cancelProgressHandler)
{
//Validates the input and output data
if (input1 == null || newCellWidth == 0 || output == null)
{
return false;
}
IEnvelope envelope = input1.Bounds.Envelope;
//Calculate new number of columns and rows
int noOfCol = Convert.ToInt32(Math.Abs(envelope.Width / newCellWidth));
int noOfRow = Convert.ToInt32(Math.Abs(envelope.Height / newCellHeight));
int previous = 0;
//************OLD Method
////Create the new raster with the appropriate dimensions
//Raster Temp = new Raster();
////Temp.CreateNew(output.Filename, noOfRow, noOfCol, input1.DataType);
//Temp.CreateNew(output.Filename, "", noOfCol, noOfRow, 1, input1.DataType, new string[] { "" });
//Temp.CellWidth = newCellSize;
//Temp.CellHeight = oldCellSize;
//Temp.Xllcenter = input1.Bounds.Envelope.Minimum.X + (Temp.CellWidth / 2);
//Temp.Yllcenter = input1.Bounds.Envelope.Minimum.Y + (Temp.CellHeight / 2);
//***************
//create output raster
output = Raster.Create(output.Filename, "", noOfCol, noOfRow, 1, input1.DataType, new[] { "" });
RasterBounds bound = new RasterBounds(noOfRow, noOfCol, envelope);
output.Bounds = bound;
output.NoDataValue = input1.NoDataValue;
RcIndex index1;
//Loop throug every cell for new value
int max = (output.Bounds.NumRows + 1);
for (int i = 0; i < output.Bounds.NumRows; i++)
{
for (int j = 0; j < output.Bounds.NumColumns; j++)
{
//Projet the cell position to Map
Coordinate cellCenter = output.CellToProj(i, j);
index1=input1.ProjToCell(cellCenter);
double val;
if (index1.Row <= input1.EndRow && index1.Column <= input1.EndColumn && index1.Row > -1 && index1.Column > -1)
{
if (input1.Value[index1.Row, index1.Column] == input1.NoDataValue)
val = output.NoDataValue;
else
val = input1.Value[index1.Row, index1.Column];
}
else
val = output.NoDataValue;
output.Value[i, j] = val;
if (cancelProgressHandler.Cancel)
return false;
}
int current = Convert.ToInt32(Math.Round(i * 100D / max));
//only update when increment in persentage
if (current > previous)
cancelProgressHandler.Progress("", current, current + TextStrings.progresscompleted);
previous = current;
}
//output = Temp;
output.Save();
return true;
}
/// <summary>
/// This will resample the cells.
/// If the cell size is zero, this will default to the shorter of the width or height
/// divided by 256.
/// </summary>
/// <param name="input1">the input raster.</param>
/// <param name="cellHeight">The new cell height or null.</param>
/// <param name="cellWidth">The new cell width or null.</param>
/// <param name="outputFileName">The string name of the output raster.</param>
/// <param name="progressHandler">An interface for handling the progress messages.</param>
/// <returns>The resampled raster.</returns>
public static IRaster Resample(IRaster input1, double cellHeight, double cellWidth, string outputFileName,
IProgressHandler progressHandler)
{
if (input1 == null)
{
return(null);
}
Extent envelope = input1.Bounds.Extent;
if (cellHeight == 0)
{
cellHeight = envelope.Height / 256;
}
if (cellWidth == 0)
{
cellWidth = envelope.Width / 256;
}
//Calculate new number of columns and rows
int noOfCol = Convert.ToInt32(Math.Abs(envelope.Width / cellWidth));
int noOfRow = Convert.ToInt32(Math.Abs(envelope.Height / cellHeight));
IRaster output = Raster.CreateRaster(outputFileName, string.Empty, noOfCol, noOfRow, 1, input1.DataType,
new[] { string.Empty });
RasterBounds bound = new RasterBounds(noOfRow, noOfCol, envelope);
output.Bounds = bound;
output.NoDataValue = input1.NoDataValue;
RcIndex index1;
int max = (output.Bounds.NumRows);
ProgressMeter pm = new ProgressMeter(progressHandler, "ReSize Cells", max);
//Loop through every cell for new value
for (int i = 0; i < max; i++)
{
for (int j = 0; j < output.Bounds.NumColumns; j++)
{
//Project the cell position to Map
Coordinate cellCenter = output.CellToProj(i, j);
index1 = input1.ProjToCell(cellCenter);
double val;
if (index1.Row <= input1.EndRow && index1.Column <= input1.EndColumn && index1.Row > -1 &&
index1.Column > -1)
{
val = input1.Value[index1.Row, index1.Column] == input1.NoDataValue
? output.NoDataValue
: input1.Value[index1.Row, index1.Column];
}
else
{
val = output.NoDataValue;
}
output.Value[i, j] = val;
}
pm.CurrentValue = i;
}
output.Save();
pm.Reset();
return(output);
}
public bool RasterMath(IRaster input1, IRaster input2, IRaster output, ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (input1 == null || input2 == null || output == null)
{
return(false);
}
// Figures out which raster has smaller cells
var smallestCellRaster = input1.CellWidth < input2.CellWidth ? input1 : input2;
var envelope = UnionEnvelope(input1, input2);
envelope.MinX = envelope.MinX + smallestCellRaster.CellWidth / 2;
envelope.MinY = envelope.MinY - smallestCellRaster.CellHeight / 2;
envelope.MaxX = envelope.MaxX + smallestCellRaster.CellWidth / 2;
envelope.MaxY = envelope.MaxY - smallestCellRaster.CellHeight / 2;
// Given the envelope of the two rasters we calculate the number of columns / rows
int noOfCol = Convert.ToInt32(Math.Abs(envelope.Width / smallestCellRaster.CellWidth));
int noOfRow = Convert.ToInt32(Math.Abs(envelope.Height / smallestCellRaster.CellHeight));
// create output raster
output = Raster.CreateRaster(
output.Filename, string.Empty, noOfCol, noOfRow, 1, typeof(int), new[] { string.Empty });
var bound = new RasterBounds(noOfRow, noOfCol, envelope);
output.Bounds = bound;
output.NoDataValue = input1.NoDataValue;
int previous = 0;
int max = output.Bounds.NumRows + 1;
for (int i = 0; i < output.Bounds.NumRows; i++)
{
for (int j = 0; j < output.Bounds.NumColumns; j++)
{
Coordinate cellCenter = output.CellToProj(i, j);
var v1 = input1.ProjToCell(cellCenter);
double val1;
if (v1.Row <= input1.EndRow && v1.Column <= input1.EndColumn && v1.Row > -1 && v1.Column > -1)
{
val1 = input1.Value[v1.Row, v1.Column];
}
else
{
val1 = input1.NoDataValue;
}
var v2 = input2.ProjToCell(cellCenter);
double val2;
if (v2.Row <= input2.EndRow && v2.Column <= input2.EndColumn && v2.Row > -1 && v2.Column > -1)
{
val2 = input2.Value[v2.Row, v2.Column];
}
else
{
val2 = input2.NoDataValue;
}
if (val1 == input1.NoDataValue || val2 == input2.NoDataValue)
{
output.Value[i, j] = output.NoDataValue;
}
else
{
output.Value[i, j] = Operation(val1, val2);
}
if (cancelProgressHandler.Cancel)
{
return(false);
}
}
int current = Convert.ToInt32(Math.Round(i * 100D / max));
// only update when increment in persentage
if (current > previous)
{
cancelProgressHandler.Progress(string.Empty, current, current + TextStrings.progresscompleted);
}
previous = current;
}
// output = Temp;
output.Save();
return(true);
}
/// <summary>
/// Executes the RasterFromLAS tool.
/// </summary>
/// <param name="filenameLAS">The string filename of the LAS file to convert.</param>
/// <param name="outputExtent">The extent of the output raster.</param>
/// <param name="numRows">The integer number of rows of the output raster.</param>
/// <param name="numColumns">The integer number of columns.</param>
/// <param name="output">The output raster.</param>
/// <param name="cancelProgressHandler">The progress handler.</param>
/// <returns>Boolean, true if the method was successful.</returns>
public bool Execute(
string filenameLAS,
Extent outputExtent,
int numRows,
int numColumns,
IRaster output,
ICancelProgressHandler cancelProgressHandler)
{
// create output raster
output = Raster.CreateRaster(
output.Filename, string.Empty, numColumns, numRows, 1, typeof(int), new[] { string.Empty });
RasterBounds bound = new RasterBounds(numRows, numColumns, outputExtent);
output.Bounds = bound;
output.NoDataValue = int.MinValue;
ProgressMeter pm = new ProgressMeter(
cancelProgressHandler,
TextStrings.ConvertingLAS + filenameLAS + TextStrings.Progresstoraster + "...",
numRows);
for (int row = 0; row < numRows; row++)
{
for (int j = 0; j < output.Bounds.NumColumns; j++)
{
// TO DO: PING CAN ADD LAS READING AND CELL ASSIGNMENT HERE
if (cancelProgressHandler.Cancel)
{
return false;
}
}
pm.CurrentValue = row;
}
// output = Temp;
output.Save();
return true;
}
/// <summary>
/// Finds the average slope in the given polygons.
/// </summary>
/// <param name="poly">The Polygon.</param>
/// <param name="output">The Raster.</param>
/// <param name="progress">The progress handler.</param>
public bool Execute(IFeatureSet poly, int noOfRow, int noOfCol, int selectionIndex, IRaster output, ICancelProgressHandler cancelProgressHandler)
{
//Validates the input and output data
if (poly == null || output == null)
{
return false;
}
if (poly.FeatureType != FeatureTypes.Polygon)
return false;
//double CellSize = poly.Envelope.Width / 255;
//int noOfRow = Convert.ToInt32(poly.Envelope.Height / CellSize);
//int noOfCol = Convert.ToInt32(poly.Envelope.Width / CellSize);
output=Raster.Create(output.Filename,"",noOfCol,noOfRow,1,typeof(int),new string[] { "" });
RasterBounds bound = new RasterBounds(noOfRow, noOfCol, poly.Envelope);
output.Bounds=bound;
output.NoDataValue = -1;
int current, previous = 0;
double area = 0.0, previousArea = 0.0;
double hCellWidth = output.CellWidth / 2;
double hCellHeight = output.CellHeight / 2;
ICoordinate[] coordinateCell=new Coordinate[4];
int polyIndex = -1;
bool cover = false;
//IEnvelope env=null;
for (int i = 0; i < output.NumRows; i++)
{
current = Convert.ToInt32(i*100 / output.NumRows);
//only update when increment in percentage
if (current > previous+5)
{
cancelProgressHandler.Progress("", current, current.ToString() + "% progress completed");
previous = current;
}
for (int j = 0; j < output.NumColumns; j++)
{
polyIndex = -1;
area = 0.0;
previousArea = 0.0;
cover=false;
ICoordinate cordinate=null;
cordinate = output.CellToProj(i, j);
//make the center of cell as point geometry
IPoint pt=new Point(cordinate);
for(int f=0;f<poly.Features.Count;f++)
{
if (selectionIndex == 0)
{
if (poly.Features[f].Covers(pt))
{
output.Value[i, j] = f;
cover = true;
break;
}
if (cancelProgressHandler.Cancel == true)
return false;
}
else //process area based selection
{
ICoordinate tempCo = new Coordinate(cordinate.X - hCellWidth, cordinate.Y - hCellHeight);
coordinateCell[0] = tempCo;
tempCo = new Coordinate(cordinate.X + hCellWidth, cordinate.Y - hCellHeight);
coordinateCell[1] = tempCo;
tempCo = new Coordinate(cordinate.X + hCellWidth, cordinate.Y + hCellHeight);
coordinateCell[2] = tempCo;
tempCo = new Coordinate(cordinate.X - hCellWidth, cordinate.Y + hCellHeight);
coordinateCell[3] = tempCo;
List<ICoordinate> ListCellCordinate = new List<ICoordinate>();
ListCellCordinate = coordinateCell.ToList<ICoordinate>();
IFeature cell = new Feature(FeatureTypes.Polygon, ListCellCordinate);
IFeature commonFeature=poly.Features[f].Intersection(cell);
if (commonFeature == null)
continue;
area=commonFeature.Area();
if (area > previousArea)
{
polyIndex = f;
cover = true;
previousArea = area;
}
if (cancelProgressHandler.Cancel == true)
return false;
}
}
if (cover == true)
{
if (selectionIndex == 1)
output.Value[i, j] = polyIndex;
}
else
output.Value[i, j] = output.NoDataValue;
}
}
//output.SaveAs(output.Filename);
output.Save();
//output.SaveAs(output.Filename);
return true;
}
/// <summary>
/// Executes the slope generation raster.
/// </summary>
/// <param name="raster">The input altitude raster.</param>
/// <param name="inZFactor">The double precision multiplicative scaling factor for elevation values.</param>
/// <param name="slopeInPercent">A boolean parameter that clarifies the nature of the slope values. If this is true, the values represent percent slope.</param>
/// <param name="result">The output slope raster.</param>
/// <param name="cancelProgressHandler">The progress handler.</param>
/// <returns>A boolean value, true if the process was successful.</returns>
public static bool GetSlope(IRaster raster, double inZFactor, bool slopeInPercent, ref IRaster result,
ICancelProgressHandler cancelProgressHandler)
{
//Validates the input and output data
if (raster == null || result == null)
{
return false;
}
int noOfCol = raster.NumColumns;
int noOfRow = raster.NumRows;
//Create the new raster with the appropriate dimensions
IRaster temp = Raster.CreateRaster("SlopeRaster.bgd", string.Empty, noOfCol, noOfRow, 1, typeof(double),
new[] { string.Empty });
temp.NoDataValue = raster.NoDataValue;
temp.Bounds = raster.Bounds;
temp.Projection = raster.Projection;
ProgressMeter progMeter = null;
try
{
if (cancelProgressHandler != null)
progMeter = new ProgressMeter(cancelProgressHandler, "Calculating Slope", temp.NumRows);
for (int i = 0; i < temp.NumRows; i++)
{
if (cancelProgressHandler != null)
{
progMeter.Next();
if ((i % 100) == 0)
{
progMeter.SendProgress();
// HACK: DoEvents messes up the normal flow of your application.
System.Windows.Forms.Application.DoEvents();
}
}
for (int j = 0; j < temp.NumColumns; j++)
{
if (i > 0 && i < temp.NumRows - 1 && j > 0 && j < temp.NumColumns - 1)
{
double z1 = raster.Value[i - 1, j - 1];
double z2 = raster.Value[i - 1, j];
double z3 = raster.Value[i - 1, j + 1];
double z4 = raster.Value[i, j - 1];
double z5 = raster.Value[i, j + 1];
double z6 = raster.Value[i + 1, j - 1];
double z7 = raster.Value[i + 1, j];
double z8 = raster.Value[i + 1, j + 1];
//3rd Order Finite Difference slope algorithm
double dZdX = inZFactor * ((z3 - z1) + (2 * (z5 - z4)) + (z8 - z6)) / (8 * raster.CellWidth);
double dZdY = inZFactor * ((z1 - z6) + (2 * (z2 - z7)) + (z3 - z8)) / (8 * raster.CellHeight);
double slope = Math.Atan(Math.Sqrt((dZdX * dZdX) + (dZdY * dZdY))) * (180 / Math.PI);
//change to radius and in percentage
if (slopeInPercent)
{
slope = (Math.Tan(slope * Math.PI / 180)) * 100;
}
temp.Value[i, j] = slope;
if (cancelProgressHandler != null && cancelProgressHandler.Cancel)
{
return false;
}
}
else
{
temp.Value[i, j] = temp.NoDataValue;
}
if (cancelProgressHandler != null && cancelProgressHandler.Cancel)
{
return false;
}
}
}
result = temp;
if (result.IsFullyWindowed())
{
result.Save();
return true;
}
return false;
}
finally
{
if (progMeter != null)
{
progMeter.Reset();
System.Windows.Forms.Application.DoEvents();
}
}
}
/// <summary>
/// Executes the Raster distance calculation
/// Ping Yang deleted static for external testing 10/2010
/// </summary>
/// <param name="input">The input raster</param>
/// <param name="output">The output raster</param>
/// <param name="maxDistance">The maximum distance value. Cells with a larger distance to nearest
/// target cell than maxDistance will be assigned 'no data' value.</param>
/// <param name="cancelProgressHandler">The progress handler</param>
/// <returns>true if execution successful, false otherwise</returns>
public bool Execute(IRaster input, IRaster output, double maxDistance, ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (input == null || output == null)
{
return false;
}
// Creates the output raster with the same bounds as the input
RasterBounds bounds = (RasterBounds)input.Bounds.Copy();
output = Raster.CreateRaster(
output.Filename, string.Empty, bounds.NumColumns, bounds.NumRows, 1, typeof(int), new[] { string.Empty });
// output.CreateNew(output.Filename, "", bounds.NumColumns, bounds.NumRows, 1, typeof(int), new string[] { "" });
// output = Raster.CreateNewRaster(output.Filename, bounds.NumRows, bounds.NumColumns, RasterDataTypes.INTEGER);
output.Bounds = bounds;
// internally we reference output as an integer type raster.
Raster<int> outRaster = output as Raster<int>;
if (outRaster != null)
{
int numColumns = outRaster.NumColumns;
int numRows = outRaster.NumRows;
int lastUpdate = 0;
// declare two jagged arrays for storing the (Rx, Ry) vectors.
// rX is distance from current cell to nearest target cell measured in the x-direction
// rY is distance from current cell to nearest target cell measured in the y-direction
// the actual distance can be calculated as sqrt(rX^2 + rY^2).
// in the resulting distance raster we store the squared distance as well as the rX, rY relative coordinates
// to improve computation speed
int[][] aRx = new int[numRows][];
int[][] aRy = new int[numRows][];
int[][] aSqDist = new int[numRows][];
const int infD = int.MaxValue;
const int targetVal = 0;
// initialize the arrays
for (int i = 0; i < numRows; i++)
{
aRx[i] = new int[numColumns];
aRy[i] = new int[numColumns];
aSqDist[i] = new int[numColumns];
ReadInputRow(input, i, aSqDist[i], targetVal, infD);
}
// *******************************************************************
// raster distance calculation pass one - top to bottom, left to right
// *******************************************************************
// int[] row1 = new int[numColumns];
// int[] row2 = new int[numColumns];
int[] aNcels = new int[4]; // the values of four neighbouring cells (W, NW, N, NE)
int[] aDiff = new int[4]; // the | y coordinate distances to nearest target cell
for (int row = 1; row < numRows; row++)
{
////read the row from input raster
// ReadInputRow(input, rowIndex, row2, targetVal, infD);
for (int col = 1; col < numColumns - 1; col++)
{
int val = aSqDist[row][col];
// Continue processing only if the current cell is not a target
if (val == targetVal)
{
continue;
}
// read the values of the cell's neighbours
aNcels[0] = aSqDist[row][col - 1]; // W
aNcels[1] = aSqDist[row - 1][col - 1]; // NW
aNcels[2] = aSqDist[row - 1][col]; // N
aNcels[3] = aSqDist[row - 1][col + 1]; // NE
// calculate the squared euclidean distances to each neighbouring cell and to the nearest target cell
aDiff[0] = (aNcels[0] < infD) ? aNcels[0] + 2 * aRx[row][col - 1] + 1 : infD;
aDiff[1] = (aNcels[1] < infD)
? aNcels[1] + 2 * (aRx[row - 1][col - 1] + aRy[row - 1][col - 1] + 1)
: infD;
aDiff[2] = (aNcels[2] < infD) ? aNcels[2] + 2 * aRy[row - 1][col] + 1 : infD;
aDiff[3] = (aNcels[3] < infD)
? aNcels[3] + 2 * (aRx[row - 1][col + 1] + aRy[row - 1][col + 1] + 1)
: infD;
// find neighbouring cell with minimum distance difference
int minDiff = aDiff[0];
int minDiffCell = 0;
for (int i = 1; i < 4; i++)
{
if (aDiff[i] < minDiff)
{
minDiff = aDiff[i];
minDiffCell = i;
}
}
// if a neighbouring cell with known distance was found:
if (minDiff < infD)
{
// assign the minimum euclidean distance
aSqDist[row][col] = minDiff;
// update the (rX, rY) cell-to-nearest-target vector
switch (minDiffCell)
{
case 0: // W
aRx[row][col] = aRx[row][col - 1] + 1;
aRy[row][col] = aRy[row][col - 1];
break;
case 1: // NW
aRx[row][col] = aRx[row - 1][col - 1] + 1;
aRy[row][col] = aRy[row - 1][col - 1] + 1;
break;
case 2: // N
aRx[row][col] = aRx[row - 1][col];
aRy[row][col] = aRy[row - 1][col] + 1;
break;
case 3: // NE
aRx[row][col] = aRx[row - 1][col + 1] + 1;
aRy[row][col] = aRy[row - 1][col + 1] + 1;
break;
}
}
// end of update (rX, rY) cell-to-nearest-target vector
}
// end or current row processing - report progress
int percent = (int)(row / (double)numRows * 100f);
if (percent > lastUpdate)
{
lastUpdate += 1;
cancelProgressHandler.Progress(
string.Empty, lastUpdate, TextStrings.Pass1 + lastUpdate + TextStrings.progresscompleted);
if (cancelProgressHandler.Cancel)
{
return false;
}
}
}
// *******************************************************************
// end of first pass for loop
// *******************************************************************
// *******************************************************************
// raster distance calculation PASS TWO - bottom to top, right to left
// *******************************************************************
lastUpdate = 0;
for (int row = numRows - 2; row > 0; row--)
{
for (int col = numColumns - 2; col > 0; col--)
{
int val = aSqDist[row][col];
// Continue processing only if the current cell is not a target
if (val == targetVal)
{
continue;
}
// read the values of the cell's neighbours
aNcels[0] = aSqDist[row][col + 1]; // E
aNcels[1] = aSqDist[row + 1][col + 1]; // SE
aNcels[2] = aSqDist[row + 1][col]; // S
aNcels[3] = aSqDist[row + 1][col - 1]; // SW
// calculate the squared euclidean distances to each neighbouring cell and to the nearest target cell
aDiff[0] = (aNcels[0] < infD) ? aNcels[0] + 2 * aRx[row][col + 1] + 1 : infD;
aDiff[1] = (aNcels[1] < infD)
? aNcels[1] + 2 * (aRx[row + 1][col + 1] + aRy[row + 1][col + 1] + 1)
: infD;
aDiff[2] = (aNcels[2] < infD) ? aNcels[2] + 2 * aRy[row + 1][col] + 1 : infD;
aDiff[3] = (aNcels[3] < infD)
? aNcels[3] + 2 * (aRx[row + 1][col - 1] + aRy[row + 1][col - 1] + 1)
: infD;
// find neighbouring cell with minimum distance difference
int minDiff = aDiff[0];
int minDiffCell = 0;
for (int i = 1; i < 4; i++)
{
if (aDiff[i] < minDiff)
{
minDiff = aDiff[i];
minDiffCell = i;
}
}
// if a neighbouring cell with known distance smaller than current known distance was found:
if (minDiff < val)
{
// assign the minimum euclidean distance
aSqDist[row][col] = minDiff;
// update the (rX, rY) cell-to-nearest-target vector
switch (minDiffCell)
{
case 0: // E
aRx[row][col] = aRx[row][col + 1] + 1;
aRy[row][col] = aRy[row][col + 1];
break;
case 1: // SE
aRx[row][col] = aRx[row + 1][col + 1] + 1;
aRy[row][col] = aRy[row + 1][col + 1] + 1;
break;
case 2: // S
aRx[row][col] = aRx[row + 1][col];
aRy[row][col] = aRy[row + 1][col] + 1;
break;
case 3: // SW
aRx[row][col] = aRx[row + 1][col - 1] + 1;
aRy[row][col] = aRy[row + 1][col - 1] + 1;
break;
}
}
// end of update (rX, rY) cell-to-nearest-target vector
}
// Write row to output raster
WriteOutputRow(outRaster, row, aSqDist[row]);
// Report progress
int percent = (int)(row / (double)numRows * 100f);
if (percent > lastUpdate)
{
lastUpdate += 1;
cancelProgressHandler.Progress(
string.Empty, lastUpdate, TextStrings.Pass2 + lastUpdate + TextStrings.progresscompleted);
if (cancelProgressHandler.Cancel)
{
return false;
}
}
}
}
// *******************************************************************
// end of second pass proximity calculation loop
// *******************************************************************
// save output raster
output.Save();
return true;
}
public bool Execute(IFeatureSet input, string zField, double cellSize, double power, int neighborType, int pointCount, double distance, IRaster output)
{
if (input == null || output == null)
{
return(false);
}
if (cellSize == 0)
{
cellSize = input.Extent.Width / 255;
}
int numColumns = Convert.ToInt32(Math.Round(input.Extent.Width / cellSize));
int numRows = Convert.ToInt32(Math.Round(input.Extent.Height / cellSize));
output = Raster.CreateRaster(output.Filename, string.Empty, numColumns, numRows, 1, typeof(double), new[] { string.Empty });//error
output.CellHeight = cellSize;
output.CellWidth = cellSize;
output.Xllcenter = input.Extent.MinX + (cellSize / 2);
output.Yllcenter = input.Extent.MinY + (cellSize / 2);
progress.Maximum = numColumns * numRows;
progress.Value = 0;
#region 构建KD树
List <KD_Point> lists = new List <KD_Point>();//构建KD-Tree的点集列表
foreach (var p in input.Features)
{
KD_Point kd = new KD_Point(p.BasicGeometry.Coordinates[0].X, p.BasicGeometry.Coordinates[0].Y, Convert.ToDouble(p.DataRow[zField]));
lists.Add(kd);
}
KDTree kDTree = new KDTree();
kDTree.CreateByPointList(lists);
/*
* double gdistance = input.Features[0].BasicGeometry.Coordinates[0].Distance(input.Features[1].BasicGeometry.Coordinates[0]);
* double tdistance = Math.Sqrt(Math.Pow(input.Features[0].BasicGeometry.Coordinates[0].X- input.Features[1].BasicGeometry.Coordinates[0].X, 2) + Math.Pow(input.Features[0].BasicGeometry.Coordinates[0].Y- input.Features[1].BasicGeometry.Coordinates[0].Y, 2));
* Console.WriteLine("gdistance: " + gdistance + " , tdistance: " + tdistance);
*/
#endregion
if (neighborType == 0)//固定数目
{
for (int x = 0; x < numColumns; x++)
{
for (int y = 0; y < numRows; y++)
{
//IDW算法的分子和分母
double top = 0;
double bottom = 0;
if (pointCount > 0)
{
Coordinate coord = output.CellToProj(y, x);
KD_Point kD_Point = new KD_Point(coord.X, coord.Y);
List <KD_Point> points = kDTree.K_Nearest(kD_Point, pointCount);
//Console.WriteLine("KDTree points count: " + points.Count);
for (int i = 0; i < points.Count; i++)
{
if (points[i] != null)
{
Coordinate kd = new Coordinate(points[i].X, points[i].Y);
double distanceToCell = kd.Distance(coord);
if (distanceToCell <= distance || distance == 0)
{
//Console.WriteLine(points[i].Z);
if (power == 2)
{
top += (1 / (distanceToCell * distanceToCell)) * points[i].Z;
bottom += 1 / (distanceToCell * distanceToCell);
}
else
{
top += (1 / Math.Pow(distanceToCell, power)) * points[i].Z;
bottom += 1 / Math.Pow(distanceToCell, power);
}
}
}
}
}
else
{
for (int i = 0; i < input.Features.Count; i++)
{
Coordinate cellCenter = output.CellToProj(y, x);
//Coordinate coord = output.CellToProj(y, x);
var featurePt = input.Features[i];
if (featurePt != null)
{
double distanceToCell = cellCenter.Distance(featurePt.BasicGeometry.Coordinates[0]);
if (distanceToCell <= distance || distance == 0)
{
try
{
Convert.ToDouble(featurePt.DataRow[zField]);
}
catch
{
continue;
}
if (power == 2)
{
top += (1 / (distanceToCell * distanceToCell)) * Convert.ToDouble(featurePt.DataRow[zField]);
bottom += 1 / (distanceToCell * distanceToCell);
}
else
{
top += (1 / Math.Pow(distanceToCell, power)) * Convert.ToDouble(featurePt.DataRow[zField]);
bottom += 1 / Math.Pow(distanceToCell, power);
}
}
}
}
}
//Console.WriteLine("top: " + top + " , bottom: " +bottom);
output.Value[y, x] = top / bottom;
//Console.WriteLine(y + " , " + x + " : " + output.Value[y, x]);
//richText.Text += output.Value[y, x] + "\n";
progress.Value++;
}
}
}
output.Save();
return(true);
}
/// <summary>
/// Clips a raster with a polygon feature.
/// </summary>
/// <param name="polygon">The clipping polygon feature.</param>
/// <param name="input">The input raster object.</param>
/// <param name="outputFileName">the output raster file name.</param>
/// <param name="cancelProgressHandler">Progress handler for reporting progress status and cancelling the operation.</param>
/// <remarks>We assume there is only one part in the polygon.
/// Traverses the raster with a vertical scan line from left to right, bottom to top.</remarks>
/// <returns>The raster resulting from the clip operation.</returns>
public static IRaster ClipRasterWithPolygon(IFeature polygon, IRaster input, string outputFileName, ICancelProgressHandler cancelProgressHandler = null)
{
// if the polygon is completely outside the raster
if (!input.ContainsFeature(polygon))
{
return(input);
}
cancelProgressHandler?.Progress(16, "Retrieving the borders.");
List <Border> borders = GetBorders(polygon);
cancelProgressHandler?.Progress(33, "Copying raster.");
// create output raster
IRaster output = Raster.CreateRaster(outputFileName, input.DriverCode, input.NumColumns, input.NumRows, 1, input.DataType, new[] { string.Empty });
output.Bounds = input.Bounds.Copy();
output.NoDataValue = input.NoDataValue;
if (input.CanReproject)
{
output.Projection = input.Projection;
}
// set all initial values of Output to NoData
for (int i = 0; i < output.NumRows; i++)
{
for (int j = 0; j < output.NumColumns; j++)
{
output.Value[i, j] = output.NoDataValue;
}
}
double xStart = GetXStart(polygon, output);
int columnStart = GetStartColumn(polygon, output); // get the index of first column
ProgressMeter pm = new ProgressMeter(cancelProgressHandler, "Clipping Raster", output.NumColumns)
{
StepPercent = 5, StartValue = 33
};
int col = 0;
for (int columnCurrent = columnStart; columnCurrent < output.NumColumns; columnCurrent++)
{
var xCurrent = xStart + (col * output.CellWidth);
var intersections = GetYIntersections(borders, xCurrent);
intersections.Sort();
ParseIntersections(intersections, xCurrent, columnCurrent, output, input);
// update progess meter
pm.CurrentValue = xCurrent;
// update counter
col++;
// cancel if requested
if (cancelProgressHandler != null && cancelProgressHandler.Cancel)
{
return(null);
}
}
output.Save();
return(output);
}
/// <summary>
/// Executes the slope generation raster.
/// </summary>
/// <param name="ras">The input altitude raster.</param>
/// <param name="output">The output slope raster.</param>
/// <param name="cancelProgressHandler">The progress handler.</param>
/// <returns></returns>
public bool Execute(IRaster ras,double inZFactor, bool slopeInPercent,IRaster output, MapWindow.Tools.ICancelProgressHandler cancelProgressHandler)
{
//Validates the input and output data
if (ras == null || output == null)
{
return false;
}
double z1, z2, z3, z4, z5, z6, z7, z8, dZ_dx, dZ_dy, slope;
int current, previous;
try
{
int noOfCol = ras.NumColumns;
int noOfRow = ras.NumRows;
IEnvelope envelope1 = new Envelope() as IEnvelope;
envelope1 = ras.Bounds.Envelope;
output = Raster.Create(output.Filename, "", noOfCol, noOfRow, 1, typeof(double), new string[] { "" });
output.NoDataValue = ras.NoDataValue;
//output.Bounds = ras.Bounds.Copy();
output.Bounds = ras.Bounds;
previous = 0;
for (int i = 0; i < output.NumRows; i++)
{
current = Convert.ToInt32(Math.Round(i * 100D / output.NumRows));
//only update when increment in percentage
if (current > previous)
cancelProgressHandler.Progress("", current, current.ToString() + TextStrings.progresscompleted);
previous = current;
for (int j = 0; j < output.NumColumns; j++)
{
if (i > 0 && i < output.NumRows - 1 && j > 0 && j < output.NumColumns - 1)
{
z1 = ras.Value[i - 1, j - 1];
z2 = ras.Value[i - 1, j];
z3 = ras.Value[i - 1, j + 1];
z4 = ras.Value[i, j - 1];
z5 = ras.Value[i, j + 1];
z6 = ras.Value[i + 1, j - 1];
z7 = ras.Value[i + 1, j];
z8 = ras.Value[i + 1, j + 1];
//3rd Order Finite Difference slope algorithm
dZ_dx = inZFactor * ((z3 - z1) + 2 * (z5 - z4) + (z8 - z6)) / (8 * ras.CellWidth);
dZ_dy = inZFactor * ((z1 - z6) + 2 * (z2 - z7) + (z3 - z8)) / (8 * ras.CellHeight);
slope = Math.Atan(Math.Sqrt((dZ_dx * dZ_dx) + (dZ_dy * dZ_dy))) * (180 / Math.PI);
//change to radious and in persentage
if (slopeInPercent)
slope = (Math.Tan(slope * Math.PI / 180)) * 100;
output.Value[i, j] = slope;
if (cancelProgressHandler.Cancel == true)
return false;
}
else
output.Value[i, j] = output.NoDataValue;
if (cancelProgressHandler.Cancel == true)
return false;
}
}
//output = Temp;
if (output.IsFullyWindowed())
{
output.Save();
return true;
}
else
return false;
}
catch (Exception ex)
{
//throw new SystemException("Error in Slope: ", ex);
throw new SystemException(ex.ToString());
}
}
public bool ExecuteByParam(IFeatureSet input, string zField, double cellSize, string model, int neighborType, int pointCount, double distance, IRaster output, double c, double r)
{
if (input == null || output == null)
{
return(false);
}
if (cellSize == 0)
{
cellSize = input.Extent.Width / 255;
}
int numColumns = Convert.ToInt32(Math.Round(input.Extent.Width / cellSize));
int numRows = Convert.ToInt32(Math.Round(input.Extent.Height / cellSize));
progress.Maximum = numColumns * numRows;
progress.Value = 0;
output = Raster.CreateRaster(output.Filename, string.Empty, numColumns, numRows, 1, typeof(double), new[] { string.Empty });//error
output.CellHeight = cellSize;
output.CellWidth = cellSize;
output.Xllcenter = input.Extent.MinX + (cellSize / 2);
output.Yllcenter = input.Extent.MinY + (cellSize / 2);
List <AltitudePoint> points = new List <AltitudePoint>();
if (neighborType == 0)
{
#region 构建KD树
List <KD_Point> lists = new List <KD_Point>();//构建KD-Tree的点集列表
foreach (var p in input.Features)
{
KD_Point kd = new KD_Point(p.BasicGeometry.Coordinates[0].X, p.BasicGeometry.Coordinates[0].Y, Convert.ToDouble(p.DataRow[zField]));
lists.Add(kd);
}
KDTree kDTree = new KDTree();
kDTree.CreateByPointList(lists);
#endregion
if (pointCount > 0)
{
for (int i = 0; i < input.Features.Count; i++)
{
var featurePt = input.Features[i];
points.Add(new AltitudePoint(featurePt.BasicGeometry.Coordinates[0].X, featurePt.BasicGeometry.Coordinates[0].Y, Convert.ToDouble(featurePt.DataRow[zField])));
}
ForRasterData forRasterData = new ForRasterData(points, model);
for (int x = 0; x < numColumns; x++)
{
for (int y = 0; y < numRows; y++)
{
points.Clear();
Coordinate coord = output.CellToProj(y, x);
KD_Point kD_Point = new KD_Point(coord.X, coord.Y);
List <KD_Point> kdpoints = kDTree.K_Nearest(kD_Point, pointCount);
foreach (var p in kdpoints)
{
points.Add(new AltitudePoint(p.X, p.Y, p.Z));
}
forRasterData.ReSetPointList(points);
if (!forRasterData.IsPointsOK())
{
return(false);
}
output.Value[y, x] = forRasterData.GetValue(coord.X, coord.Y);
progress.Value++;
}
}
}
else
{
for (int i = 0; i < input.Features.Count; i++)
{
var featurePt = input.Features[i];
points.Add(new AltitudePoint(featurePt.BasicGeometry.Coordinates[0].X, featurePt.BasicGeometry.Coordinates[0].Y, Convert.ToDouble(featurePt.DataRow[zField])));
}
ForRasterData forRasterData = new ForRasterData(points, model, c, r);
if (!forRasterData.IsPointsOK())
{
return(false);
}
for (int x = 0; x < numColumns; x++)
{
for (int y = 0; y < numRows; y++)
{
Coordinate coordinate = output.CellToProj(y, x);
output.Value[y, x] = forRasterData.GetValue(coordinate.X, coordinate.Y);
progress.Value++;
}
}
}
}
output.Save();
return(true);
}
/// <summary>
/// Executes the threshold operation
/// </summary>
/// <param name="input1">The input raster</param>
/// <param name="threshold">The threshold value</param>
/// <param name="output">The output raster</param>
/// <param name="cancelProgressHandler">The progress handler</param>
/// <returns></returns>
public bool Execute(IRaster input, double threshold, IRaster output, MapWindow.Tools.ICancelProgressHandler cancelProgressHandler)
{
//Validates the input and output data
if (input == null || output == null)
{
return false;
}
int noOfCol=input.NumColumns;
int noOfRow=input.NumRows;
int previous = 0;
int current = 0;
//Create the new raster with the appropriate dimensions
output = Raster.Create(output.Filename, "", noOfCol, noOfRow,1 , typeof(int), new string[] { "" });
output.CellWidth = input.CellWidth;
output.CellHeight = input.CellHeight;
output.Xllcenter = input.Xllcenter;
output.Yllcenter = input.Yllcenter;
output.NoDataValue = -1;
//Loop throug every cell
int max = (output.Bounds.NumRows + 1);
for (int i = 0; i < output.NumRows; i++)
{
for (int j = 0; j < output.NumColumns; j++)
{
if (input.Value[i, j] == input.NoDataValue)
output.Value[i,j] = -1;
else if (input.Value[i, j] >= threshold)
output.Value[i,j] = 1;
else
output.Value[i,j] = 0;
if (cancelProgressHandler.Cancel == true)
return false;
}
//only update when increment in persentage
current = Convert.ToInt32(Math.Round(i * 100D / max));
if (current > previous)
cancelProgressHandler.Progress("", current, current.ToString() + "% progress completed");
previous = current;
}
output.Save();
return true;
}
public override bool Execute(DotSpatial.Data.ICancelProgressHandler cancelProgressHandler)
{
int progress = 0;
int count = 1;
int ndays = 174;
if (senseor == 5)
{
ndays = 174;
}
else
{
ndays = 56;
}
//string lake_centroid = @"E:\Project\HRB\Badan Jarian\Data\Geospatial\mask_centroid.shp";
string lake_centroid = @"E:\Project\HRB\Badan Jarian\Data\Geospatial\mask_centroid_selected.shp";
var lake_centroid_fs = FeatureSet.Open(lake_centroid);
DataTable centroid_dt = lake_centroid_fs.DataTable;
//var lake_list = (from DataRow dr in centroid_dt.Rows where dr["Flag"].ToString() == "1" select int.Parse(dr["Id"].ToString())).ToList();
// var lake_list = new int[] { 1,18,19,28,30,35,41,49,50,55,57,58,59,60,63,89,91,97,99,100,112,113,118,133,135,136,160,169,181,183};
var lake_list = new int[] { 59 };
int nlakes = lake_list.Length;
double [,] water_area = new double[ndays, nlakes];
double[,] water_bond_area = new double[ndays, nlakes];
for (int K = 0; K < nlakes; K++)
{
int lake_id = lake_list[K];
var dr_lake = (from DataRow dr in centroid_dt.Rows where dr["Id"].ToString() == lake_id.ToString() select dr).First();
string img_dir = Path.Combine(FileDirectory, lake_id.ToString());
StreamReader sr_date_list = new StreamReader(Path.Combine(img_dir, "date_list.txt"));
int nfile = 0;
while (!sr_date_list.EndOfStream)
{
sr_date_list.ReadLine();
nfile++;
}
sr_date_list.Close();
sr_date_list = new StreamReader(Path.Combine(img_dir, "date_list.txt"));
string[] dirs = new string[nfile];
for (int i = 0; i < nfile; i++)
{
var str = sr_date_list.ReadLine();
dirs[i] = Path.Combine(img_dir, str + "_cmb.tif");
}
string class_file_list = Path.Combine(img_dir, @"class\class_list.txt");
StreamWriter sw_area = new StreamWriter(Path.Combine(img_dir, "class\\area.csv"));
FileStream fs_class = new FileStream(class_file_list, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
StreamReader sr_class_file = new StreamReader(fs_class);
var center_pt = new Coordinate(double.Parse(dr_lake["X"].ToString()), double.Parse(dr_lake["Y"].ToString()));
int cell_area = 5 * 5;
int date_index = 0;
try
{
foreach (var file in dirs)
{
int water_cell_count = 0;
int water_bound_cell_count = 0;
var temp = Path.GetFileNameWithoutExtension(file);
var daystr = temp.Remove(10);
var water_file = file.Replace("_cmb", "_water");
IRaster raster2 = Raster.OpenFile(file);
raster2.SaveAs(water_file);
IRaster raster_water = Raster.OpenFile(water_file);
var class_file = sr_class_file.ReadLine();
var class_mat = ReadClassFile(class_file, raster2.NumRows, raster2.NumColumns);
for (int i = 0; i < raster2.NumRows; i++)
{
for (int j = 0; j < raster2.NumColumns; j++)
{
if (raster2.Value[i, j] != raster2.NoDataValue)
{
raster_water.Value[i, j] = class_mat[i][j];
}
else
{
raster_water.Value[i, j] = raster2.NoDataValue;
}
}
}
var cell = raster2.ProjToCell(center_pt);
var center_class = raster_water.Value[cell.Row, cell.Column];
var center_bound_class = center_class;
for (int i = cell.Row + 1; i < raster2.NumRows; i++)
{
if (raster_water.Value[i, cell.Column] != center_class)
{
center_bound_class = raster_water.Value[i, cell.Column];
break;
}
}
if (center_bound_class == center_class)
{
for (int i = cell.Column + 1; i < raster2.NumColumns; i++)
{
if (raster_water.Value[cell.Row, i] != center_class)
{
center_bound_class = raster_water.Value[cell.Row, i];
break;
}
}
}
for (int i = 0; i < raster2.NumRows; i++)
{
for (int j = 0; j < raster2.NumColumns; j++)
{
if (raster2.Value[i, j] != raster2.NoDataValue)
{
if (raster_water.Value[i, j] == center_class)
{
water_cell_count++;
}
if (raster_water.Value[i, j] == center_bound_class)
{
water_bound_cell_count++;
}
}
}
}
water_area[date_index, K] = water_cell_count * cell_area;
water_bond_area[date_index, K] = water_bound_cell_count * cell_area;
sw_area.WriteLine(string.Format("{0},{1},{2},{3}", daystr, water_area[date_index, K], water_bond_area[date_index, K],
water_area[date_index, K] + water_bond_area[date_index, K]));
raster_water.Save();
raster_water.Close();
date_index++;
}
}
catch (Exception ex)
{
cancelProgressHandler.Progress("Package_Tool", 100, "Error: " + ex.Message);
}
finally
{
sw_area.Close();
sr_class_file.Close();
sr_date_list.Close();
}
progress = K * 100 / nlakes;
//if (progress > count)
//{
cancelProgressHandler.Progress("Package_Tool", progress, "Processing lake " + lake_id);
count++;
// }
}
string lake_area_file = Path.Combine(FileDirectory, "water_area.csv");
string lake_area_bond_file = Path.Combine(FileDirectory, "waterbond_area.csv");
StreamWriter csv_water = new StreamWriter(lake_area_file);
StreamWriter csv_bond = new StreamWriter(lake_area_bond_file);
var line = string.Join(",", lake_list.ToArray());
csv_water.WriteLine(line);
csv_bond.WriteLine(line);
for (int t = 0; t < ndays; t++)
{
line = "";
for (int j = 0; j < nlakes; j++)
{
line += water_area[t, j] + ",";
}
line = line.TrimEnd(new char[] { ',' });
csv_water.WriteLine(line);
line = "";
for (int j = 0; j < nlakes; j++)
{
line += water_bond_area[t, j] + ",";
}
line = line.TrimEnd(new char[] { ',' });
csv_bond.WriteLine(line);
}
csv_water.Close();
csv_bond.Close();
lake_centroid_fs.Close();
return(true);
}
/// <summary>
/// Executes the Area tool with programatic input
/// Ping delete static for external testing.
/// </summary>
/// <param name="input">The input raster.</param>
/// <param name="zField">The field name containing the values to interpolate.</param>
/// <param name="cellSize">The double geographic size of the raster cells to create.</param>
/// <param name="power">The double power representing the inverse.</param>
/// <param name="neighborType">Fixed distance of fixed number of neighbors.</param>
/// <param name="pointCount">The number of neighbors to include if the neighborhood type
/// is Fixed.</param>
/// <param name="distance">Points further from the raster cell than this distance are not included
/// in the calculation if the neighborhood type is Fixed Distance.</param>
/// <param name="output">The output raster where values are stored. The fileName is used, but the number
/// of rows and columns will be computed from the cellSize and input featureset.</param>
/// <param name="cancelProgressHandler">A progress handler for receiving progress messages.</param>
/// <returns>A boolean, true if the IDW process worked correctly.</returns>
public bool Execute(IFeatureSet input, string zField, double cellSize, double power, NeighborhoodType neighborType, int pointCount, double distance, IRaster output, ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (input == null || output == null)
{
return(false);
}
// If the cellSize is 0 we calculate a cell size based on the input extents
if (cellSize == 0)
{
cellSize = input.Extent.Width / 255;
}
// Defines the dimensions and position of the raster
int numColumns = Convert.ToInt32(Math.Round(input.Extent.Width / cellSize));
int numRows = Convert.ToInt32(Math.Round(input.Extent.Height / cellSize));
output = Raster.CreateRaster(output.Filename, string.Empty, numColumns, numRows, 1, typeof(double), new[] { string.Empty });
output.CellHeight = cellSize;
output.CellWidth = cellSize;
output.Xllcenter = input.Extent.MinX + (cellSize / 2);
output.Yllcenter = input.Extent.MinY + (cellSize / 2);
// Used to calculate progress
int lastUpdate = 0;
// Populates the KD tree
var kd = new KdTreeEx <IFeature>();
List <int> randomList = new();
for (int i = 0; i < input.Features.Count; i++)
{
randomList.Add(i);
}
Random rnd = new();
List <int> completed = new();
while (randomList.Count > 0)
{
int index = rnd.Next(0, randomList.Count - 1);
Coordinate coord = input.Features[randomList[index]].Geometry.Coordinates[0];
while (kd.Search(coord) != null)
{
coord.X *= 1.000000000000001D;
}
kd.Insert(coord, input.Features[randomList[index]]);
completed.Add(randomList[index]);
randomList.RemoveAt(index);
}
if (neighborType == NeighborhoodType.FixedCount)
{
// we add all the old features to output
for (int x = 0; x < numColumns; x++)
{
for (int y = 0; y < numRows; y++)
{
// Gets the pointCount number of cells closest to the current cell
Coordinate cellCenter = output.CellToProj(y, x);
var coord = output.CellToProj(y, x);
var result = kd.NearestNeighbor(coord);
var featurePt = result?.Data;
if (featurePt != null)
{
// Sets up the IDW numerator and denominator
double top = 0;
double bottom = 0;
double distanceToCell = cellCenter.Distance(featurePt.Geometry.Coordinates[0]);
if (distanceToCell <= distance || distance == 0)
{
// If we can't convert the value to a double throw it out
try
{
Convert.ToDouble(featurePt.DataRow[zField]);
}
catch
{
continue;
}
if (power == 2)
{
top += (1 / (distanceToCell * distanceToCell)) * Convert.ToDouble(featurePt.DataRow[zField]);
bottom += 1 / (distanceToCell * distanceToCell);
}
else
{
top += (1 / Math.Pow(distanceToCell, power)) * Convert.ToDouble(featurePt.DataRow[zField]);
bottom += 1 / Math.Pow(distanceToCell, power);
}
}
output.Value[y, x] = top / bottom;
}
}
// Checks if we need to update the status bar
if (Convert.ToInt32(Convert.ToDouble(x * numRows) / Convert.ToDouble(numColumns * numRows) * 100) > lastUpdate)
{
lastUpdate = Convert.ToInt32(Convert.ToDouble(x * numRows) / Convert.ToDouble(numColumns * numRows) * 100);
cancelProgressHandler.Progress(lastUpdate, "Cell: " + (x * numRows) + " of " + (numColumns * numRows));
if (cancelProgressHandler.Cancel)
{
return(false);
}
}
}
}
output.Save();
return(true);
}
/// <summary>
/// Executes the ReSample Opaeration tool programmatically
/// Ping deleted the static property for external testing.
/// </summary>
/// <param name="input1">The input raster.</param>
/// <param name="newCellHeight">The size of the cell's hight.</param>
/// <param name="newCellWidth">The size of the cell's width.</param>
/// <param name="output">The output raster.</param>
/// <param name="cancelProgressHandler">The progress handler.</param>
/// <returns>Boolean, true if the method was successful.</returns>
public bool Execute(IRaster input1, double newCellHeight, double newCellWidth, IRaster output, ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (input1 == null || newCellWidth == 0 || output == null)
{
return(false);
}
Extent envelope = input1.Bounds.Extent;
// Calculate new number of columns and rows
int noOfCol = Convert.ToInt32(Math.Abs(envelope.Width / newCellWidth));
int noOfRow = Convert.ToInt32(Math.Abs(envelope.Height / newCellHeight));
int previous = 0;
// create output raster
output = Raster.CreateRaster(output.Filename, string.Empty, noOfCol, noOfRow, 1, input1.DataType, new[] { string.Empty });
RasterBounds bound = new(noOfRow, noOfCol, envelope);
output.Bounds = bound;
output.NoDataValue = input1.NoDataValue;
// Loop throug every cell for new value
int max = output.Bounds.NumRows + 1;
for (int i = 0; i < output.Bounds.NumRows; i++)
{
for (int j = 0; j < output.Bounds.NumColumns; j++)
{
// Projet the cell position to Map
Coordinate cellCenter = output.CellToProj(i, j);
var index1 = input1.ProjToCell(cellCenter);
double val;
if (index1.Row <= input1.EndRow && index1.Column <= input1.EndColumn && index1.Row > -1 && index1.Column > -1)
{
val = input1.Value[index1.Row, index1.Column] == input1.NoDataValue ? output.NoDataValue : input1.Value[index1.Row, index1.Column];
}
else
{
val = output.NoDataValue;
}
output.Value[i, j] = val;
if (cancelProgressHandler.Cancel)
{
return(false);
}
}
int current = Convert.ToInt32(Math.Round(i * 100D / max));
// only update when increment in persentage
if (current > previous)
{
cancelProgressHandler.Progress(current, current + TextStrings.progresscompleted);
}
previous = current;
}
output.Save();
return(true);
}
/// <summary>
/// Executes the Raster distance calculation
/// Ping Yang deleted static for external testing 10/2010.
/// </summary>
/// <param name="input">The input raster.</param>
/// <param name="output">The output raster.</param>
/// <param name="maxDistance">The maximum distance value. Cells with a larger distance to nearest
/// target cell than maxDistance will be assigned 'no data' value.</param>
/// <param name="cancelProgressHandler">The progress handler.</param>
/// <returns>true if execution was successful, false otherwise.</returns>
public bool Execute(IRaster input, IRaster output, double maxDistance, ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (input == null || output == null)
{
return(false);
}
// Creates the output raster with the same bounds as the input
RasterBounds bounds = (RasterBounds)input.Bounds.Copy();
output = Raster.CreateRaster(output.Filename, string.Empty, bounds.NumColumns, bounds.NumRows, 1, typeof(int), new[] { string.Empty });
output.Bounds = bounds;
// internally we reference output as an integer type raster.
if (output is Raster <int> outRaster)
{
int numColumns = outRaster.NumColumns;
int numRows = outRaster.NumRows;
int lastUpdate = 0;
// declare two jagged arrays for storing the (Rx, Ry) vectors.
// rX is distance from current cell to nearest target cell measured in the x-direction
// rY is distance from current cell to nearest target cell measured in the y-direction
// the actual distance can be calculated as sqrt(rX^2 + rY^2).
// in the resulting distance raster we store the squared distance as well as the rX, rY relative coordinates
// to improve computation speed
int[][] aRx = new int[numRows][];
int[][] aRy = new int[numRows][];
int[][] aSqDist = new int[numRows][];
const int InfD = int.MaxValue;
const int TargetVal = 0;
// initialize the arrays
for (int i = 0; i < numRows; i++)
{
aRx[i] = new int[numColumns];
aRy[i] = new int[numColumns];
aSqDist[i] = new int[numColumns];
ReadInputRow(input, i, aSqDist[i], TargetVal, InfD);
}
// *******************************************************************
// raster distance calculation pass one - top to bottom, left to right
// *******************************************************************
// int[] row1 = new int[numColumns];
// int[] row2 = new int[numColumns];
int[] aNcels = new int[4]; // the values of four neighbouring cells (W, NW, N, NE)
int[] aDiff = new int[4]; // the | y coordinate distances to nearest target cell
for (int row = 1; row < numRows; row++)
{
//// read the row from input raster
// ReadInputRow(input, rowIndex, row2, targetVal, infD);
for (int col = 1; col < numColumns - 1; col++)
{
int val = aSqDist[row][col];
// Continue processing only if the current cell is not a target
if (val == TargetVal)
{
continue;
}
// read the values of the cell's neighbours
aNcels[0] = aSqDist[row][col - 1]; // W
aNcels[1] = aSqDist[row - 1][col - 1]; // NW
aNcels[2] = aSqDist[row - 1][col]; // N
aNcels[3] = aSqDist[row - 1][col + 1]; // NE
// calculate the squared euclidean distances to each neighbouring cell and to the nearest target cell
aDiff[0] = (aNcels[0] < InfD) ? aNcels[0] + (2 * aRx[row][col - 1]) + 1 : InfD;
aDiff[1] = (aNcels[1] < InfD) ? aNcels[1] + (2 * (aRx[row - 1][col - 1] + aRy[row - 1][col - 1] + 1)) : InfD;
aDiff[2] = (aNcels[2] < InfD) ? aNcels[2] + (2 * aRy[row - 1][col]) + 1 : InfD;
aDiff[3] = (aNcels[3] < InfD) ? aNcels[3] + (2 * (aRx[row - 1][col + 1] + aRy[row - 1][col + 1] + 1)) : InfD;
// find neighbouring cell with minimum distance difference
int minDiff = aDiff[0];
int minDiffCell = 0;
for (int i = 1; i < 4; i++)
{
if (aDiff[i] < minDiff)
{
minDiff = aDiff[i];
minDiffCell = i;
}
}
// if a neighbouring cell with known distance was found:
if (minDiff < InfD)
{
// assign the minimum euclidean distance
aSqDist[row][col] = minDiff;
// update the (rX, rY) cell-to-nearest-target vector
switch (minDiffCell)
{
case 0: // W
aRx[row][col] = aRx[row][col - 1] + 1;
aRy[row][col] = aRy[row][col - 1];
break;
case 1: // NW
aRx[row][col] = aRx[row - 1][col - 1] + 1;
aRy[row][col] = aRy[row - 1][col - 1] + 1;
break;
case 2: // N
aRx[row][col] = aRx[row - 1][col];
aRy[row][col] = aRy[row - 1][col] + 1;
break;
case 3: // NE
aRx[row][col] = aRx[row - 1][col + 1] + 1;
aRy[row][col] = aRy[row - 1][col + 1] + 1;
break;
}
}
// end of update (rX, rY) cell-to-nearest-target vector
}
// end or current row processing - report progress
int percent = (int)(row / (double)numRows * 100f);
if (percent > lastUpdate)
{
lastUpdate += 1;
cancelProgressHandler.Progress(lastUpdate, TextStrings.Pass1 + lastUpdate + TextStrings.progresscompleted);
if (cancelProgressHandler.Cancel)
{
return(false);
}
}
}
// *******************************************************************
// end of first pass for loop
// *******************************************************************
// *******************************************************************
// raster distance calculation PASS TWO - bottom to top, right to left
// *******************************************************************
lastUpdate = 0;
for (int row = numRows - 2; row > 0; row--)
{
for (int col = numColumns - 2; col > 0; col--)
{
int val = aSqDist[row][col];
// Continue processing only if the current cell is not a target
if (val == TargetVal)
{
continue;
}
// read the values of the cell's neighbours
aNcels[0] = aSqDist[row][col + 1]; // E
aNcels[1] = aSqDist[row + 1][col + 1]; // SE
aNcels[2] = aSqDist[row + 1][col]; // S
aNcels[3] = aSqDist[row + 1][col - 1]; // SW
// calculate the squared euclidean distances to each neighbouring cell and to the nearest target cell
aDiff[0] = (aNcels[0] < InfD) ? aNcels[0] + (2 * aRx[row][col + 1]) + 1 : InfD;
aDiff[1] = (aNcels[1] < InfD) ? aNcels[1] + (2 * (aRx[row + 1][col + 1] + aRy[row + 1][col + 1] + 1)) : InfD;
aDiff[2] = (aNcels[2] < InfD) ? aNcels[2] + (2 * aRy[row + 1][col]) + 1 : InfD;
aDiff[3] = (aNcels[3] < InfD) ? aNcels[3] + (2 * (aRx[row + 1][col - 1] + aRy[row + 1][col - 1] + 1)) : InfD;
// find neighbouring cell with minimum distance difference
int minDiff = aDiff[0];
int minDiffCell = 0;
for (int i = 1; i < 4; i++)
{
if (aDiff[i] < minDiff)
{
minDiff = aDiff[i];
minDiffCell = i;
}
}
// if a neighbouring cell with known distance smaller than current known distance was found:
if (minDiff < val)
{
// assign the minimum euclidean distance
aSqDist[row][col] = minDiff;
// update the (rX, rY) cell-to-nearest-target vector
switch (minDiffCell)
{
case 0: // E
aRx[row][col] = aRx[row][col + 1] + 1;
aRy[row][col] = aRy[row][col + 1];
break;
case 1: // SE
aRx[row][col] = aRx[row + 1][col + 1] + 1;
aRy[row][col] = aRy[row + 1][col + 1] + 1;
break;
case 2: // S
aRx[row][col] = aRx[row + 1][col];
aRy[row][col] = aRy[row + 1][col] + 1;
break;
case 3: // SW
aRx[row][col] = aRx[row + 1][col - 1] + 1;
aRy[row][col] = aRy[row + 1][col - 1] + 1;
break;
}
}
// end of update (rX, rY) cell-to-nearest-target vector
}
// Write row to output raster
WriteOutputRow(outRaster, row, aSqDist[row]);
// Report progress
int percent = (int)(row / (double)numRows * 100f);
if (percent > lastUpdate)
{
lastUpdate += 1;
cancelProgressHandler.Progress(lastUpdate, TextStrings.Pass2 + lastUpdate + TextStrings.progresscompleted);
if (cancelProgressHandler.Cancel)
{
return(false);
}
}
}
}
// *******************************************************************
// end of second pass proximity calculation loop
// *******************************************************************
// save output raster
output.Save();
return(true);
}
/// <summary>
/// Generates a new raster given the specified featureset. Values will be given to
/// each cell that coincide with the values in the specified field of the attribute
/// table. If the cellSize is 0, then it will be automatically calculated so that
/// the smaller dimension (between width and height) is 256 cells.
/// Ping Yang delete static for external testing 01/2010
/// </summary>
/// <param name="source">The featureset to convert into a vector format</param>
/// <param name="cellSize">A double giving the geographic cell size.</param>
/// <param name="fieldName">The string fieldName to use</param>
/// <param name="output">The raster that will be created</param>
/// <param name="cancelProgressHandler">A progress handler for handling progress messages</param>
/// <returns></returns>
public bool Execute(IFeatureSet source, double cellSize, string fieldName, IRaster output, ICancelProgressHandler cancelProgressHandler)
{
//Validates the input and output data
if (source == null || output == null)
{
return false;
}
output = MapWindow.Analysis.VectorToRaster.ToRaster(source, ref cellSize, fieldName, output.Filename, "", new string[]{}, cancelProgressHandler);
output.Save();
return true;
}
/// <summary>
/// Executes the slope generation raster.
/// </summary>
/// <param name="ras">The input altitude raster.</param>
/// <param name="inZFactor">A multiplicative scaling factor to be applied to the elevation values before calculating the slope.</param>
/// <param name="slopeInPercent">If this is true, the resulting slopes are returned as percentages.</param>
/// <param name="output">The output slope raster.</param>
/// <param name="cancelProgressHandler">The progress handler.</param>
/// <returns>True if the method worked.</returns>
public bool Execute(
IRaster ras,
double inZFactor,
bool slopeInPercent,
IRaster output,
ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (ras == null || output == null)
{
return false;
}
try
{
int noOfCol = ras.NumColumns;
int noOfRow = ras.NumRows;
output = Raster.CreateRaster(
output.Filename, string.Empty, noOfCol, noOfRow, 1, typeof(double), new[] { string.Empty });
output.NoDataValue = ras.NoDataValue;
// output.Bounds = ras.Bounds.Copy();
output.Bounds = ras.Bounds;
int previous = 0;
for (int i = 0; i < output.NumRows; i++)
{
int current = Convert.ToInt32(Math.Round(i * 100D / output.NumRows));
// only update when increment in percentage
if (current > previous)
{
cancelProgressHandler.Progress(string.Empty, current, current + TextStrings.progresscompleted);
}
previous = current;
for (int j = 0; j < output.NumColumns; j++)
{
if (i > 0 && i < output.NumRows - 1 && j > 0 && j < output.NumColumns - 1)
{
double z1 = ras.Value[i - 1, j - 1];
double z2 = ras.Value[i - 1, j];
double z3 = ras.Value[i - 1, j + 1];
double z4 = ras.Value[i, j - 1];
double z5 = ras.Value[i, j + 1];
double z6 = ras.Value[i + 1, j - 1];
double z7 = ras.Value[i + 1, j];
double z8 = ras.Value[i + 1, j + 1];
// 3rd Order Finite Difference slope algorithm
double dZdX = inZFactor * ((z3 - z1) + 2 * (z5 - z4) + (z8 - z6)) / (8 * ras.CellWidth);
double dZdY = inZFactor * ((z1 - z6) + 2 * (z2 - z7) + (z3 - z8)) / (8 * ras.CellHeight);
double slope = Math.Atan(Math.Sqrt((dZdX * dZdX) + (dZdY * dZdY))) * (180 / Math.PI);
// change to radious and in persentage
if (slopeInPercent)
{
slope = Math.Tan(slope * Math.PI / 180) * 100;
}
output.Value[i, j] = slope;
if (cancelProgressHandler.Cancel)
{
return false;
}
}
else
{
output.Value[i, j] = output.NoDataValue;
}
if (cancelProgressHandler.Cancel)
{
return false;
}
}
}
// output = Temp;
if (output.IsFullyWindowed())
{
output.Save();
return true;
}
return false;
}
catch (Exception ex)
{
// throw new SystemException("Error in Slope: ", ex);
throw new SystemException(ex.ToString());
}
}
/// <summary>
/// Executes the Erase Opaeration tool programaticaly
/// </summary>
/// <param name="input1">The input raster</param>
/// <param name="input2">The input raster</param>
/// <param name="output">The output raster</param>
/// <param name="cancelProgressHandler">The progress handler</param>
/// <returns></returns>
public bool Execute(IRaster input1, IRaster input2, IRaster output, MapWindow.Tools.ICancelProgressHandler cancelProgressHandler)
{
//Validates the input and output data
if (input1 == null || input2 == null || output == null)
{
return false;
}
IEnvelope envelope = new Envelope() as IEnvelope;
envelope = UnionEnvelope(input1, input2);
int noOfCol;
int noOfRow;
//Figures out which raster has smaller cells
IRaster smallestCellRaster;
if (input1.CellWidth < input2.CellWidth) smallestCellRaster = input1;
else smallestCellRaster = input2;
//Given the envelope of the two rasters we calculate the number of columns / rows
noOfCol = Convert.ToInt32(Math.Abs(envelope.Width / smallestCellRaster.CellWidth));
noOfRow = Convert.ToInt32(Math.Abs(envelope.Height / smallestCellRaster.CellHeight));
//Create the new raster with the appropriate dimensions
Raster Temp = new Raster();
//Temp.CreateNew(output.Filename, noOfRow, noOfCol, input1.DataType);
Temp.CreateNew(output.Filename, "", noOfCol, noOfRow, 1, input1.DataType, new string[] { "" });
Temp.CellWidth = smallestCellRaster.CellWidth;
Temp.CellHeight = smallestCellRaster.CellHeight;
Temp.Xllcenter = envelope.Minimum.X + (Temp.CellWidth / 2);
Temp.Yllcenter = envelope.Minimum.Y + (Temp.CellHeight / 2);
MapWindow.Geometries.ICoordinate I1 = new MapWindow.Geometries.Coordinate() as MapWindow.Geometries.ICoordinate;
RcIndex v1 = new RcIndex();
RcIndex v2 = new RcIndex();
double val1;
double val2;
int previous=0;
int current=0;
int max = (Temp.Bounds.NumRows + 1);
for (int i = 0; i < Temp.Bounds.NumRows; i++)
{
for (int j = 0; j < Temp.Bounds.NumColumns; j++)
{
I1 = Temp.CellToProj(i, j);
v1 = input1.ProjToCell(I1);
if (v1.Row <= input1.EndRow && v1.Column <= input1.EndColumn && v1.Row > -1 && v1.Column > -1)
val1 = input1.Value[v1.Row, v1.Column];
else
val1 = input1.NoDataValue;
v2 = input2.ProjToCell(I1);
if (v2.Row <= input2.EndRow && v2.Column <= input2.EndColumn && v2.Row > -1 && v2.Column > -1)
val2 = input2.Value[v2.Row, v2.Column];
else
val2 = input2.NoDataValue;
if (val1 == input1.NoDataValue && val2 == input2.NoDataValue)
{
Temp.Value[i, j] = Temp.NoDataValue;
}
else if (val1 != input1.NoDataValue && val2 == input2.NoDataValue)
{
Temp.Value[i, j] = val1;
}
else if (val1 == input1.NoDataValue && val2 != input2.NoDataValue)
{
Temp.Value[i, j] = val2;
}
else
{
Temp.Value[i, j] = val1;
}
if (cancelProgressHandler.Cancel == true)
return false;
}
current = Convert.ToInt32(Math.Round(i * 100D / max));
//only update when increment in persentage
if(current>previous)
cancelProgressHandler.Progress("", current, current.ToString() + "% progress completed");
previous = current;
}
output = Temp;
output.Save();
return true;
}
/// <summary>
/// Executes the Erase Opaeration tool programaticaly.
/// </summary>
/// <param name="input1">The input raster.</param>
/// <param name="input2">The input raster.</param>
/// <param name="output">The output raster.</param>
/// <param name="cancelProgressHandler">The progress handler.</param>
/// <returns></returns>
public bool Execute(IRaster input1, IFeatureSet input2, IRaster output, MapWindow.Tools.ICancelProgressHandler cancelProgressHandler)
{
//Validates the input and output data
if (input1 == null || input2 == null || output == null)
{
return false;
}
int noOfCol = input1.NumColumns;
int noOfRow = input1.NumRows;
//Calculate the Intersect Envelope
IEnvelope envelope1 = new Envelope() as IEnvelope;
IEnvelope envelope2 = new Envelope() as IEnvelope;
envelope1 = input1.Bounds.Envelope;
envelope2 = input2.Envelope;
envelope1 = envelope1.Intersection(envelope2);
//Create the new raster with the appropriate dimensions
IRaster Temp = Raster.Create(output.Filename, "", noOfCol, noOfRow, 1, input1.DataType, new string[] { });
//Temp.CreateNew(output.Filename, noOfRow, noOfCol, input1.DataType);
Temp.CellWidth = input1.CellWidth;
Temp.CellHeight = input1.CellHeight;
Temp.Xllcenter = envelope1.Minimum.X + (Temp.CellWidth / 2);
Temp.Yllcenter = envelope1.Minimum.Y + (Temp.CellHeight / 2);
MapWindow.Geometries.ICoordinate I1 = new MapWindow.Geometries.Coordinate() as MapWindow.Geometries.ICoordinate;
RcIndex v1 = new RcIndex();
// MapWindow.Analysis.Topology.Algorithm.PointLocator pointLocator1 = new MapWindow.Analysis.Topology.Algorithm.PointLocator();
double val1;
int previous = 0;
int current = 0;
int max = (Temp.Bounds.NumRows + 1);
for (int i = 0; i < Temp.Bounds.NumRows; i++)
{
for (int j = 0; j < Temp.Bounds.NumColumns; j++)
{
I1 = Temp.CellToProj(i, j);
v1 = input1.ProjToCell(I1);
if (v1.Row <= input1.EndRow && v1.Column <= input1.EndColumn && v1.Row > -1 && v1.Column > -1)
val1 = input1.Value[v1.Row, v1.Column];
else
val1 = Temp.NoDataValue;
//test if the coordinate is inside of the polygon
bool isInside = false;
IFeature pointFeat = new Feature(new Point(I1)) as IFeature;
foreach (IFeature f in input2.Features)
{
if (f.Contains(pointFeat))
{
Temp.Value[i, j] = val1;
isInside = true;
break;
}
}
if (isInside == false)
{
Temp.Value[i, j] = Temp.NoDataValue;
}
if (cancelProgressHandler.Cancel == true)
return false;
}
current = Convert.ToInt32(Math.Round(i * 100D / max));
//only update when increment in percentage
if (current > previous)
cancelProgressHandler.Progress("", current, current.ToString() + "% progress completed");
previous = current;
}
output = Temp;
output.Save();
return true;
}
/// <summary>
/// Executes the Erase Opaeration tool programaticaly
/// Ping Yang deleted static for external testing 01/2010
/// </summary>
/// <param name="input">The input raster</param>
/// <param name="oldValue">The original double value representing no-data</param>
/// <param name="newValue">The new double value representing no-data</param>
/// <param name="output">The output raster</param>
/// <param name="cancelProgressHandler">The progress handler</param>
/// <returns></returns>
public bool Execute(
IRaster input,
double oldValue,
double newValue,
IRaster output,
ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (input == null || newValue == 0 || output == null)
{
return(false);
}
Extent envelope = input.Bounds.Extent;
int noOfCol = input.NumColumns;
int noOfRow = input.NumRows;
int previous = 0;
Type dataType = input.DataType;
// create output raster
output = Raster.CreateRaster(
output.Filename, string.Empty, noOfCol, noOfRow, 1, dataType, new[] { string.Empty });
RasterBounds bound = new RasterBounds(noOfRow, noOfCol, envelope);
output.Bounds = bound;
output.NoDataValue = newValue;
// Loop throug every cell
int max = output.Bounds.NumRows + 1;
for (int i = 0; i < output.Bounds.NumRows; i++)
{
for (int j = 0; j < output.Bounds.NumColumns; j++)
{
if (input.Value[i, j] == oldValue)
{
output.Value[i, j] = newValue;
}
else
{
output.Value[i, j] = input.Value[i, j];
}
if (cancelProgressHandler.Cancel)
{
return(false);
}
}
int current = Convert.ToInt32(Math.Round(i * 100D / max));
// only update when increment in persentage
if (current > previous)
{
cancelProgressHandler.Progress(string.Empty, current, current + TextStrings.progresscompleted);
}
previous = current;
}
// output = Temp;
output.Save();
return(true);
}
/// <summary>
/// Executes the slope generation raster.
/// </summary>
/// <param name="ras">The input altitude raster.</param>
/// <param name="inZFactor">A multiplicative scaling factor to be applied to the elevation values before calculating the slope.</param>
/// <param name="slopeInPercent">If this is true, the resulting slopes are returned as percentages.</param>
/// <param name="output">The output slope raster.</param>
/// <param name="cancelProgressHandler">The progress handler.</param>
/// <returns>True if the method worked.</returns>
public bool Execute(
IRaster ras,
double inZFactor,
bool slopeInPercent,
IRaster output,
ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (ras == null || output == null)
{
return(false);
}
try
{
int noOfCol = ras.NumColumns;
int noOfRow = ras.NumRows;
output = Raster.CreateRaster(
output.Filename, string.Empty, noOfCol, noOfRow, 1, typeof(double), new[] { string.Empty });
output.NoDataValue = ras.NoDataValue;
// output.Bounds = ras.Bounds.Copy();
output.Bounds = ras.Bounds;
int previous = 0;
for (int i = 0; i < output.NumRows; i++)
{
int current = Convert.ToInt32(Math.Round(i * 100D / output.NumRows));
// only update when increment in percentage
if (current > previous)
{
cancelProgressHandler.Progress(string.Empty, current, current + TextStrings.progresscompleted);
}
previous = current;
for (int j = 0; j < output.NumColumns; j++)
{
if (i > 0 && i < output.NumRows - 1 && j > 0 && j < output.NumColumns - 1)
{
double z1 = ras.Value[i - 1, j - 1];
double z2 = ras.Value[i - 1, j];
double z3 = ras.Value[i - 1, j + 1];
double z4 = ras.Value[i, j - 1];
double z5 = ras.Value[i, j + 1];
double z6 = ras.Value[i + 1, j - 1];
double z7 = ras.Value[i + 1, j];
double z8 = ras.Value[i + 1, j + 1];
// 3rd Order Finite Difference slope algorithm
double dZdX = inZFactor * ((z3 - z1) + 2 * (z5 - z4) + (z8 - z6)) / (8 * ras.CellWidth);
double dZdY = inZFactor * ((z1 - z6) + 2 * (z2 - z7) + (z3 - z8)) / (8 * ras.CellHeight);
double slope = Math.Atan(Math.Sqrt((dZdX * dZdX) + (dZdY * dZdY))) * (180 / Math.PI);
// change to radious and in persentage
if (slopeInPercent)
{
slope = Math.Tan(slope * Math.PI / 180) * 100;
}
output.Value[i, j] = slope;
if (cancelProgressHandler.Cancel)
{
return(false);
}
}
else
{
output.Value[i, j] = output.NoDataValue;
}
if (cancelProgressHandler.Cancel)
{
return(false);
}
}
}
// output = Temp;
if (output.IsFullyWindowed())
{
output.Save();
return(true);
}
return(false);
}
catch (Exception ex)
{
// throw new SystemException("Error in Slope: ", ex);
throw new SystemException(ex.ToString());
}
}
/// <summary>
/// Executes the Area tool with programatic input
/// Ping delete static for external testing
/// </summary>
/// <param name="input">The input raster</param>
/// <param name="zField">The field name containing the values to interpolate</param>
/// <param name="cellSize">The double geographic size of the raster cells to create</param>
/// <param name="power">The double power representing the inverse</param>
/// <param name="neighborType">Fixed distance of fixed number of neighbors</param>
/// <param name="pointCount">The number of neighbors to include if the neighborhood type
/// is Fixed</param>
/// <param name="distance">Points further from the raster cell than this distance are not included
/// in the calculation if the neighborhood type is Fixed Distance.</param>
/// <param name="output">The output raster where values are stored. The fileName is used, but the number
/// of rows and columns will be computed from the cellSize and input featureset</param>
/// <param name="cancelProgressHandler">A progress handler for receiving progress messages</param>
/// <returns>A boolean, true if the IDW process worked correctly</returns>
public bool Execute(IFeatureSet input, string zField, double cellSize, double power, NeighborhoodType neighborType, int pointCount, double distance,
IRaster output, ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (input == null || output == null)
{
return(false);
}
// If the cellSize is 0 we calculate a cell size based on the input extents
if (cellSize == 0)
{
cellSize = input.Extent.Width / 255;
}
// Defines the dimensions and position of the raster
int numColumns = Convert.ToInt32(Math.Round(input.Extent.Width / cellSize));
int numRows = Convert.ToInt32(Math.Round(input.Extent.Height / cellSize));
output = Raster.CreateRaster(output.Filename, string.Empty, numColumns, numRows, 1, typeof(double), new[] { string.Empty });
output.CellHeight = cellSize;
output.CellWidth = cellSize;
output.Xllcenter = input.Extent.MinX + (cellSize / 2);
output.Yllcenter = input.Extent.MinY + (cellSize / 2);
// Used to calculate progress
//int lastUpdate = 0;
//TODO jany_ correct code to work with new KdTree
//// Populates the KD tree
//KdTree kd = new KdTree(2);
//List<int> randomList = new List<int>();
//for (int i = 0; i < input.Features.Count; i++)
//{
// randomList.Add(i);
//}
//Random rnd = new Random();
//List<int> completed = new List<int>();
//while (randomList.Count > 0)
//{
// int index = rnd.Next(0, randomList.Count - 1);
// Coordinate coord = input.Features[randomList[index]].Geometry.Coordinates[0];
// while (kd.Search(coord.ToArray()) != null)
// {
// coord.X = coord.X * 1.000000000000001D;
// }
// kd.Insert(coord.ToArray(), input.Features[randomList[index]]);
// completed.Add(randomList[index]);
// randomList.RemoveAt(index);
//}
//// Makes sure we don't try to search for more points then exist
//if (kd.Count < pointCount)
//{
// pointCount = kd.Count;
//}
//if (neighborType == NeighborhoodType.FixedCount)
//{
// // we add all the old features to output
// for (int x = 0; x < numColumns; x++)
// {
// for (int y = 0; y < numRows; y++)
// {
// // Gets the pointCount number of cells closest to the current cell
// Coordinate cellCenter = output.CellToProj(y, x);
// Double[] pixelCoord = new double[2];
// pixelCoord[0] = output.CellToProj(y, x).X;
// pixelCoord[1] = output.CellToProj(y, x).Y;
// object[] result = kd.Nearest(pixelCoord, pointCount);
// // Sets up the IDW numerator and denominator
// double top = 0;
// double bottom = 0;
// foreach (object feat in result)
// {
// IFeature featurePt = feat as Feature;
// if (featurePt == null)
// {
// continue;
// }
// double distanceToCell = cellCenter.Distance(featurePt.Geometry.Coordinates[0]);
// if (distanceToCell <= distance || distance == 0)
// {
// // If we can't convert the value to a double throw it out
// try
// {
// Convert.ToDouble(featurePt.DataRow[zField]);
// }
// catch
// {
// continue;
// }
// if (power == 2)
// {
// top += (1 / (distanceToCell * distanceToCell))
// * Convert.ToDouble(featurePt.DataRow[zField]);
// bottom += 1 / (distanceToCell * distanceToCell);
// }
// else
// {
// top += (1 / Math.Pow(distanceToCell, power))
// * Convert.ToDouble(featurePt.DataRow[zField]);
// bottom += 1 / Math.Pow(distanceToCell, power);
// }
// }
// }
// output.Value[y, x] = top / bottom;
// }
// // Checks if we need to update the status bar
// if (Convert.ToInt32(Convert.ToDouble(x * numRows) / Convert.ToDouble(numColumns * numRows) * 100) > lastUpdate)
// {
// lastUpdate = Convert.ToInt32(Convert.ToDouble(x * numRows) / Convert.ToDouble(numColumns * numRows) * 100);
// cancelProgressHandler.Progress(
// string.Empty, lastUpdate, "Cell: " + (x * numRows) + " of " + (numColumns * numRows));
// if (cancelProgressHandler.Cancel)
// {
// return false;
// }
// }
// }
//}
output.Save();
return(true);
}
/// <summary>
/// Executes the slope generation raster.
/// </summary>
/// <param name="ras">The input altitude raster.</param>
/// <param name="inZFactor">The multiplicitive scaling factor for elveation.</param>
/// <param name="slopeInPercent">Boolean that is true if the slope values should be returned as percentages.</param>
/// <param name="result">The output slope raster.</param>
/// <param name="cancelProgressHandler">The progress handler.</param>
/// <returns>Boolean, true if the method was successful.</returns>
private static bool Slope(
ref IRaster ras,
double inZFactor,
bool slopeInPercent,
ref IRaster result,
ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (ras == null || result == null)
{
return false;
}
try
{
int noOfCol = ras.NumColumns;
int noOfRow = ras.NumRows;
// Create the new raster with the appropriate dimensions
IRaster temp = Raster.CreateRaster(
"SlopeRaster.bgd", string.Empty, noOfCol, noOfRow, 1, typeof(double), new[] { string.Empty });
temp.NoDataValue = ras.NoDataValue;
temp.Bounds = ras.Bounds;
for (int i = 0; i < temp.NumRows; i++)
{
for (int j = 0; j < temp.NumColumns; j++)
{
if (i > 0 && i < temp.NumRows - 1 && j > 0 && j < temp.NumColumns - 1)
{
double z1 = ras.Value[i - 1, j - 1];
double z2 = ras.Value[i - 1, j];
double z3 = ras.Value[i - 1, j + 1];
double z4 = ras.Value[i, j - 1];
double z5 = ras.Value[i, j + 1];
double z6 = ras.Value[i + 1, j - 1];
double z7 = ras.Value[i + 1, j];
double z8 = ras.Value[i + 1, j + 1];
// 3rd Order Finite Difference slope algorithm
double dZdX = inZFactor * ((z3 - z1) + 2 * (z5 - z4) + (z8 - z6)) / (8 * ras.CellWidth);
double dZdY = inZFactor * ((z1 - z6) + 2 * (z2 - z7) + (z3 - z8)) / (8 * ras.CellHeight);
double slope = Math.Atan(Math.Sqrt((dZdX * dZdX) + (dZdY * dZdY))) * (180 / Math.PI);
// change to radious and in persentage
if (slopeInPercent)
{
slope = Math.Tan(slope * Math.PI / 180) * 100;
}
temp.Value[i, j] = slope;
if (cancelProgressHandler.Cancel)
{
return false;
}
}
else
{
temp.Value[i, j] = temp.NoDataValue;
}
if (cancelProgressHandler.Cancel)
{
return false;
}
}
}
result = temp;
if (result.IsFullyWindowed())
{
result.Save();
return true;
}
return false;
}
catch (Exception ex)
{
// throw new SystemException("Error in Slope: ", ex);
throw new SystemException(ex.ToString());
}
}
/// <summary>
/// Executes the slope generation raster.
/// </summary>
/// <param name="ras">The input altitude raster.</param>
/// <param name="inZFactor">A multiplicative scaling factor to be applied to the elevation values before calculating the slope.</param>
/// <param name="slopeInPercent">If this is true, the slope is returned as a percentage.</param>
/// <param name="result">The output slope raster.</param>
/// <param name="cancelProgressHandler">The progress handler.</param>
private static void Slope(IRaster ras, double inZFactor, bool slopeInPercent, IRaster result, ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (ras == null || result == null)
{
return;
}
try
{
int noOfCol = ras.NumColumns;
int noOfRow = ras.NumRows;
// Create the new raster with the appropriate dimensions
IRaster temp = Raster.CreateRaster("SlopeRaster.bgd", string.Empty, noOfCol, noOfRow, 1, typeof(double), new[] { string.Empty });
temp.NoDataValue = ras.NoDataValue;
temp.Bounds = ras.Bounds;
for (int i = 0; i < temp.NumRows; i++)
{
for (int j = 0; j < temp.NumColumns; j++)
{
if (i > 0 && i < temp.NumRows - 1 && j > 0 && j < temp.NumColumns - 1)
{
double z1 = ras.Value[i - 1, j - 1];
double z2 = ras.Value[i - 1, j];
double z3 = ras.Value[i - 1, j + 1];
double z4 = ras.Value[i, j - 1];
double z5 = ras.Value[i, j + 1];
double z6 = ras.Value[i + 1, j - 1];
double z7 = ras.Value[i + 1, j];
double z8 = ras.Value[i + 1, j + 1];
// 3rd Order Finite Difference slope algorithm
double dZdX = inZFactor * ((z3 - z1) + 2 * (z5 - z4) + (z8 - z6)) / (8 * ras.CellWidth);
double dZdY = inZFactor * ((z1 - z6) + 2 * (z2 - z7) + (z3 - z8)) / (8 * ras.CellHeight);
double slope = Math.Atan(Math.Sqrt((dZdX * dZdX) + (dZdY * dZdY))) * (180 / Math.PI);
// change to radious and in persentage
if (slopeInPercent)
{
slope = Math.Tan(slope * Math.PI / 180) * 100;
}
temp.Value[i, j] = slope;
if (cancelProgressHandler.Cancel)
{
return;
}
}
else
{
temp.Value[i, j] = temp.NoDataValue;
}
if (cancelProgressHandler.Cancel)
{
return;
}
}
}
result = temp;
if (result.IsFullyWindowed())
{
result.Save();
}
}
catch (Exception ex)
{
throw new SystemException(ex.ToString());
}
}
/// <summary>
/// Executes the Erase Opaeration tool programaticaly.
/// Ping deleted static for external testing 01/2010
/// </summary>
/// <param name="input1">The input raster.</param>
/// <param name="input2">The input raster.</param>
/// <param name="output">The output raster.</param>
/// <param name="cancelProgressHandler">The progress handler.</param>
/// <returns></returns>
public bool Execute(IRaster input1, IFeatureSet input2, IRaster output, ICancelProgressHandler cancelProgressHandler)
{
//Validates the input and output data
if (input1 == null || input2 == null || output == null)
{
return false;
}
double cellWidth = input1.CellWidth;
double cellHeight = input1.CellHeight;
//Calculate the Intersect Envelope
IEnvelope envelope1 = input1.Bounds.Envelope;
IEnvelope envelope2 = input2.Envelope;
envelope1 = envelope1.Intersection(envelope2);
int noOfCol = Convert.ToInt32(envelope1.Height / cellHeight);
int noOfRow = Convert.ToInt32(envelope1.Width / cellWidth);
//create output raster
output = Raster.Create(output.Filename, "", noOfCol, noOfRow, 1, typeof(int), new[] { "" });
RasterBounds bound = new RasterBounds(noOfRow, noOfCol, envelope1);
output.Bounds = bound;
output.NoDataValue = input1.NoDataValue;
RcIndex v1;
// MapWindow.Analysis.Topology.Algorithm.PointLocator pointLocator1 = new MapWindow.Analysis.Topology.Algorithm.PointLocator();
int previous = 0;
int max = (output.Bounds.NumRows + 1);
for (int i = 0; i < output.Bounds.NumRows; i++)
{
for (int j = 0; j < output.Bounds.NumColumns; j++)
{
Coordinate cellCenter = output.CellToProj(i, j);
//test if the coordinate is inside of the polygon
bool isInside = false;
IFeature pointFeat = new Feature(new Point(cellCenter));
foreach (IFeature f in input2.Features)
{
if (f.Contains(pointFeat))
{
//output.Value[i, j] = val1;
isInside = true;
break;
}
}
if (isInside)
{
v1 = input1.ProjToCell(cellCenter);
double val1;
if (v1.Row <= input1.EndRow && v1.Column <= input1.EndColumn && v1.Row > -1 && v1.Column > -1)
val1 = input1.Value[v1.Row, v1.Column];
else
val1 = output.NoDataValue;
output.Value[i, j] = val1;
}
else
{
output.Value[i, j] = output.NoDataValue;
}
if (cancelProgressHandler.Cancel)
return false;
}
int current = Convert.ToInt32(Math.Round(i * 100D / max));
//only update when increment in percentage
if (current > previous)
cancelProgressHandler.Progress("", current, current + TextStrings.progresscompleted);
previous = current;
}
//output = Temp;
output.Save();
return true;
}
/// <summary>
/// Executes the Erase Opaeration tool programaticaly
/// Ping Yang deleted static for external testing 01/2010
/// </summary>
/// <param name="input">The input raster</param>
/// <param name="oldValue">The original double value representing no-data</param>
/// <param name="newValue">The new double value representing no-data</param>
/// <param name="output">The output raster</param>
/// <param name="cancelProgressHandler">The progress handler</param>
/// <returns></returns>
public bool Execute(
IRaster input,
double oldValue,
double newValue,
IRaster output,
ICancelProgressHandler cancelProgressHandler)
{
// Validates the input and output data
if (input == null || newValue == 0 || output == null)
{
return false;
}
Extent envelope = input.Bounds.Extent;
int noOfCol = input.NumColumns;
int noOfRow = input.NumRows;
int previous = 0;
Type dataType = input.DataType;
// create output raster
output = Raster.CreateRaster(
output.Filename, string.Empty, noOfCol, noOfRow, 1, dataType, new[] { string.Empty });
RasterBounds bound = new RasterBounds(noOfRow, noOfCol, envelope);
output.Bounds = bound;
output.NoDataValue = newValue;
// Loop throug every cell
int max = output.Bounds.NumRows + 1;
for (int i = 0; i < output.Bounds.NumRows; i++)
{
for (int j = 0; j < output.Bounds.NumColumns; j++)
{
if (input.Value[i, j] == oldValue)
{
output.Value[i, j] = newValue;
}
else
{
output.Value[i, j] = input.Value[i, j];
}
if (cancelProgressHandler.Cancel)
{
return false;
}
}
int current = Convert.ToInt32(Math.Round(i * 100D / max));
// only update when increment in persentage
if (current > previous)
{
cancelProgressHandler.Progress(string.Empty, current, current + TextStrings.progresscompleted);
}
previous = current;
}
// output = Temp;
output.Save();
return true;
}
/// <summary>
/// Executes the Area tool with programatic input
/// Ping delete static for external testing
/// </summary>
/// <param name="input">The input raster</param>
/// <param name="output">The output polygon feature set</param>
/// <param name="zField">The field name containing the values to interpolate</param>
/// <param name="cellSize">The double geographic size of the raster cells to create</param>
/// <param name="power">The double power representing the inverse</param>
/// <param name="neighborType">Fixed distance of fixed number of neighbors</param>
/// <param name="pointCount">The number of neighbors to include if the neighborhood type
/// is Fixed</param>
/// <param name="distance">Points further from the raster cell than this distance are not included
/// in the calculation if the neighborhood type is Fixed Distance.</param>
/// <param name="output">The output raster where values are stored. The filename is used, but the number
/// of rows and columns will be computed from the cellSize and input featureset</param>
/// <param name="cancelProgressHandler">A progress handler for receiving progress messages</param>
/// <returns>A boolean, true if the IDW process worked correctly</returns>
public bool Execute(IFeatureSet input, string zField, double cellSize, double power, NeighborhoodType neighborType, int pointCount, double distance, IRaster output, ICancelProgressHandler cancelProgressHandler)
{
//Validates the input and output data
if (input == null || output == null)
return false;
//If the cellSize is 0 we calculate a cellsize based on the input extents
if (cellSize == 0)
cellSize = input.Envelope.Width / 255;
//Defines the dimesions and position of the raster
int numColumns = Convert.ToInt32(Math.Round(input.Envelope.Width / cellSize));
int numRows = Convert.ToInt32(Math.Round(input.Envelope.Height / cellSize));
output = Raster.Create(output.Filename, "",numColumns, numRows, 1, typeof(double), new[] {""} );
output.CellHeight = cellSize;
output.CellWidth = cellSize;
output.Xllcenter = input.Envelope.Minimum.X + (cellSize/2);
output.Yllcenter = input.Envelope.Minimum.Y + (cellSize/2);
//Used to calculate progress
int lastUpdate=0;
//Populates the KD tree
MapWindow.Analysis.Topology.KDTree.KDTree kd = new MapWindow.Analysis.Topology.KDTree.KDTree(2);
List<int> randomList = new List<int>();
for (int i = 0; i < input.Features.Count; i++)
{
randomList.Add(i);
}
Random rnd = new Random();
List<int> completed = new List<int>();
while (randomList.Count > 0)
{
int index = rnd.Next(0,randomList.Count -1);
Coordinate coord = input.Features[randomList[index]].Coordinates[0];
while (kd.Search(coord.ToArray()) != null)
coord.X = coord.X * 1.000000000000001D;
kd.Insert(coord.ToArray(), input.Features[randomList[index]]);
completed.Add(randomList[index]);
randomList.RemoveAt(index);
}
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
//Makes sure we don't try to search for more points then exist
if (kd.Count < pointCount)
pointCount = kd.Count;
if (neighborType == NeighborhoodType.FixedCount)
{
//we add all the old features to output
for (int x = 0; x < numColumns; x++)
{
for (int y = 0; y < numRows; y++)
{
//Gets the pointCount number of cells closest to the current cell
Coordinate cellCenter = output.CellToProj(y, x);
Double[] pixelCoord = new double[2];
pixelCoord[0] = output.CellToProj(y, x).X;
pixelCoord[1] = output.CellToProj(y, x).Y;
sw.Start();
object[] result = kd.Nearest(pixelCoord, pointCount);
sw.Stop();
//Sets up the IDW numerator and denominator
double top = 0;
double bottom = 0;
foreach (object feat in result)
{
IFeature featurePt = feat as Feature;
if (featurePt == null) continue;
double distanceToCell = cellCenter.Distance(featurePt.Coordinates[0]);
if (distanceToCell <= distance || distance == 0)
{
//If we can't convert the value to a double throw it out
try
{
Convert.ToDouble(featurePt.DataRow[zField]);
}
catch
{
continue;
}
if (power == 2)
{
top += (1 / (distanceToCell * distanceToCell)) * Convert.ToDouble(featurePt.DataRow[zField]);
bottom += (1 / (distanceToCell* distanceToCell));
}
else
{
top += (1 / Math.Pow(distanceToCell, power)) * Convert.ToDouble(featurePt.DataRow[zField]);
bottom += (1 / Math.Pow(distanceToCell, power));
}
}
}
output.Value[y, x] = top / bottom;
}
//Checks if we need to update the status bar
if (Convert.ToInt32(Convert.ToDouble(x*numRows ) / Convert.ToDouble(numColumns * numRows) * 100) > lastUpdate)
{
lastUpdate = Convert.ToInt32(Convert.ToDouble(x * numRows) / Convert.ToDouble(numColumns * numRows) * 100);
cancelProgressHandler.Progress("", lastUpdate, "Cell: " + (x * numRows) + " of " + (numColumns * numRows));
if (cancelProgressHandler.Cancel)
return false;
}
}
System.Diagnostics.Debug.WriteLine(sw.ElapsedMilliseconds);
}
output.Save();
return true;
}
public bool Execute1(DotSpatial.Data.ICancelProgressHandler cancelProgressHandler)
{
StreamReader sr = new StreamReader(Path.Combine(FileDirectory, "list.txt"));
int nfile = 0;
while (!sr.EndOfStream)
{
sr.ReadLine();
nfile++;
}
sr.Close();
sr = new StreamReader(Path.Combine(FileDirectory, "list.txt"));
string[] dirs = new string[nfile];
for (int i = 0; i < nfile; i++)
{
var str = sr.ReadLine();
dirs[i] = Path.Combine(FileDirectory, str + "_2.tif");
}
int[] bandlist = new int[] { 4, 3, 2 };
//string[] dirs = Directory.GetFiles(FileDirectory, "*_2.tif");
string center_shp = @"E:\Project\HRB\Badan Jarian\Data\Geospatial\Center35.shp";
StreamWriter sw = new StreamWriter(Path.Combine(FileDirectory, "area.csv"));
StreamWriter sw_alpha = new StreamWriter(Path.Combine(FileDirectory, "alpha.txt"));
IFeatureSet center_fs = FeatureSet.Open(center_shp);
List <double> vec = new List <double>();
try
{
double cell_area = 5 * 5;
var center_pt = center_fs.Features[0].Geometry.Coordinate;
var center_vec = new double[3];
var pt_vec = new double[3];
int progress = 0;
int count = 1;
int t = 0;
vec.Clear();
foreach (var file in dirs)
{
long wcount = 0;
var temp = Path.GetFileNameWithoutExtension(file);
var daystr = temp.Remove(10);
var water_file = file.Replace("_2", "_water");
IRaster raster2 = Raster.OpenFile(file);
raster2.SaveAs(water_file);
IRaster raster3 = Raster.OpenFile(file.Replace("_2", "_3"));
IRaster raster4 = Raster.OpenFile(file.Replace("_2", "_4"));
IRaster raster_water = Raster.OpenFile(water_file);
double[,] img = new double[raster2.NumRows, raster2.NumColumns];
var cell = raster2.ProjToCell(center_pt);
center_vec[0] = raster2.Value[cell.Row, cell.Column];
center_vec[1] = raster3.Value[cell.Row, cell.Column];
center_vec[2] = raster4.Value[cell.Row, cell.Column];
for (int i = 0; i < raster2.NumRows; i++)
{
for (int j = 0; j < raster2.NumColumns; j++)
{
if (raster2.Value[i, j] == raster2.NoDataValue)
{
img[i, j] = 0;
raster_water.Value[i, j] = 0;
sw_alpha.WriteLine(0);
vec.Add(0);
}
else
{
pt_vec[0] = raster2.Value[i, j];
pt_vec[1] = raster3.Value[i, j];
pt_vec[2] = raster4.Value[i, j];
var alpha = sam(pt_vec, center_vec);
if (alpha <= AlphaThreashhold)
{
raster_water.Value[i, j] = 1;
wcount++;
}
else
{
raster_water.Value[i, j] = 0;
}
try
{
raster_water.Value[i, j] = alpha;
}
catch (Exception ex)
{
cancelProgressHandler.Progress("Package_Tool", progress, "Warning: " + ex.Message + " " + alpha);
alpha = 0;
raster_water.Value[i, j] = 0;
}
finally
{
img[i, j] = alpha;
vec.Add(alpha);
sw_alpha.WriteLine(alpha);
}
}
}
}
var max = vec.Max();
var min = vec.Min();
var delta = max - min;
int k = 0;
for (int i = 0; i < raster2.NumRows; i++)
{
for (int j = 0; j < raster2.NumColumns; j++)
{
img[i, j] = (vec[k] - min) / delta * 255;
raster_water.Value[i, j] = img[i, j];
k++;
}
}
var sobled_img = sobel(img, raster2.NumRows, raster2.NumColumns);
for (int i = 0; i < raster2.NumRows; i++)
{
for (int j = 0; j < raster2.NumColumns; j++)
{
raster_water.Value[i, j] = sobled_img[i, j];
}
}
var water_area = wcount * cell_area;
sw.WriteLine(daystr + "," + water_area);
raster2.Close();
raster3.Close();
raster4.Close();
raster_water.Save();
raster_water.Close();
progress = t * 100 / dirs.Length;
if (progress > count)
{
cancelProgressHandler.Progress("Package_Tool", progress, "Processing: " + file);
count++;
}
t++;
}
}
catch (Exception ex)
{
cancelProgressHandler.Progress("Package_Tool", 100, "Error: " + ex.Message);
}
finally
{
sw_alpha.Close();
sr.Close();
sw.Close();
center_fs.Close();
}
return(true);
}
