@Override
public void run() {
amIActive = true;
int progress;
int row, col, i;
int baseCol, baseRow, appendCol, appendRow;
double x, y, z, zN, zBase, zAppend;
double w1, w2, dist1, dist2, sumDist;
boolean performHistoMatching = true;
if (args.length <= 0) {
showFeedback("Plugin parameters have not been set.");
return;
}
// read the input parameters
String inputBaseHeader = args[0];
String inputHeader = args[1];
String outputHeader = args[2];
String resampleMethod = args[3].toLowerCase().trim();
if (!resampleMethod.equals("nearest neighbour")
&& !resampleMethod.equals("bilinear")
&& !resampleMethod.contains("cubic")) {
showFeedback("Resample method not recognized");
return;
}
if (args[4].toLowerCase().contains("true")) {
performHistoMatching = true;
} else {
performHistoMatching = false;
}
double power = Double.parseDouble(args[5]);
if (power > 15.0) {
power = 15.0;
}
if (power < 1.0) {
power = 1.0;
}
try {
// first perform histogram matching if necessary
if (performHistoMatching) {
String inputHeaderAdjusted = StringUtilities.replaceLast(inputHeader, ".dep", "_temp1.dep");
histogramMatching(inputHeader, inputBaseHeader, inputHeaderAdjusted);
inputHeader = inputHeaderAdjusted;
}
WhiteboxRaster baseRaster = new WhiteboxRaster(inputBaseHeader, "r");
WhiteboxRaster appendRaster = new WhiteboxRaster(inputHeader, "r");
double cellSizeX = baseRaster.getCellSizeX();
double cellSizeY = baseRaster.getCellSizeY();
double baseNoData = baseRaster.getNoDataValue();
double appendNoData = appendRaster.getNoDataValue();
double outputNoData = baseNoData;
int baseCols = baseRaster.getNumberColumns();
int baseRows = baseRaster.getNumberRows();
int appendCols = appendRaster.getNumberColumns();
int appendRows = appendRaster.getNumberRows();
// figure out the north, south, east, and west coordinates and the rows and
// columns of the output image.
double baseNorth = baseRaster.getNorth();
double baseSouth = baseRaster.getSouth();
double baseEast = baseRaster.getEast();
double baseWest = baseRaster.getWest();
double baseNSRange = baseNorth - baseSouth;
double baseEWRange = baseEast - baseWest;
double appendNorth = appendRaster.getNorth();
double appendSouth = appendRaster.getSouth();
double appendEast = appendRaster.getEast();
double appendWest = appendRaster.getWest();
double appendNSRange = appendNorth - appendSouth;
double appendEWRange = appendEast - appendWest;
double north, south, east, west;
if (baseNorth > baseSouth) {
north = Double.NEGATIVE_INFINITY;
south = Double.POSITIVE_INFINITY;
if (baseNorth > north) {
north = baseNorth;
}
if (appendNorth > north) {
north = appendNorth;
}
if (baseSouth < south) {
south = baseSouth;
}
if (appendSouth < south) {
south = appendSouth;
}
} else {
north = Double.POSITIVE_INFINITY;
south = Double.NEGATIVE_INFINITY;
if (baseNorth < north) {
north = baseNorth;
}
if (appendNorth < north) {
north = appendNorth;
}
if (baseSouth > south) {
south = baseSouth;
}
if (appendSouth > south) {
south = appendSouth;
}
}
if (baseEast > baseWest) {
east = Double.NEGATIVE_INFINITY;
west = Double.POSITIVE_INFINITY;
if (baseEast > east) {
east = baseEast;
}
if (appendEast > east) {
east = appendEast;
}
if (baseWest < west) {
west = baseWest;
}
if (appendWest < west) {
west = appendWest;
}
} else {
east = Double.POSITIVE_INFINITY;
west = Double.NEGATIVE_INFINITY;
if (baseEast < east) {
east = baseEast;
}
if (appendEast < east) {
east = appendEast;
}
if (baseWest > west) {
west = baseWest;
}
if (appendWest > west) {
west = appendWest;
}
}
// create the new destination image.
int nRows = (int) Math.round(Math.abs(north - south) / cellSizeY);
int nCols = (int) Math.round(Math.abs(east - west) / cellSizeX);
WhiteboxRaster destination =
new WhiteboxRaster(
outputHeader,
north,
south,
east,
west,
nRows,
nCols,
WhiteboxRasterBase.DataScale.CONTINUOUS,
WhiteboxRasterBase.DataType.FLOAT,
outputNoData,
outputNoData);
int nRowsLessOne = nRows - 1;
// distance to edge images
String distToEdgeBaseHeader =
StringUtilities.replaceLast(inputBaseHeader, ".dep", "_temp1.dep");
WhiteboxRaster distToEdgeBase =
new WhiteboxRaster(
distToEdgeBaseHeader,
"rw",
inputBaseHeader,
WhiteboxRaster.DataType.FLOAT,
Float.POSITIVE_INFINITY);
distToEdgeBase.isTemporaryFile = true;
double[] data;
for (row = 0; row < baseRows; row++) {
data = baseRaster.getRowValues(row);
for (col = 0; col < baseCols; col++) {
if (row == 0 || row == baseRows - 1) {
distToEdgeBase.setValue(row, col, 0.0);
} else if (col == 0 || col == baseCols - 1) {
distToEdgeBase.setValue(row, col, 0.0);
} else {
if (data[col] != baseNoData) {
if (data[col - 1] == baseNoData || data[col + 1] == baseNoData) {
distToEdgeBase.setValue(row, col, 0.0);
}
} else {
distToEdgeBase.setValue(row, col, 0.0);
}
}
}
}
calculateDistance(distToEdgeBase);
String distToEdgeAppendHeader =
whitebox.utilities.StringUtilities.replaceLast(inputBaseHeader, ".dep", "_temp2.dep");
WhiteboxRaster distToEdgeAppend =
new WhiteboxRaster(
distToEdgeAppendHeader,
"rw",
inputHeader,
WhiteboxRaster.DataType.FLOAT,
Float.POSITIVE_INFINITY);
distToEdgeAppend.isTemporaryFile = true;
for (row = 0; row < appendRows; row++) {
data = appendRaster.getRowValues(row);
for (col = 0; col < appendCols; col++) {
if (row == 0 || row == appendRows - 1) {
distToEdgeAppend.setValue(row, col, 0.0);
} else if (col == 0 || col == appendCols - 1) {
distToEdgeAppend.setValue(row, col, 0.0);
} else {
if (data[col] != appendNoData) {
if (data[col - 1] == appendNoData || data[col + 1] == appendNoData) {
distToEdgeAppend.setValue(row, col, 0.0);
}
} else {
distToEdgeAppend.setValue(row, col, 0.0);
}
}
}
}
calculateDistance(distToEdgeAppend);
if (resampleMethod.contains("nearest")) {
for (row = 0; row < nRows; row++) {
for (col = 0; col < nCols; col++) {
x = destination.getXCoordinateFromColumn(col);
y = destination.getYCoordinateFromRow(row);
baseCol = baseRaster.getColumnFromXCoordinate(x);
baseRow = baseRaster.getRowFromYCoordinate(y);
appendCol = appendRaster.getColumnFromXCoordinate(x);
appendRow = appendRaster.getRowFromYCoordinate(y);
zBase = baseRaster.getValue(baseRow, baseCol);
zAppend = appendRaster.getValue(appendRow, appendCol);
if (zBase != baseNoData && zAppend == appendNoData) {
destination.setValue(row, col, zBase);
} else if (zBase == baseNoData && zAppend != appendNoData) {
destination.setValue(row, col, zAppend);
} else if (zBase == baseNoData && zAppend == appendNoData) {
destination.setValue(row, col, outputNoData);
} else { // two valid values.
// find the distance to the nearest edge in the base image
dist1 = distToEdgeBase.getValue(baseRow, baseCol); // baseCol;
dist2 = distToEdgeAppend.getValue(appendRow, appendCol); // appendCol;
sumDist = Math.pow(dist1, power) + Math.pow(dist2, power);
w1 = Math.pow(dist1, power) / sumDist;
w2 = Math.pow(dist2, power) / sumDist;
z = w1 * zBase + w2 * zAppend;
destination.setValue(row, col, z);
}
}
if (cancelOp) {
cancelOperation();
return;
}
progress = (int) (100f * row / nRowsLessOne);
updateProgress("Resampling images: ", progress);
}
} else {
if (destination.getDataType() != WhiteboxRaster.DataType.DOUBLE
&& destination.getDataType() != WhiteboxRaster.DataType.FLOAT) {
showFeedback(
"The destination image is not of an appropriate data"
+ " type (i.e. double or float) to perform this operation.");
return;
}
double dX, dY;
double srcRow, srcCol;
double originRow, originCol;
double rowN, colN;
double sumOfDist;
double[] shiftX;
double[] shiftY;
int numNeighbours = 0;
double[][] neighbour;
if (resampleMethod.contains("cubic")) {
shiftX = new double[] {-1, 0, 1, 2, -1, 0, 1, 2, -1, 0, 1, 2, -1, 0, 1, 2};
shiftY = new double[] {-1, -1, -1, -1, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2};
numNeighbours = 16;
neighbour = new double[numNeighbours][2];
} else { // resampleMethod is "bilinear"
shiftX = new double[] {0, 1, 0, 1};
shiftY = new double[] {0, 0, 1, 1};
numNeighbours = 4;
neighbour = new double[numNeighbours][2];
}
for (row = 0; row < nRows; row++) {
for (col = 0; col < nCols; col++) {
x = destination.getXCoordinateFromColumn(col);
y = destination.getYCoordinateFromRow(row);
baseCol = baseRaster.getColumnFromXCoordinate(x);
baseRow = baseRaster.getRowFromYCoordinate(y);
// what are the exact col and row of the image?
srcRow = (baseNorth - y) / baseNSRange * (baseRows - 0.5);
srcCol = (x - baseWest) / baseEWRange * (baseCols - 0.5);
originRow = Math.floor(srcRow);
originCol = Math.floor(srcCol);
sumOfDist = 0;
for (i = 0; i < numNeighbours; i++) {
rowN = originRow + shiftY[i];
colN = originCol + shiftX[i];
neighbour[i][0] = baseRaster.getValue((int) rowN, (int) colN);
dY = rowN - srcRow;
dX = colN - srcCol;
if ((dX + dY) != 0 && neighbour[i][0] != baseNoData) {
neighbour[i][1] = 1 / (dX * dX + dY * dY);
sumOfDist += neighbour[i][1];
} else if (neighbour[i][0] == baseNoData) {
neighbour[i][1] = 0;
} else { // dist is zero
neighbour[i][1] = 99999999;
sumOfDist += neighbour[i][1];
}
}
if (sumOfDist > 0) {
z = 0;
for (i = 0; i < numNeighbours; i++) {
z += neighbour[i][0] * neighbour[i][1] / sumOfDist;
}
zBase = z;
} else {
zBase = baseNoData;
}
appendCol = appendRaster.getColumnFromXCoordinate(x);
appendRow = appendRaster.getRowFromYCoordinate(y);
srcRow = (appendNorth - y) / appendNSRange * (appendRows - 0.5);
srcCol = (x - appendWest) / appendEWRange * (appendCols - 0.5);
originRow = Math.floor(srcRow);
originCol = Math.floor(srcCol);
sumOfDist = 0;
for (i = 0; i < numNeighbours; i++) {
rowN = originRow + shiftY[i];
colN = originCol + shiftX[i];
neighbour[i][0] = appendRaster.getValue((int) rowN, (int) colN);
dY = rowN - srcRow;
dX = colN - srcCol;
if ((dX + dY) != 0 && neighbour[i][0] != appendNoData) {
neighbour[i][1] = 1 / (dX * dX + dY * dY);
sumOfDist += neighbour[i][1];
} else if (neighbour[i][0] == appendNoData) {
neighbour[i][1] = 0;
} else { // dist is zero
neighbour[i][1] = 99999999;
sumOfDist += neighbour[i][1];
}
}
if (sumOfDist > 0) {
z = 0;
for (i = 0; i < numNeighbours; i++) {
z += (neighbour[i][0] * neighbour[i][1]) / sumOfDist;
}
zAppend = z;
} else {
zAppend = appendNoData;
}
if (zBase != baseNoData && zAppend == appendNoData) {
destination.setValue(row, col, zBase);
} else if (zBase == baseNoData && zAppend != appendNoData) {
destination.setValue(row, col, zAppend);
} else if (zBase == baseNoData && zAppend == appendNoData) {
destination.setValue(row, col, outputNoData);
} else { // two valid values.
// find the distance to the nearest edge in the base image
dist1 = distToEdgeBase.getValue(baseRow, baseCol); // baseCol;
dist2 = distToEdgeAppend.getValue(appendRow, appendCol); // appendCol;
sumDist = dist1 + dist2;
w1 = dist1 / sumDist;
w2 = dist2 / sumDist;
z = w1 * zBase + w2 * zAppend;
destination.setValue(row, col, z);
}
}
if (cancelOp) {
cancelOperation();
return;
}
progress = (int) (100f * row / nRowsLessOne);
updateProgress("Resampling images: ", progress);
}
}
destination.addMetadataEntry("Created by the " + getDescriptiveName() + " tool.");
destination.addMetadataEntry("Created on " + new Date());
destination.close();
distToEdgeBase.close();
distToEdgeAppend.close();
baseRaster.close();
if (performHistoMatching) {
File header = new File(inputHeader);
if (header.exists()) {
header.delete();
}
File dataFile = new File(StringUtilities.replaceLast(inputHeader, ".dep", ".tas"));
if (dataFile.exists()) {
dataFile.delete();
}
} else {
appendRaster.close();
}
returnData(outputHeader);
} catch (OutOfMemoryError oe) {
myHost.showFeedback("An out-of-memory error has occurred during operation.");
} catch (Exception e) {
myHost.showFeedback("An error has occurred during operation. See log file for details.");
myHost.logException("Error in " + getDescriptiveName(), e);
} finally {
updateProgress("Progress: ", 0);
// tells the main application that this process is completed.
amIActive = false;
myHost.pluginComplete();
}
}
/** Used to execute this plugin tool. */
@Override
public void run() {
amIActive = true;
String streamsHeader;
String pointerHeader;
String outputFileName;
int row, col, x, y;
double xCoord, yCoord;
int progress;
int c;
int[] dX = new int[] {1, 1, 1, 0, -1, -1, -1, 0};
int[] dY = new int[] {-1, 0, 1, 1, 1, 0, -1, -1};
double[] inflowingVals = new double[] {16, 32, 64, 128, 1, 2, 4, 8};
boolean flag;
double flowDir;
double previousFlowDir;
double linkLength;
double streamValue;
if (args.length <= 0) {
showFeedback("Plugin parameters have not been set.");
return;
}
streamsHeader = args[0];
pointerHeader = args[1];
outputFileName = args[2];
// check to see that the inputHeader and outputHeader are not null.
if ((streamsHeader == null) || (pointerHeader == null) || (outputFileName == null)) {
showFeedback("One or more of the input parameters have not been set properly.");
return;
}
try {
WhiteboxRaster streams = new WhiteboxRaster(streamsHeader, "r");
int rows = streams.getNumberRows();
int cols = streams.getNumberColumns();
double noData = streams.getNoDataValue();
double gridResX = streams.getCellSizeX();
double gridResY = streams.getCellSizeY();
double diagGridRes = Math.sqrt(gridResX * gridResX + gridResY * gridResY);
double[] gridLengths =
new double[] {
diagGridRes,
gridResX,
diagGridRes,
gridResY,
diagGridRes,
gridResX,
diagGridRes,
gridResY
};
double east = streams.getEast() - gridResX / 2.0;
double west = streams.getWest() + gridResX / 2.0;
double EWRange = east - west;
double north = streams.getNorth() - gridResY / 2.0;
double south = streams.getSouth() + gridResY / 2.0;
double NSRange = north - south;
WhiteboxRaster pntr = new WhiteboxRaster(pointerHeader, "r");
if (pntr.getNumberRows() != rows || pntr.getNumberColumns() != cols) {
showFeedback("The input images must be of the same dimensions.");
return;
}
DBFField fields[] = new DBFField[3];
fields[0] = new DBFField();
fields[0].setName("FID");
fields[0].setDataType(DBFField.DBFDataType.NUMERIC);
fields[0].setFieldLength(10);
fields[0].setDecimalCount(0);
fields[1] = new DBFField();
fields[1].setName("STRM_VAL");
fields[1].setDataType(DBFField.DBFDataType.NUMERIC);
fields[1].setFieldLength(10);
fields[1].setDecimalCount(3);
fields[2] = new DBFField();
fields[2].setName("Length");
fields[2].setDataType(DBFField.DBFDataType.NUMERIC);
fields[2].setFieldLength(10);
fields[2].setDecimalCount(3);
// set up the output files of the shapefile and the dbf
ShapeFile output = new ShapeFile(outputFileName, ShapeType.POLYLINE, fields);
byte numNeighbouringStreamCells;
int FID = 0;
for (row = 0; row < rows; row++) {
for (col = 0; col < cols; col++) {
streamValue = streams.getValue(row, col);
if (streamValue > 0) {
// see if it is a headwater location
numNeighbouringStreamCells = 0;
for (c = 0; c < 8; c++) {
x = col + dX[c];
y = row + dY[c];
if (streams.getValue(y, x) > 0 && pntr.getValue(y, x) == inflowingVals[c]) {
numNeighbouringStreamCells++;
}
}
if (numNeighbouringStreamCells != 1) {
// it's the start of a link.
FID++;
linkLength = 0;
int[] parts = {0};
PointsList points = new PointsList();
x = col;
y = row;
previousFlowDir = -99;
flag = true;
do {
// find the downslope neighbour
flowDir = pntr.getValue(y, x);
if (flowDir > 0) {
if (flowDir != previousFlowDir) {
// it's a bend in the stream so add this point
xCoord = west + ((double) x / cols) * EWRange;
yCoord = north - ((double) y / rows) * NSRange;
points.addPoint(xCoord, yCoord);
previousFlowDir = flowDir;
}
// update the row and column values to the
// cell that the flowpath leads to.
c = (int) (Math.log(flowDir) / LnOf2);
if (c > 7) {
showFeedback(
"An unexpected value has "
+ "been identified in the pointer "
+ "image. This tool requires a "
+ "pointer grid that has been "
+ "created using either the D8 "
+ "or Rho8 tools.");
return;
}
x += dX[c];
y += dY[c];
linkLength += gridLengths[c];
if (streams.getValue(y, x) <= 0) { // it's not a stream cell
flag = false;
} else {
// is it a confluence
numNeighbouringStreamCells = 0;
int x2, y2;
for (int d = 0; d < 8; d++) {
x2 = x + dX[d];
y2 = y + dY[d];
if (streams.getValue(y2, x2) > 0
&& pntr.getValue(y2, x2) == inflowingVals[d]) {
numNeighbouringStreamCells++;
}
}
if (numNeighbouringStreamCells > 1) {
// It's a confluence and you should stop here.
flag = false;
}
}
} else {
flag = false;
}
if (!flag) {
// it's the end of the stream link so
// add the point.
xCoord = west + ((double) x / cols) * EWRange;
yCoord = north - ((double) y / rows) * NSRange;
points.addPoint(xCoord, yCoord);
}
} while (flag);
// add the line to the shapefile.
PolyLine line = new PolyLine(parts, points.getPointsArray());
Object[] rowData = new Object[3];
rowData[0] = new Double(FID);
rowData[1] = new Double(streamValue);
rowData[2] = new Double(linkLength / 1000.0);
output.addRecord(line, rowData);
}
}
}
if (cancelOp) {
cancelOperation();
return;
}
progress = (int) (100f * row / (rows - 1));
updateProgress(progress);
}
output.write();
pntr.close();
streams.close();
// returning a header file string displays the image.
returnData(outputFileName);
} catch (OutOfMemoryError oe) {
myHost.showFeedback("An out-of-memory error has occurred during operation.");
} catch (Exception e) {
myHost.showFeedback("An error has occurred during operation. See log file for details.");
myHost.logException("Error in " + getDescriptiveName(), e);
} finally {
updateProgress("Progress: ", 0);
// tells the main application that this process is completed.
amIActive = false;
myHost.pluginComplete();
}
}
