//---------------------------------------------------------
void CActive_Attributes_Control::On_Field_Rename(wxCommandEvent &event)
{
if( !g_pActive->Get_Active_Data_Item() || g_pActive->Get_Active_Data_Item()->Get_Type() != WKSP_ITEM_Grids ) { return; }
CSG_Grids *pGrids = ((CWKSP_Grids *)g_pActive->Get_Active_Data_Item())->Get_Grids();
//-----------------------------------------------------
int i;
CSG_Parameters P;
P.Set_Name(_TL("Rename Fields"));
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
P.Add_String(NULL, SG_Get_String(i), m_pTable->Get_Field_Name(i), _TL(""), m_pTable->Get_Field_Name(i));
}
//-----------------------------------------------------
if( DLG_Parameters(&P) )
{
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
CSG_String s(P(i)->asString());
if( s.Length() > 0 && s.Cmp(m_pTable->Get_Field_Name(i)) )
{
pGrids->Get_Attributes_Ptr()->Set_Field_Name(i, s);
SetColLabelValue(i, s.c_str());
}
}
g_pData->Update(pGrids, NULL);
}
}
//---------------------------------------------------------
void CVIEW_Table_Control::On_Field_Rename(wxCommandEvent &event)
{
int i;
CSG_Parameters P;
P.Set_Name(_TL("Rename Fields"));
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
P.Add_String(NULL, "", m_pTable->Get_Field_Name(i), _TL(""), m_pTable->Get_Field_Name(i));
}
//-----------------------------------------------------
if( DLG_Parameters(&P) )
{
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
CSG_String s(P(i)->asString());
if( s.Length() > 0 && s.Cmp(m_pTable->Get_Field_Name(i)) )
{
m_pTable->Set_Field_Name(i, s);
SetColLabelValue(i, s.c_str());
}
}
g_pData->Update(m_pTable, NULL);
}
}
//---------------------------------------------------------
void CActive_Attributes_Control::On_Field_Del(wxCommandEvent &event)
{
if( !g_pActive->Get_Active_Data_Item() || g_pActive->Get_Active_Data_Item()->Get_Type() != WKSP_ITEM_Grids ) { return; }
CSG_Grids *pGrids = ((CWKSP_Grids *)g_pActive->Get_Active_Data_Item())->Get_Grids();
//-----------------------------------------------------
int i;
CSG_Parameters P;
//-----------------------------------------------------
P.Set_Name(_TL("Delete Fields"));
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
P.Add_Value(NULL, SG_Get_String(i), m_pTable->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false);
}
//-----------------------------------------------------
if( DLG_Parameters(&P) )
{
for(i=m_pTable->Get_Field_Count()-1; i>=0; i--)
{
if( P(SG_Get_String(i))->asBool() )
{
pGrids->Get_Attributes_Ptr()->Del_Field(i);
DeleteCols(i);
}
}
g_pData->Update(pGrids, NULL);
}
}
//---------------------------------------------------------
void CVIEW_Table_Control::On_Field_Del(wxCommandEvent &event)
{
int i;
CSG_Parameters P;
//-----------------------------------------------------
P.Set_Name(_TL("Delete Fields"));
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
P.Add_Value(NULL, SG_Get_String(i, 0), m_pTable->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false);
}
//-----------------------------------------------------
if( DLG_Parameters(&P) )
{
for(i=m_pTable->Get_Field_Count()-1; i>=0; i--)
{
if( P(SG_Get_String(i, 0))->asBool() )
{
m_pTable->Del_Field(i);
DeleteCols(i);
}
}
g_pData->Update(m_pTable, NULL);
}
}
//---------------------------------------------------------
bool CShapes_Create_Empty::On_Execute(void)
{
TSG_Vertex_Type Vertex;
switch( Parameters("VERTEX")->asInt() )
{
default:
case 0: Vertex = SG_VERTEX_TYPE_XY; break;
case 1: Vertex = SG_VERTEX_TYPE_XYZ; break;
case 2: Vertex = SG_VERTEX_TYPE_XYZM; break;
}
//-----------------------------------------------------
CSG_Shapes *pShapes;
switch( Parameters("TYPE")->asInt() )
{
default: return( false );
case 0: pShapes = SG_Create_Shapes(SHAPE_TYPE_Point , Parameters("NAME")->asString(), NULL, Vertex); break;
case 1: pShapes = SG_Create_Shapes(SHAPE_TYPE_Points , Parameters("NAME")->asString(), NULL, Vertex); break;
case 2: pShapes = SG_Create_Shapes(SHAPE_TYPE_Line , Parameters("NAME")->asString(), NULL, Vertex); break;
case 3: pShapes = SG_Create_Shapes(SHAPE_TYPE_Polygon, Parameters("NAME")->asString(), NULL, Vertex); break;
}
//-----------------------------------------------------
int i, n;
TSG_Data_Type Type;
CSG_Parameters *pAttributes;
pAttributes = Parameters("FIELDS")->asParameters();
n = pAttributes->Get_Count() / 3;
for(i=0; i<n; i++)
{
switch( pAttributes->Get_Parameter(GET_TYPE(i))->asInt() )
{
default:
case 0: Type = SG_DATATYPE_String; break;
case 1: Type = SG_DATATYPE_Date; break;
case 2: Type = SG_DATATYPE_Color; break;
case 3: Type = SG_DATATYPE_Byte; break;
case 4: Type = SG_DATATYPE_Char; break;
case 5: Type = SG_DATATYPE_Word; break;
case 6: Type = SG_DATATYPE_Short; break;
case 7: Type = SG_DATATYPE_DWord; break;
case 8: Type = SG_DATATYPE_Int; break;
case 9: Type = SG_DATATYPE_ULong; break;
case 10: Type = SG_DATATYPE_Long; break;
case 11: Type = SG_DATATYPE_Float; break;
case 12: Type = SG_DATATYPE_Double; break;
case 13: Type = SG_DATATYPE_Binary; break;
}
pShapes->Add_Field(pAttributes->Get_Parameter(GET_NAME(i))->asString(), Type);
}
Parameters("SHAPES")->Set_Value(pShapes);
return( true );
}
bool Cihacres_elev::_CreateDialog3()
{
CSG_String s;
CSG_Parameters P; // used to add Parameters in the second dialog
CSG_Parameter *pNode;
// Dialog design
P.Set_Name(_TL("Choose Time Range"));
s.Printf(SG_T("Node1"), 1);
pNode = P.Add_Node(NULL,s,SG_T("Time Range"),_TL(""));
s.Printf(SG_T("FDAY") , 1-1);
P.Add_String(pNode,s,_TL("First Day"),_TL(""),
m_p_InputTable->Get_Record(0)->asString(m_dateField));
s.Printf(SG_T("LDAY") , 1-2);
P.Add_String(pNode,s,_TL("Last Day"),_TL(""),
m_p_InputTable->Get_Record(m_p_InputTable->Get_Record_Count()-1)->asString(m_dateField));
if( SG_UI_Dlg_Parameters(&P, _TL("Choose Time Range")) )
{
///////////////////////////////////////////////////////////////
//
// ASSIGN DATA FROM SECOND DIALOG
//
///////////////////////////////////////////////////////////////
m_date1 = P(CSG_String::Format(SG_T("FDAY"),m_dateField).c_str())->asString();
m_date2 = P(CSG_String::Format(SG_T("LDAY"),m_streamflowField).c_str())->asString();
return(true);
}
return(false);
}
//---------------------------------------------------------
int CDecision_Tree::On_Parameter_Changed(CSG_Parameters *pParameters, CSG_Parameter *pParameter)
{
if( CSG_String(pParameter->Get_Identifier()).Find(SG_T("NODE")) >= 0 )
{
CSG_String ID = CSG_String(pParameter->Get_Identifier()).BeforeFirst(SG_T('|'));
if( pParameter->asBool() )
{
CSG_Parameters *pDecision = pParameters->Get_Parameter(ID)->asParameters();
pDecision->Set_Name(CSG_String::Format(SG_T("%s|%s"), pParameters->Get_Name().c_str(), pParameters->Get_Parameter(ID + SG_T("|NAME"))->asString()));
Add_Decision(pDecision);
}
else
{
pParameters->Get_Parameter(ID)->asParameters()->Del_Parameters();
}
}
if( !SG_STR_CMP(pParameter->Get_Identifier(), SG_T("GRID")) )
{
if( pParameter->asGrid() )
{
pParameters->Get_Parameter("THRESHOLD")->Set_Value(pParameter->asGrid()->Get_ArithMean());
}
}
return( 0 );
}
//---------------------------------------------------------
CTable_Create_Empty::CTable_Create_Empty(void)
{
//-----------------------------------------------------
Set_Name (_TL("Create New Table"));
Set_Author (SG_T("O. Conrad (c) 2005"));
Set_Description (CSG_String::Format(_TW(
"Creates a new empty table.\n\n"
"Possible field types are:\n"
"- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n- %s\n"),
SG_Data_Type_Get_Name(SG_DATATYPE_String).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Date ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Color ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Byte ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Char ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Word ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Short ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_DWord ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Int ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_ULong ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Long ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Float ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Double).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Binary).c_str()
));
//-----------------------------------------------------
Parameters.Add_Table_Output(
NULL , "TABLE" , _TL("Table"),
_TL("")
);
Parameters.Add_String(
NULL , "NAME" , _TL("Name"),
_TL(""),
_TL("New Table")
);
Parameters.Add_Value(
NULL , "NFIELDS" , _TL("Number of Attributes"),
_TL(""),
PARAMETER_TYPE_Int , 2, 1, true
);
Parameters.Add_Parameters(
NULL , "FIELDS" , _TL("Attributes"),
_TL("")
);
//-----------------------------------------------------
CSG_Parameters *pAttributes = Parameters("FIELDS")->asParameters();
_Set_Field_Count(pAttributes, Parameters("NFIELDS")->asInt());
pAttributes->Get_Parameter(GET_NAME(0))->Set_Value(_TL("ID"));
pAttributes->Get_Parameter(GET_TYPE(0))->Set_Value(3);
}
//---------------------------------------------------------
int Scatter_Plot_On_Parameter_Changed(CSG_Parameter *pParameter, int Flags)
{
if( !pParameter || !pParameter->Get_Owner() )
{
return( -1 );
}
CSG_Parameters *pParameters = pParameter->Get_Owner();
if( Flags & PARAMETER_CHECK_ENABLE )
{
if( pParameter->Cmp_Identifier("CMP_WITH") )
{
pParameters->Get_Parameter("GRID")->Get_Parent()->Set_Enabled(pParameter->asInt() == 0);
pParameters->Set_Enabled("GRID" , pParameter->asInt() == 0);
pParameters->Set_Enabled("POINTS" , pParameter->asInt() == 1);
}
if( pParameter->Cmp_Identifier("REG_SHOW") )
{
pParameters->Set_Enabled("REG_FORMULA", pParameter->asBool());
pParameters->Set_Enabled("REG_COLOR" , pParameter->asBool());
pParameters->Set_Enabled("REG_SIZE" , pParameter->asBool());
pParameters->Set_Enabled("REG_INFO" , pParameter->asBool());
}
if( pParameter->Cmp_Identifier("DISPLAY") )
{
pParameters->Set_Enabled("DENSITY_RES", pParameter->asInt() == 1);
pParameters->Set_Enabled("DENSITY_PAL", pParameter->asInt() == 1);
pParameters->Set_Enabled("DENSITY_LEG", pParameter->asInt() == 1);
}
}
if( Flags & PARAMETER_CHECK_VALUES )
{
if( pParameter->Cmp_Identifier("CMP_WITH") )
{
// pParameters->Get_Parameter("OPTIONS")->asParameters()->
// Get_Parameter("DISPLAY")->Set_Value(pParameter->asInt() == 0 ? 1 : 0);
pParameters->Get_Parameter("DISPLAY")->Set_Value(pParameter->asInt() == 0 ? 1 : 0);
pParameters->Set_Enabled("DENSITY_RES", pParameter->asInt() == 0);
pParameters->Set_Enabled("DENSITY_PAL", pParameter->asInt() == 0);
pParameters->Set_Enabled("DENSITY_LEG", pParameter->asInt() == 0);
}
}
return( 0 );
}
//---------------------------------------------------------
bool DLG_Table_Fields(const wxString &Caption, CSG_Parameter_Table_Fields *pFields)
{
CSG_Table *pTable = pFields->Get_Table();
if( pTable )
{
int i;
CSG_Parameters P;
for(i=0; i<pTable->Get_Field_Count(); i++)
{
P.Add_Value(NULL, SG_Get_String(i), pTable->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false);
}
for(i=0; i<pFields->Get_Count(); i++)
{
CSG_Parameter *pParameter = P(pFields->Get_Index(i));
if( pParameter )
{
pParameter->Set_Value(true);
}
}
if( DLG_Parameters(&P) )
{
CSG_String s;
for(i=0; i<pTable->Get_Field_Count(); i++)
{
if( P(i)->asBool() )
{
s += CSG_String::Format(s.Length() ? SG_T(",%d") : SG_T("%d"), i);
}
}
pFields->Set_Value(s);
return( true );
}
}
return( false );
}
//---------------------------------------------------------
int CGW_Multi_Regression::On_Parameter_Changed(CSG_Parameters *pParameters, CSG_Parameter *pParameter)
{
if( m_Grid_Target.On_User_Changed(pParameters, pParameter) )
{
return( true );
}
if( !SG_STR_CMP(pParameter->Get_Identifier(), SG_T("POINTS")) )
{
CSG_Shapes *pPoints = pParameters->Get_Parameter("POINTS") ->asShapes();
CSG_Parameters *pAttributes = pParameters->Get_Parameter("PREDICTORS") ->asParameters();
pAttributes->Destroy();
pAttributes->Set_Name(_TL("Predictors"));
for(int i=0; pPoints && i<pPoints->Get_Field_Count(); i++)
{
switch( pPoints->Get_Field_Type(i) )
{
default: // not numeric
break;
case SG_DATATYPE_Byte:
case SG_DATATYPE_Char:
case SG_DATATYPE_Word:
case SG_DATATYPE_Short:
case SG_DATATYPE_DWord:
case SG_DATATYPE_Int:
case SG_DATATYPE_ULong:
case SG_DATATYPE_Long:
case SG_DATATYPE_Float:
case SG_DATATYPE_Double:
pAttributes->Add_Value(
NULL, SG_Get_String(i, 0), pPoints->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false
);
break;
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CTable_PCA::Get_Fields(void)
{
CSG_Parameters *pFields = Parameters("FIELDS")->asParameters();
m_Features = (int *)SG_Calloc(pFields->Get_Count(), sizeof(int));
m_nFeatures = 0;
for(int iFeature=0; iFeature<pFields->Get_Count(); iFeature++)
{
if( pFields->Get_Parameter(iFeature)->asBool() )
{
CSG_String s(pFields->Get_Parameter(iFeature)->Get_Identifier());
m_Features[m_nFeatures++] = s.asInt();
}
}
return( m_nFeatures > 1 );
}
//---------------------------------------------------------
CSG_Grid * C_Kriging_Base::_Get_Grid(TSG_Rect Extent)
{
CSG_Parameters *P = Get_Parameters("USER");
if( !P->Get_Parameter("FIT_EXTENT")->asBool() )
{
Extent.xMin = P->Get_Parameter("X_EXTENT")->asRange()->Get_LoVal();
Extent.yMin = P->Get_Parameter("Y_EXTENT")->asRange()->Get_LoVal();
Extent.xMax = P->Get_Parameter("X_EXTENT")->asRange()->Get_HiVal();
Extent.yMax = P->Get_Parameter("Y_EXTENT")->asRange()->Get_HiVal();
}
double d = P->Get_Parameter("CELL_SIZE")->asDouble();
int nx = 1 + (int)((Extent.xMax - Extent.xMin) / d);
int ny = 1 + (int)((Extent.yMax - Extent.yMin) / d);
return( nx > 1 && ny > 1 ? SG_Create_Grid(SG_DATATYPE_Float, nx, ny, d, Extent.xMin, Extent.yMin) : NULL );
}
//---------------------------------------------------------
void CGrid_Filler::Parameters_Add(CSG_Parameters &Parameters)
{
Parameters.Add_Grid("",
"GRID" , _TL("Grid"),
_TL(""),
PARAMETER_INPUT
);
Parameters.Add_Grid("",
"GRID_OUT" , _TL("Changed Grid"),
_TL(""),
PARAMETER_OUTPUT_OPTIONAL
);
Parameters.Add_Choice("",
"REPLACE" , _TL("Value to be replaced"),
_TL(""),
CSG_String::Format("%s|%s|",
_TL("value at mouse position"),
_TL("fixed value")
), 0
);
Parameters.Add_Double("REPLACE",
"REPLACE_VALUE" , _TL("Fixed value to be replaced"),
_TL("Replace only this value with respect to the specified tolerance."),
0.0
);
Parameters.Add_Double("REPLACE",
"TOLERANCE" , _TL("Tolerance"),
_TL(""),
1.0, 0.0, true
);
Parameters.Add_Bool("REPLACE",
"IGNORE_NODATA" , _TL("Ignore No-Data"),
_TL("Do not fill areas representing no-data."),
true
);
Parameters.Add_Bool("",
"FILL_NODATA" , _TL("Fill with No-Data"),
_TL(""),
false
);
Parameters.Add_Double("FILL_NODATA",
"FILL_VALUE" , _TL("Fill Value"),
_TL(""),
0.0
);
}
//---------------------------------------------------------
bool CTable_Create_Empty::On_Execute(void)
{
CSG_Table *pTable = SG_Create_Table();
pTable->Set_Name(Parameters("NAME")->asString());
//-----------------------------------------------------
int i, n;
TSG_Data_Type Type;
CSG_Parameters *pAttributes;
pAttributes = Parameters("FIELDS")->asParameters();
n = pAttributes->Get_Count() / 3;
for(i=0; i<n; i++)
{
switch( pAttributes->Get_Parameter(GET_TYPE(i))->asInt() )
{
default:
case 0: Type = SG_DATATYPE_String; break;
case 1: Type = SG_DATATYPE_Date; break;
case 2: Type = SG_DATATYPE_Color; break;
case 3: Type = SG_DATATYPE_Byte; break;
case 4: Type = SG_DATATYPE_Char; break;
case 5: Type = SG_DATATYPE_Word; break;
case 6: Type = SG_DATATYPE_Short; break;
case 7: Type = SG_DATATYPE_DWord; break;
case 8: Type = SG_DATATYPE_Int; break;
case 9: Type = SG_DATATYPE_ULong; break;
case 10: Type = SG_DATATYPE_Long; break;
case 11: Type = SG_DATATYPE_Float; break;
case 12: Type = SG_DATATYPE_Double; break;
case 13: Type = SG_DATATYPE_Binary; break;
}
pTable->Add_Field(pAttributes->Get_Parameter(GET_NAME(i))->asString(), Type);
}
Parameters("TABLE")->Set_Value(pTable);
return( true );
}
//---------------------------------------------------------
void CTable_Query_GUI::On_Connection_Changed(CSG_Parameters *pParameters)
{
CSG_Parameters *pTables = pParameters->Get_Parameter("TABLES")->asParameters();
pTables->Del_Parameters();
CSG_Strings Tables;
if( Get_Connection()->Get_Tables(Tables) > 0 )
{
for(int i=0; i<Tables.Get_Count(); i++)
{
pTables->Add_Bool("", Tables[i], Tables[i], "");
}
}
pParameters->Get_Parameter("FIELDS")->asParameters()->Del_Parameters();
pParameters->Get_Parameter("GROUP" )->asParameters()->Del_Parameters();
On_Parameter_Changed(pParameters, pParameters->Get_Parameter("TABLES"));
}
//---------------------------------------------------------
bool CShapes_Cut_Interactive::Get_Extent(CSG_Rect &r)
{
CSG_Parameters *pParameters = Get_Parameters("CUT");
pParameters->Get_Parameter("AX")->Set_Value(r.Get_XMin());
pParameters->Get_Parameter("AY")->Set_Value(r.Get_YMin());
pParameters->Get_Parameter("BX")->Set_Value(r.Get_XMax());
pParameters->Get_Parameter("BY")->Set_Value(r.Get_YMax());
pParameters->Get_Parameter("DX")->Set_Value(r.Get_XRange());
pParameters->Get_Parameter("DY")->Set_Value(r.Get_YRange());
if( Dlg_Parameters("CUT") )
{
r.Assign(
pParameters->Get_Parameter("AX")->asDouble(),
pParameters->Get_Parameter("AY")->asDouble(),
pParameters->Get_Parameter("BX")->asDouble(),
pParameters->Get_Parameter("BY")->asDouble()
);
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGW_Multi_Regression::Get_Predictors(void)
{
int i;
CSG_Shapes *pPoints = Parameters("POINTS") ->asShapes();
CSG_Parameters *pAttributes = Parameters("PREDICTORS") ->asParameters();
m_nPredictors = 0;
m_iPredictor = new int[pPoints->Get_Field_Count()];
for(i=0; i<pAttributes->Get_Count(); i++)
{
if( pAttributes->Get_Parameter(i)->asBool() )
{
m_iPredictor[m_nPredictors++] = CSG_String(pAttributes->Get_Parameter(i)->Get_Identifier()).asInt();
}
}
CSG_Parameters *pGrids = Get_Parameters("GRID"), Tmp;
Tmp.Assign(pGrids);
pGrids->Create(this, Tmp.Get_Name(), Tmp.Get_Description(), Tmp.Get_Identifier(), false);
m_Grid_Target.Add_Grid_Parameter(SG_T("QUALITY") , _TL("Quality") , false);
m_Grid_Target.Add_Grid_Parameter(SG_T("INTERCEPT") , _TL("Intercept"), false);
pGrids->Get_Parameter("QUALITY")->Get_Parent()->asGrid_System()->Assign(*Tmp("QUALITY")->Get_Parent()->asGrid_System());
pGrids->Get_Parameter("QUALITY") ->Set_Value(Tmp("QUALITY") ->asGrid());
pGrids->Get_Parameter("INTERCEPT")->Set_Value(Tmp("INTERCEPT")->asGrid());
for(i=0; i<m_nPredictors; i++)
{
m_Grid_Target.Add_Grid_Parameter(SG_Get_String(i, 0),
CSG_String::Format(SG_T("%s [%s]"), _TL("Slope"), pPoints->Get_Field_Name(m_iPredictor[i])), false
);
if( Tmp(SG_Get_String(i, 0)) )
{
pGrids->Get_Parameter(SG_Get_String(i, 0))->Set_Value(Tmp(SG_Get_String(i, 0))->asGrid());
}
}
return( m_nPredictors > 0 );
}
//---------------------------------------------------------
FILE * CSRTM30_Import::Tile_Open(const SG_Char *sTile)
{
const SG_Char *sPath;
FILE *Stream;
CSG_String fName;
CSG_Parameters *pParameters;
fName = sTile;
if( (Stream = fopen(fName.b_str(), "rb")) == NULL )
{
pParameters = Get_Parameters("TILE");
pParameters->Get_Parameter("INFO")->Set_Value(sTile);
if( Dlg_Parameters(pParameters, _TL("Locate STRM30 Data File")) && (sPath = pParameters->Get_Parameter("PATH")->asString()) != NULL )
{
fName = sPath;
Stream = fopen(fName.b_str(), "rb");
}
}
return( Stream );
}
//---------------------------------------------------------
int CTable_PCA::On_Parameter_Changed(CSG_Parameters *pParameters, CSG_Parameter *pParameter)
{
if( !SG_STR_CMP(pParameter->Get_Identifier(), SG_T("TABLE")) )
{
CSG_Table *pTable = pParameter->asTable();
CSG_Parameters *pFields = pParameters->Get_Parameter("FIELDS")->asParameters();
pFields->Del_Parameters();
if( pTable && pTable->Get_Field_Count() > 0 )
{
for(int i=0; i<pTable->Get_Field_Count(); i++)
{
if( SG_Data_Type_is_Numeric(pTable->Get_Field_Type(i)) )
{
pFields->Add_Value(NULL, CSG_String::Format(SG_T("%d"), i), pTable->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false);
}
}
}
}
return( 0 );
}
//---------------------------------------------------------
void CVisibility_BASE::Finalize(CSG_Grid *pVisibility, int iMethod)
{
CSG_Parameters Parameters;
switch( iMethod )
{
case 0: // Visibility
Parameters.Add_Range(NULL, SG_T("METRIC_ZRANGE"), SG_T(""), SG_T(""), 0.0, 1.0);
SG_UI_DataObject_Update(pVisibility, true, &Parameters);
break;
case 1: // Shade
Parameters.Add_Range(NULL, SG_T("METRIC_ZRANGE"), SG_T(""), SG_T(""), 0.0, M_PI_090);
SG_UI_DataObject_Update(pVisibility, true, &Parameters);
break;
case 2: // Distance
case 3: // Size
SG_UI_DataObject_Show(pVisibility, true);
break;
}
return;
}
//---------------------------------------------------------
void CVIEW_Table_Control::On_Field_Sort(wxCommandEvent &event)
{
CSG_String sFields, sOrder;
CSG_Parameter *pNode;
CSG_Parameters P;
//-----------------------------------------------------
for(int i=0; i<m_pTable->Get_Field_Count(); i++)
{
sFields.Append(m_pTable->Get_Field_Name(i)); sFields.Append('|');
}
sOrder.Printf(SG_T("%s|%s|%s|"),
_TL("unsorted"),
_TL("ascending"),
_TL("descending")
);
//-----------------------------------------------------
P.Set_Name(_TL("Sort Table"));
pNode = P.Add_Choice(NULL , "FIELD_1" , _TL("Sort first by") , _TL(""), sFields , !m_pTable->is_Indexed() ? 0 : m_pTable->Get_Index_Field(0));
pNode = P.Add_Choice(pNode, "ORDER_1" , _TL("Direction") , _TL(""), sOrder , !m_pTable->is_Indexed() ? 1 : m_pTable->Get_Index_Order(0));
pNode = P.Add_Choice(NULL , "FIELD_2" , _TL("Sort second by") , _TL(""), sFields , !m_pTable->is_Indexed() ? 0 : m_pTable->Get_Index_Field(1));
pNode = P.Add_Choice(pNode, "ORDER_2" , _TL("Direction") , _TL(""), sOrder , !m_pTable->is_Indexed() ? 0 : m_pTable->Get_Index_Order(1));
pNode = P.Add_Choice(NULL , "FIELD_3" , _TL("Sort third by") , _TL(""), sFields , !m_pTable->is_Indexed() ? 0 : m_pTable->Get_Index_Field(2));
pNode = P.Add_Choice(pNode, "ORDER_3" , _TL("Direction") , _TL(""), sOrder , !m_pTable->is_Indexed() ? 0 : m_pTable->Get_Index_Order(2));
//-----------------------------------------------------
if( DLG_Parameters(&P) )
{
m_pTable->Set_Index(
P("FIELD_1")->asInt(), P("ORDER_1")->asInt() == 1 ? TABLE_INDEX_Ascending : P("ORDER_1")->asInt() == 2 ? TABLE_INDEX_Descending : TABLE_INDEX_None,
P("FIELD_2")->asInt(), P("ORDER_2")->asInt() == 1 ? TABLE_INDEX_Ascending : P("ORDER_2")->asInt() == 2 ? TABLE_INDEX_Descending : TABLE_INDEX_None,
P("FIELD_3")->asInt(), P("ORDER_3")->asInt() == 1 ? TABLE_INDEX_Ascending : P("ORDER_3")->asInt() == 2 ? TABLE_INDEX_Descending : TABLE_INDEX_None
);
_Set_Records();
}
}
//---------------------------------------------------------
void CVIEW_Table_Control::On_Field_Type(wxCommandEvent &event)
{
int i, *Types = new int[m_pTable->Get_Field_Count()];
CSG_Parameters P;
P.Set_Name(_TL("Change Field Type"));
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
switch( m_pTable->Get_Field_Type(i) )
{
default:
case SG_DATATYPE_String: Types[i] = 0; break;
case SG_DATATYPE_Date: Types[i] = 1; break;
case SG_DATATYPE_Color: Types[i] = 2; break;
case SG_DATATYPE_Byte: Types[i] = 3; break;
case SG_DATATYPE_Char: Types[i] = 4; break;
case SG_DATATYPE_Word: Types[i] = 5; break;
case SG_DATATYPE_Short: Types[i] = 6; break;
case SG_DATATYPE_DWord: Types[i] = 7; break;
case SG_DATATYPE_Int: Types[i] = 8; break;
case SG_DATATYPE_ULong: Types[i] = 9; break;
case SG_DATATYPE_Long: Types[i] = 10; break;
case SG_DATATYPE_Float: Types[i] = 11; break;
case SG_DATATYPE_Double: Types[i] = 12; break;
case SG_DATATYPE_Binary: Types[i] = 13; break;
}
P.Add_Choice(NULL, "", m_pTable->Get_Field_Name(i), _TL(""),
CSG_String::Format(SG_T("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|"),
SG_Data_Type_Get_Name(SG_DATATYPE_String).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Date ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Color ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Byte ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Char ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Word ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Short ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_DWord ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Int ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_ULong ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Long ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Float ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Double).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Binary).c_str()
), Types[i]
);
}
//-----------------------------------------------------
if( DLG_Parameters(&P) )
{
bool bChanged = false;
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
TSG_Data_Type Type;
switch( P(i)->asInt() )
{
default:
case 0: Type = SG_DATATYPE_String; break;
case 1: Type = SG_DATATYPE_Date; break;
case 2: Type = SG_DATATYPE_Color; break;
case 3: Type = SG_DATATYPE_Byte; break;
case 4: Type = SG_DATATYPE_Char; break;
case 5: Type = SG_DATATYPE_Word; break;
case 6: Type = SG_DATATYPE_Short; break;
case 7: Type = SG_DATATYPE_DWord; break;
case 8: Type = SG_DATATYPE_Int; break;
case 9: Type = SG_DATATYPE_ULong; break;
case 10: Type = SG_DATATYPE_Long; break;
case 11: Type = SG_DATATYPE_Float; break;
case 12: Type = SG_DATATYPE_Double; break;
case 13: Type = SG_DATATYPE_Binary; break;
}
if( Type != Types[i] )
{
m_pTable->Set_Field_Type(i, Type);
bChanged = true;
}
}
if( bChanged )
{
Update_Table();
g_pData->Update(m_pTable, NULL);
}
}
}
//---------------------------------------------------------
bool CWKSP_Shapes::_Edit_Split(void)
{
if( Get_Shapes()->Get_Type() == SHAPE_TYPE_Polygon
|| Get_Shapes()->Get_Type() == SHAPE_TYPE_Line )
{
switch( m_Edit_Mode )
{
default:
break;
//-------------------------------------------------
case EDIT_SHAPE_MODE_Normal:
m_Edit_Mode = EDIT_SHAPE_MODE_Split;
if( m_Edit_Shapes.Get_Count() == 0 )
{
m_Edit_Shapes.Add_Shape(Get_Shapes()->Get_Selection());
}
if( m_Edit_Shapes.Get_Count() > 1 )
{
m_Edit_Shapes.Get_Shape(1)->Del_Parts();
}
else
{
m_Edit_Shapes.Add_Shape();
}
return( true );
//-------------------------------------------------
case EDIT_SHAPE_MODE_Split:
m_Edit_Mode = EDIT_SHAPE_MODE_Normal;
CSG_Module *pModule = Get_Shapes()->Get_Type() == SHAPE_TYPE_Polygon
? SG_Get_Module_Library_Manager().Get_Module(SG_T("shapes_polygons"), 8) // Polygon-Line Intersection
: SG_Get_Module_Library_Manager().Get_Module(SG_T("shapes_lines" ), 6); // Split Lines with Lines
if( pModule )
{
CSG_Shapes Line(SHAPE_TYPE_Line), Split(Get_Shapes()->Get_Type());
Line.Add_Shape();
for(int i=0; i<m_Edit_Shapes.Get_Shape(1)->Get_Point_Count(); i++)
{
Line.Get_Shape(0)->Add_Point(m_Edit_Shapes.Get_Shape(1)->Get_Point(i));
}
m_Edit_Shapes.Del_Shape(1);
//-----------------------------------------
bool bResult;
CSG_Parameters P; P.Assign(pModule->Get_Parameters());
pModule->Set_Manager(NULL);
if( Get_Shapes()->Get_Type() == SHAPE_TYPE_Polygon )
{
bResult = pModule->Get_Parameters()->Set_Parameter("POLYGONS" , &m_Edit_Shapes)
&& pModule->Get_Parameters()->Set_Parameter("LINES" , &Line)
&& pModule->Get_Parameters()->Set_Parameter("INTERSECT", &Split)
&& pModule->Execute();
}
else // if( Get_Shapes()->Get_Type() == SHAPE_TYPE_Line )
{
bResult = pModule->Get_Parameters()->Set_Parameter("LINES" , &m_Edit_Shapes)
&& pModule->Get_Parameters()->Set_Parameter("SPLIT" , &Line)
&& pModule->Get_Parameters()->Set_Parameter("INTERSECT", &Split)
&& pModule->Execute();
}
//-----------------------------------------
if( bResult )
{
if( m_Edit_pShape )
{
m_Edit_pShape->Assign(Split.Get_Shape(0), false);
for(int iSplit=1; iSplit<Split.Get_Count(); iSplit++)
{
CSG_Shape *pSplit = Split.Get_Shape(iSplit);
for(int iPart=0; iPart<pSplit->Get_Part_Count(); iPart++)
{
for(int iPoint=0, jPart=m_Edit_pShape->Get_Part_Count(); iPoint<pSplit->Get_Point_Count(iPart); iPoint++)
{
m_Edit_pShape->Add_Point(pSplit->Get_Point(iPoint, iPart), jPart);
}
}
}
}
else if( Get_Shapes()->Get_Selection_Count() == 1 ) // if( !m_Edit_pShape )
{
CSG_Shape *pSelection = Get_Shapes()->Get_Selection();
pSelection->Assign(Split.Get_Shape(0), false);
for(int iSplit=1; iSplit<Split.Get_Count(); iSplit++)
{
CSG_Shape *pSplit = Get_Shapes()->Add_Shape(Split.Get_Shape(iSplit));
((CSG_Table_Record *)pSplit)->Assign(pSelection);
Get_Shapes()->Select(pSplit, true);
}
m_Edit_Shapes.Del_Shapes();
}
}
pModule->Get_Parameters()->Assign_Values(&P);
pModule->Set_Manager(P.Get_Manager());
}
Update_Views(false);
return( true );
}
}
return( false );
}
//---------------------------------------------------------
void CVIEW_Table_Control::On_Field_Add(wxCommandEvent &event)
{
int i;
CSG_String sFields;
CSG_Parameters P;
//-----------------------------------------------------
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
sFields.Append(m_pTable->Get_Field_Name(i)); sFields.Append(wxT('|'));
}
//-----------------------------------------------------
P.Set_Name(_TL("Add Field"));
P.Add_String(
NULL , "NAME" , _TL("Name"),
_TL(""),
_TL("Field")
);
P.Add_Choice(
NULL , "TYPE" , _TL("Field Type"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|"),
SG_Data_Type_Get_Name(SG_DATATYPE_String).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Date ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Color ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Byte ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Char ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Word ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Short ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_DWord ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Int ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_ULong ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Long ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Float ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Double).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Binary).c_str()
), 0
);
P.Add_Choice(
NULL , "FIELD" , _TL("Insert Position"),
_TL(""),
sFields, m_pTable->Get_Field_Count() - 1
);
P.Add_Choice(
NULL , "INSERT" , _TL("Insert Method"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|"),
_TL("before"),
_TL("after")
), 1
);
//-----------------------------------------------------
if( DLG_Parameters(&P) )
{
int Position;
TSG_Data_Type Type;
switch( P("TYPE")->asInt() )
{
default:
case 0: Type = SG_DATATYPE_String; break;
case 1: Type = SG_DATATYPE_Date; break;
case 2: Type = SG_DATATYPE_Color; break;
case 3: Type = SG_DATATYPE_Byte; break;
case 4: Type = SG_DATATYPE_Char; break;
case 5: Type = SG_DATATYPE_Word; break;
case 6: Type = SG_DATATYPE_Short; break;
case 7: Type = SG_DATATYPE_DWord; break;
case 8: Type = SG_DATATYPE_Int; break;
case 9: Type = SG_DATATYPE_ULong; break;
case 10: Type = SG_DATATYPE_Long; break;
case 11: Type = SG_DATATYPE_Float; break;
case 12: Type = SG_DATATYPE_Double; break;
case 13: Type = SG_DATATYPE_Binary; break;
}
Position = P("FIELD")->asInt() + P("INSERT")->asInt();
m_pTable->Add_Field(P("NAME")->asString(), Type, Position);
g_pData->Update(m_pTable, NULL);
}
}
//---------------------------------------------------------
CShapes_Cut::CShapes_Cut(void)
{
Set_Name (_TL("Cut Shapes Layer"));
Set_Author (SG_T("O. Conrad (c) 2006"));
Set_Description (_TW(
""
));
//-----------------------------------------------------
Parameters.Add_Shapes_List(
NULL , "SHAPES" , _TL("Shapes"),
_TL(""),
PARAMETER_INPUT
);
Parameters.Add_Shapes_List(
NULL , "CUT" , _TL("Cut"),
_TL(""),
PARAMETER_OUTPUT
);
Parameters.Add_Shapes(
NULL , "EXTENT" , _TL("Extent"),
_TL(""),
PARAMETER_OUTPUT_OPTIONAL, SHAPE_TYPE_Polygon
);
Parameters.Add_Choice(
NULL , "METHOD" , _TL("Method"),
_TL(""),
Cut_Methods_Str(), 0
);
Parameters.Add_Choice(
NULL , "TARGET" , _TL("Extent"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|%s|%s|"),
_TL("user defined"),
_TL("grid project"),
_TL("shapes layer extent"),
_TL("polygons")
), 0
);
//-----------------------------------------------------
CSG_Parameters *pParameters;
pParameters = Add_Parameters("CUT", _TL("Extent"), _TL(""));
pParameters->Add_Value(
NULL, "AX" , _TL("Left") , _TL(""), PARAMETER_TYPE_Double
);
pParameters->Add_Value(
NULL, "BX" , _TL("Right") , _TL(""), PARAMETER_TYPE_Double
);
pParameters->Add_Value(
NULL, "AY" , _TL("Bottom") , _TL(""), PARAMETER_TYPE_Double
);
pParameters->Add_Value(
NULL, "BY" , _TL("Top") , _TL(""), PARAMETER_TYPE_Double
);
pParameters->Add_Value(
NULL, "DX" , _TL("Horizontal Range") , _TL(""), PARAMETER_TYPE_Double, 1.0, 0.0, true
);
pParameters->Add_Value(
NULL, "DY" , _TL("Vertical Range") , _TL(""), PARAMETER_TYPE_Double, 1.0, 0.0, true
);
pParameters = Add_Parameters("GRID", _TL("Extent"), _TL(""));
pParameters->Add_Grid_System(
NULL, "GRID", _TL("Grid Project") , _TL("")
);
pParameters = Add_Parameters("SHAPES", _TL("Extent"), _TL(""));
pParameters->Add_Shapes(
NULL, "SHAPES", _TL("Shapes") , _TL(""), PARAMETER_INPUT
);
pParameters = Add_Parameters("POLYGONS", _TL("Polygons"), _TL(""));
pParameters->Add_Shapes(
NULL, "POLYGONS", _TL("Polygons") , _TL(""), PARAMETER_INPUT, SHAPE_TYPE_Polygon
);
}
//---------------------------------------------------------
void CActive_Attributes_Control::On_Field_Type(wxCommandEvent &event)
{
if( !g_pActive->Get_Active_Data_Item() || g_pActive->Get_Active_Data_Item()->Get_Type() != WKSP_ITEM_Grids ) { return; }
CSG_Grids *pGrids = ((CWKSP_Grids *)g_pActive->Get_Active_Data_Item())->Get_Grids();
//-----------------------------------------------------
int i, *Types = new int[m_pTable->Get_Field_Count()];
CSG_Parameters P;
P.Set_Name(_TL("Change Field Type"));
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
switch( m_pTable->Get_Field_Type(i) )
{
default:
case SG_DATATYPE_String: Types[i] = 0; break;
case SG_DATATYPE_Date : Types[i] = 1; break;
case SG_DATATYPE_Color : Types[i] = 2; break;
case SG_DATATYPE_Byte : Types[i] = 3; break;
case SG_DATATYPE_Char : Types[i] = 4; break;
case SG_DATATYPE_Word : Types[i] = 5; break;
case SG_DATATYPE_Short : Types[i] = 6; break;
case SG_DATATYPE_DWord : Types[i] = 7; break;
case SG_DATATYPE_Int : Types[i] = 8; break;
case SG_DATATYPE_ULong : Types[i] = 9; break;
case SG_DATATYPE_Long : Types[i] = 10; break;
case SG_DATATYPE_Float : Types[i] = 11; break;
case SG_DATATYPE_Double: Types[i] = 12; break;
case SG_DATATYPE_Binary: Types[i] = 13; break;
}
P.Add_Choice("", SG_Get_String(i), m_pTable->Get_Field_Name(i), _TL(""),
CSG_String::Format("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|",
SG_Data_Type_Get_Name(SG_DATATYPE_String).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Date ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Color ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Byte ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Char ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Word ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Short ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_DWord ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Int ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_ULong ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Long ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Float ).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Double).c_str(),
SG_Data_Type_Get_Name(SG_DATATYPE_Binary).c_str()
), Types[i]
);
}
//-----------------------------------------------------
if( DLG_Parameters(&P) )
{
bool bChanged = false;
for(i=0; i<m_pTable->Get_Field_Count(); i++)
{
TSG_Data_Type Type;
switch( P(i)->asInt() )
{
default: Type = SG_DATATYPE_String; break;
case 1: Type = SG_DATATYPE_Date ; break;
case 2: Type = SG_DATATYPE_Color ; break;
case 3: Type = SG_DATATYPE_Byte ; break;
case 4: Type = SG_DATATYPE_Char ; break;
case 5: Type = SG_DATATYPE_Word ; break;
case 6: Type = SG_DATATYPE_Short ; break;
case 7: Type = SG_DATATYPE_DWord ; break;
case 8: Type = SG_DATATYPE_Int ; break;
case 9: Type = SG_DATATYPE_ULong ; break;
case 10: Type = SG_DATATYPE_Long ; break;
case 11: Type = SG_DATATYPE_Float ; break;
case 12: Type = SG_DATATYPE_Double; break;
case 13: Type = SG_DATATYPE_Binary; break;
}
if( Type != m_pTable->Get_Field_Type(i) )
{
pGrids->Get_Attributes_Ptr()->Set_Field_Type(i, Type);
bChanged = true;
}
}
if( bChanged )
{
Update_Table();
g_pData->Update(pGrids, NULL);
}
}
}
//---------------------------------------------------------
CCRS_Transform_Grid::CCRS_Transform_Grid(bool bList)
{
CSG_Parameter *pNode;
m_bList = bList;
//-----------------------------------------------------
Set_Name (m_bList
? _TL("Coordinate Transformation (Grid List)")
: _TL("Coordinate Transformation (Grid)")
);
Set_Author (SG_T("O. Conrad (c) 2010"));
Set_Description (_TW(
"Coordinate transformation for grids.\n"
));
Set_Description (Get_Description() + "\n" + CSG_CRSProjector::Get_Description());
//-----------------------------------------------------
if( m_bList )
{
pNode = Parameters.Add_Grid_List(
NULL , "SOURCE" , _TL("Source"),
_TL(""),
PARAMETER_INPUT
);
Parameters.Add_Grid_List(
NULL , "TARGET" , _TL("Target"),
_TL(""),
PARAMETER_OUTPUT_OPTIONAL
);
m_Grid_Target.Add_Parameters_User (Add_Parameters("GET_USER" , _TL("User Defined Grid System"), _TL("")), false);
m_Grid_Target.Add_Parameters_System(Add_Parameters("GET_SYSTEM", _TL("Select Grid System") , _TL("")));
}
//-----------------------------------------------------
else
{
pNode = Parameters.Add_Grid(
NULL , "SOURCE" , _TL("Source"),
_TL(""),
PARAMETER_INPUT
);
m_Grid_Target.Add_Parameters_User (Add_Parameters("GET_USER" , _TL("User Defined Grid"), _TL("")));
m_Grid_Target.Add_Parameters_Grid (Add_Parameters("GET_GRID" , _TL("Select Grid") , _TL("")));
}
//-----------------------------------------------------
Parameters.Add_Value(
pNode , "CREATE_XY" , _TL("Create X/Y Grids"),
_TL(""),
PARAMETER_TYPE_Bool, false
);
Parameters.Add_Grid_Output(NULL, "OUT_X", _TL("X Coordinates"), _TL(""));
Parameters.Add_Grid_Output(NULL, "OUT_Y", _TL("Y Coordinates"), _TL(""));
//-----------------------------------------------------
Parameters.Add_Choice(
pNode , "INTERPOLATION" , _TL("Interpolation"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|%s|%s|%s|"),
_TL("Nearest Neigbhor"),
_TL("Bilinear Interpolation"),
_TL("Inverse Distance Interpolation"),
_TL("Bicubic Spline Interpolation"),
_TL("B-Spline Interpolation")
), 4
);
//-----------------------------------------------------
Parameters.Add_Choice(
pNode , "TARGET_TYPE" , _TL("Target"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|%s|"),
_TL("user defined grid system"),
_TL("existing grid system"),
_TL("points")
), 0
);
Parameters.Add_Value(
pNode , "TARGET_AREA" , _TL("Use Target Area Polygon"),
_TL(""),
PARAMETER_TYPE_Bool, false
);
//-----------------------------------------------------
CSG_Parameters *pParameters = Add_Parameters("POINTS", _TL("Points"), _TL(""));
pParameters->Add_Shapes(
NULL , "POINTS" , _TL("Points"),
_TL(""),
PARAMETER_OUTPUT, SHAPE_TYPE_Point
);
}
//---------------------------------------------------------
bool CCRS_Transform_Grid::On_Execute_Transformation(void)
{
m_Interpolation = Parameters("INTERPOLATION")->asInt();
//-----------------------------------------------------
if( m_bList )
{
int i;
CSG_Parameters Grids;
CSG_Parameter_Grid_List *pSources, *pTargets, *pGrids;
pSources = Parameters("SOURCE")->asGridList();
pTargets = Parameters("TARGET")->asGridList();
pTargets->Del_Items();
pGrids = Grids.Add_Grid_List(NULL, "GRD", SG_T(""), SG_T(""), PARAMETER_INPUT, false)->asGridList();
for(i=0; i<pSources->Get_Count(); i++)
{
if( pSources->asGrid(i)->Get_Projection().is_Okay() )
{
pGrids->Add_Item(pSources->asGrid(i));
}
else
{
Error_Set(CSG_String::Format(SG_T("%s: %s\n"), _TL("unknown projection"), pSources->asGrid(i)->Get_Name()));
}
}
pSources = Grids.Add_Grid_List(NULL, "SRC", SG_T(""), SG_T(""), PARAMETER_INPUT, false)->asGridList();
while( pGrids->Get_Count() > 0 )
{
pSources->Add_Item(pGrids->asGrid(pGrids->Get_Count() - 1));
pGrids ->Del_Item(pGrids->Get_Count() - 1);
for(i=pGrids->Get_Count()-1; i>=0; i--)
{
if( pGrids->asGrid(i)->Get_Projection() == pSources->asGrid(0)->Get_Projection() )
{
pSources->Add_Item(pGrids->asGrid(i));
pGrids ->Del_Item(i);
}
}
m_Projector.Set_Inverse(false);
Transform(pSources);
pSources->Del_Items();
}
return( pTargets->Get_Count() > 0 );
}
//-----------------------------------------------------
else
{
return( Transform(Parameters("SOURCE")->asGrid()) );
}
}
bool Cihacres_elev::_CreateDialog2()
{
int i;
//std::ofstream f("_out_elev.txt");
CSG_Parameters P; // used to add Parameters in the second dialog
CSG_Parameter *pNode, *pNode1;
CSG_String s;
CSG_String tmpNode, tmpName;
P.Set_Name(_TL("IHACRES Elevation Bands (Dialog 2)"));
// Input file ----------------------------------------------
pNode = P.Add_Table(
NULL , "TABLE" , _TL("IHACRES Input Table"),
_TL(""),
PARAMETER_INPUT
);
P.Add_Table_Field(
pNode , "DATE_Field" , _TL("Date Column"),
SG_T("Select the column containing the Date")
);
P.Add_Table_Field(
pNode , "DISCHARGE_Field" , _TL("Streamflow (obs.) Column"),
SG_T("Select the column containing the observed streamflow time series)")
);
for (i = 0; i < m_nElevBands; i++)
{
tmpNode = convert_sl::Int2String(i+1).c_str();
//s.Printf(tmpNode.c_str(), i);
//pNode1 = P.Add_Node(NULL,s,SG_T("Elevation Band Input",_TL(""));
tmpName = SG_T("PCP Column: Elevation Band: ");
tmpName+=tmpNode;
P.Add_Table_Field(
pNode , tmpName.c_str(), tmpName.c_str(),
SG_T("Select Precipitation Column")
);
tmpName = SG_T("TMP Column: Elevation Band: ");
tmpName+=tmpNode;
P.Add_Table_Field(
pNode , tmpName.c_str() , tmpName.c_str(),
SG_T("Select Temperature Column")
);
}
// Input file ----------------------------------------------
for (i = 0; i < m_nElevBands; i++)
{
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+100).c_str();
tmpName = SG_T("Elevation Band ");
tmpName+=convert_sl::Int2String(i+1).c_str();
s.Printf(tmpNode.c_str(), i+100);
pNode = P.Add_Node(NULL,s,tmpName.c_str(),_TL(""));
tmpName = SG_T("Area [km2] Elev(");
tmpName += tmpNode;
tmpName += SG_T(")");
P.Add_Value(
pNode, tmpName, _TL("Area [km2]"),
_TL(""),
PARAMETER_TYPE_Double
);
tmpName = SG_T("Mean Elevation [m.a.s.l] Elev(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode, tmpName, _TL("Mean Elevation [m.a.s.l]"),
_TL(""),
PARAMETER_TYPE_Double
);
//}
// Parameters of non-linear module -------------------------
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+150).c_str();
s.Printf(tmpNode.c_str(), i+150);
pNode1 = P.Add_Node(pNode,s,SG_T("Non-Linear Module"),_TL(""));
tmpName = SG_T("TwFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1, tmpName, _TL("Wetness decline time constant (Tw)"),
_TW("Tw is approximately the time constant, or inversely, "
"the rate at which the catchment wetness declines in the absence of rainfall"),
PARAMETER_TYPE_Double,
1.0, 0.01, true, 150.0, true
);
tmpName = SG_T("TFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1, tmpName, SG_T("Temperature Modulation Factor (f)"),
_TL("Temperature Modulation Factor f"),
PARAMETER_TYPE_Double,
1.0, 0.0001, true, 10.0, true
);
tmpName = SG_T("CFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1,tmpName, _TL("Parameter (c)"),
_TL("Parameter (c) to fit streamflow volume"),
PARAMETER_TYPE_Double,
0.001, 0.0, true, 1.0, true
);
switch(m_IHAC_version)
{
case 0: // Jakeman & Hornberger (1993)
break;
case 1: // Croke et al. (2005)
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+200).c_str();
s.Printf(tmpNode.c_str(), i+200);
pNode1 = P.Add_Node(pNode,s,SG_T("Soil Moisture Power Eq."),_TL(""));
tmpName = SG_T("LFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1, tmpName, _TL("Parameter (l)"),
_TL("Soil moisture index threshold"),
PARAMETER_TYPE_Double,
0.0, 0.0, true, 5.0, true
);
tmpName = SG_T("PFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1, tmpName, _TL("Parameter (p)"),
_TL("non-linear response term"),
PARAMETER_TYPE_Double,
0.0, 0.0, true, 5.0, true
);
break;
}
// Parameters of non-linear module -------------------------
// Parameters of linear module -----------------------------
switch(m_StorConf)
{
case 0: // single storage
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+250).c_str();
s.Printf(tmpNode.c_str(), i+250);
pNode1 = P.Add_Node(pNode,s,SG_T("Linear Module"),_TL(""));
tmpName = SG_T("AFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1, tmpName, _TL("(a)"),
_TL(""),
PARAMETER_TYPE_Double,
-0.8, -0.99, true, -0.01, true
);
tmpName = SG_T("BFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1, tmpName, _TL("(b)"),
_TL(""),
PARAMETER_TYPE_Double,
0.2, 0.001, true, 1.0, true
);
break;
case 1: // two parallel storages
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+250).c_str();
s.Printf(tmpNode.c_str(), i+250);
pNode1 = P.Add_Node(pNode,s,SG_T("Linear Module"),_TL(""));
// Parameter a
tmpName = SG_T("AQ(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1,tmpName, _TL("a(q)"),
_TL(""),
PARAMETER_TYPE_Double,
-0.7, -0.99, true, -0.01, true
);
tmpName = SG_T("AS(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1, tmpName, _TL("a(s)"),
_TL(""),
PARAMETER_TYPE_Double,
-0.9, -0.99, true, -0.01, true
);
// Parameter b
tmpName = SG_T("BQ(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1, tmpName, _TL("b(q)"),
_TL(""),
PARAMETER_TYPE_Double,
0.0, 0.0, true, 1.0, true
);
break;
case 2: // two storages in series
break;
} // end switch (storconf)
// Parameters of linear module -----------------------------
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+300).c_str();
s.Printf(tmpNode.c_str(), i+300);
pNode1 = P.Add_Node(pNode,s,SG_T("Time Delay after Start of Rainfall (INTEGER)"),_TL(""));
tmpName = SG_T("DELAY(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1,tmpName, SG_T("Time Delay (Rain-Runoff)"),
SG_T("The delay after the start of rainfall, before the discharge starts to rise."),
PARAMETER_TYPE_Int,
0, 1, true, 100, true
);
// snow module parameters ----------------------------------
if (m_bSnowModule)
{
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+350).c_str();
s.Printf(tmpNode.c_str(), i+350);
pNode1 = P.Add_Node(pNode,s,SG_T("Snow Module Parameters"),_TL(""));
tmpName = SG_T("T_RAIN(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1,tmpName, SG_T("Temperature Threshold for Rainfall)"),
SG_T("Below this threshold precipitation will fall as snow"),
PARAMETER_TYPE_Double,
-1.0, -10.0, true, 10.0, true
);
tmpName = SG_T("T_MELT(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1,tmpName, SG_T("Temperature Threshold for Melting"),
SG_T("Above this threshold snow will start to melt"),
PARAMETER_TYPE_Double,
1.0, -5.0, true, 10.0, true
);
tmpName = SG_T("DD_FAC(");
tmpName += tmpNode;
tmpName += _TL(")");
P.Add_Value(
pNode1,tmpName, SG_T("Day-Degree Factor"),
SG_T("Day-Degree Factor depends on catchment characteristics"),
PARAMETER_TYPE_Double,
0.7, 0.7, true, 9.2, true
);
}
// snow module parameters ----------------------------------
}
if( SG_UI_Dlg_Parameters(&P, _TL("IHACRES Distributed Input Dialog 2")) )
{
// input table
m_p_InputTable = P("TABLE") ->asTable();
// field numbers
m_dateField = P("DATE_Field") ->asInt();
m_streamflowField = P("DISCHARGE_Field") ->asInt();
for (int i = 0; i < m_nElevBands; i++)
{
tmpNode = convert_sl::Int2String(i+1).c_str();
// get precipitation column of Elevation Band[i]
tmpName = SG_T("PCP Column: Elevation Band: ");
tmpName+=tmpNode;
m_p_pcpField[i] = P(tmpName) ->asInt();
// get temperature column of Elevation Band[i]
tmpName = SG_T("TMP Column: Elevation Band: ");
tmpName+=tmpNode;
m_p_tmpField[i] = P(tmpName) ->asInt();
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+100).c_str();
// get area[km2] of Elevation Band[i]
tmpName = SG_T("Area [km2] Elev(");
tmpName += tmpNode;
tmpName += _TL(")");
m_p_elevbands[i].m_area = P(tmpName) ->asDouble();
// get mean elevation of Elevation Band[i]
tmpName = SG_T("Mean Elevation [m.a.s.l] Elev(");
tmpName += tmpNode;
tmpName += _TL(")");
m_p_elevbands[i].m_mean_elev =P(tmpName) ->asDouble();
// non-linear module parameters
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+150).c_str();
// get Tw
tmpName = SG_T("TwFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
m_p_nonlinparms->mp_tw[i] = P(tmpName) ->asDouble();
// get f
tmpName = SG_T("TFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
m_p_nonlinparms->mp_f[i] = P(tmpName) ->asDouble();
// get c
tmpName = SG_T("CFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
m_p_nonlinparms->mp_c[i] = P(tmpName) ->asDouble();
switch(m_IHAC_version)
{
case 0: // Jakeman & Hornberger (1993)
break;
case 1: // Croke et al. (2005)
// get l
tmpName = SG_T("LFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
m_p_nonlinparms->mp_l[i]= P(tmpName) ->asDouble();
// get p
tmpName = SG_T("PFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
m_p_nonlinparms->mp_p[i]= P(tmpName) ->asDouble();
}
// linear module parameters
switch(m_nStorages)
{
case 1: // single storage
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+250).c_str();
// get a
tmpName = SG_T("AFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
m_p_linparms->a[i] = P(tmpName) ->asDouble();
// get b
tmpName = SG_T("BFAC(");
tmpName += tmpNode;
tmpName += _TL(")");
m_p_linparms->b[i] = P(tmpName) ->asDouble();
break;
case 2: // two storages
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+250).c_str();
// get aq
tmpName = SG_T("AQ(");
tmpName += tmpNode;
tmpName += _TL(")");
m_p_linparms->aq[i] = P(tmpName) ->asDouble();
// get bq
tmpName = SG_T("BQ(");
tmpName += tmpNode;
tmpName += _TL(")");
m_p_linparms->bq[i] = P(tmpName) ->asDouble();
// get as
tmpName = SG_T("AS(");
tmpName += tmpNode;
tmpName += _TL(")");
m_p_linparms->as[i] = P(tmpName) ->asDouble();
// get bs
m_p_linparms->bs[i] = ihacres.Calc_Parm_BS(m_p_linparms->aq[i],m_p_linparms->as[i],m_p_linparms->bq[i]);
break;
}
// get delay
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+300).c_str();
tmpName = SG_T("DELAY(");
tmpName += tmpNode;
tmpName += _TL(")");
m_delay = P(tmpName) ->asInt();
if (m_bSnowModule)
{
tmpNode = SG_T("Node");
tmpNode+=convert_sl::Int2String(i+350).c_str();
// get T_RAIN
tmpName = SG_T("T_RAIN(");
tmpName += tmpNode;
tmpName += _TL(")");
m_pSnowparms[i].T_Rain = P(tmpName) ->asDouble();
// get T_MELT
tmpName = SG_T("T_MELT(");
tmpName += tmpNode;
tmpName += _TL(")");
m_pSnowparms[i].T_Melt = P(tmpName) ->asDouble();
// get DD_FAC
tmpName = SG_T("DD_FAC(");
tmpName += tmpNode;
tmpName += _TL(")");
m_pSnowparms[i].DD_FAC = P(tmpName) ->asDouble();
}
}
return(true);
}
return(false);
}