//---------------------------------------------------------
bool CGDAL_Export_GeoTIFF::On_Execute(void)
{
CSG_String File_Name, Options;
CSG_Projection Projection;
CSG_Parameter_Grid_List *pGrids;
CSG_GDAL_DataSet DataSet;
//-----------------------------------------------------
pGrids = Parameters("GRIDS") ->asGridList();
File_Name = Parameters("FILE") ->asString();
Options = Parameters("OPTIONS") ->asString();
Get_Projection(Projection);
//-----------------------------------------------------
if( !DataSet.Open_Write(File_Name, SG_T("GTiff"), Options, SG_Get_Grid_Type(pGrids), pGrids->Get_Count(), *Get_System(), Projection) )
{
return( false );
}
//-----------------------------------------------------
for(int i=0; i<pGrids->Get_Count(); i++)
{
Process_Set_Text(CSG_String::Format(SG_T("%s %d"), _TL("Band"), i + 1));
DataSet.Write(i, pGrids->asGrid(i));
}
if( !DataSet.Close() )
{
return( false );
}
return( true );
}
//---------------------------------------------------------
bool CSG_PointCloud::_Save(const CSG_String &File_Name)
{
CSG_File Stream;
SG_UI_Msg_Add(CSG_String::Format(SG_T("%s: %s..."), _TL("Save point cloud"), File_Name.c_str()), true);
CSG_String sFile_Name = SG_File_Make_Path(NULL, File_Name, SG_T("spc"));
if( Stream.Open(sFile_Name, SG_FILE_W, true) == false )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("unable to create file."));
return( false );
}
int i, iBuffer, nPointBytes = m_nPointBytes - 1;
Stream.Write((void *)PC_FILE_VERSION, 6);
Stream.Write(&nPointBytes , sizeof(int));
Stream.Write(&m_nFields , sizeof(int));
for(i=0; i<m_nFields; i++)
{
Stream.Write(&m_Field_Type[i], sizeof(TSG_Data_Type));
iBuffer = (int)m_Field_Name[i]->Length();
if( iBuffer >= 1024 - 1 ) iBuffer = 1024 - 1;
Stream.Write(&iBuffer, sizeof(int));
Stream.Write((void *)m_Field_Name[i]->b_str(), sizeof(char), iBuffer);
}
_Set_Shape(m_Shapes_Index);
for(i=0; i<Get_Count() && SG_UI_Process_Set_Progress(i, Get_Count()); i++)
{
Stream.Write(m_Points[i] + 1, nPointBytes);
}
Set_Modified(false);
Set_File_Name(sFile_Name, true);
Save_MetaData(File_Name);
Get_Projection().Save(SG_File_Make_Path(NULL, File_Name, SG_T("prj")), SG_PROJ_FMT_WKT);
SG_UI_Msg_Add(_TL("okay"), false, SG_UI_MSG_STYLE_SUCCESS);
SG_UI_Process_Set_Ready();
return( true );
}
//---------------------------------------------------------
bool CSG_CRSProjector::Get_Projection(CSG_Point &Point) const
{
double x = Point.Get_X();
double y = Point.Get_Y();
if( Get_Projection(x, y) )
{
Point.Assign(x, y);
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGCS_Graticule::On_Execute(void)
{
//-----------------------------------------------------
CSG_Projection Projection;
if( !Get_Projection(Projection) )
{
return( false );
}
//-----------------------------------------------------
m_Projector.Set_Source(CSG_Projection("+proj=longlat +ellps=WGS84 +datum=WGS84", SG_PROJ_FMT_Proj4));
if( !m_Projector.Set_Target(Projection) )
{
m_Projector.Destroy();
return( false );
}
//-----------------------------------------------------
CSG_Rect Extent(
Parameters("XMIN")->asDouble(),
Parameters("YMIN")->asDouble(),
Parameters("XMAX")->asDouble(),
Parameters("YMAX")->asDouble()
);
if( !Get_Graticule(Extent) )
{
m_Projector.Destroy();
return( false );
}
//-----------------------------------------------------
m_Projector.Destroy();
return( true );
}
//---------------------------------------------------------
Cdodproperror::Cdodproperror(void)
{
#ifdef _WIN32
CSG_String UserHomeDir = CSG_String(getenv("USERPROFILE"));
#else
CSG_String UserHomeDir = CSG_String(getenv("HOME"));
#endif
CSG_String DefaultTempDir = SG_File_Make_Path(UserHomeDir, CSG_String("Saga_GIS_tmp"));
// Module info
Set_Name (_TL("Propogated Error DoD"));
Set_Author (SG_T("Sina Masoud-Ansari"));
Set_Description (_TW("Calculate a raw DEM and threshold it using propagated error"));
// GCD setup
GCDBinDir = SG_File_Make_Path(CSG_String("bin"), CSG_String("GCD"));
GCDBinDir = SG_File_Get_Path_Absolute(GCDBinDir);
GCD = SG_File_Make_Path(GCDBinDir, CSG_String("gcd"), CSG_String("exe"));
GCD_CMD = CSG_String("dodproperror");
// Grids
Parameters.Add_Grid(NULL, "NEW_DEM" , _TL("New DEM"), _TL("New DEM raster"), PARAMETER_INPUT);
Parameters.Add_Grid(NULL, "OLD_DEM" , _TL("Old DEM"), _TL("Old DEM raster"), PARAMETER_INPUT);
Parameters.Add_Grid(NULL, "PROP_ERROR", _TL("Propagated Error"), _TL("Propagated Error"), PARAMETER_INPUT);
Parameters.Add_Grid(NULL, "RAW_DOD", _TL("Raw DoD"), _TL("Raw DEM of difference"), PARAMETER_OUTPUT);
Parameters.Add_Grid(NULL, "THRESHOLDED_DOD", _TL("Thresholded DoD"), _TL("Thresholded DEM of difference"), PARAMETER_OUTPUT);
//Other
Parameters.Add_FilePath(NULL, "TEMP_DIR", _TL("Temp File Directory"), _TL("Directory used for storing temporary files during processing."), NULL, DefaultTempDir, false, true, false);
//GDAL
GDALDriver = CSG_String("GTiff");
GDALOptions = CSG_String("");
Get_Projection(Projection);
}
//---------------------------------------------------------
bool CSG_PointCloud::_Load(const CSG_String &File_Name)
{
TSG_Data_Type Type;
char ID[6];
int i, iBuffer, nPointBytes, nFields;
char Name[1024];
CSG_File Stream;
SG_UI_Msg_Add(CSG_String::Format(SG_T("%s: %s..."), _TL("Load point cloud"), File_Name.c_str()), true);
//-----------------------------------------------------
if( !Stream.Open(File_Name, SG_FILE_R, true) )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("file could not be opened."));
return( false );
}
if( !Stream.Read(ID, 6) || strncmp(ID, PC_FILE_VERSION, 5) != 0 )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("incompatible file."));
return( false );
}
if( !Stream.Read(&nPointBytes, sizeof(int)) || nPointBytes < (int)(3 * sizeof(float)) )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("incompatible file."));
return( false );
}
if( !Stream.Read(&nFields, sizeof(int)) || nFields < 3 )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("incompatible file."));
return( false );
}
//-----------------------------------------------------
Destroy();
for(i=0; i<nFields; i++)
{
if( !Stream.Read(&Type , sizeof(TSG_Data_Type))
|| !Stream.Read(&iBuffer , sizeof(int)) || !(iBuffer > 0 && iBuffer < 1024)
|| !Stream.Read(Name , iBuffer) )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("incompatible file."));
return( false );
}
if( ID[5] == '0' ) // Data Type Definition changed!!!
{
switch( Type )
{
default:
Type = SG_DATATYPE_Undefined;
break;
case 1:
Type = SG_DATATYPE_Char;
break;
case 2:
Type = SG_DATATYPE_Short;
break;
case 3:
Type = SG_DATATYPE_Int;
break;
case 4:
Type = SG_DATATYPE_Long;
break;
case 5:
Type = SG_DATATYPE_Float;
break;
case 6:
Type = SG_DATATYPE_Double;
break;
}
}
Name[iBuffer] = '\0';
if( !_Add_Field(CSG_String((const char *)Name), Type) )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("incompatible file."));
return( false );
}
}
if( m_nPointBytes != nPointBytes + 1 )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("incompatible file."));
return( false );
}
//-----------------------------------------------------
sLong fLength = Stream.Length();
while( _Inc_Array() && Stream.Read(m_Cursor + 1, nPointBytes) && SG_UI_Process_Set_Progress((double)Stream.Tell(), (double)fLength) )
{}
_Dec_Array();
Set_File_Name(File_Name, true);
Load_MetaData(File_Name);
if( 0 > Get_Count() )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("no records in file."));
return( false );
}
//-----------------------------------------------------
SG_UI_Process_Set_Ready();
Get_Projection().Load(SG_File_Make_Path(NULL, File_Name, SG_T("prj")), SG_PROJ_FMT_WKT);
SG_UI_Msg_Add(_TL("okay"), false, SG_UI_MSG_STYLE_SUCCESS);
return( true );
}
void CSG_3DView_Projector::Get_Projection(TSG_Point_Z &p)
{
Get_Projection(p.x, p.y, p.z);
}
//---------------------------------------------------------
CSG_Grid * CLandsat_Import::Get_Band(const CSG_String &File)
{
CSG_Data_Manager tmpMgr;
if( !tmpMgr.Add(File) || !tmpMgr.Get_Grid_System(0) || !tmpMgr.Get_Grid_System(0)->Get(0) )
{
Error_Set(CSG_String::Format(SG_T("%s: %s"), _TL("could not load file"), File.c_str()));
return( NULL );
}
tmpMgr.Get_Grid_System(0)->Get(0)->Set_NoData_Value(0); // landsat 8 pretends to use a value of 65535 (2^16 - 1)
CSG_Grid *pBand = NULL;
//-----------------------------------------------------
if( !tmpMgr.Get_Grid_System(0)->Get(0)->Get_Projection().is_Okay() )
{
// undefined coordinate system, nothing to do be done further...
}
//-----------------------------------------------------
else if( Parameters("PROJECTION")->asInt() == 2 ) // Geographic Coordinates
{
pBand = Get_Projection((CSG_Grid *)tmpMgr.Get_Grid_System(0)->Get(0), "+proj=longlat +ellps=WGS84 +datum=WGS84");
}
//-----------------------------------------------------
else // UTM
{
CSG_Grid *pTmp = (CSG_Grid *)tmpMgr.Get_Grid_System(0)->Get(0);
CSG_String Projection = pTmp->Get_Projection().Get_Proj4();
if( Projection.Find("+proj=utm") >= 0
&& ( (Projection.Find("+south") >= 0 && Parameters("PROJECTION")->asInt() == 0)
|| (Projection.Find("+south") < 0 && Parameters("PROJECTION")->asInt() == 1))
&& (pBand = SG_Create_Grid(pTmp->Get_Type(), pTmp->Get_NX(), pTmp->Get_NY(), pTmp->Get_Cellsize(),
pTmp->Get_XMin(), pTmp->Get_YMin() + (Parameters("PROJECTION")->asInt() == 1 ? 10000000 : -10000000)
)) != NULL )
{
if( Parameters("PROJECTION")->asInt() == 1 )
Projection.Append (" +south");
else
Projection.Replace(" +south", "");
pBand->Get_Projection().Create(Projection, SG_PROJ_FMT_Proj4);
pBand->Set_Name (pTmp->Get_Name());
pBand->Set_Description (pTmp->Get_Description());
pBand->Set_NoData_Value_Range(pTmp->Get_NoData_Value(), pTmp->Get_NoData_hiValue());
pBand->Set_Scaling (pTmp->Get_Scaling(), pTmp->Get_Offset());
#pragma omp parallel for
for(int y=0; y<pBand->Get_NY(); y++)
{
for(int x=0; x<pBand->Get_NX(); x++)
{
pBand->Set_Value(x, y, pTmp->asDouble(x, y));
}
}
}
}
//-----------------------------------------------------
if( !pBand )
{
pBand = (CSG_Grid *)tmpMgr.Get_Grid_System(0)->Get(0);
tmpMgr.Delete(tmpMgr.Get_Grid_System(0)->Get(0), true); // make permanent, detach from temporary data manager
}
return( pBand );
}
bool CGridNet::On_Execute(void)
{
TSG_Data_Type Type;
CSG_String InputBasename = CSG_String("input");
CSG_String OutputBasename = CSG_String("output");
CSG_String FLOWD8_INPUT_FileName, FLOWD8_INPUT_FilePath;
CSG_String LONGEST_OUTPUT_FileName, LONGEST_OUTPUT_FilePath;
CSG_String TOTAL_LENGTH_OUTPUT_FileName, TOTAL_LENGTH_OUTPUT_FilePath;
CSG_String ORDER_OUTPUT_FileName, ORDER_OUTPUT_FilePath;
CSG_String OUTLET_INPUT_FileName, OUTLET_INPUT_FilePath, MASK_INPUT_FileName, MASK_INPUT_FilePath;
CSG_String GDALDriver, sCmd, TempDirPath, TauDEMBinDir, BinaryName, BinaryPath, LogFile;
CSG_String LONGESTName, LENGTHName, ORDERName;
CSG_Projection Projection;
CSG_GDAL_DataSet DataSet;
CSG_Grid *FLOWD8_INPUT_Grid, *LONGEST_OUTPUT_Grid, *TOTAL_LENGTH_OUTPUT_Grid, *ORDER_OUTPUT_Grid, *MASK_INPUT_Grid;
CSG_Shapes *OUTLET_INPUT_Grid;
int Threshold, nproc;
FLOWD8_INPUT_Grid = Parameters("FLOWD8_INPUT")->asGrid();
LONGEST_OUTPUT_Grid = Parameters("LONGEST_OUTPUT")->asGrid();
TOTAL_LENGTH_OUTPUT_Grid = Parameters("TOTAL_LENGTH_OUTPUT")->asGrid();
ORDER_OUTPUT_Grid = Parameters("ORDER_OUTPUT")->asGrid();
MASK_INPUT_Grid = Parameters("MASK_INPUT")->asGrid();
OUTLET_INPUT_Grid = Parameters("OUTLET_INPUT")->asShapes();
Threshold = Parameters("THRESHOLD")->asInt();
nproc = Parameters("NPROC")->asInt();
GDALDriver = CSG_String("GTiff");
Get_Projection(Projection);
Type = FLOWD8_INPUT_Grid->Get_Type();
//TempDirPath = SG_File_Get_Path_Absolute(CSG_String("taudem_tmp"));
TempDirPath = Parameters("TEMP_DIR")->asFilePath()->asString();
FLOWD8_INPUT_FileName = InputBasename + CSG_String("p");
FLOWD8_INPUT_FilePath = SG_File_Make_Path(TempDirPath, FLOWD8_INPUT_FileName, CSG_String("tif"));
LONGEST_OUTPUT_FileName = OutputBasename + CSG_String("plen");
LONGEST_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, LONGEST_OUTPUT_FileName, CSG_String("tif"));
TOTAL_LENGTH_OUTPUT_FileName = OutputBasename + CSG_String("tlen");
TOTAL_LENGTH_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, TOTAL_LENGTH_OUTPUT_FileName, CSG_String("tif"));
ORDER_OUTPUT_FileName = OutputBasename + CSG_String("gord");
ORDER_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, ORDER_OUTPUT_FileName, CSG_String("tif"));
OUTLET_INPUT_FileName = InputBasename + CSG_String("o");
OUTLET_INPUT_FilePath = SG_File_Make_Path(TempDirPath, OUTLET_INPUT_FileName, CSG_String("shp"));
MASK_INPUT_FileName = InputBasename + CSG_String("wg");
MASK_INPUT_FilePath = SG_File_Make_Path(TempDirPath, MASK_INPUT_FileName, CSG_String("tif"));
LogFile = SG_File_Make_Path(TempDirPath, CSG_String("taudem_log.txt"));
LogFile = SG_File_Get_Path_Absolute(LogFile);
TauDEMBinDir = SG_File_Make_Path(CSG_String("bin"), CSG_String("TauDEM"));
TauDEMBinDir = SG_File_Get_Path_Absolute(TauDEMBinDir);
// optional flags
CSG_String OptionalFlags = CSG_String("");
if (OUTLET_INPUT_Grid != NULL)
{
OptionalFlags = CSG_String::Format(SG_T(" -o \"%s\""), OUTLET_INPUT_FilePath.c_str());
}
if (MASK_INPUT_Grid != NULL)
{
OptionalFlags = OptionalFlags + CSG_String::Format(SG_T(" -mask \"%s\" -thresh %d"), MASK_INPUT_FilePath.c_str(), Threshold);
}
BinaryName = CSG_String("GridNet");
BinaryPath = SG_File_Make_Path(TauDEMBinDir, BinaryName);
sCmd = CSG_String::Format(SG_T("\"mpiexec -n %d \"%s\" -p \"%s\" -plen \"%s\" -tlen \"%s\" -gord \"%s\" %s > \"%s\" 2>&1\""), nproc, BinaryPath.c_str(), FLOWD8_INPUT_FilePath.c_str(), LONGEST_OUTPUT_FilePath.c_str(), TOTAL_LENGTH_OUTPUT_FilePath.c_str(), ORDER_OUTPUT_FilePath.c_str(), OptionalFlags.c_str(), LogFile.c_str());
LONGESTName = CSG_String("D8 LongestPath");
LENGTHName = CSG_String("D8 TotalLength");
ORDERName = CSG_String("D8 GridOrder");
// make sure temp dir exists
if (!SG_Dir_Exists(TempDirPath))
{
if (!SG_Dir_Create(TempDirPath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to create temp directory"), TempDirPath.c_str()));
}
}
// Delete old input file if exists
if (SG_File_Exists(FLOWD8_INPUT_FilePath))
{
if (!SG_File_Delete(FLOWD8_INPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to delete previous input file: "), FLOWD8_INPUT_FilePath.c_str()));
return( false );
}
}
if (OUTLET_INPUT_Grid != NULL)
{
// Delete old input file if exists
if (SG_File_Exists(OUTLET_INPUT_FilePath))
{
if (!SG_File_Delete(OUTLET_INPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to delete previous input file: "), OUTLET_INPUT_FilePath.c_str()));
return( false );
}
}
}
if (MASK_INPUT_Grid != NULL)
{
// Delete old input file if exists
if (SG_File_Exists(MASK_INPUT_FilePath))
{
if (!SG_File_Delete(MASK_INPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to delete previous input file: "), MASK_INPUT_FilePath.c_str()));
return( false );
}
}
}
// Delete old output files
if (SG_File_Exists(LONGEST_OUTPUT_FilePath))
{
if (!SG_File_Delete(LONGEST_OUTPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to delete previous output file: "), LONGEST_OUTPUT_FilePath.c_str()));
return( false );
}
}
// Delete old output files
if (SG_File_Exists(TOTAL_LENGTH_OUTPUT_FilePath))
{
if (!SG_File_Delete(TOTAL_LENGTH_OUTPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to delete previous output file: "), TOTAL_LENGTH_OUTPUT_FilePath.c_str()));
return( false );
}
}
// Delete old output files
if (SG_File_Exists(ORDER_OUTPUT_FilePath))
{
if (!SG_File_Delete(ORDER_OUTPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to delete previous output file: "), ORDER_OUTPUT_FilePath.c_str()));
return( false );
}
}
// save input file
if( !DataSet.Open_Write(FLOWD8_INPUT_FilePath, GDALDriver, CSG_String(""), Type, 1, *Get_System(), Projection) )
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open file for writing: "), FLOWD8_INPUT_FilePath.c_str()));
return( false );
}
DataSet.Write(0, FLOWD8_INPUT_Grid);
if( !DataSet.Close() )
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to close file after writing: "), FLOWD8_INPUT_FilePath.c_str()));
return( false );
}
// save mask grid
if (MASK_INPUT_Grid != NULL)
{
if( !DataSet.Open_Write(MASK_INPUT_FilePath, GDALDriver, CSG_String(""), Type, 1, *Get_System(), Projection) )
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open file for writing: "), MASK_INPUT_FilePath.c_str()));
return( false );
}
DataSet.Write(0, MASK_INPUT_Grid);
if( !DataSet.Close() )
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to close file after writing: "), MASK_INPUT_FilePath.c_str()));
return( false );
}
}
// save outlet shapefile
if (OUTLET_INPUT_Grid != NULL)
{
CSG_OGR_DataSource DataSource;
CSG_String OGRDriver = CSG_String("ESRI Shapefile");
if( !DataSource.Create(OUTLET_INPUT_FilePath, OGRDriver) )
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open file for writing: "), OUTLET_INPUT_FilePath.c_str()));
return( false );
}
DataSource.Write(OUTLET_INPUT_Grid, OGRDriver);
}
// Run TauDEM GridNet
Message_Add(CSG_String("Executing ") + sCmd);
// run process
if (system(sCmd.b_str()) != 0)
{
Error_Set(CSG_String::Format(SG_T("Error executing '%s' see Execution log for details"), BinaryName.c_str()));
// read log output
CSG_File File;
if (File.Open(LogFile, SG_FILE_R, false))
{
CSG_String Line;
while (! File.is_EOF() && File.Read_Line(Line))
{
Message_Add(Line);
}
File.Close();
} else
{
Message_Add(CSG_String("Unable to open " + LogFile + CSG_String(" for reading")));
}
return( false );
}
// Open new output tif file
if( !DataSet.Open_Read(LONGEST_OUTPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open generated file: "), LONGEST_OUTPUT_FilePath.c_str()));
return( false );
}
else
{
LONGEST_OUTPUT_Grid->Assign(DataSet.Read(0));
LONGEST_OUTPUT_Grid->Set_Name(LONGESTName);
Parameters("LONGEST_OUTPUT")->Set_Value(LONGEST_OUTPUT_Grid);
CSG_Colors colors;
DataObject_Get_Colors(FLOWD8_INPUT_Grid, colors);
DataObject_Set_Colors(LONGEST_OUTPUT_Grid, colors);
DataObject_Update(LONGEST_OUTPUT_Grid, false);
}
// Open new output tif file
if( !DataSet.Open_Read(TOTAL_LENGTH_OUTPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open generated file: "), TOTAL_LENGTH_OUTPUT_FilePath.c_str()));
return( false );
}
else
{
TOTAL_LENGTH_OUTPUT_Grid->Assign(DataSet.Read(0));
TOTAL_LENGTH_OUTPUT_Grid->Set_Name(LENGTHName);
Parameters("TOTAL_LENGTH_OUTPUT")->Set_Value(TOTAL_LENGTH_OUTPUT_Grid);
CSG_Colors colors;
DataObject_Get_Colors(FLOWD8_INPUT_Grid, colors);
DataObject_Set_Colors(TOTAL_LENGTH_OUTPUT_Grid, colors);
DataObject_Update(TOTAL_LENGTH_OUTPUT_Grid, false);
}
// Open new output tif
if( !DataSet.Open_Read(ORDER_OUTPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open generated file: "), ORDER_OUTPUT_FilePath.c_str()));
return( false );
}
else
{
ORDER_OUTPUT_Grid->Assign(DataSet.Read(0));
ORDER_OUTPUT_Grid->Set_Name(ORDERName);
Parameters("ORDER_OUTPUT")->Set_Value(ORDER_OUTPUT_Grid);
CSG_Colors colors;
DataObject_Get_Colors(FLOWD8_INPUT_Grid, colors);
DataObject_Set_Colors(ORDER_OUTPUT_Grid, colors);
DataObject_Update(ORDER_OUTPUT_Grid, false);
}
return( true );
}
bool CStreamNet::On_Execute(void)
{
// Inputs and Output Strings
CSG_String InputBasename = CSG_String("input");
CSG_String OutputBasename = CSG_String("output");
CSG_String FEL_INPUT_FileName, FEL_INPUT_FilePath;
CSG_String FLOWD8_INPUT_FileName, FLOWD8_INPUT_FilePath;
CSG_String AREAD8_INPUT_FileName, AREAD8_INPUT_FilePath;
CSG_String SRC_INPUT_FileName, SRC_INPUT_FilePath;
CSG_String ORD_OUTPUT_FileName, ORD_OUTPUT_FilePath, ORD_OUTPUT_Name;
CSG_String W_OUTPUT_FileName, W_OUTPUT_FilePath, W_OUTPUT_Name;
CSG_String NET_OUTPUT_FileName, NET_OUTPUT_FilePath, NET_OUTPUT_Name;
CSG_String TREE_OUTPUT_FileName, TREE_OUTPUT_FilePath, TREE_OUTPUT_Name;
CSG_String COORD_OUTPUT_FileName, COORD_OUTPUT_FilePath, COORD_OUTPUT_Name;
CSG_String OUTLET_INPUT_FileName, OUTLET_INPUT_FilePath;
// Data Objects
CSG_Grid *FEL_INPUT_Grid, *FLOWD8_INPUT_Grid, *SRC_INPUT_Grid, *AREAD8_INPUT_Grid, *ORD_OUTPUT_Grid, *W_OUTPUT_Grid;
CSG_Shapes *OUTLET_INPUT_Shapes, *NET_OUTPUT_Shapes;
CSG_Table *TREE_OUTPUT_Table, *COORD_OUTPUT_Table;
// Misc
TSG_Data_Type Type;
CSG_String GDALDriver, sCmd, TempDirPath, TauDEMBinDir, BinaryName, BinaryPath, LogFile;
CSG_Projection Projection;
CSG_GDAL_DataSet DataSet;
CSG_OGR_DataSource OGRDataSource;
CSG_String OGRDriver = CSG_String("ESRI Shapefile");
bool sw;
int nproc;
// Grab inputs
FEL_INPUT_Grid = Parameters("FEL_INPUT")->asGrid();
FLOWD8_INPUT_Grid = Parameters("FLOWD8_INPUT")->asGrid();
SRC_INPUT_Grid = Parameters("SRC_INPUT")->asGrid();
AREAD8_INPUT_Grid = Parameters("AREAD8_INPUT")->asGrid();
ORD_OUTPUT_Grid = Parameters("ORD_OUTPUT")->asGrid();
W_OUTPUT_Grid = Parameters("W_OUTPUT")->asGrid();
nproc = Parameters("NPROC")->asInt();
OUTLET_INPUT_Shapes = Parameters("OUTLET_INPUT")->asShapes();
NET_OUTPUT_Shapes = Parameters("NET_OUTPUT")->asShapes();
TREE_OUTPUT_Table = Parameters("TREE_OUTPUT")->asTable();
COORD_OUTPUT_Table = Parameters("COORD_OUTPUT")->asTable();
sw = Parameters("SW")->asBool();
GDALDriver = CSG_String("GTiff");
Get_Projection(Projection);
Type = FEL_INPUT_Grid->Get_Type();
//TempDirPath = SG_File_Get_Path_Absolute(CSG_String("taudem_tmp"));
TempDirPath = Parameters("TEMP_DIR")->asFilePath()->asString();
FEL_INPUT_FileName = InputBasename + CSG_String("fel");
FEL_INPUT_FilePath = SG_File_Make_Path(TempDirPath, FEL_INPUT_FileName, CSG_String("tif"));
FLOWD8_INPUT_FileName = InputBasename + CSG_String("p");
FLOWD8_INPUT_FilePath = SG_File_Make_Path(TempDirPath, FLOWD8_INPUT_FileName, CSG_String("tif"));
SRC_INPUT_FileName = InputBasename + CSG_String("src");
SRC_INPUT_FilePath = SG_File_Make_Path(TempDirPath, SRC_INPUT_FileName, CSG_String("tif"));
AREAD8_INPUT_FileName = InputBasename + CSG_String("ad8");
AREAD8_INPUT_FilePath = SG_File_Make_Path(TempDirPath, AREAD8_INPUT_FileName, CSG_String("tif"));
ORD_OUTPUT_FileName = OutputBasename + CSG_String("ord");
ORD_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, ORD_OUTPUT_FileName, CSG_String("tif"));
ORD_OUTPUT_Name = CSG_String("NetworkOrder");
W_OUTPUT_FileName = OutputBasename + CSG_String("w");
W_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, W_OUTPUT_FileName, CSG_String("tif"));
W_OUTPUT_Name = CSG_String("WatershedIDs");
OUTLET_INPUT_FileName = InputBasename + CSG_String("o");
OUTLET_INPUT_FilePath = SG_File_Make_Path(TempDirPath, OUTLET_INPUT_FileName, CSG_String("shp"));
NET_OUTPUT_FileName = OutputBasename + CSG_String("net");
NET_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, NET_OUTPUT_FileName, CSG_String("shp"));
NET_OUTPUT_Name = CSG_String("Channel Network");
TREE_OUTPUT_FileName = OutputBasename + CSG_String("tree");
TREE_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, TREE_OUTPUT_FileName, CSG_String("dat"));
TREE_OUTPUT_Name = CSG_String("Channel Network Tree");
COORD_OUTPUT_FileName = OutputBasename + CSG_String("coord");
COORD_OUTPUT_FilePath = SG_File_Make_Path(TempDirPath, COORD_OUTPUT_FileName, CSG_String("dat"));
COORD_OUTPUT_Name = CSG_String("Channel Network Coords");
LogFile = SG_File_Make_Path(TempDirPath, CSG_String("taudem_log.txt"));
LogFile = SG_File_Get_Path_Absolute(LogFile);
TauDEMBinDir = SG_File_Make_Path(CSG_String("bin"), CSG_String("TauDEM"));
TauDEMBinDir = SG_File_Get_Path_Absolute(TauDEMBinDir);
// options
CSG_String OptionalFlags = CSG_String("");
if (OUTLET_INPUT_Shapes != NULL)
{
OptionalFlags = CSG_String::Format(SG_T("-o \"%s\" "), OUTLET_INPUT_FilePath.c_str());
}
if (sw)
{
OptionalFlags = OptionalFlags + CSG_String::Format(SG_T("-sw"));
}
// exec commnad
BinaryName = CSG_String("StreamNet"); // D8
BinaryPath = SG_File_Make_Path(TauDEMBinDir, BinaryName);
sCmd = CSG_String::Format(SG_T("\"mpiexec -n %d \"%s\" -fel \"%s\" -p \"%s\" -ad8 \"%s\" -src \"%s\" -ord \"%s\" -tree \"%s\" -coord \"%s\" -net \"%s\" -w \"%s\" %s >\"%s\" 2>&1\""), nproc, BinaryPath.c_str(), FEL_INPUT_FilePath.c_str(), FLOWD8_INPUT_FilePath.c_str(), AREAD8_INPUT_FilePath.c_str(), SRC_INPUT_FilePath.c_str(), ORD_OUTPUT_FilePath.c_str(), TREE_OUTPUT_FilePath.c_str(), COORD_OUTPUT_FilePath.c_str(), NET_OUTPUT_FilePath.c_str(), W_OUTPUT_FilePath.c_str(), OptionalFlags.c_str(), LogFile.c_str());
// make sure temp dir exists
if (!SG_Dir_Exists(TempDirPath))
{
if (!SG_Dir_Create(TempDirPath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to create temp directory"), TempDirPath.c_str()));
}
}
CSG_String FilePaths [10] = {FEL_INPUT_FilePath, FLOWD8_INPUT_FilePath, SRC_INPUT_FilePath, AREAD8_INPUT_FilePath, ORD_OUTPUT_FilePath, W_OUTPUT_FilePath, OUTLET_INPUT_FilePath, NET_OUTPUT_FilePath, TREE_OUTPUT_FilePath, COORD_OUTPUT_FilePath};
for (int i = 0; i < 10; i++)
{
CSG_String FilePath = FilePaths[i];
// Delete old file if exists
if (SG_File_Exists(FilePath))
{
if (!SG_File_Delete(FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to delete existing file: "), FilePath.c_str()));
return( false );
}
}
}
// SAVE TIFFS
CSG_String TIFF_INPUT_FilePaths [4] = {FEL_INPUT_FilePath, FLOWD8_INPUT_FilePath, SRC_INPUT_FilePath, AREAD8_INPUT_FilePath};
CSG_Grid* TIFF_INPUT_Grids [4] = {FEL_INPUT_Grid, FLOWD8_INPUT_Grid, SRC_INPUT_Grid, AREAD8_INPUT_Grid};
for (int i = 0; i < 4; i++)
{
CSG_String FilePath = TIFF_INPUT_FilePaths[i];
CSG_Grid* Grid = TIFF_INPUT_Grids[i];
if( !DataSet.Open_Write(FilePath, GDALDriver, CSG_String(""), Type, 1, *Get_System(), Projection) )
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open file for writing: "), FilePath.c_str()));
return( false );
}
DataSet.Write(0, Grid);
if( !DataSet.Close() )
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to close file after writing: "), FilePath.c_str()));
return( false );
}
}
if (OUTLET_INPUT_Shapes != NULL)
{
// save outlet shapefile
CSG_String OGRDriver = CSG_String("ESRI Shapefile");
if( !OGRDataSource.Create(OUTLET_INPUT_FilePath, OGRDriver) )
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open file for writing: "), OUTLET_INPUT_FilePath.c_str()));
return( false );
}
OGRDataSource.Write(OUTLET_INPUT_Shapes, OGRDriver);
OGRDataSource.Destroy();
}
// Run TauDEM StreamNet
Message_Add(CSG_String("Executing ") + sCmd);
if (system(sCmd.b_str()) != 0)
{
Error_Set(CSG_String::Format(SG_T("Error executing '%s' see Execution log for details"), BinaryName.c_str()));
// read log output
CSG_File File;
if (File.Open(LogFile, SG_FILE_R, false))
{
CSG_String Line;
while (! File.is_EOF() && File.Read_Line(Line))
{
Message_Add(Line);
}
File.Close();
} else
{
Message_Add(CSG_String("Unable to open " + LogFile + CSG_String(" for reading")));
}
return( false );
}
// Load output tiffs
if( !DataSet.Open_Read(ORD_OUTPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open output file: "), ORD_OUTPUT_FilePath.c_str()));
return( false );
}
else
{
ORD_OUTPUT_Grid->Assign(DataSet.Read(0));
ORD_OUTPUT_Grid->Set_Name(ORD_OUTPUT_Name);
Parameters("ORD_OUTPUT")->Set_Value(ORD_OUTPUT_Grid);
}
if( !DataSet.Open_Read(W_OUTPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open output file: "), W_OUTPUT_FilePath.c_str()));
return( false );
}
else
{
W_OUTPUT_Grid->Assign(DataSet.Read(0));
W_OUTPUT_Grid->Set_Name(W_OUTPUT_Name);
Parameters("W_OUTPUT")->Set_Value(W_OUTPUT_Grid);
CSG_Colors colors;
DataObject_Get_Colors(SRC_INPUT_Grid, colors);
DataObject_Set_Colors(ORD_OUTPUT_Grid, colors);
DataObject_Update(ORD_OUTPUT_Grid, false);
}
// load output shapefile
if( !OGRDataSource.Create(NET_OUTPUT_FilePath) )
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to open file for reading: "), NET_OUTPUT_FilePath.c_str()));
return( false );
}
NET_OUTPUT_Shapes->Assign(OGRDataSource.Read(0, 0));
NET_OUTPUT_Shapes->Set_Name(NET_OUTPUT_Name);
OGRDataSource.Destroy();
// load table data
if (!SG_File_Exists(COORD_OUTPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Output file does not exist: "), COORD_OUTPUT_FilePath.c_str()));
return false;
}
else
{
COORD_OUTPUT_Table->Destroy();
COORD_OUTPUT_Table->Set_Name(COORD_OUTPUT_Name);
// create table fields
COORD_OUTPUT_Table->Add_Field(SG_T("X"), SG_DATATYPE_Double);
COORD_OUTPUT_Table->Add_Field(SG_T("Y"), SG_DATATYPE_Double);
COORD_OUTPUT_Table->Add_Field(SG_T("Terminal Distance"), SG_DATATYPE_Double);
COORD_OUTPUT_Table->Add_Field(SG_T("Elevation"), SG_DATATYPE_Double);
COORD_OUTPUT_Table->Add_Field(SG_T("Contributing Area"), SG_DATATYPE_Double);
// read table data
CSG_File File;
if (File.Open(COORD_OUTPUT_FilePath, SG_FILE_R, false))
{
CSG_String Line;
// determine number of lines
while (! File.is_EOF() && File.Read_Line(Line))
{
Line.Trim();
if (Line.Length() == 0)
{
break;
}
else
{
CSG_Table_Record *Record = COORD_OUTPUT_Table->Add_Record();
for (int i = 0; i < COORD_OUTPUT_Table->Get_Field_Count(); i++)
{
Record->Set_Value(i, Line.asDouble());
Line = Line.AfterFirst('\t');
Line.Trim();
}
}
}
File.Close();
} else
{
Message_Add(CSG_String("Unable to open " + COORD_OUTPUT_FilePath + CSG_String(" for reading")));
}
}
if (!SG_File_Exists(TREE_OUTPUT_FilePath))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Output file does not exist: "), TREE_OUTPUT_FilePath.c_str()));
return false;
}
else
{
TREE_OUTPUT_Table->Destroy();
TREE_OUTPUT_Table->Set_Name(TREE_OUTPUT_Name);
// create table fields
TREE_OUTPUT_Table->Add_Field(SG_T("Link"), SG_DATATYPE_Int);
TREE_OUTPUT_Table->Add_Field(SG_T("Start Point"), SG_DATATYPE_Int);
TREE_OUTPUT_Table->Add_Field(SG_T("End Point"), SG_DATATYPE_Int);
TREE_OUTPUT_Table->Add_Field(SG_T("Next (Downstream) Link"), SG_DATATYPE_Int);
TREE_OUTPUT_Table->Add_Field(SG_T("First Previous (Upstream) Link"), SG_DATATYPE_Int);
TREE_OUTPUT_Table->Add_Field(SG_T("Second Previous (Upstream) Link"), SG_DATATYPE_Int);
TREE_OUTPUT_Table->Add_Field(SG_T("Strahler Order"), SG_DATATYPE_Int);
TREE_OUTPUT_Table->Add_Field(SG_T("Monitoring Point ID"), SG_DATATYPE_Int);
TREE_OUTPUT_Table->Add_Field(SG_T("Link Network Magnitude"), SG_DATATYPE_Int);
// read table data
CSG_File File;
if (File.Open(TREE_OUTPUT_FilePath, SG_FILE_R, false))
{
CSG_String Line;
// determine number of lines
while (! File.is_EOF() && File.Read_Line(Line))
{
Line.Trim();
if (Line.Length() == 0)
{
break;
}
else
{
CSG_Table_Record *Record = TREE_OUTPUT_Table->Add_Record();
for (int i = 0; i < TREE_OUTPUT_Table->Get_Field_Count(); i++)
{
Record->Set_Value(i, Line.asDouble());
Line = Line.AfterFirst('\t');
Line.Trim();
}
}
}
File.Close();
} else
{
Message_Add(CSG_String("Unable to open " + TREE_OUTPUT_FilePath + CSG_String(" for reading")));
}
}
return( true );
}
//---------------------------------------------------------
bool CSG_CRSProjector::Get_Projection(TSG_Point &Point) const
{
return( Get_Projection(Point.x, Point.y) );
}