void setFlow2(int i, int j, linearpart<short>& flowDir, T& elev, SparsePartition<int>& inc) { /* This function sets directions based upon secondary elevations for assignment of flow directions across flats according to Garbrecht and Martz scheme. There are two possibilities: A. The neighbor is outside the flat set B. The neighbor is in the flat set. In the case of A the input elevations are used and if a draining neighbor is found it is selected. Case B requires slope to be positive. Remaining flats are removed by iterating this process */ int nx = flowDir.getnx(); int ny = flowDir.getny(); const short order[8]= {1,3,5,7,2,4,6,8}; float slopeMax = 0; for (short k : order) { int in = i+d1[k]; int jn = j+d2[k]; if (!flowDir.hasAccess(in, jn)) continue; if (inc.getData(in, jn) > 0) { // Neighbor is in flat float slope = fact[j][k]*(inc.getData(i, j) - inc.getData(in, jn)); if (slope > slopeMax) { flowDir.setData(i, j, k); slopeMax = slope; } } else { // Neighbor is not in flat auto ed = elev.getData(i, j) - elev.getData(in, jn); if (ed >= 0) { // Found a way out - this is outlet flowDir.setData(i, j, k); break; } } } }
size_t propagateIncrements(linearpart<float>& flowDir, SparsePartition<short>& inc, std::vector<node>& queue) { size_t numInc = 0; int st = 1; std::vector<node> newFlats; while (!queue.empty()) { for(node flat : queue) { // Duplicate. already set if (inc.getData(flat.x, flat.y) > 0) continue; for (int k = 1; k <= 8; k++) { if (dontCross(k, flat.x, flat.y, flowDir) == 0) { int in = flat.x + d1[k]; int jn = flat.y + d2[k]; if (!flowDir.isInPartition(in, jn)) continue; float flow = flowDir.getData(in, jn); if (flow == -1 && inc.getData(in, jn) == 0) { newFlats.push_back(node(in, jn)); inc.setData(in, jn, -1); } } } numInc++; inc.setData(flat.x, flat.y, st); } queue.clear(); queue.swap(newFlats); st++; } return numInc; }
int markPits(T& elevDEM, linearpart<float>& flowDir, std::vector<std::vector<node>>&islands, SparsePartition<short>& inc) { int nx = flowDir.getnx(); int ny = flowDir.getny(); int numPits = 0; //There are pits remaining - set direction to no data for (auto& island : islands) { for (node flat : island) { bool skip = false; for (int k=1; k<=8; k++) { if (dontCross(k, flat.x, flat.y, flowDir)==0) { int jn = flat.y + d2[k]; int in = flat.x + d1[k]; if (!flowDir.hasAccess(in, jn)) continue; auto elevDiff = elevDEM.getData(flat.x, flat.y) - elevDEM.getData(in, jn); float flow = flowDir.getData(in, jn); // Adjacent cell drains and is equal or lower in elevation so this is a low boundary if (elevDiff >= 0 && flow == -1) { skip = true; break; } else if (flow == -1) { // If neighbor is in flat // FIXME: check if this is correct if (inc.getData(in,jn) >= 0){ // && inc.getData(in,jn)<st) { skip = true; break; } } } } // mark pit if (!skip) { numPits++; flowDir.setToNodata(flat.x, flat.y); } } } return numPits; }
void flowTowardsLower(T& elev, linearpart<float>& flowDir, std::vector<std::vector<node>>&islands, SparsePartition<short>& inc) { long nx = flowDir.getnx(); long ny = flowDir.getny(); std::vector<node> lowBoundaries; // Find low boundaries. for(auto& island : islands) { for(node flat : island) { float flatElev = elev.getData(flat.x, flat.y); for (int k = 1; k <= 8; k++) { if (dontCross(k, flat.x, flat.y, flowDir) == 0) { int in = flat.x + d1[k]; int jn = flat.y + d2[k]; if (!flowDir.hasAccess(in, jn)) continue; auto elevDiff = flatElev - elev.getData(in,jn); float flow = flowDir.getData(in, jn); bool edgeDrain = flowDir.isNodata(in, jn); // Adjacent cell drains and is equal or lower in elevation so this is a low boundary if ((elevDiff >= 0 && flow >= 0.0) || edgeDrain) { lowBoundaries.push_back(flat); inc.setData(flat.x, flat.y, -1); // No need to check the other neighbors break; } } } } } size_t numInc = propagateIncrements(flowDir, inc, lowBoundaries); // Not all grid cells were resolved - pits remain // Remaining grid cells are unresolvable pits if (numInc > 0) { markPits(elev, flowDir, islands, inc); } }
void flowFromHigher(T& elev, linearpart<float>& flowDir, std::vector<std::vector<node>>&islands, SparsePartition<short>& inc) { long nx = flowDir.getnx(); long ny = flowDir.getny(); // Find high boundaries for (auto& island : islands) { std::vector<node> highBoundaries; for (node flat : island) { float flatElev = elev.getData(flat.x, flat.y); bool highBoundary = false; for (int k = 1; k <= 8; k++) { if (dontCross(k, flat.x, flat.y, flowDir) == 0) { int in = flat.x + d1[k]; int jn = flat.y + d2[k]; if (!flowDir.hasAccess(in, jn)) continue; auto elevDiff = flatElev - elev.getData(in, jn); if (elevDiff < 0) { // Adjacent cell has higher elevation so this is a high boundary highBoundary = true; break; } } } if (highBoundary) { inc.setData(flat.x, flat.y, -1); highBoundaries.push_back(flat); } } propagateIncrements(flowDir, inc, highBoundaries); } }
long resolveFlats_parallel(T& elev, SparsePartition<short>& inc, linearpart<float>& flowDir, std::vector<std::vector<node>>&islands, linearpart<float>& orelevDir) { long nx = flowDir.getnx(); long ny = flowDir.getny(); int rank; MPI_Comm_rank(MCW, &rank); int numFlatsChanged = 0, totalNumFlatsChanged = 0; flowTowardsLower(elev, flowDir, islands, inc); do { inc.share(); numFlatsChanged = propagateBorderIncrements(flowDir, inc); MPI_Allreduce(&numFlatsChanged, &totalNumFlatsChanged, 1, MPI_INT, MPI_SUM, MCW); if (rank == 0) { printf("PRL: Lower gradient processed %d flats this iteration\n", totalNumFlatsChanged); } } while(totalNumFlatsChanged > 0); // Not all grid cells were resolved - pits remain // Remaining grid cells are unresolvable pits markPits(elev, flowDir, islands, inc); // Drain flats away from higher adjacent terrain SparsePartition<short> higherGradient(nx, ny, 0); flowFromHigher(elev, flowDir, islands, higherGradient); do { higherGradient.share(); numFlatsChanged = propagateBorderIncrements(flowDir, higherGradient); MPI_Allreduce(&numFlatsChanged, &totalNumFlatsChanged, 1, MPI_INT, MPI_SUM, MCW); if (rank == 0) { printf("PRL: Higher gradient processed %d flats this iteration\n", totalNumFlatsChanged); } } while(totalNumFlatsChanged > 0); // High flow must be inverted before it is combined // // higherFlowMax has to be greater than all of the increments // higherFlowMax can be maximum value of the data type (e.g. 65535) but it will cause overflow problems if more than one iteration is needed short higherFlowMax = 0; for (auto& island : islands) { for (auto& flat : island) { short val = higherGradient.getData(flat.x, flat.y); if (val > higherFlowMax) higherFlowMax = val; } } // FIXME: Is this needed? would it affect directions at the border? short globalHigherFlowmax = 0; MPI_Allreduce(&higherFlowMax, &globalHigherFlowmax, 1, MPI_SHORT, MPI_MAX, MCW); for (auto& island : islands) { for (auto flat : island) { inc.addToData(flat.x, flat.y, globalHigherFlowmax - higherGradient.getData(flat.x, flat.y)); } } inc.share(); if (rank==0) { fprintf(stderr,"\nPRL: Setting directions\n"); fflush(stderr); } uint64_t localFlatsRemaining = 0, globalFlatsRemaining = 0; double tempdxc, tempdyc; for (auto& island : islands) { for (node flat : island) { //setFlow2(flat.x, flat.y, flowDir, elev, inc); orelevDir.getdxdyc(flat.y, tempdxc, tempdyc); float DXX[3] = {0, tempdxc, tempdyc}; //tardemlib.cpp ln 1291 float DD = sqrt(tempdxc * tempdxc + tempdyc * tempdyc); //tardemlib.cpp ln 1293 SET2(flat.y, flat.x, DXX, DD, elev, inc, flowDir); if (flowDir.getData(flat.x, flat.y) == -1) { localFlatsRemaining++; } } } flowDir.share(); MPI_Allreduce(&localFlatsRemaining, &globalFlatsRemaining, 1, MPI_UINT64_T, MPI_SUM, MCW); auto hasFlowDirection = [&](const node& n) { return flowDir.getData(n.x, n.y) != -1; }; auto isEmpty = [&](const std::vector<node>& i) { return i.empty(); }; // Remove flats which have flow direction set for (auto& island : islands) { island.erase(std::remove_if(island.begin(), island.end(), hasFlowDirection), island.end()); } // Remove empty islands islands.erase(std::remove_if(islands.begin(), islands.end(), isEmpty), islands.end()); return globalFlatsRemaining; }
long resolveFlats(T& elevDEM, SparsePartition<short>& inc, linearpart<float>& flowDir, std::vector<std::vector<node>>&islands, linearpart<float>& orelevDir) { long nx = flowDir.getnx(); long ny = flowDir.getny(); int rank; MPI_Comm_rank(MCW, &rank); if (rank==0) { fprintf(stderr,"Resolving flats\n"); fflush(stderr); } flowTowardsLower(elevDEM, flowDir, islands, inc); // Drain flats away from higher adjacent terrain SparsePartition<short> s(nx, ny, 0); flowFromHigher(elevDEM, flowDir, islands, s); // High flow must be inverted before it is combined // // higherFlowMax has to be greater than all of the increments // higherFlowMax can be maximum value of the data type but it will cause overflow problems if more than one iteration is needed short higherFlowMax = 0; for (auto& island : islands) { for (node flat : island) { short val = s.getData(flat.x, flat.y); if (val > higherFlowMax) higherFlowMax = val; } } for (auto& island : islands) { for (auto flat : island) { inc.addToData(flat.x, flat.y, higherFlowMax - s.getData(flat.x, flat.y)); } } if (rank==0) { fprintf(stderr,"Setting directions\n"); fflush(stderr); } long flatsRemaining = 0; double tempdxc, tempdyc; for (auto& island : islands) { for (node flat : island) { //setFlow2(flat.x, flat.y, flowDir, elevDEM, inc); orelevDir.getdxdyc(flat.y, tempdxc, tempdyc); float DXX[3] = {0, tempdxc, tempdyc}; //tardemlib.cpp ln 1291 float DD = sqrt(tempdxc * tempdxc + tempdyc * tempdyc); //tardemlib.cpp ln 1293 SET2(flat.y, flat.x, DXX, DD, elevDEM, inc, flowDir); if (flowDir.getData(flat.x, flat.y) == -1) { flatsRemaining++; } } } auto hasFlowDirection = [&](const node& n) { return flowDir.getData(n.x, n.y) != -1; }; auto isEmpty = [&](const std::vector<node>& i) { return i.empty(); }; // Remove flats which have flow direction set for (auto& island : islands) { island.erase(std::remove_if(island.begin(), island.end(), hasFlowDirection), island.end()); } // Remove empty islands islands.erase(std::remove_if(islands.begin(), islands.end(), isEmpty), islands.end()); return flatsRemaining; }
void SET2(int I, int J, float *DXX, float DD, T& elevDEM, SparsePartition<short>& elev2, linearpart<float>& flowDir) { float SK[9]; float ANGLE[9]; float SMAX = 0.0; float tempFloat; short tempShort, tempShort1, tempShort2; int K; int KD = 0; int ID1[] = {0, 1, 2, 2, 1, 1, 2, 2, 1}; int ID2[] = {0, 2, 1, 1, 2, 2, 1, 1, 2}; int I1[] = {0, 0, -1, -1, 0, 0, 1, 1, 0}; int I2[] = {0, -1, -1, -1, -1, 1, 1, 1, 1}; int J1[] = {0, 1, 0, 0, -1, -1, 0, 0, 1}; int J2[] = {0, 1, 1, -1, -1, -1, -1, 1, 1}; float ANGC[] = {0, 0., 1., 1., 2., 2., 3., 3., 4.}; float ANGF[] = {0, 1., -1., 1., -1., 1., -1., 1., -1.}; bool diagOutFound = false; for (K = 1; K <= 8; K++) { tempShort1 = elev2.getData(J + J1[K], I + I1[K]); tempShort2 = elev2.getData(J + J2[K], I + I2[K]); if (tempShort1 <= 0 && tempShort2 <= 0) { //Both E1 and E2 are outside the flat get slope and angle float a = elevDEM.getData(J, I); float b = elevDEM.getData(J + J1[K], I + I1[K]); float c = elevDEM.getData(J + J2[K], I + I2[K]); VSLOPE( a, //E0 b, //E1 c, //E2 DXX[ID1[K]], //dx or dy depending on ID1 DXX[ID2[K]], //dx or dy depending on ID2 DD, //Hypotenuse &SK[K], //Slope Returned &ANGLE[K]//Angle Returned ); if (SK[K] >= 0.0) // Found an outlet { if (b > a) // Outlet found had better be a diagonal, because it is not an edge { if (!diagOutFound) { diagOutFound = true; KD = K; } } else { // Here it is an adjacent outlet KD = K; break; } } } else if (tempShort1 <= 0 && tempShort2 > 0) {//E1 is outside of the flat and E2 is inside the flat. Use DEM elevations. tempShort2/E2 is in the artificial grid float a = elevDEM.getData(J, I); float b = elevDEM.getData(J + J1[K], I + I1[K]); if (a >= b) { ANGLE[K] = 0.0; SK[K] = 0.0; KD = K; break; } short a1 = elev2.getData(J, I); short c1 = elev2.getData(J + J2[K], I + I2[K]); short b1 = max(a1, c1); VSLOPE( (float) a1, //felevg.d[J][I], (float) b1, //[felevg.d[J+J1[K]][I+I1[K]], (float) c1, //felevg.d[J+J2[K]][I+I2[K]], DXX[ID1[K]], //dx or dy DXX[ID2[K]], //dx or dy DD, //Hypotenuse &SK[K], //Slope Returned &ANGLE[K]//Angle Reutnred ); if (SK[K] > SMAX) { SMAX = SK[K]; KD = K; } } else if (tempShort1 > 0 && tempShort2 <= 0) {//E2 is out side of the flat and E1 is inside the flat, use DEM elevations float a = elevDEM.getData(J, I); //float b=elevDEM->getData(J+J1[K],I+I1[K],tempFloat); float c = elevDEM.getData(J + J2[K], I + I2[K]); if (a >= c) { if (!diagOutFound) { ANGLE[K] = (float) atan2(DXX[ID2[K]], DXX[ID1[K]]); SK[K] = 0.0; KD = K; diagOutFound = true; } } else { short a1 = elev2.getData(J, I); short b1 = elev2.getData(J + J1[K], I + I1[K]); short c1 = max(a1, b1); VSLOPE( (float) a1, //felevg.d[J][I], (float) b1, //[felevg.d[J+J1[K]][I+I1[K]], (float) c1, //felevg.d[J+J2[K]][I+I2[K]], DXX[ID1[K]], //dx or dy DXX[ID2[K]], //dx or dy DD, //Hypotenuse &SK[K], //Slope Returned &ANGLE[K]//Angle Reutnred ); if (SK[K] > SMAX) { SMAX = SK[K]; KD = K; } } } else {//Both E1 and E2 are in the flat. Use artificial elevation to get slope and angle short a, b, c; a = elev2.getData(J, I); b = elev2.getData(J + J1[K], I + I1[K]); c = elev2.getData(J + J2[K], I + I2[K]); VSLOPE( (float) a, //felevg.d[J][I], (float) b, //[felevg.d[J+J1[K]][I+I1[K]], (float) c, //felevg.d[J+J2[K]][I+I2[K]], DXX[ID1[K]], //dx or dy DXX[ID2[K]], //dx or dy DD, //Hypotenuse &SK[K], //Slope Returned &ANGLE[K]//Angle Reutnred ); if (SK[K] > SMAX) { SMAX = SK[K]; KD = K; } } } //USE -1 TO INDICATE DIRECTION NOT YET SET, // but only for non pit grid cells. Pits will have flowDir as no data if (!flowDir.isNodata(J, I)) { tempFloat = -1; flowDir.setData(J, I, tempFloat); } if (KD > 0)//We have a flow direction. Calculate the Angle and save/write it. { tempFloat = (float) (ANGC[KD]*(PI / 2) + ANGF[KD] * ANGLE[KD]); //Calculate the Angle if (tempFloat >= 0.0)//Make sure the angle is positive flowDir.setData(J, I, tempFloat); //set the angle in the flowPartition } }
size_t propagateBorderIncrements(linearpart<float>& flowDir, SparsePartition<short>& inc) { int nx = flowDir.getnx(); int ny = flowDir.getny(); struct pnode { int x; int y; int inc; bool operator<(const struct pnode& b) const { return inc < b.inc; } }; std::vector<pnode> queue; // Find the starting nodes at the edge of the raster // // FIXME: oob access for (auto y : {-1, ny}) { for(int x = 0; x < nx; x++) { int st = inc.getData(x, y); if (st == 0) continue; auto jn = y == -1 ? 0 : ny - 1; for (auto in : {x-1, x, x+1}) { if (!flowDir.isInPartition(in, jn)) continue; float flow = flowDir.getData(in, jn); auto neighSt = inc.getData(in, jn); if (flow == -1 && (neighSt == 0 || neighSt > st + 1 || -neighSt > st + 1)) { queue.push_back({in, jn, st + 1}); // Here we set a negative increment if it's still pending // // Another flat might be neighboring the same cell with a lower increment, // which has to override the higher increment (that hasn't been set yet but is in the queue). inc.setData(in, jn, -(st + 1)); } } } } size_t numChanged = 0; // Sort queue by lowest increment std::sort(queue.begin(), queue.end()); std::vector<pnode> newFlats; while (!queue.empty()) { for(pnode flat : queue) { // Skip if the increment was already set and it is lower auto st = inc.getData(flat.x, flat.y); if (st > 0 && st <= flat.inc) { continue; } for (int k = 1; k <= 8; k++) { if (dontCross(k, flat.x, flat.y, flowDir) == 0) { int in = flat.x + d1[k]; int jn = flat.y + d2[k]; if (!flowDir.isInPartition(in, jn)) continue; float flow = flowDir.getData(in, jn); auto neighInc = inc.getData(in, jn); if (flow == -1 && (neighInc == 0 || neighInc > flat.inc + 1 || -neighInc > flat.inc + 1)) { newFlats.push_back({in, jn, flat.inc + 1}); inc.setData(in, jn, -(flat.inc + 1)); } } } inc.setData(flat.x, flat.y, flat.inc); numChanged++; } std::sort(newFlats.begin(), newFlats.end()); queue.clear(); queue.swap(newFlats); } return numChanged; }