private void calculateDistance(WhiteboxRaster outputImage) {
String outputHeader = outputImage.getHeaderFile();
int row, col, whichCell, i, x, y;
double z, z2, zMin, h = 0;
double infVal = Float.POSITIVE_INFINITY;
int[] dX = new int[] {-1, -1, 0, 1, 1, 1, 0, -1};
int[] dY = new int[] {0, -1, -1, -1, 0, 1, 1, 1};
int[] Gx = new int[] {1, 1, 0, 1, 1, 1, 0, 1};
int[] Gy = new int[] {0, 1, 1, 1, 0, 1, 1, 1};
int progress;
int rows = outputImage.getNumberRows();
int cols = outputImage.getNumberColumns();
double noData = outputImage.getNoDataValue();
double gridRes = (outputImage.getCellSizeX() + outputImage.getCellSizeY()) / 2;
WhiteboxRaster Rx =
new WhiteboxRaster(
outputHeader.replace(".dep", "_temp1.dep"),
"rw",
outputHeader,
WhiteboxRaster.DataType.FLOAT,
0);
Rx.isTemporaryFile = true;
WhiteboxRaster Ry =
new WhiteboxRaster(
outputHeader.replace(".dep", "_temp2.dep"),
"rw",
outputHeader,
WhiteboxRaster.DataType.FLOAT,
0);
Ry.isTemporaryFile = true;
for (row = 0; row < rows; row++) {
for (col = 0; col < cols; col++) {
z = outputImage.getValue(row, col);
if (z != 0) {
zMin = infVal;
whichCell = -1;
for (i = 0; i <= 3; i++) {
x = col + dX[i];
y = row + dY[i];
z2 = outputImage.getValue(y, x);
if (z2 != noData) {
switch (i) {
case 0:
h = 2 * Rx.getValue(y, x) + 1;
break;
case 1:
h = 2 * (Rx.getValue(y, x) + Ry.getValue(y, x) + 1);
break;
case 2:
h = 2 * Ry.getValue(y, x) + 1;
break;
case 3:
h = 2 * (Rx.getValue(y, x) + Ry.getValue(y, x) + 1);
break;
}
z2 += h;
if (z2 < zMin) {
zMin = z2;
whichCell = i;
}
}
}
if (zMin < z) {
outputImage.setValue(row, col, zMin);
x = col + dX[whichCell];
y = row + dY[whichCell];
Rx.setValue(row, col, Rx.getValue(y, x) + Gx[whichCell]);
Ry.setValue(row, col, Ry.getValue(y, x) + Gy[whichCell]);
}
}
}
if (cancelOp) {
cancelOperation();
return;
}
progress = (int) (100f * row / (rows - 1));
updateProgress("Calculating distances: ", progress);
}
for (row = rows - 1; row >= 0; row--) {
for (col = cols - 1; col >= 0; col--) {
z = outputImage.getValue(row, col);
if (z != 0) {
zMin = infVal;
whichCell = -1;
for (i = 4; i <= 7; i++) {
x = col + dX[i];
y = row + dY[i];
z2 = outputImage.getValue(y, x);
if (z2 != noData) {
switch (i) {
case 5:
h = 2 * (Rx.getValue(y, x) + Ry.getValue(y, x) + 1);
break;
case 4:
h = 2 * Rx.getValue(y, x) + 1;
break;
case 6:
h = 2 * Ry.getValue(y, x) + 1;
break;
case 7:
h = 2 * (Rx.getValue(y, x) + Ry.getValue(y, x) + 1);
break;
}
z2 += h;
if (z2 < zMin) {
zMin = z2;
whichCell = i;
}
}
}
if (zMin < z) {
outputImage.setValue(row, col, zMin);
x = col + dX[whichCell];
y = row + dY[whichCell];
Rx.setValue(row, col, Rx.getValue(y, x) + Gx[whichCell]);
Ry.setValue(row, col, Ry.getValue(y, x) + Gy[whichCell]);
}
}
}
if (cancelOp) {
cancelOperation();
return;
}
progress = (int) (100f * (rows - 1 - row) / (rows - 1));
updateProgress("Calculating distances: ", progress);
}
// for (row = 0; row < rows; row++) {
// for (col = 0; col < cols; col++) {
// z = outputImage.getValue(row, col);
// outputImage.setValue(row, col, Math.sqrt(z) * gridRes);
// }
// if (cancelOp) {
// cancelOperation();
// return;
// }
// progress = (int) (100f * row / (rows - 1));
// updateProgress(progress);
// }
outputImage.flush();
Rx.close();
Ry.close();
}
@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();
}
}
