void DBVPolyIF::FourColoring () { char nameStr [DBStringLength]; DBInt symbol, maxSymbol = 0, line, index; DBObjRecord *polyRec,*searchPoly, *neighborPolyRec, *lineRec, *symRec; for (polyRec = FirstItem ();polyRec != (DBObjRecord *) NULL;polyRec = NextItem ()) SymbolFLD->Record (polyRec,(DBObjRecord *) NULL); ListSort (LineNumFLD); for (searchPoly = FirstItem ();searchPoly != (DBObjRecord *) NULL;searchPoly = NextItem ()) { if (((DBInt) (SymbolFLD->Record (searchPoly) - (DBObjRecord *) NULL)) != 0) continue; DBPause (searchPoly->RowID () * 100 / ItemNum ()); symbol = 1; Restart: for (polyRec = ItemTable->First (&index);polyRec != (DBObjRecord *) NULL;polyRec = ItemTable->Next (&index)) { if (strcmp (polyRec->Name (),searchPoly->Name ()) != 0) continue; lineRec = FirstLine (polyRec); for (line = 0;line <= LineNum (polyRec);++line) { if (LineRightPoly (lineRec) == polyRec) { neighborPolyRec = LineLeftPoly (lineRec); lineRec = LineNextLine (lineRec); } else { neighborPolyRec = LineRightPoly (lineRec); lineRec = LinePrevLine (lineRec); } if (neighborPolyRec == (DBObjRecord *) NULL) continue; if (SymbolFLD->Record (neighborPolyRec) == (DBObjRecord *) symbol) { symbol++; goto Restart; } } } for (polyRec = ItemTable->First (&index);polyRec != (DBObjRecord *) NULL;polyRec = ItemTable->Next (&index)) if (strcmp (polyRec->Name (),searchPoly->Name ()) == 0) SymbolFLD->Record (polyRec,(DBObjRecord *) symbol); maxSymbol = maxSymbol > symbol ? maxSymbol : symbol; } while (maxSymbol < SymbolTable->ItemNum ()) SymbolTable->Remove (SymbolTable->ItemNum () - 1); while (maxSymbol > SymbolTable->ItemNum ()) SymbolTable->Add (); for (symbol = 0;symbol < SymbolTable->ItemNum ();++symbol) { symRec = SymbolTable->Item (symbol); sprintf (nameStr,"Symbol:%2d",symbol); symRec->Name (nameStr); StyleFLD->Int (symRec,0); ForegroundFLD->Int (symRec,1); BackgroundFLD->Int (symRec,0); } for (polyRec = FirstItem ();polyRec != (DBObjRecord *) NULL;polyRec = NextItem ()) SymbolFLD->Record (polyRec,SymbolTable->Item ((DBInt) (SymbolFLD->Record (polyRec) - (DBObjRecord *) NULL) - 1)); ListReset (); }
int DBNetworkIF::Trim () { DBInt i, row, col; DBPosition pos, min, max; DBRegion extent = DataPTR->Extent (); DBObjRecord *cellRec; DBCoordinate coord; min.Row = RowNum (); min.Col = ColNum (); max.Row = max.Col = 0; for (i = 0;i < CellNum ();++i) { DBPause (33 * i / CellNum ()); cellRec = CellTable->Item (i); pos = CellPosition (cellRec); min.Row = min.Row < pos.Row ? min.Row : pos.Row; min.Col = min.Col < pos.Col ? min.Col : pos.Col; max.Row = max.Row > pos.Row ? max.Row : pos.Row; max.Col = max.Col > pos.Col ? max.Col : pos.Col; } for (i = 0;i < CellNum ();++i) { DBPause (33 + 33 * i / CellNum ()); cellRec = CellTable->Item (i); pos = CellPosition (cellRec); pos.Row = pos.Row - min.Row; pos.Col = pos.Col - min.Col; PositionFLD->Position (cellRec,pos); } coord.X = min.Col * CellWidth (); coord.Y = min.Row * CellHeight (); extent.LowerLeft = extent.LowerLeft + coord; coord.X = (ColNum () - max.Col - 1) * CellWidth (); coord.Y = (RowNum () - max.Row - 1) * CellHeight (); extent.UpperRight = extent.UpperRight - coord; DataPTR->Extent (extent); row = max.Row - min.Row + 1; col = max.Col - min.Col + 1; RowNumFLD->Int (LayerRecord,row); ColNumFLD->Int (LayerRecord,col); DataRec->Realloc (row * col * sizeof (int)); for (row = 0;row < RowNum ();row++) for (col = 0;col < ColNum ();col++) ((DBInt *) DataRec->Data ()) [row * ColNum () + col] = DBFault; for (i = 0;i < CellNum ();++i) { DBPause (67 + 33 * i / CellNum ()); pos = CellPosition (CellTable->Item (i)); ((DBInt *) DataRec->Data ()) [pos.Row * ColNum () + pos.Col] = cellRec->RowID (); } return (DBSuccess); }
void DBNetworkIF::SetDistToMouth () { DBInt cellID; DBObjRecord *cellRec, *upCellRec; if (DistToMouthFLD == (DBObjTableField *) NULL) { DistToMouthFLD = new DBObjTableField (DBrNDistToMouth,DBTableFieldFloat,"%8.0f",sizeof (DBFloat)); CellTable->AddField (DistToMouthFLD); } for (cellID = 0;cellID < CellNum ();++cellID) { cellRec = Cell (cellID); DistToMouthFLD->Float (cellRec,CellLength (cellRec)); } for (cellID = 0;cellID < CellNum ();++cellID) { cellRec = Cell (cellID); DBPause (cellID * 100 / CellNum ()); if ((upCellRec = FromCell (cellRec)) != (DBObjRecord *) NULL) DistToMouthFLD->Float (upCellRec,DistToMouthFLD->Float (upCellRec) + DistToMouthFLD->Float (cellRec)); } }
DBInt RGlibPointSTNCoordinates(DBObjData *dbData, DBObjTableField *field) { DBInt pointID, ret = DBFault; DBCoordinate coord; DBPosition pos; DBObjData *linkedData = dbData->LinkedData(); DBVPointIF *pntIF; DBNetworkIF *netIF; DBObjRecord *pntRec, *cellRec; if (linkedData == (DBObjData *) NULL) return (DBFault); pntIF = new DBVPointIF(dbData); netIF = new DBNetworkIF(linkedData); for (pointID = 0; pointID < pntIF->ItemNum(); ++pointID) { pntRec = pntIF->Item(pointID); if (DBPause(pointID * 100 / pntIF->ItemNum())) goto Stop; if ((pntRec->Flags () & DBObjectFlagIdle) == DBObjectFlagIdle) continue; coord = pntIF->Coordinate(pntRec); if (netIF->Coord2Pos(coord, pos) == DBFault) continue; netIF->Pos2Coord(pos, coord); if ((field != (DBObjTableField *) NULL) && (!CMmathEqualValues(field->Float(pntRec), field->FloatNoData())) && ((cellRec = netIF->Cell(coord, field->Float(pntRec))) != (DBObjRecord *) NULL)) coord = netIF->Center(cellRec); pntIF->Coordinate(pntRec, coord); } ret = DBSuccess; Stop: delete netIF; delete pntIF; return (ret); }
void DBNetworkIF::SetDistToOcean () { DBInt cellID, dir; DBObjRecord *cellRec, *upCellRec; if (DistToOceanFLD == (DBObjTableField *) NULL) { DistToOceanFLD = new DBObjTableField (DBrNDistToOcean,DBTableFieldFloat,"%8.0f",sizeof (DBFloat)); CellTable->AddField (DistToOceanFLD); } for (cellID = 0;cellID < CellNum ();++cellID) { cellRec = Cell (cellID); DistToOceanFLD->Float (cellRec,CellLength (cellRec)); } for (cellID = 0;cellID < CellNum ();++cellID) { cellRec = Cell (cellID); DBPause (cellRec->RowID () * 100 / CellNum ()); for (dir = 0;dir < 8;++dir) if ((upCellRec = FromCell (cellRec,0x01 << dir)) != (DBObjRecord *) NULL) DistToOceanFLD->Float (upCellRec,DistToOceanFLD->Float (upCellRec) + DistToOceanFLD->Float (cellRec)); } }
void DBGridOperationAbs(DBObjData *grdData) { DBInt layerID; DBFloat value; DBPosition pos; DBObjRecord *layerRec; DBGridIF *gridIF = new DBGridIF(grdData); for (layerID = 0; layerID < gridIF->LayerNum(); ++layerID) { layerRec = gridIF->Layer(layerID); if ((layerRec->Flags() & DBObjectFlagIdle) != DBObjectFlagIdle) break; } if (layerID == gridIF->LayerNum()) { CMmsgPrint(CMmsgAppError, "No Layer to Process in %s %d", __FILE__, __LINE__); return; } for (layerID = 0; layerID < gridIF->LayerNum(); ++layerID) { layerRec = gridIF->Layer(layerID); if ((layerRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) continue; for (pos.Row = 0; pos.Row < gridIF->RowNum(); pos.Row++) { if (DBPause((layerID * gridIF->RowNum() + pos.Row) * 100 / (gridIF->LayerNum() * gridIF->RowNum()))) goto Stop; for (pos.Col = 0; pos.Col < gridIF->ColNum(); pos.Col++) if (gridIF->Value(layerRec, pos, &value)) gridIF->Value(layerRec, pos, fabs(value)); } gridIF->RecalcStats(layerRec); } Stop: return; }
int RGlibGenFuncSymbolField (DBObjData *data, const char *fieldName) { DBInt recID; char symbolName [DBStringLength + 1]; DBObjTable *table = data->Table (DBrNItems); DBObjTable *symbols = data->Table (DBrNSymbols); DBObjRecord *record, *symbolRec; DBObjTableField *field; DBObjTableField *symbolFLD; DBObjTableField *symbolIDFLD; DBObjTableField *foregroundFLD; DBObjTableField *backgroundFLD; DBObjTableField *styleFLD; if (table == (DBObjTable *) NULL) return (DBFault); if ((field = table->Field (fieldName)) == (DBObjTableField *) NULL) { CMmsgPrint (CMmsgAppError, "Invalid field name in: %s %d",__FILE__,__LINE__); return (DBFault); } if ((symbolFLD = table->Field (DBrNSymbol)) == (DBObjTableField *) NULL) { CMmsgPrint (CMmsgAppError, "Missing symbol field in: %s %d",__FILE__,__LINE__); return (DBFault); } if (symbols == (DBObjTable *) NULL) { CMmsgPrint (CMmsgAppError, "Missing symbol table in: %s %d",__FILE__,__LINE__); return (DBFault); } if ((symbolIDFLD = symbols->Field (DBrNSymbolID)) == (DBObjTableField *) NULL) { CMmsgPrint (CMmsgAppError, "Missing symbolID field in: %s %d",__FILE__,__LINE__); return (DBFault); } if ((foregroundFLD = symbols->Field (DBrNForeground)) == (DBObjTableField *) NULL) { CMmsgPrint (CMmsgAppError, "Missing foreground field in: %s %d",__FILE__,__LINE__); return (DBFault); } if ((backgroundFLD = symbols->Field (DBrNBackground)) == (DBObjTableField *) NULL) { CMmsgPrint (CMmsgAppError, "Missing background field in: %s %d",__FILE__,__LINE__); return (DBFault); } if ((styleFLD = symbols->Field (DBrNStyle)) == (DBObjTableField *) NULL) { CMmsgPrint (CMmsgAppError, "Missing style field in: %s %d",__FILE__,__LINE__); return (DBFault); } symbols->DeleteAll (); for (recID = 0;recID < table->ItemNum (); ++recID) { record = table->Item (recID); DBPause (record->RowID () * 100 / table->ItemNum ()); if (field->Type () == DBTableFieldString) sprintf (symbolName,"%s",field->String (record)); else sprintf (symbolName,"Symbol:%03d",field->Int (record)); if ((symbolRec = (DBObjRecord *) symbols->Item (symbolName)) == (DBObjRecord *) NULL) { if ((symbolRec = symbols->Add (symbolName)) == NULL) { CMmsgPrint (CMmsgAppError, "Symbol Object Creation Error in: %s %d",__FILE__,__LINE__); return (DBFault); } symbolIDFLD->Int (symbolRec,field->Type () == DBTableFieldString ? symbolRec->RowID () : field->Int (record)); foregroundFLD->Int (symbolRec,1); backgroundFLD->Int (symbolRec,0); styleFLD->Int (symbolRec,0); } symbolFLD->Record (record,symbolRec); } return (DBSuccess); }
DBInt RGlibPointSubbasinCenter(DBObjData *pntData, DBObjData *netData) { DBCoordinate massCoord; DBVPointIF *pntIF = new DBVPointIF(pntData); DBObjTable *pointTable = pntData->Table(DBrNItems); DBObjTableField *massCoordXFLD = pointTable->Field(RGlibMassCoordX); DBObjTableField *massCoordYFLD = pointTable->Field(RGlibMassCoordY); DBNetworkIF *netIF = new DBNetworkIF(netData); DBObjRecord *pointRec, *cellRec; if (massCoordXFLD == NULL) { massCoordXFLD = new DBObjTableField(RGlibMassCoordX, DBTableFieldFloat, "%10.3f", sizeof(DBFloat4)); pointTable->AddField(massCoordXFLD); } if (massCoordYFLD == NULL) { massCoordYFLD = new DBObjTableField(RGlibMassCoordY, DBTableFieldFloat, "%10.3f", sizeof(DBFloat4)); pointTable->AddField(massCoordYFLD); } for (pointRec = pntIF->FirstItem(); pointRec != (DBObjRecord *) NULL; pointRec = pntIF->NextItem()) { if ((pointRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) { massCoordXFLD->Float(pointRec, massCoordXFLD->FloatNoData()); massCoordYFLD->Float(pointRec, massCoordYFLD->FloatNoData()); continue; } if (DBPause(pointRec->RowID() * 100 / pntIF->ItemNum())) goto Stop; if ((cellRec = netIF->Cell(pntIF->Coordinate(pointRec))) == (DBObjRecord *) NULL) massCoord = pntIF->Coordinate(pointRec); else { if (netIF->CellBasinCells(cellRec) > 1) { massCoord.X = 0.0; massCoord.Y = 0.0; netIF->UpStreamSearch(cellRec, (DBNetworkACTION) _RGlibSubbasinCenterAction, &massCoord); massCoord.X = massCoord.X / (DBFloat) netIF->CellBasinCells(cellRec); massCoord.Y = massCoord.Y / (DBFloat) netIF->CellBasinCells(cellRec); } else massCoord = netIF->Center(cellRec); } massCoordXFLD->Float(pointRec, massCoord.X); massCoordYFLD->Float(pointRec, massCoord.Y); } Stop: if (pointRec != (DBObjRecord *) NULL) { pointTable->DeleteField(massCoordXFLD); pointTable->DeleteField(massCoordYFLD); return (DBFault); } return (DBSuccess); }
DBInt RGlibGenFuncTopoAccum (DBObjTable *table,char *nextStnFldName,char *srcFldName,char *dstFldName) { DBInt rowID; DBObjTableField *srcField, *dstField, *nextField; DBObjRecord *record, *nextRec; if (((srcField = table->Field (srcFldName)) == (DBObjTableField *) NULL) || ((nextField =table->Field (nextStnFldName)) == (DBObjTableField *) NULL)) return (DBFault); if ((dstField = table->Field (dstFldName)) == (DBObjTableField *) NULL) { dstField = new DBObjTableField (*srcField); dstField->Name (dstFldName); table->AddField (dstField); } for (rowID = 0;rowID < table->ItemNum ();++rowID) { record = table->Item (rowID); dstField->Float (record,srcField->Float (record)); record->Flags (DBObjectFlagSelected,DBClear); } for (rowID = 0;rowID < table->ItemNum ();++rowID) { record = table->Item (rowID); DBPause (rowID * 100 / table->ItemNum ()); if ((record->Flags () & DBObjectFlagIdle) == DBObjectFlagIdle) { dstField->Float (record,dstField->FloatNoData ()); continue; } for (nextRec = table->Item (nextField->Int (record) - 1); nextRec != (DBObjRecord *) NULL; nextRec = table->Item (nextField->Int (nextRec) - 1)) { if (nextRec == record) { record->Flags (DBObjectFlagSelected,DBSet); break; } if ((nextRec->Flags () & DBObjectFlagIdle) != DBObjectFlagIdle) { if (CMmathEqualValues (dstField->Float (nextRec),dstField->FloatNoData ()) || CMmathEqualValues (srcField->Float (record),srcField->FloatNoData ())) dstField->Float (nextRec,dstField->FloatNoData ()); else dstField->Float (nextRec,dstField->Float (nextRec) + srcField->Float (record)); } } } return (DBSuccess); }
void DBGridOperation(DBObjData *grdData, DBFloat constant, DBInt oper) { DBInt layerID; DBFloat value; DBPosition pos; DBObjRecord *layerRec; DBGridIF *gridIF = new DBGridIF(grdData); for (layerID = 0; layerID < gridIF->LayerNum(); ++layerID) { layerRec = gridIF->Layer(layerID); if ((layerRec->Flags() & DBObjectFlagIdle) != DBObjectFlagIdle) break; } if (layerID == gridIF->LayerNum()) { CMmsgPrint(CMmsgAppError, "No Layer to Process in %s %d", __FILE__, __LINE__); return; } for (layerID = 0; layerID < gridIF->LayerNum(); ++layerID) { layerRec = gridIF->Layer(layerID); if ((layerRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) continue; for (pos.Row = 0; pos.Row < gridIF->RowNum(); pos.Row++) { if (DBPause((layerID * gridIF->RowNum() + pos.Row) * 100 / (gridIF->LayerNum() * gridIF->RowNum()))) goto Stop; for (pos.Col = 0; pos.Col < gridIF->ColNum(); pos.Col++) { if (gridIF->Value(layerRec, pos, &value)) switch (oper) { case DBMathOperatorAdd: gridIF->Value(layerRec, pos, value + constant); break; case DBMathOperatorSub: gridIF->Value(layerRec, pos, value - constant); break; case DBMathOperatorMul: gridIF->Value(layerRec, pos, value * constant); break; case DBMathOperatorDiv: gridIF->Value(layerRec, pos, value / constant); break; } } } gridIF->RecalcStats(layerRec); } Stop: return; }
void DBNetworkIF::SetMagnitude () { DBInt cellID; DBObjRecord *cellRec, *toCellRec; if (MagnitudeFLD == (DBObjTableField *) NULL) { MagnitudeFLD = new DBObjTableField (DBrNMagnitude,DBTableFieldInt,"%4d",sizeof (DBShort)); CellTable->AddField (MagnitudeFLD); } for (cellID = 0;cellID < CellNum ();++cellID) { cellRec = Cell (cellID); MagnitudeFLD->Int (cellRec,(FromCellDirs (cellRec) == 0x0) ? 1 : 0); } for (cellID = 0;cellID < CellNum ();++cellID) { cellRec = Cell (cellID); DBPause ((CellNum () - cellRec->RowID ()) * 100 / CellNum ()); if ((toCellRec = ToCell (cellRec)) != (DBObjRecord *) NULL) MagnitudeFLD->Int (toCellRec,MagnitudeFLD->Int (toCellRec) + MagnitudeFLD->Int (cellRec)); } }
void RGISEditLineDirectionCBK (Widget widget, RGISWorkspace *workspace,XmAnyCallbackStruct *callData) { DBFloat elev0, elev1; DBCoordinate coord; DBObjRecord *lineRec; DBDataset *dataset = UIDataset (); DBObjData *lineData = dataset->Data (); DBObjData *gridData = lineData->LinkedData (); DBVLineIF *lineIF = new DBVLineIF (lineData); DBGridIF *gridIF = new DBGridIF (gridData); UIPauseDialogOpen ((char *) "Changing Directionality"); for (lineRec = lineIF->FirstItem ();lineRec != (DBObjRecord *) NULL;lineRec = lineIF->NextItem ()) { DBPause (lineRec->RowID () * 100 / lineIF->ItemNum ()); coord = lineIF->FromCoord (lineRec); if (gridIF->Value (coord,&elev0) == false) continue; coord = lineIF->ToCoord (lineRec); if (gridIF->Value (coord,&elev1) == false) continue; if (elev0 < elev1) lineIF->Flip (lineRec); } UIPauseDialogClose (); }
DBInt LoadPoints (FILE *file,DBObjTable *points,DBRegion *extent) { DBInt swap = DBByteOrder (DBByteOrderLITTLE), pointNum = 0;; DBObjTableField *coordField = points->Field (DBrNCoord); DBObjRecord *record; DBCoordinate coord; if (coordField == (DBObjTableField *) NULL) { CMmsgPrint (CMmsgAppError, "Corrupt Point Data Block in: %s %d",__FILE__,__LINE__); return (DBFault); } for (record = points->First ();record != (DBObjRecord *) NULL;record = (DBObjRecord *) points->Next ()) { if (Read (file,swap) == DBFault) return (DBFault); DBPause ((++pointNum * 100)/ points->ItemNum ()); coord.X = CoordX; coord.Y = CoordY; extent->Expand (coord); coordField->Coordinate (record,coord); } return (DBSuccess); }
DBInt DBPointToGrid(DBObjData *pntData, DBObjData *netData, DBObjData *grdData) { DBInt i; DBPosition pos; DBObjTable *pntTable = pntData->Table(DBrNItems); DBObjTable *grdTable = grdData->Table(DBrNItems); DBObjTable *symTable = grdData->Table(DBrNSymbols); DBObjectLIST<DBObjTableField> *pntFields = pntTable->Fields(); DBObjTableField *pntFLD; DBObjTableField *grdAttribFLD; DBObjTableField *grdFLD = grdTable->Field(DBrNGridValue); DBObjTableField *symFLD = grdTable->Field(DBrNSymbol); DBObjRecord *cellRec, *toCell, *pntRec, *itemRec; DBObjRecord *symRec = symTable->First(); DBVPointIF *pntIF; DBNetworkIF *netIF; DBGridIF *grdIF; pntIF = new DBVPointIF(pntData); netIF = new DBNetworkIF(netData); grdIF = new DBGridIF(grdData); grdIF->RenameLayer(grdIF->Layer((DBInt) 0), (char *) "Subbasins"); for (pos.Row = 0; pos.Row < grdIF->RowNum(); ++pos.Row) for (pos.Col = 0; pos.Col < grdIF->ColNum(); ++pos.Col) grdIF->Value(pos, DBFault); for (pntFLD = pntFields->First(); pntFLD != (DBObjTableField *) NULL; pntFLD = pntFields->Next()) if (DBTableFieldIsVisible(pntFLD)) grdTable->AddField(new DBObjTableField(*pntFLD)); for (i = 0; i < pntIF->ItemNum(); ++i) { DBPause(i * 100 / pntIF->ItemNum()); pntRec = pntIF->Item(i); if ((pntRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) continue; if ((cellRec = netIF->Cell(pntIF->Coordinate(pntRec))) == (DBObjRecord *) NULL) continue; itemRec = grdTable->Add(pntRec->Name()); grdFLD->Int(itemRec, pntRec->RowID() + 1); symFLD->Record(itemRec, symRec); for (pntFLD = pntFields->First(); pntFLD != (DBObjTableField *) NULL; pntFLD = pntFields->Next()) if ((grdAttribFLD = grdTable->Field(pntFLD->Name())) != (DBObjTableField *) NULL) switch (pntFLD->Type()) { case DBTableFieldString: grdAttribFLD->String(itemRec, pntFLD->String(pntRec)); break; case DBTableFieldInt: grdAttribFLD->Int(itemRec, pntFLD->Int(pntRec)); break; case DBTableFieldFloat: grdAttribFLD->Float(itemRec, pntFLD->Float(pntRec)); break; case DBTableFieldDate: grdAttribFLD->Date(itemRec, pntFLD->Date(pntRec)); break; } grdIF->Value(netIF->CellPosition(cellRec), itemRec->RowID()); } for (i = 0; i < netIF->CellNum(); ++i) { if ((cellRec = netIF->Cell(i)) == (DBObjRecord *) NULL) continue; if ((itemRec = grdIF->GridItem(netIF->CellPosition(cellRec))) != (DBObjRecord *) NULL) continue; if ((toCell = netIF->ToCell(cellRec)) == (DBObjRecord *) NULL) continue; if ((itemRec = grdIF->GridItem(netIF->CellPosition(toCell))) != (DBObjRecord *) NULL) grdIF->Value(netIF->CellPosition(cellRec), itemRec->RowID()); } grdIF->DiscreteStats(); delete pntIF; delete netIF; delete grdIF; return (DBSuccess); }
int DBImportARCLine (DBObjData *vecData,const char *arcCov) { FILE *inFile; DBInt arcNum, vertex, swap = DBByteOrder (DBByteOrderLITTLE), floatCov; char fileName [DBDataFileNameLen], objName [DBStringLength]; short infoHeader [50]; DBARCRecord arcRecord; DBObjTable *lines; DBObjTable *nodes; DBObjectLIST<DBObjRecord> *data; DBObjRecord *lineRec, *nodeRec, *dataRec; DBRegion dataExtent = vecData->Extent (), itemExtent; DBObjTableField *fromNodeFLD; DBObjTableField *toNodeFLD; DBObjTableField *leftPolyFLD; DBObjTableField *rightPolyFLD; DBObjTableField *vertexesFLD; DBObjTableField *vertexNumFLD; DBObjTableField *extentFLD; DBObjTableField *coordFLD; DBObjTableField *linkNumFLD; DBCoordinate *vertexes, nodeCoord; DBFloat4 floatVAR [2]; switch (vecData->Type ()) { case DBTypeVectorLine: lines = vecData->Table (DBrNItems); break; case DBTypeVectorPolygon: lines = vecData->Table (DBrNContours); break; default: CMmsgPrint (CMmsgAppError, "Invalide Vector Data Type in: %s %d",__FILE__,__LINE__); return (DBFault); } fromNodeFLD = lines->Field (DBrNFromNode); toNodeFLD = lines->Field (DBrNToNode); leftPolyFLD = lines->Field (DBrNLeftPoly); rightPolyFLD= lines->Field (DBrNRightPoly); vertexesFLD = lines->Field (DBrNVertexes); vertexNumFLD= lines->Field (DBrNVertexNum); extentFLD = lines->Field (DBrNRegion); nodes = vecData->Table (DBrNNodes); coordFLD = nodes->Field (DBrNCoord); linkNumFLD = nodes->Field (DBrNLinkNum); data = vecData->Arrays (); sprintf (fileName,"%s/arc",arcCov); if (access (fileName,R_OK) == DBFault) sprintf (fileName,"%s/arc.adf",arcCov); if ((inFile = fopen (fileName,"r")) == NULL) { CMmsgPrint (CMmsgSysError, "File Opening Error in: %s %d",__FILE__,__LINE__); return (DBFault); } if (fread (infoHeader,sizeof (short),50,inFile) != 50) { CMmsgPrint (CMmsgSysError, "File Reading Error in: %s %d",__FILE__,__LINE__); return (DBFault); } arcNum = 0; for (lineRec = lines->First ();arcRecord.Read (inFile,swap) != DBFault;lineRec = lines->Next ()) { if (lineRec == NULL) { sprintf (objName,"Line: %5d",arcRecord.ID () + 1); if ((lineRec = lines->Add (objName)) == (DBObjRecord *) NULL) return (DBFault); } else DBPause ((++arcNum * 100) / lines->ItemNum ()); floatCov = arcRecord.RecordLength () - 12 == arcRecord.NumOfPnts () * (DBInt) sizeof (float) ? true : false; while (arcRecord.FromNode () > nodes->ItemNum ()) { sprintf (objName,"Node: %5d",nodes->ItemNum () + 1); nodes->Add (objName); if ((nodeRec = nodes->Item ()) == NULL) return (DBFault); linkNumFLD->Int (nodeRec,0); } if ((nodeRec = nodes->Item (arcRecord.FromNode () - 1)) == (DBObjRecord *) NULL) { CMmsgPrint (CMmsgAppError, "Node Not Found in: %s %d",__FILE__,__LINE__); return (DBFault); } if (floatCov) { if (fread (floatVAR,sizeof (floatVAR),1,inFile) != 1) { CMmsgPrint (CMmsgSysError, "File Reading Error in: %s %d",__FILE__,__LINE__); return (DBFault); } if (swap) { DBByteOrderSwapWord (floatVAR); DBByteOrderSwapWord (floatVAR + 1); } nodeCoord.X = (DBFloat) floatVAR [0]; nodeCoord.Y = (DBFloat) floatVAR [1]; } else { if (fread (&nodeCoord,sizeof (DBCoordinate),1,inFile) != 1) { CMmsgPrint (CMmsgSysError, "File Reading Error in: %s %d",__FILE__,__LINE__); return (DBFault); } if (swap) nodeCoord.Swap (); } coordFLD->Coordinate (nodeRec,nodeCoord); fromNodeFLD->Record (lineRec,nodeRec); if (leftPolyFLD != (DBObjTableField *) NULL) leftPolyFLD->Record (lineRec,arcRecord.LeftPoly ()); if (rightPolyFLD != (DBObjTableField *) NULL) rightPolyFLD->Record (lineRec,arcRecord.RightPoly ()); itemExtent.LowerLeft = nodeCoord; itemExtent.UpperRight = nodeCoord; linkNumFLD->Int (nodeRec,linkNumFLD->Int (nodeRec) + 1); if (arcRecord.NumOfPnts () > 2) { if ((dataRec = data->Item (lineRec->RowID ())) == (DBObjRecord *) NULL) { if ((dataRec = new DBObjRecord ("LineData",0,sizeof (DBFloat))) == (DBObjRecord *) NULL) return (DBFault); data->Add (dataRec); } dataRec->Realloc ((arcRecord.NumOfPnts () - 2) * sizeof (DBCoordinate)); if ((vertexes = (DBCoordinate *) dataRec->Data ()) == NULL) { CMmsgPrint (CMmsgSysError, "Memory Allocation Error in: %s %d",__FILE__,__LINE__); return (DBFault); } if (floatCov) for (vertex = 0;vertex < arcRecord.NumOfPnts () - 2;++vertex) { if (fread (floatVAR,sizeof (floatVAR),1,inFile) != 1) { CMmsgPrint (CMmsgSysError, "File Reading Error in: %s %d",__FILE__,__LINE__); return (DBFault); } if (swap) { DBByteOrderSwapWord (floatVAR); DBByteOrderSwapWord (floatVAR + 1); } vertexes [vertex].X = (DBFloat) floatVAR [0]; vertexes [vertex].Y = (DBFloat) floatVAR [1]; dataExtent.Expand (vertexes [vertex]); itemExtent.Expand (vertexes [vertex]); } else for (vertex = 0;vertex < arcRecord.NumOfPnts () - 2;++vertex) { if (fread (vertexes + vertex,sizeof (DBCoordinate),1,inFile) != 1) { CMmsgPrint (CMmsgSysError, "File Reading Error in: %s %d",__FILE__,__LINE__); return (DBFault); } if (swap) vertexes [vertex].Swap (); dataExtent.Expand (vertexes [vertex]); itemExtent.Expand (vertexes [vertex]); } vertexesFLD->Record (lineRec,dataRec); } else vertexesFLD->Record (lineRec,(DBObjRecord *) NULL); vertexNumFLD->Int (lineRec,arcRecord.NumOfPnts () - 2); while (arcRecord.ToNode () > nodes->ItemNum ()) { sprintf (objName,"Node: %5d",nodes->ItemNum () + 1); nodes->Add (objName); if ((nodeRec = nodes->Item ()) == NULL) return (DBFault); linkNumFLD->Int (nodeRec,0); } if ((nodeRec = nodes->Item (arcRecord.ToNode () - 1)) == (DBObjRecord *) NULL) { CMmsgPrint (CMmsgAppError, "Node Not Found in: %s %d",__FILE__,__LINE__); return (DBFault); } if (floatCov) { if (fread (floatVAR,sizeof (floatVAR),1,inFile) != 1) { CMmsgPrint (CMmsgAppError, "File Reading Error in: %s %d",__FILE__,__LINE__); return (DBFault); } if (swap) { DBByteOrderSwapWord (floatVAR); DBByteOrderSwapWord (floatVAR + 1); } nodeCoord.X = (DBFloat) floatVAR [0]; nodeCoord.Y = (DBFloat) floatVAR [1]; } else { if (fread (&nodeCoord,sizeof (DBCoordinate),1,inFile) != 1) { CMmsgPrint (CMmsgAppError, "File Reading Error in: %s %d",__FILE__,__LINE__); return (DBFault); } if (swap) nodeCoord.Swap (); } itemExtent.Expand (nodeCoord); coordFLD->Coordinate (nodeRec,nodeCoord); linkNumFLD->Int (nodeRec,linkNumFLD->Int (nodeRec) + 1); toNodeFLD->Record (lineRec,nodeRec); extentFLD->Region (lineRec,itemExtent); } fclose (inFile); vertexesFLD->RecordProp ((DBInt) sizeof (DBFloat)); vecData->Extent (dataExtent); vecData->Projection (DBMathGuessProjection (dataExtent)); return (DBSuccess); }
DBInt DBGridCont2Network (DBObjData *gridData,DBObjData *netData, bool downhill) { DBInt basinID, layerID, zLayerID, zLayerNum, dir, maxDir, projection = gridData->Projection (), *zones; DBFloat elev0, elev1, delta, maxDelta, distance; DBCoordinate coord0, coord1; DBInt row, col; DBPosition pos, auxPos; char nameSTR [DBStringLength]; DBObjTable *basinTable = netData->Table (DBrNItems); DBObjTable *cellTable = netData->Table (DBrNCells); DBObjTable *layerTable = netData->Table (DBrNLayers); DBObjRecord *layerRec, *dataRec, *cellRec, *basinRec; DBObjTableField *mouthPosFLD = basinTable->Field (DBrNMouthPos); DBObjTableField *colorFLD = basinTable->Field (DBrNColor); DBObjTableField *positionFLD = cellTable->Field (DBrNPosition); DBObjTableField *toCellFLD = cellTable->Field (DBrNToCell); DBObjTableField *fromCellFLD = cellTable->Field (DBrNFromCell); DBObjTableField *orderFLD = cellTable->Field (DBrNOrder); DBObjTableField *basinFLD = cellTable->Field (DBrNBasin); DBObjTableField *basinCellsFLD= cellTable->Field (DBrNBasinCells); DBObjTableField *travelFLD = cellTable->Field (DBrNTravel); DBObjTableField *upCellPosFLD = cellTable->Field (DBrNUpCellPos); DBObjTableField *cellAreaFLD = cellTable->Field (DBrNCellArea); DBObjTableField *subbasinLengthFLD = cellTable->Field (DBrNSubbasinLength); DBObjTableField *subbasinAreaFLD = cellTable->Field (DBrNSubbasinArea); DBObjTableField *rowNumFLD = layerTable->Field (DBrNRowNum); DBObjTableField *colNumFLD = layerTable->Field (DBrNColNum); DBObjTableField *cellWidthFLD = layerTable->Field (DBrNCellWidth); DBObjTableField *cellHeightFLD = layerTable->Field (DBrNCellHeight); DBObjTableField *valueTypeFLD = layerTable->Field (DBrNValueType); DBObjTableField *valueSizeFLD = layerTable->Field (DBrNValueSize); DBObjTableField *layerFLD = layerTable->Field (DBrNLayer); DBObjData *zGridData = gridData->LinkedData (); DBGridIF *gridIF = new DBGridIF (gridData), *zGridIF; DBNetworkIF *netIF; if ((zGridData != (DBObjData *) NULL) && ((zGridData->Type () == DBTypeGridDiscrete) || (zGridData->Type () == DBTypeGridContinuous))) { zGridIF = new DBGridIF (zGridData); zLayerNum = zGridIF->LayerNum () + 1; } else { zGridIF = (DBGridIF *) NULL; zLayerNum = 1; } if ((zones = (DBInt *) calloc (9 * zLayerNum,sizeof (DBInt))) == (DBInt *) NULL) { CMmsgPrint (CMmsgSysError, "Memory Allocation Error in: %s %d",__FILE__,__LINE__); if (zGridIF != (DBGridIF *) NULL) delete zGridIF; delete gridIF; return (DBFault); } layerTable->Add (DBrNLookupGrid); if ((layerRec = layerTable->Item (DBrNLookupGrid)) == (DBObjRecord *) NULL) { free (zones); if (zGridIF != (DBGridIF *) NULL) delete zGridIF; delete gridIF; return (DBFault); } netData->Projection (projection); netData->Extent (gridData->Extent ()); cellWidthFLD->Float (layerRec,gridIF->CellWidth ()); cellHeightFLD->Float (layerRec,gridIF->CellHeight ()); valueTypeFLD->Int (layerRec,DBTableFieldInt); valueSizeFLD->Int (layerRec,sizeof (DBInt)); rowNumFLD->Int (layerRec,gridIF->RowNum ()); colNumFLD->Int (layerRec,gridIF->ColNum ()); dataRec = new DBObjRecord ("NetLookupGridRecord",((size_t) gridIF->RowNum ()) * gridIF->ColNum () * sizeof (DBInt),sizeof (DBInt)); if (dataRec == (DBObjRecord *) NULL) { if (zGridIF != (DBGridIF *) NULL) delete zGridIF; return (DBFault); } layerFLD->Record (layerRec,dataRec); (netData->Arrays ())->Add (dataRec); for (pos.Row = 0;pos.Row < gridIF->RowNum ();pos.Row++) for (pos.Col = 0;pos.Col < gridIF->ColNum ();pos.Col++) ((DBInt *) dataRec->Data ()) [pos.Row * gridIF->ColNum () + pos.Col] = DBFault; for (pos.Row = 0;pos.Row < gridIF->RowNum ();pos.Row++) { if (DBPause (10 * pos.Row / gridIF->RowNum ())) goto PauseStop; for (pos.Col = 0;pos.Col < gridIF->ColNum ();pos.Col++) { gridIF->Pos2Coord (pos,coord0); zLayerID = 0; if (zGridIF != (DBGridIF *) NULL) for ( ; zLayerID < zGridIF->LayerNum (); zLayerID++) { layerRec = zGridIF->Layer (zLayerID); if ((layerRec->Flags () & DBObjectFlagIdle) == DBObjectFlagIdle) continue; for (dir = 0;dir < 8;++dir) { row = pos.Row; col = pos.Col; if (((0x01 << dir) == DBNetDirNW) || ((0x01 << dir) == DBNetDirN) || ((0x01 << dir) == DBNetDirNE)) row++; if (((0x01 << dir) == DBNetDirSE) || ((0x01 << dir) == DBNetDirS) || ((0x01 << dir) == DBNetDirSW)) row--; if (((0x01 << dir) == DBNetDirNE) || ((0x01 << dir) == DBNetDirE) || ((0x01 << dir) == DBNetDirSE)) col++; if (((0x01 << dir) == DBNetDirNW) || ((0x01 << dir) == DBNetDirW) || ((0x01 << dir) == DBNetDirSW)) col--; if (row < 0) continue; if (col < 0) continue; if (row >= gridIF->RowNum ()) continue; if (col >= gridIF->ColNum ()) continue; auxPos.Row = row; auxPos.Col = col; gridIF->Pos2Coord (auxPos,coord1); switch (zGridData->Type ()) { case DBTypeGridDiscrete: basinID = zGridIF->GridValue (layerRec,coord1); break; case DBTypeGridContinuous: zGridIF->Value (layerRec,coord1,&basinID); break; } zones [zLayerID * 9 + dir] = basinID; } switch (zGridData->Type ()) { case DBTypeGridDiscrete: basinID = zGridIF->GridValue (layerRec,coord0); break; case DBTypeGridContinuous: zGridIF->Value (layerRec,coord0,&basinID); break; } zones [zLayerID * 9 + 8] = basinID; } for (dir = 0;dir < 9;++dir) zones [zLayerID * 9 + dir] = 0; maxDir = DBFault; for (layerID = 0;layerID < gridIF->LayerNum ();++layerID) { layerRec = gridIF->Layer (layerID); if ((layerRec->Flags () & DBObjectFlagIdle) == DBObjectFlagIdle) continue; if (gridIF->Value (layerRec,pos,&elev0)) { maxDelta = (DBFloat) 0.0; maxDir = 0; for (zLayerID = 0;zLayerID < zLayerNum;++zLayerID) { for (dir = 0;dir < 8;++dir) { row = pos.Row; col = pos.Col; if (((0x01 << dir) == DBNetDirNW) || ((0x01 << dir) == DBNetDirN) || ((0x01 << dir) == DBNetDirNE)) row++; if (((0x01 << dir) == DBNetDirSE) || ((0x01 << dir) == DBNetDirS) || ((0x01 << dir) == DBNetDirSW)) row--; if (((0x01 << dir) == DBNetDirNE) || ((0x01 << dir) == DBNetDirE) || ((0x01 << dir) == DBNetDirSE)) col++; if (((0x01 << dir) == DBNetDirNW) || ((0x01 << dir) == DBNetDirW) || ((0x01 << dir) == DBNetDirSW)) col--; if (col < 0) continue; if (row < 0) continue; if (col >= gridIF->ColNum ()) continue; if (row >= gridIF->RowNum ()) continue; auxPos.Row = row; auxPos.Col = col; gridIF->Pos2Coord (auxPos,coord1); distance = DBMathCoordinateDistance (projection,coord0,coord1); if ((zones [zLayerID * 9 + dir] == zones [zLayerID * 9 + 8]) && (gridIF->Value (layerRec,auxPos,&elev1))) { delta = (downhill ? (elev1 - elev0) : (elev0 - elev1)) / distance; if (maxDelta > delta) { maxDelta = delta; maxDir = (0x01 << dir); } } } if (maxDir != 0) goto SlopeStop; } } } SlopeStop: if (maxDir != DBFault) { sprintf (nameSTR,"GHAASCell:%d",cellTable->ItemNum ()); cellRec = cellTable->Add (nameSTR); positionFLD->Position(cellRec,pos); toCellFLD->Int (cellRec,(DBInt) maxDir); fromCellFLD->Int (cellRec,(DBInt) 0); orderFLD->Int (cellRec,(DBInt) 0); basinFLD->Int (cellRec,(DBInt) 0); basinCellsFLD->Int (cellRec,(DBInt) 0); travelFLD->Int (cellRec,(DBInt) 0); upCellPosFLD->Position (cellRec,pos); cellAreaFLD->Float (cellRec,(DBFloat) 0.0); subbasinLengthFLD->Float(cellRec,(DBFloat) 0.0); subbasinAreaFLD->Float (cellRec,(DBFloat) 0.0); ((DBInt *) dataRec->Data ()) [pos.Row * gridIF->ColNum () + pos.Col] = cellRec->RowID (); } } } PauseStop: if (pos.Row < gridIF->RowNum ()) return (DBFault); sprintf (nameSTR,"GHAASBasin%d",(DBInt) 0); basinRec = basinTable->Add (nameSTR); mouthPosFLD->Position (basinRec,positionFLD->Position (cellTable->Item (0))); colorFLD->Int (basinRec,0); free (zones); delete gridIF; if (zGridIF != (DBGridIF *) NULL) delete zGridIF; netData->Precision (DBMathMin (gridIF->CellWidth (),gridIF->CellHeight ()) / 25.0); netIF = new DBNetworkIF (netData); netIF->Build (); delete netIF; return (DBSuccess); }
DBInt RGlibPointInterStationTS(DBObjData *pntData, DBObjData *tsData, char *relateFldName, char *joinFldName) { DBInt first = true, tsIndex, tsRowNum = 0; DBObjTable *pntTBL = pntData->Table(DBrNItems), *tsTBL; DBObjectLIST<DBObjTableField> *fields; DBObjTableField *pntNextFLD = pntTBL->Field(RGlibNextStation); DBObjTableField *pntAreaFLD = pntTBL->Field(RGlibArea); DBObjTableField *pntInterStnFLD = pntTBL->Field(RGlibInterStation); DBObjTableField *pntRelateFLD; DBObjTableField *pntNewNextFLD; DBObjTableField *pntNewInterStnFLD; DBObjTableField *tsTimeFLD; DBObjTableField *tsJoinFLD; DBObjTableField *tsNextStnFLD, *tsInterStnFLD; DBObjRecord *pntRec, *nextPntRec, *tsRec, *tsIndexRec; DBDate curDate, date; if (pntNextFLD == (DBObjTableField *) NULL) { CMmsgPrint(CMmsgUsrError, "Missing Next Station Field!"); return (DBFault); } if (pntAreaFLD == (DBObjTableField *) NULL) { CMmsgPrint(CMmsgUsrError, "Missing STN Area Field!"); return (DBFault); } if (pntInterStnFLD == (DBObjTableField *) NULL) { CMmsgPrint(CMmsgUsrError, "Missing Interfluvial Area Field!"); return (DBFault); } tsTBL = tsData->Table(DBrNItems); tsNextStnFLD = new DBObjTableField(RGlibNextStation, DBTableFieldInt, "%8d", sizeof(DBInt)); tsTBL->AddField(tsNextStnFLD); tsInterStnFLD = new DBObjTableField(RGlibInterStation, DBTableFieldFloat, "%9.1f", sizeof(DBFloat4)); tsTBL->AddField(tsInterStnFLD); fields = tsTBL->Fields(); for (tsTimeFLD = fields->First(); tsTimeFLD != (DBObjTableField *) NULL; tsTimeFLD = fields->Next()) if (tsTimeFLD->Type() == DBTableFieldDate) break; if (tsTimeFLD == (DBObjTableField *) NULL) { CMmsgPrint(CMmsgUsrError, "Missing Date Field!"); return (DBFault); } if ((tsJoinFLD = tsTBL->Field(joinFldName)) == (DBObjTableField *) NULL) { CMmsgPrint(CMmsgUsrError, "Missing Join Field!"); return (DBFault); } fields = new DBObjectLIST<DBObjTableField>("Field List"); fields->Add(new DBObjTableField(*tsTimeFLD)); fields->Add(new DBObjTableField(*tsJoinFLD)); tsTBL->ListSort(fields); delete fields; pntTBL = new DBObjTable(*pntTBL); pntNextFLD = pntTBL->Field(RGlibNextStation); pntAreaFLD = pntTBL->Field(RGlibArea); pntInterStnFLD = pntTBL->Field(RGlibInterStation); pntNewNextFLD = new DBObjTableField("NextStnTS", pntNextFLD->Type(), pntNextFLD->Format(), pntNextFLD->Length()); pntNewInterStnFLD = new DBObjTableField("InterFluTS", pntInterStnFLD->Type(), pntInterStnFLD->Format(), pntInterStnFLD->Length()); pntRelateFLD = pntTBL->Field(relateFldName); pntTBL->AddField(pntNewNextFLD); pntTBL->AddField(pntNewInterStnFLD); pntTBL->ListSort(pntRelateFLD); tsIndexRec = tsTBL->First(&tsIndex); for (tsRec = tsTBL->First(); tsRec != (DBObjRecord *) NULL; tsRec = tsTBL->Next()) { DBPause(tsRowNum++ * 100 / tsTBL->ItemNum()); date = tsTimeFLD->Date(tsRec); if (date != curDate) { if (first) first = false; else { for (pntRec = pntTBL->First(); pntRec != (DBObjRecord *) NULL; pntRec = pntTBL->Next()) { if ((pntRec->Flags() & DBObjectFlagLocked) != DBObjectFlagLocked) continue; for (nextPntRec = pntTBL->Item(pntNextFLD->Int(pntRec) - 1); (nextPntRec != (DBObjRecord *) NULL) && ((nextPntRec->Flags() & DBObjectFlagLocked) != DBObjectFlagLocked); nextPntRec = pntTBL->Item(pntNextFLD->Int(nextPntRec) - 1)); if (nextPntRec != (DBObjRecord *) NULL) { pntNewNextFLD->Int(pntRec, nextPntRec->RowID() + 1); pntNewInterStnFLD->Float(nextPntRec, pntNewInterStnFLD->Float(nextPntRec) - pntAreaFLD->Float(pntRec)); } } pntRec = pntTBL->First(); for (; tsIndexRec != (DBObjRecord *) NULL; tsIndexRec = tsTBL->Next(&tsIndex)) { if (tsRec == tsIndexRec) break; for (; pntRec != (DBObjRecord *) NULL; pntRec = pntTBL->Next()) if (pntRelateFLD->Int(pntRec) == tsJoinFLD->Int(tsIndexRec)) { tsNextStnFLD->Int(tsIndexRec, pntNewNextFLD->Int(pntRec)); tsInterStnFLD->Float(tsIndexRec, pntNewInterStnFLD->Float(pntRec)); break; } if (pntRec == (DBObjRecord *) NULL) pntRec = pntTBL->First(); } } for (pntRec = pntTBL->First(); pntRec != (DBObjRecord *) NULL; pntRec = pntTBL->Next()) { pntNewNextFLD->Int(pntRec, 0); pntNewInterStnFLD->Float(pntRec, pntAreaFLD->Float(pntRec)); pntRec->Flags(DBObjectFlagLocked, DBClear); } curDate = date; pntRec = pntTBL->First(); } for (; pntRec != (DBObjRecord *) NULL; pntRec = pntTBL->Next()) if (pntRelateFLD->Int(pntRec) == tsJoinFLD->Int(tsRec)) { pntRec->Flags(DBObjectFlagLocked, DBSet); break; } if (pntRec == (DBObjRecord *) NULL) pntRec = pntTBL->First(); } if (!first) { for (pntRec = pntTBL->First(); pntRec != (DBObjRecord *) NULL; pntRec = pntTBL->Next()) { if ((pntRec->Flags() & DBObjectFlagLocked) != DBObjectFlagLocked) continue; for (nextPntRec = pntTBL->Item(pntNextFLD->Int(pntRec) - 1); (nextPntRec != (DBObjRecord *) NULL) && ((nextPntRec->Flags() & DBObjectFlagLocked) != DBObjectFlagLocked); nextPntRec = pntTBL->Item(pntNextFLD->Int(nextPntRec) - 1)); if (nextPntRec != (DBObjRecord *) NULL) { pntNewNextFLD->Int(pntRec, nextPntRec->RowID() + 1); pntNewInterStnFLD->Float(nextPntRec, pntNewInterStnFLD->Float(nextPntRec) - pntAreaFLD->Float(pntRec)); } } pntRec = pntTBL->First(); for (; tsIndexRec != (DBObjRecord *) NULL; tsIndexRec = tsTBL->Next(&tsIndex)) { if (tsRec == tsIndexRec) break; for (; pntRec != (DBObjRecord *) NULL; pntRec = pntTBL->Next()) if (pntRelateFLD->Int(pntRec) == tsJoinFLD->Int(tsIndexRec)) { tsNextStnFLD->Int(tsIndexRec, pntNewNextFLD->Int(pntRec)); tsInterStnFLD->Float(tsIndexRec, pntNewInterStnFLD->Float(pntRec)); break; } if (pntRec == (DBObjRecord *) NULL) pntRec = pntTBL->First(); } } delete pntTBL; return (DBSuccess); }
DBInt RGlibPointSubbasinStats(DBObjData *pntData, DBObjData *netData, DBObjData *grdData, DBObjData *tblData) { DBInt layerID, layerNum = 0, progress = 0, maxProgress; DBObjTable *table; DBObjTableField *pointIDFLD; DBObjTableField *layerIDFLD; DBObjTableField *layerNameFLD; DBObjTableField *minimumFLD; DBObjTableField *maximumFLD; DBObjTableField *averageFLD; DBObjTableField *stdDevFLD; DBObjTableField *areaFLD; DBVPointIF *pntIF; DBNetworkIF *netIF; DBObjRecord *pntRec, *tblRec; DBObjectLIST<DBObjTableField> *fields; _RGlibPointGrdIF = new DBGridIF(grdData); for (layerID = 0; layerID < _RGlibPointGrdIF->LayerNum(); ++layerID) { _RGlibPointGrdLayerRec = _RGlibPointGrdIF->Layer(layerID); if ((_RGlibPointGrdLayerRec->Flags() & DBObjectFlagIdle) != DBObjectFlagIdle) ++layerNum; } if (layerNum < 1) { CMmsgPrint(CMmsgUsrError, "No Layer to Process!"); delete _RGlibPointGrdIF; return (DBFault); } table = tblData->Table(DBrNItems); pntIF = new DBVPointIF(pntData); netIF = new DBNetworkIF(netData); table->AddField(pointIDFLD = new DBObjTableField("GHAASPointID", DBTableFieldInt, "%8d", sizeof(DBInt))); table->AddField(layerIDFLD = new DBObjTableField("LayerID", DBTableFieldInt, "%4d", sizeof(DBShort))); table->AddField(layerNameFLD = new DBObjTableField("LayerName", DBTableFieldString, "%s", DBStringLength)); table->AddField(averageFLD = new DBObjTableField(RGlibPointMean, DBTableFieldFloat, _RGlibPointGrdIF->ValueFormat(), sizeof(DBFloat4))); table->AddField(minimumFLD = new DBObjTableField(RGlibPointMin, DBTableFieldFloat, _RGlibPointGrdIF->ValueFormat(), sizeof(DBFloat4))); table->AddField(maximumFLD = new DBObjTableField(RGlibPointMax, DBTableFieldFloat, _RGlibPointGrdIF->ValueFormat(), sizeof(DBFloat4))); table->AddField( stdDevFLD = new DBObjTableField(RGlibPointStdDev, DBTableFieldFloat, _RGlibPointGrdIF->ValueFormat(), sizeof(DBFloat4))); table->AddField(areaFLD = new DBObjTableField(RGlibPointArea, DBTableFieldFloat, _RGlibPointGrdIF->ValueFormat(), sizeof(DBFloat4))); grdData->Flags(DBObjectFlagProcessed, DBSet); maxProgress = pntIF->ItemNum() * _RGlibPointGrdIF->LayerNum(); for (layerID = 0; layerID < _RGlibPointGrdIF->LayerNum(); ++layerID) { _RGlibPointGrdLayerRec = _RGlibPointGrdIF->Layer(layerID); if ((_RGlibPointGrdLayerRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) continue; for (pntRec = pntIF->FirstItem(); pntRec != (DBObjRecord *) NULL; pntRec = pntIF->NextItem()) { if (DBPause(progress * 100 / maxProgress)) goto Stop; progress++; if ((pntRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) continue; tblRec = table->Add(pntRec->Name()); pointIDFLD->Int(tblRec, pntRec->RowID() + 1); layerIDFLD->Int(tblRec, _RGlibPointGrdLayerRec->RowID()); layerNameFLD->String(tblRec, _RGlibPointGrdLayerRec->Name()); _RGlibSubbasinArea = 0.0; _RGlibSubbasinMin = DBHugeVal; _RGlibSubbasinMax = -DBHugeVal; _RGlibSubbasinMean = 0.0; _RGlibSubbasinStdDev = 0.0; netIF->UpStreamSearch(netIF->Cell(pntIF->Coordinate(pntRec)), (DBNetworkACTION) _RGlibSubbasinStatistics); _RGlibSubbasinMean = _RGlibSubbasinMean / _RGlibSubbasinArea; _RGlibSubbasinStdDev = _RGlibSubbasinStdDev / _RGlibSubbasinArea; _RGlibSubbasinStdDev = _RGlibSubbasinStdDev - _RGlibSubbasinMean * _RGlibSubbasinMean; _RGlibSubbasinStdDev = sqrt(_RGlibSubbasinStdDev); minimumFLD->Float(tblRec, _RGlibSubbasinMin); maximumFLD->Float(tblRec, _RGlibSubbasinMax); averageFLD->Float(tblRec, _RGlibSubbasinMean); stdDevFLD->Float(tblRec, _RGlibSubbasinStdDev); areaFLD->Float(tblRec, _RGlibSubbasinArea); } } Stop: delete _RGlibPointGrdIF; delete netIF; delete pntIF; if (progress == maxProgress) { fields = new DBObjectLIST<DBObjTableField>("Field List"); fields->Add(new DBObjTableField(*pointIDFLD)); fields->Add(new DBObjTableField(*layerIDFLD)); table->ListSort(fields); delete fields; return (DBSuccess); } return (DBFault); }
DBInt DBNetworkIF::Build () { DBInt i, j, row, col, basin, dir, projection = DataPTR->Projection (); DBCoordinate coord0, coord1; char nameStr [DBStringLength]; DBPosition pos; DBObjRecord *cellRec, *toCell, *fromCell, *basinRec, *symbolRec; _DBnetIF = this; for (j = 0;j < BasinTable->ItemNum ();++j) { basinRec = BasinTable->Item (j); if (((cellRec = Cell (MouthPosFLD->Position (basinRec))) == (DBObjRecord *) NULL) || (ToCell (cellRec) != (DBObjRecord *) NULL)) { BasinTable->Delete (basinRec); j--; } } for (i = 0;i < CellNum ();++i) { cellRec = CellTable->Item (i); DBPause (i * 10 / CellNum ()); if (Cell (CellPosition (cellRec)) == (DBObjRecord *) NULL) continue; else if (ToCell (ToCell (cellRec)) == cellRec) ToCellFLD->Int (cellRec,DBNull); } DBPause (10); for (i = 0;i < CellNum ();++i) { cellRec = CellTable->Item (i); DBPause (10 + i * 10 / CellNum ()); pos = CellPosition (cellRec); if (((DBInt *) DataRec->Data ()) [pos.Row * ColNum () + pos.Col] == DBFault) { CellTable->Delete (cellRec); --i; } else { cellRec->Flags (DBObjectFlagLocked,DBClear); FromCellFLD->Int (cellRec,DBNull); OrderFLD->Int (cellRec,1); BasinFLD->Int (cellRec,DBFault); BasinCellsFLD->Int (cellRec,1); TravelFLD->Int (cellRec,0); UpCellPosFLD->Position (cellRec,pos); CellAreaFLD->Float (cellRec,DBMathRectangleArea (projection,Center (cellRec) - CellSize () / 2,Center (cellRec) + CellSize () / 2)); coord0 = Center (cellRec); coord1 = Center (cellRec) + Delta (cellRec); CellLengthFLD->Float (cellRec,DBMathCoordinateDistance (DataPTR->Projection (),coord0,coord1)); SubbasinLengthFLD->Float (cellRec,CellLength (cellRec)); SubbasinAreaFLD->Float (cellRec,CellAreaFLD->Float (cellRec)); } } for (j = 0;j < BasinTable->ItemNum ();++j) { basinRec = BasinTable->Item (j); cellRec = Cell (MouthPosFLD->Position (basinRec)); if ((cellRec == (DBObjRecord *) NULL) || ((cellRec->Flags () & DBObjectFlagLocked) == DBObjectFlagLocked)) { BasinTable->Delete (basinRec); j--; } else cellRec->Flags (DBObjectFlagLocked,DBSet); } DBPause (20); for (row = 0;row < RowNum ();row++) for (col = 0;col < ColNum ();col++) ((DBInt *) DataRec->Data ()) [row * ColNum () + col] = DBFault; for (i = 0;i < CellNum ();++i) { cellRec = CellTable->Item (i); cellRec->Flags (DBObjectFlagLocked,DBClear); DBPause (20 + i * 10 / CellNum ()); pos = CellPosition (cellRec); if (((DBInt *) DataRec->Data ()) [pos.Row * ColNum () + pos.Col] != DBFault) { CellTable->Delete (cellRec); --i; } else ((DBInt *) DataRec->Data ()) [pos.Row * ColNum () + pos.Col] = cellRec->RowID (); } DBPause (30); for (i = 0;i < CellNum ();++i) { cellRec = CellTable->Item (i); if ((toCell = ToCell (cellRec)) != (DBObjRecord *) NULL) FromCellFLD->Int (toCell,FromCellFLD->Int (toCell) | _DBNetworkOppositeDirection (ToCellFLD->Int (cellRec))); } for (i = 0;i < CellNum ();++i) { DBPause (30 + i * 10 / CellNum ()); cellRec = CellTable->Item (i); if (ToCell (cellRec) == (DBObjRecord *) NULL) Climb (cellRec,0); } DBPause (40); CellTable->ItemSort (_DBGNetworkCellCompare); for (i = 0;i < CellNum ();++i) { cellRec = CellTable->Item (i); DBPause (35 + i * 10/ CellNum ()); pos = CellPosition (cellRec); ((DBInt *) DataRec->Data ()) [pos.Row * ColNum () + pos.Col] = cellRec->RowID (); } DBPause (50); basin = 0; for (i = 0;i < CellNum ();++i) { cellRec = CellTable->Item (i); DBPause (50 + i * 20 / CellNum ()); if (ToCell (cellRec) == (DBObjRecord *) NULL) { SetBasin (cellRec,basin + 1); basinRec = (DBObjRecord *) NULL; for (j = 0;j < BasinTable->ItemNum ();++j) { if (((basin - j) >= 0) && ((basin - j) < BasinTable->ItemNum ()) && (cellRec == MouthCell (basinRec = BasinTable->Item (basin - j)))) break; if (((basin + j) < BasinTable->ItemNum ()) && (cellRec == MouthCell (basinRec = BasinTable->Item (basin + j)))) break; basinRec = (DBObjRecord *) NULL; } if (basinRec == (DBObjRecord *) NULL) { basinRec = BasinTable->Add ("GHAASBasin"); MouthPosFLD->Position (basinRec,CellPosition (cellRec)); } basinRec->ListPos (basin++); } } DBPause (70); CellTable->ItemSort (_DBGNetworkCellCompare); BasinTable->ItemSort (); for (i = 0;i < CellNum ();++i) { cellRec = CellTable->Item (i); DBPause (70 + i * 10 / CellNum ()); pos = CellPosition (cellRec); ((DBInt *) DataRec->Data ()) [pos.Row * ColNum () + pos.Col] = cellRec->RowID (); sprintf (nameStr,"GHAASCell:%d",cellRec->RowID () + 1); cellRec->Name (nameStr); } DBPause (80); SymbolTable->DeleteAll (); symbolRec = SymbolTable->Add ("Network Symbol"); SymbolIDFLD->Int (symbolRec,1); ForegroundFLD->Int (symbolRec,1); BackgroundFLD->Int (symbolRec,0); for (j = 0;j < BasinTable->ItemNum ();++j) { basinRec = BasinTable->Item (j); if ((strncmp (basinRec->Name (),"GHAASBasin",strlen ("GHAASBasin")) == 0) || (strlen (basinRec->Name ()) < 1)) { sprintf (nameStr,"GHAASBasin%d",basinRec->RowID () + 1); basinRec->Name (nameStr); } ColorFLD->Int (basinRec,DBFault); BasinOrderFLD->Int (basinRec,CellOrder (MouthCell (basinRec))); BasinAreaFLD->Float (basinRec,CellBasinArea (MouthCell (basinRec))); BasinLengthFLD->Float (basinRec,CellBasinLength (MouthCell (basinRec))); SymbolFLD->Record (basinRec,symbolRec); } basin = DBFault; for (i = 0;i < CellNum ();++i) { cellRec = CellTable->Item (i); if ((basinRec = Basin (cellRec)) == (DBObjRecord *) NULL) { CMmsgPrint (CMmsgAppError,"BasinID: %d CellID:%d",BasinFLD->Int (cellRec),cellRec->RowID ()); continue; } if (basin != basinRec->RowID ()) { basin = basinRec->RowID (); DBPause (80 + basin * 20 / BasinNum ()); ColorFLD->Int (basinRec,7); toCell = cellRec; } for (dir = 0;dir < 8;dir += 2) { if ((fromCell = FromCell (cellRec,0x01 << dir,false)) == (DBObjRecord *) NULL) continue; if (basinRec == Basin (fromCell)) continue; if (ColorFLD->Int (basinRec) == ColorFLD->Int (Basin (fromCell))) { ColorFLD->Int (basinRec,ColorFLD->Int (basinRec) + 1); cellRec = MouthCell (basinRec); i = cellRec->RowID () - 1; } } } DBPause (100); if (DistToMouth ()) SetDistToMouth (); if (DistToOcean ()) SetDistToOcean (); if (Magnitude ()) SetMagnitude (); return (DBSuccess); }
int DBImportARCPoly (DBObjData *vecData,const char *arcCov) { DBInt polyNum = 0, line, lineNum, vertexNum, polyDir; DBObjTable *items = vecData->Table (DBrNItems); DBObjTable *lines = vecData->Table (DBrNContours); DBObjTableField *firstLineFLD = items->Field (DBrNFirstLine); DBObjTableField *lineNumFLD = items->Field (DBrNLineNum); DBObjTableField *polyVertexNumFLD = items->Field (DBrNVertexNum); DBObjTableField *polyExtentFLD = items->Field (DBrNRegion); DBObjTableField *leftPolyFLD = lines->Field (DBrNLeftPoly); DBObjTableField *rightPolyFLD = lines->Field (DBrNRightPoly); DBObjTableField *nextLineFLD = lines->Field (DBrNNextLine); DBObjTableField *prevLineFLD = lines->Field (DBrNPrevLine); DBObjTableField *fromNodeFLD = lines->Field (DBrNFromNode); DBObjTableField *toNodeFLD = lines->Field (DBrNToNode); DBObjTableField *lineVertextNumFLD = lines->Field (DBrNVertexNum); DBObjTableField *lineExtentFLD = lines->Field (DBrNRegion); DBObjRecord *polyRec, *lineRec, *firstNodeRec, *nodeRec, **lineRecArray; DBRegion extent, initRegion; if (DBImportARCLine (vecData,arcCov) == DBFault) return (DBFault); items->Delete (0); for (polyRec = items->First ();polyRec != (DBObjRecord *) NULL;polyRec = items->Next ()) lineNumFLD->Int (polyRec,0); for (lineRec = lines->First ();lineRec != (DBObjRecord *) NULL;lineRec = lines->Next ()) { rightPolyFLD->Record (lineRec,items->Item ((DBInt) (rightPolyFLD->Record(lineRec) - (DBObjRecord *) NULL))); leftPolyFLD->Record (lineRec,items->Item ((DBInt) (leftPolyFLD->Record (lineRec) - (DBObjRecord *) NULL))); nextLineFLD->Record (lineRec,(DBObjRecord *) NULL); prevLineFLD->Record (lineRec,(DBObjRecord *) NULL); } if ((lineRecArray = (DBObjRecord **) calloc (lines->ItemNum (),sizeof (DBObjRecord *))) == (DBObjRecord **) NULL) { CMmsgPrint (CMmsgSysError, "Memory Allocation Error in: %s %d",__FILE__,__LINE__); return (DBFault); } for (polyRec = items->First ();polyRec != (DBObjRecord *) NULL;polyRec = items->Next ()) { DBPause ((++polyNum * 100) / items->ItemNum ()); lineNum = vertexNum = 0; extent = initRegion; for (lineRec = lines->First ();lineRec != (DBObjRecord *) NULL;lineRec = lines->Next ()) if ((rightPolyFLD->Record (lineRec) == polyRec) || (leftPolyFLD->Record (lineRec) == polyRec)) { lineRecArray [lineNum++] = lineRec; vertexNum += lineVertextNumFLD->Int (lineRec); extent.Expand (lineExtentFLD->Region (lineRec)); } lineNumFLD->Int (polyRec,lineNum); polyExtentFLD->Region (polyRec,extent); firstLineFLD->Record (polyRec,lineRecArray [0]); firstNodeRec = (rightPolyFLD->Record (lineRecArray [0]) == polyRec) ? fromNodeFLD->Record (lineRecArray [0]) : toNodeFLD->Record(lineRecArray [0]); for (lineNum = 1;lineNum < lineNumFLD->Int (polyRec);++lineNum) { polyDir = (rightPolyFLD->Record (lineRecArray [lineNum - 1]) == polyRec); nodeRec = polyDir ? toNodeFLD->Record (lineRecArray [lineNum - 1]) : fromNodeFLD->Record(lineRecArray [lineNum - 1]); for (line = lineNum;line < lineNumFLD->Int (polyRec); ++line) if ((nodeRec == fromNodeFLD->Record (lineRecArray [line])) || (nodeRec == toNodeFLD->Record (lineRecArray [line]))) break; if (line < lineNumFLD->Int (polyRec)) { lineRec = lineRecArray [lineNum]; lineRecArray [lineNum] = lineRecArray [line]; lineRecArray [line] = lineRec; } else { vertexNum += 1; if (nodeRec != firstNodeRec) vertexNum += 1; } } polyDir = (rightPolyFLD->Record (lineRecArray [lineNum - 1]) == polyRec); nodeRec = polyDir ? toNodeFLD->Record (lineRecArray [lineNum - 1]) : fromNodeFLD->Record(lineRecArray [lineNum - 1]); polyVertexNumFLD->Int (polyRec,vertexNum + lineNum + 1 + (nodeRec != firstNodeRec ? 1 : 0)); for (lineNum = 1;lineNum < lineNumFLD->Int (polyRec);++lineNum) { if (rightPolyFLD->Record (lineRecArray [lineNum - 1]) == polyRec) nextLineFLD->Record (lineRecArray [lineNum - 1],lineRecArray [lineNum]); else prevLineFLD->Record (lineRecArray [lineNum - 1],lineRecArray [lineNum]); } if (rightPolyFLD->Record (lineRecArray [lineNum - 1]) == polyRec) nextLineFLD->Record (lineRecArray [lineNum - 1],lineRecArray [0]); else prevLineFLD->Record (lineRecArray [lineNum - 1],lineRecArray [0]); } free (lineRecArray); return (DBSuccess); }
DBInt RGlibPointSubbasinHist(DBObjData *pntData, DBObjData *netData, DBObjData *grdData, DBObjData *tblData) { DBInt layerID, layerNum = 0, progress = 0, maxProgress; DBObjTable *itemTable = grdData->Table(DBrNItems); DBObjTable *table = tblData->Table(DBrNItems); DBObjTableField *pointIDFLD; DBObjTableField *layerIDFLD; DBObjTableField *layerNameFLD; DBObjTableField *categoryIDFLD; DBObjTableField *categoryFLD; DBObjTableField *percentFLD; DBObjTableField *areaFLD; DBObjTableField *cellNumFLD; DBVPointIF *pntIF; DBNetworkIF *netIF; DBObjRecord *pntRec, *itemRec, *tblRec; DBObjectLIST<DBObjTableField> *fields; _RGlibPointGrdIF = new DBGridIF(grdData); for (layerID = 0; layerID < _RGlibPointGrdIF->LayerNum(); ++layerID) { _RGlibPointGrdLayerRec = _RGlibPointGrdIF->Layer(layerID); if ((_RGlibPointGrdLayerRec->Flags() & DBObjectFlagIdle) != DBObjectFlagIdle) ++layerNum; } if (layerNum < 1) { CMmsgPrint(CMmsgUsrError, "No Layer to Process!"); delete _RGlibPointGrdIF; return (DBFault); } pntIF = new DBVPointIF(pntData); netIF = new DBNetworkIF(netData); table->AddField(pointIDFLD = new DBObjTableField("GHAASPointID", DBTableFieldInt, "%8d", sizeof(DBInt))); table->AddField(layerIDFLD = new DBObjTableField("LayerID", DBTableFieldInt, "%4d", sizeof(DBShort))); table->AddField(layerNameFLD = new DBObjTableField("LayerName", DBTableFieldString, "%s", DBStringLength)); table->AddField(categoryIDFLD = new DBObjTableField(DBrNCategoryID, DBTableFieldInt, "%2d", sizeof(DBShort))); table->AddField(categoryFLD = new DBObjTableField(DBrNCategory, DBTableFieldString, _RGlibPointGrdIF->ValueFormat(), DBStringLength)); table->AddField(cellNumFLD = new DBObjTableField("CellNum", DBTableFieldInt, "%8d", sizeof(DBInt))); table->AddField(areaFLD = new DBObjTableField(DBrNArea, DBTableFieldFloat, "%10.1f", sizeof(DBFloat4))); table->AddField(percentFLD = new DBObjTableField(DBrNPercent, DBTableFieldFloat, "%6.2f", sizeof(DBFloat4))); _RGlibHistogram = (Histogram *) malloc(itemTable->ItemNum() * sizeof(Histogram)); if (_RGlibHistogram == (Histogram *) NULL) { CMmsgPrint(CMmsgAppError, "Memory Allocation Error in: %s %d", __FILE__, __LINE__); return (DBFault); } maxProgress = pntIF->ItemNum() * _RGlibPointGrdIF->LayerNum(); for (layerID = 0; layerID < _RGlibPointGrdIF->LayerNum(); ++layerID) { _RGlibPointGrdLayerRec = _RGlibPointGrdIF->Layer(layerID); if ((_RGlibPointGrdLayerRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) continue; for (pntRec = pntIF->FirstItem(); pntRec != (DBObjRecord *) NULL; pntRec = pntIF->NextItem()) { if (DBPause(progress * 100 / maxProgress)) goto Stop; progress++; if ((pntRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) continue; for (itemRec = itemTable->First(); itemRec != (DBObjRecord *) NULL; itemRec = itemTable->Next()) _RGlibHistogram[itemRec->RowID()].Initialize(); netIF->UpStreamSearch(netIF->Cell(pntIF->Coordinate(pntRec)), (DBNetworkACTION) _RGlibSubbasinCategories); for (itemRec = itemTable->First(); itemRec != (DBObjRecord *) NULL; itemRec = itemTable->Next()) if (_RGlibHistogram[itemRec->RowID()].cellNum > 0) { tblRec = table->Add(pntRec->Name()); pointIDFLD->Int(tblRec, pntRec->RowID() + 1); layerIDFLD->Int(tblRec, _RGlibPointGrdLayerRec->RowID()); layerNameFLD->String(tblRec, _RGlibPointGrdLayerRec->Name()); categoryIDFLD->Int(tblRec, itemRec->RowID() + 1); categoryFLD->String(tblRec, itemRec->Name()); areaFLD->Float(tblRec, _RGlibHistogram[itemRec->RowID()].area); percentFLD->Float(tblRec, _RGlibHistogram[itemRec->RowID()].area / netIF->CellBasinArea(netIF->Cell(pntIF->Coordinate(pntRec))) * 100.0); cellNumFLD->Int(tblRec, _RGlibHistogram[itemRec->RowID()].cellNum); } } } Stop: delete _RGlibPointGrdIF; delete netIF; delete pntIF; free(_RGlibHistogram); if (progress == maxProgress) { fields = new DBObjectLIST<DBObjTableField>("Field List"); fields->Add(new DBObjTableField(*pointIDFLD)); fields->Add(new DBObjTableField(*layerIDFLD)); fields->Add(areaFLD = new DBObjTableField(*areaFLD)); areaFLD->Flags(DBObjectFlagSortReversed, DBSet); table->ListSort(fields); delete fields; return (DBSuccess); } return (DBFault); }
DBInt RGlibPointSTNCharacteristics(DBObjData *dbData) { DBInt i, pointID, dPointID, cellID, mouthID, basinID, color, ret = DBFault, dir; DBVPointIF *pntIF; DBObjTable *pointTable, *cellTable; DBObjTableField *cellIDFLD; DBObjTableField *basinFLD; DBObjTableField *basinNameFLD; DBObjTableField *orderFLD; DBObjTableField *colorFLD; DBObjTableField *basinCellsFLD; DBObjTableField *basinLengthFLD; DBObjTableField *basinAreaFLD; DBObjTableField *interAreaFLD; DBObjTableField *nextStationFLD; DBObjData *netData; DBNetworkIF *netIF; DBObjRecord *pointRec, *dPointRec, *cellRec, *fromCell, *basinRec; if ((netData = dbData->LinkedData()) == (DBObjData *) NULL) return (DBFault); pointTable = dbData->Table(DBrNItems); pntIF = new DBVPointIF(dbData); netIF = new DBNetworkIF(netData); cellTable = netData->Table(DBrNCells); if ((cellIDFLD = pointTable->Field(RGlibCellID)) == NULL) { cellIDFLD = new DBObjTableField(RGlibCellID, DBTableFieldInt, "%8d", sizeof(DBInt)); pointTable->AddField(cellIDFLD); DBPause(1); } if ((basinFLD = pointTable->Field(DBrNBasin)) == NULL) { basinFLD = new DBObjTableField(DBrNBasin, DBTableFieldInt, "%8d", sizeof(DBInt)); pointTable->AddField(basinFLD); DBPause(2); } if ((basinNameFLD = pointTable->Field(RGlibBasinName)) == NULL) { basinNameFLD = new DBObjTableField(RGlibBasinName, DBTableFieldString, "%32s", DBStringLength); pointTable->AddField(basinNameFLD); DBPause(3); } if ((orderFLD = pointTable->Field(DBrNOrder)) == NULL) { orderFLD = new DBObjTableField(DBrNOrder, DBTableFieldInt, "%3d", sizeof(DBByte)); pointTable->AddField(orderFLD); DBPause(4); } if ((colorFLD = pointTable->Field(RGlibColor)) == NULL) { colorFLD = new DBObjTableField(RGlibColor, DBTableFieldInt, "%2d", sizeof(DBShort)); pointTable->AddField(colorFLD); DBPause(5); } if ((basinCellsFLD = pointTable->Field(RGlibCellNum)) == NULL) { basinCellsFLD = new DBObjTableField(RGlibCellNum, DBTableFieldInt, "%8d", sizeof(DBInt)); pointTable->AddField(basinCellsFLD); DBPause(6); } if ((basinLengthFLD = pointTable->Field(RGlibLength)) == NULL) { basinLengthFLD = new DBObjTableField(RGlibLength, DBTableFieldFloat, "%10.1f", sizeof(DBFloat4)); pointTable->AddField(basinLengthFLD); DBPause(7); } if ((basinAreaFLD = pointTable->Field(RGlibArea)) == NULL) { basinAreaFLD = new DBObjTableField(RGlibArea, DBTableFieldFloat, "%10.1f", sizeof(DBFloat4)); pointTable->AddField(basinAreaFLD); DBPause(8); } if ((interAreaFLD = pointTable->Field(RGlibInterStation)) == NULL) { interAreaFLD = new DBObjTableField(RGlibInterStation, DBTableFieldFloat, "%10.1f", sizeof(DBFloat4)); pointTable->AddField(interAreaFLD); DBPause(9); } if ((nextStationFLD = pointTable->Field(RGlibNextStation)) == NULL) { nextStationFLD = new DBObjTableField(RGlibNextStation, DBTableFieldInt, "%8d", sizeof(DBInt)); pointTable->AddField(nextStationFLD); DBPause(10); } if ((_RGlibTEMPPointIDFLD = cellTable->Field(RGlibTEMPPointID)) == NULL) { _RGlibTEMPPointIDFLD = new DBObjTableField(RGlibTEMPPointID, DBTableFieldInt, "%8d", sizeof(DBInt)); cellTable->AddField(_RGlibTEMPPointIDFLD); } for (pointID = 0; pointID < pointTable->ItemNum(); pointID++) { pointRec = pointTable->Item(pointID); if (DBPause(10 + pointID * 10 / pointTable->ItemNum())) goto Stop; if ((pointRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) { cellIDFLD->Int(pointRec, cellIDFLD->IntNoData()); basinFLD->Int(pointRec, basinFLD->IntNoData()); basinNameFLD->String(pointRec, ""); orderFLD->Int(pointRec, orderFLD->IntNoData()); colorFLD->Int(pointRec, colorFLD->IntNoData()); basinCellsFLD->Int(pointRec, basinCellsFLD->IntNoData()); basinAreaFLD->Float(pointRec, basinAreaFLD->FloatNoData()); interAreaFLD->Float(pointRec, interAreaFLD->FloatNoData()); continue; } if ((cellRec = netIF->Cell(pntIF->Coordinate(pointRec))) == (DBObjRecord *) NULL) { cellIDFLD->Int(pointRec, 0); basinFLD->Int(pointRec, 0); basinNameFLD->String(pointRec, "Water"); orderFLD->Int(pointRec, colorFLD->IntNoData()); colorFLD->Int(pointRec, colorFLD->IntNoData()); basinCellsFLD->Int(pointRec, 0); basinAreaFLD->Float(pointRec, 0.0); interAreaFLD->Float(pointRec, 0.0); } else { cellIDFLD->Int(pointRec, cellRec->RowID() + 1); basinRec = netIF->Basin(cellRec); basinFLD->Int(pointRec, basinRec->RowID() + 1); basinNameFLD->String(pointRec, basinRec->Name()); orderFLD->Int(pointRec, netIF->CellOrder(cellRec)); colorFLD->Int(pointRec, 0); basinCellsFLD->Int(pointRec, netIF->CellBasinCells(cellRec)); basinLengthFLD->Float(pointRec, netIF->CellBasinLength(cellRec)); basinAreaFLD->Float(pointRec, netIF->CellBasinArea(cellRec)); interAreaFLD->Float(pointRec, netIF->CellBasinArea(cellRec)); } nextStationFLD->Int(pointRec, 0); } for (cellID = 0; cellID < cellTable->ItemNum(); ++cellID) { if (DBPause(20 + cellID * 20 / cellTable->ItemNum())) goto Stop; cellRec = cellTable->Item(cellID); _RGlibTEMPPointIDFLD->Int(cellRec, DBFault); } pointTable->ListSort(basinAreaFLD); for (pointRec = pointTable->Last(); pointRec != (DBObjRecord *) NULL; pointRec = pointTable->Next(DBBackward)) { if ((pointRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) continue; if (DBPause(40 + pointID * 20 / pointTable->ItemNum())) goto Stop; cellRec = netIF->Cell(pntIF->Coordinate(pointRec)); netIF->UpStreamSearch(cellRec, (DBNetworkACTION) _RGlibSetPointID, (void *) ((char *) NULL + pointRec->RowID())); } for (pointID = 0; pointID < pointTable->ItemNum(); pointID++) { pointRec = pointTable->Item(pointID); if ((pointRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) continue; if (DBPause(60 + pointID * 20 / pointTable->ItemNum())) goto Stop; if ((cellRec = netIF->Cell(pntIF->Coordinate(pointRec))) != (DBObjRecord *) NULL) { if ((cellRec = netIF->ToCell(cellRec)) == (DBObjRecord *) NULL) continue; if ((dPointID = _RGlibTEMPPointIDFLD->Int(cellRec)) != DBFault) { dPointRec = pointTable->Item(dPointID); nextStationFLD->Int(pointRec, dPointRec->RowID() + 1); interAreaFLD->Float(dPointRec, interAreaFLD->Float(dPointRec) - basinAreaFLD->Float(pointRec)); } } } pointTable->ListSort(interAreaFLD); i = 0; for (pointRec = pointTable->Last(); pointRec != (DBObjRecord *) NULL; pointRec = pointTable->Next(DBBackward)) { if (DBPause(80 + (i++) * 20 / pointTable->ItemNum())) goto Stop; pointID = pointRec->RowID(); if ((pointRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) continue; if ((basinID = basinFLD->Int(pointRec)) == 0) continue; cellRec = netIF->Cell(pntIF->Coordinate(pointRec)); mouthID = cellRec->RowID(); color = 1; Start: for (cellID = mouthID; cellID < cellTable->ItemNum(); ++cellID) { cellRec = cellTable->Item(cellID); if (netIF->CellBasinID(cellRec) != basinID) break; if (_RGlibTEMPPointIDFLD->Int(cellRec) != pointID) continue; for (dir = 0; dir < 8; ++dir) { if ((fromCell = netIF->FromCell(cellRec, 0x01 << dir, false)) == (DBObjRecord *) NULL) continue; if ((dPointID = _RGlibTEMPPointIDFLD->Int(fromCell)) == pointID) continue; if (dPointID == DBFault) continue; dPointRec = pointTable->Item(dPointID); if (colorFLD->Int(dPointRec) == color) { color++; goto Start; } } } colorFLD->Int(pointRec, color); } ret = DBSuccess; Stop: pointTable->ListSort(); cellTable->DeleteField(_RGlibTEMPPointIDFLD); delete pntIF; delete netIF; return (ret); }
DBInt DBPointToGrid(DBObjData *pntData, DBObjData *grdData, DBFloat factor) { DBInt startID, pnt0ID, pntID, id, itemNum; double dist, minDist, box, box0, bWidth, bHeight; DBPosition pos; DBCoordinate gCoord, *pCoord; DBObjRecord *grdRec, *pntRec, *symRec; DBObjTable *itemTable, *symTable; DBObjTableField *valField, *symField; DBVPointIF *pntIF; DBGridIF *gridIF; DBMathDistanceFunction distFunc = DBMathGetDistanceFunction(pntData); if (distFunc != DBMathGetDistanceFunction(grdData)) { CMmsgPrint(CMmsgAppError, "Incompatible projections in: %s %d", __FILE__, __LINE__); return (DBFault); } pntIF = new DBVPointIF(pntData); itemNum = pntIF->ItemNum(); if ((pCoord = (DBCoordinate *) calloc(itemNum, sizeof(DBCoordinate))) == (DBCoordinate *) NULL) { CMmsgPrint(CMmsgSysError, "Memory allocation Error in: %s %d", __FILE__, __LINE__); return (DBFault); } gridIF = new DBGridIF(grdData); for (pntID = 0; pntID < itemNum; ++pntID) pCoord[pntID] = pntIF->Coordinate(pntIF->Item(pntID)); if (grdData->Type() == DBTypeGridContinuous) gridIF->RenameLayer(gridIF->Layer((DBInt) 0), (char *) "Distance to Station"); else { gridIF->RenameLayer(gridIF->Layer((DBInt) 0), (char *) "Station grid"); itemTable = grdData->Table(DBrNItems); symTable = grdData->Table(DBrNSymbols); valField = itemTable->Field(DBrNGridValue); symField = itemTable->Field(DBrNSymbol); if ((symRec = symTable->Item(0)) == (DBObjRecord *) NULL) CMmsgPrint(CMmsgAppError, "Total Metal Gebasz in: %s %d", __FILE__, __LINE__); for (pntID = 0; pntID < itemNum; ++pntID) { pntRec = pntIF->Item(pntID); grdRec = itemTable->Add(pntRec->Name()); valField->Int(grdRec, pntID + 1); symField->Record(grdRec, symRec); } } startID = 0; for (pos.Row = 0; pos.Row < gridIF->RowNum(); ++pos.Row) { DBPause(pos.Row * 100 / gridIF->RowNum()); for (pos.Col = 0; pos.Col < gridIF->ColNum(); ++pos.Col) { gridIF->Pos2Coord(pos, gCoord); minDist = box0 = DBHugeVal; pnt0ID = pntID = startID; id = DBFault; do { bWidth = fabs(gCoord.X - pCoord[pntID].X); bHeight = fabs(gCoord.Y - pCoord[pntID].Y); box = bWidth > bHeight ? bWidth : bHeight; if ((box < box0) && ((dist = DBMathCoordinateDistance(distFunc, gCoord, pCoord[pntID])) < minDist)) { minDist = dist; id = startID = pntID; box *= factor; if (box0 > box) box0 = box; } pntID = pntID + 1 < itemNum ? pntID + 1 : 0; } while (pntID != pnt0ID); if (grdData->Type() == DBTypeGridContinuous) gridIF->Value(pos, minDist); else gridIF->Value(pos, id); } } if (grdData->Type() == DBTypeGridContinuous) gridIF->RecalcStats(); else gridIF->DiscreteStats(); delete gridIF; free(pCoord); return (DBSuccess); }
void DBGridOperation(DBObjData *leftGrd, DBObjData *rightGrd, DBInt oper, DBInt mergeMissingVal) { DBInt leftID, rightID; DBFloat leftVal, rightVal; DBPosition pos; DBCoordinate coord; DBObjRecord *leftRec, *rightRec; DBGridIF *leftIF = new DBGridIF(leftGrd); DBGridIF *rightIF = new DBGridIF(rightGrd); for (leftID = 0; leftID < leftIF->LayerNum(); ++leftID) { leftRec = leftIF->Layer(leftID); if ((leftRec->Flags() & DBObjectFlagIdle) != DBObjectFlagIdle) break; } if (leftID == leftIF->LayerNum()) { CMmsgPrint(CMmsgAppError, "No Layer to Process in %s %d", __FILE__, __LINE__); return; } for (rightID = 0; rightID < rightIF->LayerNum(); ++rightID) { rightRec = rightIF->Layer(rightID); if ((rightRec->Flags() & DBObjectFlagIdle) != DBObjectFlagIdle) break; } if (rightID == rightIF->LayerNum()) { CMmsgPrint(CMmsgAppError, "No Layer to Process in %s %d", __FILE__, __LINE__); return; } rightID = (DBInt) 0; for (leftID = 0; leftID < leftIF->LayerNum(); ++leftID) { leftRec = leftIF->Layer(leftID); while ((leftRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) { ++leftID; if (leftID == leftIF->LayerNum()) goto Stop; leftRec = leftIF->Layer(leftID); } if ((rightRec = rightIF->Layer(rightID)) == (DBObjRecord *) NULL) { rightID = 0; rightRec = rightIF->Layer(rightID); } while ((rightRec->Flags() & DBObjectFlagIdle) == DBObjectFlagIdle) { ++rightID; if (rightID == rightIF->LayerNum()) rightID = 0; rightRec = rightIF->Layer(rightID); } for (pos.Row = 0; pos.Row < leftIF->RowNum(); pos.Row++) { if (DBPause((leftID * leftIF->RowNum() + pos.Row) * 100 / (leftIF->LayerNum() * leftIF->RowNum()))) goto Stop; for (pos.Col = 0; pos.Col < leftIF->ColNum(); pos.Col++) { leftIF->Pos2Coord(pos, coord); if (leftIF->Value(leftRec, pos, &leftVal)) { if (rightIF->Value(rightRec, coord, &rightVal)) switch (oper) { case DBMathOperatorAdd: leftIF->Value(leftRec, pos, leftVal + rightVal); break; case DBMathOperatorSub: leftIF->Value(leftRec, pos, leftVal - rightVal); break; case DBMathOperatorMul: leftIF->Value(leftRec, pos, leftVal * rightVal); break; case DBMathOperatorDiv: if (fabs(rightVal) > 0.000001) leftIF->Value(leftRec, pos, leftVal / rightVal); else leftIF->Value(leftRec, pos, leftIF->MissingValue()); break; } else if (mergeMissingVal) leftIF->Value(leftRec, pos, leftIF->MissingValue()); } } } ++rightID; leftIF->RecalcStats(leftRec); } Stop: return; }
int _CMDnetErosion(DBObjData *netData, DBObjData *inData, DBObjData *weightData, DBObjData *outData, DBFloat coeff, DBInt areaMult) { DBInt ret = DBSuccess, layerID, cellID, progress, maxProgress; DBFloat inValue, weight, outValue, *sumWeights; DBPosition pos; DBNetworkIF *netIF = new DBNetworkIF(netData); DBGridIF *inIF = new DBGridIF(inData); DBGridIF *outIF = new DBGridIF(outData); DBGridIF *weightIF = weightData != (DBObjData *) NULL ? new DBGridIF(weightData) : (DBGridIF *) NULL; DBObjRecord *inLayerRec, *outLayerRec, *weightLayerRec, *cellRec, *toCell; if ((sumWeights = (DBFloat *) calloc(netIF->CellNum(), sizeof(DBFloat))) == (DBFloat *) NULL) { CMmsgPrint(CMmsgSysError, "Memory allocation error in: %s %d", __FILE__, __LINE__); ret = DBFault; goto Stop; } layerID = 0; inLayerRec = inIF->Layer(layerID); outLayerRec = outIF->Layer(layerID); outIF->RenameLayer(outLayerRec, inLayerRec->Name()); outValue = outIF->MissingValue(outLayerRec); for (pos.Row = 0; pos.Row < outIF->RowNum(); pos.Row++) for (pos.Col = 0; pos.Col < outIF->ColNum(); pos.Col++) outIF->Value(outLayerRec, pos, outValue); for (layerID = 1; layerID < inIF->LayerNum(); ++layerID) { inLayerRec = inIF->Layer(layerID); if ((outLayerRec = outIF->AddLayer(inLayerRec->Name())) == (DBObjRecord *) NULL) { ret = DBFault; goto Stop; } for (pos.Row = 0; pos.Row < outIF->RowNum(); pos.Row++) for (pos.Col = 0; pos.Col < outIF->ColNum(); pos.Col++) outIF->Value(outLayerRec, pos, outValue); } maxProgress = inIF->LayerNum() * netIF->CellNum(); for (layerID = 0; layerID < inIF->LayerNum(); ++layerID) { inLayerRec = inIF->Layer(layerID); outLayerRec = outIF->Layer(layerID); if (weightIF != (DBGridIF *) NULL) weightLayerRec = weightIF->Layer(layerID % weightIF->LayerNum()); for (cellID = 0; cellID < netIF->CellNum(); cellID++) { sumWeights[cellID] = 0.0; cellRec = netIF->Cell(cellID); if (inIF->Value(inLayerRec, netIF->Center(cellRec), &inValue) == false) outIF->Value(outLayerRec, netIF->CellPosition(cellRec), 0.0); else { if (weightIF != (DBGridIF *) NULL) weight = weightIF->Value(weightLayerRec, netIF->Center(cellRec), &weight) == false ? 0.0 : weight * coeff; else weight = coeff; if (areaMult) weight = weight * netIF->CellArea(cellRec); sumWeights[cellID] = weight; outIF->Value(outLayerRec, netIF->CellPosition(cellRec), inValue * weight); } } for (cellID = netIF->CellNum() - 1; cellID >= 0; --cellID) { progress = layerID * netIF->CellNum() + (netIF->CellNum() - cellID); if (DBPause(progress * 100 / maxProgress)) goto Stop; cellRec = netIF->Cell(cellID); if ((toCell = netIF->ToCell(cellRec)) == (DBObjRecord *) NULL) continue; if (outIF->Value(outLayerRec, netIF->CellPosition(cellRec), &inValue) == false) continue; if (outIF->Value(outLayerRec, netIF->CellPosition(toCell), &outValue) == false) continue; sumWeights[toCell->RowID()] = sumWeights[toCell->RowID()] + weight; outIF->Value(outLayerRec, netIF->CellPosition(toCell), outValue + inValue); } outIF->RecalcStats(outLayerRec); } free(sumWeights); Stop: delete netIF; delete inIF; delete outIF; if (weightIF != (DBGridIF *) NULL) delete weightIF; return (ret); }
int _CMDnetTransfer(DBObjData *netData, DBObjData *inData, DBObjData *weightData, DBObjData *outData, DBFloat coeff, DBObjData *coeffData, DBObjData *QData, DBObjData *HLData, DBFloat umax, DBFloat ksat, DBInt areaMult) { DBInt ret = DBSuccess, layerID, cellID, progress, maxProgress; DBFloat inValue, weight, outValue, *sumWeights, kCoeff, q, hl, Conc, Uptake, Vf; DBPosition pos; DBNetworkIF *netIF = new DBNetworkIF(netData); DBGridIF *inIF = new DBGridIF(inData); DBGridIF *outIF = new DBGridIF(outData); DBGridIF *weightIF = weightData != (DBObjData *) NULL ? new DBGridIF(weightData) : (DBGridIF *) NULL; DBGridIF *coeffIF = coeffData != (DBObjData *) NULL ? new DBGridIF(coeffData) : (DBGridIF *) NULL; DBGridIF *Q_IF = QData != (DBObjData *) NULL ? new DBGridIF(QData) : (DBGridIF *) NULL; DBGridIF *HL_IF = HLData != (DBObjData *) NULL ? new DBGridIF(HLData) : (DBGridIF *) NULL; DBObjRecord *inLayerRec, *outLayerRec, *weightLayerRec, *coeffLayerRec, *Q_LayerRec, *HL_LayerRec, *cellRec, *toCell; DBCoordinate coord; if ((sumWeights = (DBFloat *) calloc(netIF->CellNum(), sizeof(DBFloat))) == (DBFloat *) NULL) { CMmsgPrint(CMmsgSysError, "Memory allocation error in: %s %d", __FILE__, __LINE__); ret = DBFault; goto Stop; } layerID = 0; inLayerRec = inIF->Layer(layerID); outLayerRec = outIF->Layer(layerID); outIF->RenameLayer(outLayerRec, inLayerRec->Name()); outValue = outIF->MissingValue(outLayerRec); for (pos.Row = 0; pos.Row < outIF->RowNum(); pos.Row++) for (pos.Col = 0; pos.Col < outIF->ColNum(); pos.Col++) outIF->Value(outLayerRec, pos, outValue); for (layerID = 1; layerID < inIF->LayerNum(); ++layerID) { inLayerRec = inIF->Layer(layerID); if ((outLayerRec = outIF->AddLayer(inLayerRec->Name())) == (DBObjRecord *) NULL) { ret = DBFault; goto Stop; } for (pos.Row = 0; pos.Row < outIF->RowNum(); pos.Row++) for (pos.Col = 0; pos.Col < outIF->ColNum(); pos.Col++) outIF->Value(outLayerRec, pos, outValue); } maxProgress = inIF->LayerNum() * netIF->CellNum(); for (layerID = 0; layerID < inIF->LayerNum(); ++layerID) { inLayerRec = inIF->Layer(layerID); outLayerRec = outIF->Layer(layerID); if (weightIF != (DBGridIF *) NULL) weightLayerRec = weightIF->Layer(layerID % weightIF->LayerNum()); if (coeffIF != (DBGridIF *) NULL) coeffLayerRec = coeffIF->Layer(layerID % coeffIF->LayerNum()); if (Q_IF != (DBGridIF *) NULL) Q_LayerRec = Q_IF->Layer(layerID % Q_IF->LayerNum()); if (HL_IF != (DBGridIF *) NULL) HL_LayerRec = HL_IF->Layer(layerID % HL_IF->LayerNum()); for (cellID = 0; cellID < netIF->CellNum(); cellID++) { sumWeights[cellID] = 0.0; cellRec = netIF->Cell(cellID); coord = netIF->Center(cellRec); if (inIF->Value(inLayerRec, coord, &inValue) == false) outIF->Value(outLayerRec, netIF->CellPosition(cellRec), 0.0); else { if (weightIF != (DBGridIF *) NULL) weight = weightIF->Value(weightLayerRec, coord, &weight) == false ? 0.0 : weight * coeff; else weight = coeff; if (areaMult) weight = weight * netIF->CellArea(cellRec); sumWeights[cellID] = weight; outIF->Value(outLayerRec, netIF->CellPosition(cellRec), inValue * weight); } } for (cellID = netIF->CellNum() - 1; cellID >= 0; --cellID) { progress = layerID * netIF->CellNum() + (netIF->CellNum() - cellID); if (DBPause(progress * 100 / maxProgress)) goto Stop; cellRec = netIF->Cell(cellID); coord = netIF->Center(cellRec); if ((toCell = netIF->ToCell(cellRec)) == (DBObjRecord *) NULL) continue; if (outIF->Value(outLayerRec, netIF->CellPosition(cellRec), &inValue) == false) continue; if (outIF->Value(outLayerRec, netIF->CellPosition(toCell), &outValue) == false) continue; sumWeights[toCell->RowID()] = sumWeights[toCell->RowID()] + weight; if (coeffIF != (DBGridIF *) NULL) { if (coeffIF->Value(coeffLayerRec, netIF->Center(cellRec), &kCoeff) == false) kCoeff = 1.0; } else { if (((Q_IF == (DBGridIF *) NULL) || (Q_IF->Value(Q_LayerRec, netIF->Center(cellRec), &q) == false)) || ((HL_IF == (DBGridIF *) NULL) || (HL_IF->Value(HL_LayerRec, netIF->Center(cellRec), &hl) == false)) || (umax == 0) || (ksat == 0)) kCoeff = 1.0; else { if ((q > 0) && (hl > 0)) { Conc = ((inValue / (q * 86400 * 365)) * 1000 * 1000); /* mg/m3 - assume input = kg/yr, Q is m3/s convert to m3/yr kg to mg */ Uptake = (umax * 24 * 365 * Conc) / (ksat * 1000 + Conc); /* mg/m2/yr - umax and ksat/Conc are in mg/m2/hr, mg/m3 */ if (Uptake > 0) { Vf = Uptake / Conc; /* Vf in m/yr */ } else Vf = 0; kCoeff = pow(2.71828, (-1.0 * Vf / hl)); /* HL in m/yr */ /* if ((cellID == 5390) || (cellID == 5015) || (cellID == 4905) || (cellID == 4857)) printf("%i, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f \n", cellID, outValue, inValue, q, hl, umax, ksat, Conc, Uptake, Vf, kCoeff); */ } else kCoeff = 0; } } /* if ((cellID == 5390) || (cellID == 5015) || (cellID == 4905) || (cellID == 4857)) printf("%i, %f \n", cellID, inValue); */ inValue = kCoeff * inValue; outIF->Value(outLayerRec, netIF->CellPosition(toCell), outValue + inValue); } outIF->RecalcStats(outLayerRec); } free(sumWeights); Stop: delete netIF; delete inIF; delete outIF; if (weightIF != (DBGridIF *) NULL) delete weightIF; return (ret); return (DBSuccess); }