//---------------------------------------------------------
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 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 );
}
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
bool CPointCloud_From_Text_File::On_Execute(void)
{
CSG_String fileName;
int iField, iType;
CSG_String Name, Types, s;
CSG_PointCloud *pPoints;
CSG_Parameters P;
CSG_Parameter *pNode;
int xField, yField, zField, nAttribs;
bool bSkipHeader;
char fieldSep;
std::vector<int> vCol;
std::ifstream tabStream;
std::string tabLine;
double lines;
long cntPt, cntInvalid;
double x, y, z;
//-----------------------------------------------------
fileName = Parameters("FILE") ->asString();
xField = Parameters("XFIELD") ->asInt() - 1;
yField = Parameters("YFIELD") ->asInt() - 1;
zField = Parameters("ZFIELD") ->asInt() - 1;
bSkipHeader = Parameters("SKIP_HEADER") ->asBool();
switch (Parameters("FIELDSEP")->asInt())
{
default:
case 0: fieldSep = '\t'; break;
case 1: fieldSep = ' '; break;
case 2: fieldSep = ','; break;
}
pPoints = SG_Create_PointCloud();
pPoints->Create();
pPoints->Set_Name(SG_File_Get_Name(fileName, false));
Parameters("POINTS")->Set_Value(pPoints);
DataObject_Add(pPoints);
//-----------------------------------------------------
if (SG_UI_Get_Window_Main())
{
nAttribs = Parameters("ATTRIBS") ->asInt();
Types.Printf(SG_T("%s|%s|%s|%s|%s|"),
_TL("1 byte integer"),
_TL("2 byte integer"),
_TL("4 byte integer"),
_TL("4 byte floating point"),
_TL("8 byte floating point")
);
P.Set_Name(_TL("Attribute Field Properties"));
for(iField=1; iField<=nAttribs; iField++)
{
s.Printf(SG_T("NODE_%03d") , iField);
pNode = P.Add_Node(NULL, s, CSG_String::Format(SG_T("%d. %s"), iField, _TL("Field")), _TL(""));
s.Printf(SG_T("FIELD_%03d"), iField);
P.Add_String(pNode, s, _TL("Name"), _TL(""), s);
s.Printf(SG_T("COLUMN_%03d"), iField);
P.Add_Value(pNode, s, _TL("Attribute is Column ..."), _TL(""), PARAMETER_TYPE_Int, iField+3, 1, true);
s.Printf(SG_T("TYPE_%03d") , iField);
P.Add_Choice(pNode, s, _TL("Type"), _TL(""), Types, 3);
}
//-----------------------------------------------------
if( nAttribs > 0 )
{
if( Dlg_Parameters(&P, _TL("Field Properties")) )
{
for(iField=0; iField<nAttribs; iField++)
{
Name = P(CSG_String::Format(SG_T("FIELD_%03d" ), iField + 1).c_str())->asString();
iType = P(CSG_String::Format(SG_T("TYPE_%03d" ), iField + 1).c_str())->asInt();
vCol.push_back(P(CSG_String::Format(SG_T("COLUMN_%03d"), iField + 1).c_str())->asInt() - 1);
pPoints->Add_Field(Name, Get_Data_Type(iType));
}
}
else
return( false );
}
}
else // CMD
{
CSG_String sFields, sNames, sTypes;
CSG_String token;
int iValue;
std::vector<int> vTypes;
sFields = Parameters("FIELDS")->asString();
sNames = Parameters("FIELDNAMES")->asString();
sTypes = Parameters("FIELDTYPES")->asString();
CSG_String_Tokenizer tkz_fields(sFields, ";", SG_TOKEN_STRTOK);
while( tkz_fields.Has_More_Tokens() )
{
token = tkz_fields.Get_Next_Token();
if( token.Length() == 0 )
break;
if( !token.asInt(iValue) )
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: can't convert to number"));
return( false );
}
iValue -= 1;
if( iValue < 1)
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: field index out of range"));
return( false );
}
else
vCol.push_back(iValue);
}
CSG_String_Tokenizer tkz_datatypes(sTypes, ";", SG_TOKEN_STRTOK);
while( tkz_datatypes.Has_More_Tokens() )
{
token = tkz_datatypes.Get_Next_Token();
if( token.Length() == 0 )
break;
if( !token.asInt(iValue) )
{
SG_UI_Msg_Add_Error(_TL("Error parsing field type: can't convert to number"));
return( false );
}
vTypes.push_back(iValue);
}
CSG_String_Tokenizer tkz_datanames(sNames, ";", SG_TOKEN_STRTOK);
int iter = 0;
while( tkz_datanames.Has_More_Tokens() )
{
token = tkz_datanames.Get_Next_Token();
if( token.Length() == 0 )
break;
pPoints->Add_Field(token, Get_Data_Type(vTypes.at(iter)));
iter++;
}
if( vCol.size() != vTypes.size() || (int)vCol.size() != iter )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Number of arguments for attribute fields (%d), names (%d) and types (%d) do not match!"), vCol.size(), iter, vTypes.size()));
return( false );
}
}
// open input stream
//---------------------------------------------------------
tabStream.open(fileName.b_str(), std::ifstream::in);
if( !tabStream )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to open input file!")));
return (false);
}
tabStream.seekg(0, std::ios::end); // get length of file
lines = (double)tabStream.tellg();
tabStream.seekg(0, std::ios::beg);
std::getline(tabStream, tabLine); // as a workaround we assume the number of lines from the length of the first line
lines = lines / (double)tabStream.tellg();
if( !bSkipHeader )
{
tabStream.clear(); // let's forget we may have reached the EOF
tabStream.seekg(0, std::ios::beg); // and rewind to the beginning
}
// import
//---------------------------------------------------------
cntPt = cntInvalid = 0;
SG_UI_Process_Set_Text(CSG_String::Format(_TL("Importing data ...")));
while( std::getline(tabStream, tabLine) )
{
std::istringstream stream(tabLine);
std::vector<std::string> tabCols;
std::string tabEntry;
if( cntPt%10000 == 0 )
{
SG_UI_Process_Set_Progress((double)cntPt, lines);
}
cntPt++;
while( std::getline(stream, tabEntry, fieldSep) ) // read every column in this line and fill vector
{
if (tabEntry.length() == 0)
continue;
tabCols.push_back(tabEntry);
}
if ((int)tabCols.size() < (vCol.size() + 3) )
{
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: Skipping misformatted line: %d!"), cntPt), true);
cntInvalid++;
continue;
}
//parse line tokens
std::vector<double> fieldValues;
fieldValues.resize(vCol.size());
x = strtod(tabCols[xField].c_str(), NULL);
y = strtod(tabCols[yField].c_str(), NULL);
z = strtod(tabCols[zField].c_str(), NULL);
for( int i=0; i<(int)vCol.size(); i++ )
{
fieldValues[i] = strtod(tabCols.at(vCol.at(i)).c_str(), NULL);
}
pPoints->Add_Point(x, y, z);
for( int i=0; i<(int)vCol.size(); i++ )
{
pPoints->Set_Attribute(i, fieldValues[i]);
}
}
// finalize
//---------------------------------------------------------
tabStream.close();
CSG_Parameters sParms;
DataObject_Get_Parameters(pPoints, sParms);
if (sParms("METRIC_ATTRIB") && sParms("COLORS_TYPE") && sParms("METRIC_COLORS")
&& sParms("METRIC_ZRANGE") && sParms("DISPLAY_VALUE_AGGREGATE"))
{
sParms("DISPLAY_VALUE_AGGREGATE")->Set_Value(3); // highest z
sParms("COLORS_TYPE")->Set_Value(2); // graduated color
sParms("METRIC_COLORS")->asColors()->Set_Count(255); // number of colors
sParms("METRIC_ATTRIB")->Set_Value(2); // z attrib
sParms("METRIC_ZRANGE")->asRange()->Set_Range(pPoints->Get_Minimum(2),pPoints->Get_Maximum(2));
DataObject_Set_Parameters(pPoints, sParms);
DataObject_Update(pPoints);
}
if (cntInvalid > 0)
SG_UI_Msg_Add(CSG_String::Format(SG_T("%s: %d %s"), _TL("WARNING"), cntInvalid, _TL("invalid points have been skipped")), true);
SG_UI_Msg_Add(CSG_String::Format(SG_T("%d %s"), (cntPt-cntInvalid), _TL("points have been imported with success")), true);
return( true );
}
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);
}
//---------------------------------------------------------
bool CTable_Text_Import_Fixed_Cols::On_Execute(void)
{
bool bHeader;
int i, nChars, iField, nFields, *iFirst, *iLength;
CSG_String sLine;
CSG_File Stream;
CSG_Table *pTable;
//-----------------------------------------------------
pTable = Parameters("TABLE") ->asTable();
bHeader = Parameters("HEADLINE") ->asBool();
//-----------------------------------------------------
if( !Stream.Open(Parameters("FILENAME")->asString(), SG_FILE_R, true) )
{
Message_Add(_TL("file could not be opened"));
return( false );
}
if( !Stream.Read_Line(sLine) || (nChars = (int)sLine.Length()) <= 0 )
{
Message_Add(_TL("empty or corrupted file"));
return( false );
}
//-----------------------------------------------------
pTable->Destroy();
pTable->Set_Name(SG_File_Get_Name(Parameters("FILENAME")->asString(), false));
switch( Parameters("FIELDDEF")->asInt() )
{
//-----------------------------------------------------
case 0:
{
CSG_Parameters *pBreaks = Get_Parameters("BREAKS");
pBreaks->Del_Parameters();
for(i=0; i<nChars; i++)
{
pBreaks->Add_Value(NULL,
CSG_String::Format(SG_T("%03d"), i),
CSG_String::Format(SG_T("%03d %c"), i + 1, sLine[i]),
_TL(""), PARAMETER_TYPE_Bool, false
);
}
if( !Dlg_Parameters("BREAKS") )
{
return( false );
}
//-------------------------------------------------
for(i=0, nFields=1; i<pBreaks->Get_Count(); i++)
{
if( pBreaks->Get_Parameter(i)->asBool() )
{
nFields++;
}
}
//-------------------------------------------------
iFirst = new int[nFields];
iLength = new int[nFields];
iFirst[0] = 0;
for(i=0, iField=1; i<pBreaks->Get_Count() && iField<nFields; i++)
{
if( pBreaks->Get_Parameter(i)->asBool() )
{
iFirst[iField++] = i + 1;
}
}
//-------------------------------------------------
for(iField=0; iField<nFields; iField++)
{
iLength[iField] = (iField < nFields - 1 ? iFirst[iField + 1] : (int)sLine.Length()) - iFirst[iField];
pTable->Add_Field(bHeader ? sLine.Mid(iFirst[iField], iLength[iField]) : CSG_String::Format(SG_T("FIELD%03d"), iField + 1), SG_DATATYPE_String);
}
}
break;
//-----------------------------------------------------
case 1:
{
CSG_Parameters *pFields = Get_Parameters("FIELDS");
pFields->Del_Parameters();
nFields = Parameters("NFIELDS")->asInt();
for(iField=0; iField<nFields; iField++)
{
CSG_String s = CSG_String::Format(SG_T("%03d"), iField);
CSG_Parameter *pNode = pFields->Add_Node(NULL, SG_T("NODE") + s, _TL("Field") + s, _TL(""));
pFields->Add_Value (pNode, SG_T("LENGTH") + s, _TL("Length"), _TL(""), PARAMETER_TYPE_Int, 1, 1, true);
// pFields->Add_Value (pNode, SG_T("IMPORT") + s, _TL("Import"), _TL(""), PARAMETER_TYPE_Bool, true);
pFields->Add_Choice (pNode, SG_T("TYPE") + s, _TL("Type") , _TL(""), CSG_String::Format(SG_T("%s|%s|%s|%s|%s|"),
_TL("text"),
_TL("2 byte integer"),
_TL("4 byte integer"),
_TL("4 byte float"),
_TL("8 byte float"))
);
}
if( !Dlg_Parameters("FIELDS") )
{
return( false );
}
//-------------------------------------------------
iFirst = new int[nFields];
iLength = new int[nFields];
iFirst[0] = 0;
for(iField=0, i=0; iField<nFields && i<nChars; iField++)
{
CSG_String s = CSG_String::Format(SG_T("%03d"), iField);
iFirst [iField] = i;
iLength[iField] = pFields->Get_Parameter(SG_T("LENGTH") + s)->asInt();
i += iLength[iField];
CSG_String Name = bHeader ? sLine.Mid(iFirst[iField], iLength[iField]) : CSG_String::Format(SG_T("FIELD%03d"), iField + 1);
switch( pFields->Get_Parameter(SG_T("TYPE") + s)->asInt() )
{
default:
case 0:
pTable->Add_Field(Name, SG_DATATYPE_String);
break;
case 1:
pTable->Add_Field(Name, SG_DATATYPE_Short);
break;
case 2:
pTable->Add_Field(Name, SG_DATATYPE_Int);
break;
case 3:
pTable->Add_Field(Name, SG_DATATYPE_Float);
break;
case 4:
pTable->Add_Field(Name, SG_DATATYPE_Double);
break;
}
}
}
break;
//-----------------------------------------------------
case 2:
{
CSG_Table *pList = Parameters("LIST")->asTable();
nFields = pList->Get_Count();
//-------------------------------------------------
iFirst = new int[nFields];
iLength = new int[nFields];
iFirst[0] = 0;
for(iField=0, i=0; iField<nFields && i<nChars; iField++)
{
iFirst [iField] = i;
iLength[iField] = pList->Get_Record(iField)->asInt(1);
i += iLength[iField];
CSG_String Name = bHeader ? sLine.Mid(iFirst[iField], iLength[iField]) : CSG_String(pList->Get_Record(iField)->asString(0));
switch( pList->Get_Record(iField)->asInt(2) )
{
case 0:
pTable->Add_Field(Name, SG_DATATYPE_String);
break;
case 1:
pTable->Add_Field(Name, SG_DATATYPE_Short);
break;
case 2:
pTable->Add_Field(Name, SG_DATATYPE_Int);
break;
case 3:
pTable->Add_Field(Name, SG_DATATYPE_Float);
break;
default:
case 4:
pTable->Add_Field(Name, SG_DATATYPE_Double);
break;
}
}
}
break;
}
//-----------------------------------------------------
if( bHeader )
{
Stream.Read_Line(sLine);
}
//-----------------------------------------------------
int fLength = Stream.Length();
do
{
if( sLine.Length() == nChars )
{
CSG_Table_Record *pRecord = pTable->Add_Record();
for(iField=0; iField<nFields; iField++)
{
pRecord->Set_Value(iField, sLine.Mid(iFirst[iField], iLength[iField]));
}
}
}
while( Stream.Read_Line(sLine) && Set_Progress(Stream.Tell(), fLength) );
//-----------------------------------------------------
delete[](iFirst);
delete[](iLength);
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CPointcloud_To_Text_File::On_Execute(void)
{
CSG_PointCloud *pPoints;
CSG_String fileName;
CSG_File *pTabStream = NULL;
bool bWriteHeader;
CSG_String fieldSep;
CSG_Parameters P;
CSG_Parameter *pNode;
CSG_String s;
std::vector<int> vCol, vPrecision;
//-----------------------------------------------------
pPoints = Parameters("POINTS") ->asPointCloud();
fileName = Parameters("FILE") ->asString();
bWriteHeader = Parameters("WRITE_HEADER")->asBool();
switch (Parameters("FIELDSEP")->asInt())
{
default:
case 0: fieldSep = "\t"; break;
case 1: fieldSep = " "; break;
case 2: fieldSep = ","; break;
}
if( fileName.Length() == 0 )
{
SG_UI_Msg_Add_Error(_TL("Please provide an output file name!"));
return( false );
}
if (SG_UI_Get_Window_Main())
{
P.Set_Name(_TL("Check the fields to export"));
for(int iField=0; iField<pPoints->Get_Field_Count(); iField++)
{
s.Printf(SG_T("NODE_%03d") , iField + 1);
pNode = P.Add_Node(NULL, s, CSG_String::Format(_TL("%d. %s"), iField + 1, _TL("Field")), _TL(""));
s.Printf(SG_T("FIELD_%03d"), iField);
P.Add_Value(pNode, s, CSG_String::Format(SG_T("%s"), pPoints->Get_Field_Name(iField)), _TL(""), PARAMETER_TYPE_Bool, false);
s.Printf(SG_T("PRECISION_%03d"), iField);
P.Add_Value(pNode, s, _TL("Decimal Precision"), _TL(""), PARAMETER_TYPE_Int, 2.0, 0.0, true);
}
//-----------------------------------------------------
if( Dlg_Parameters(&P, _TL("Field Properties")) )
{
vCol.clear();
vPrecision.clear();
for(int iField=0; iField<pPoints->Get_Field_Count(); iField++)
{
if( P(CSG_String::Format(SG_T("FIELD_%03d" ), iField).c_str())->asBool() )
{
vCol.push_back(iField);
vPrecision.push_back(P(CSG_String::Format(SG_T("PRECISION_%03d" ), iField).c_str())->asInt());
}
}
}
else
return( false );
}
else // CMD
{
CSG_String sFields, sPrecision;
CSG_String token;
int iValue;
sFields = Parameters("FIELDS")->asString();
sPrecision = Parameters("PRECISIONS")->asString();
CSG_String_Tokenizer tkz_fields(sFields, ";", SG_TOKEN_STRTOK);
while( tkz_fields.Has_More_Tokens() )
{
token = tkz_fields.Get_Next_Token();
if( token.Length() == 0 )
break;
if( !token.asInt(iValue) )
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: can't convert to number"));
return( false );
}
iValue -= 1;
if( iValue < 0 || iValue > pPoints->Get_Field_Count() - 1 )
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: field index out of range"));
return( false );
}
else
vCol.push_back(iValue);
}
CSG_String_Tokenizer tkz_precisons(sPrecision.c_str(), ";", SG_TOKEN_STRTOK);
while( tkz_precisons.Has_More_Tokens() )
{
token = tkz_precisons.Get_Next_Token();
if( token.Length() == 0 )
break;
if( !token.asInt(iValue) )
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: can't convert to number"));
return( false );
}
vPrecision.push_back(iValue);
}
}
if( vCol.size() == 0 )
{
SG_UI_Msg_Add_Error(_TL("Please provide at least one column to export!"));
return( false );
}
if( vCol.size() != vPrecision.size() )
{
SG_UI_Msg_Add_Error(_TL("Number of fields and precisions must be equal!"));
return( false );
}
//-----------------------------------------------------
pTabStream = new CSG_File();
if( !pTabStream->Open(fileName, SG_FILE_W, false) )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to open output file %s!"), fileName.c_str()));
delete (pTabStream);
return (false);
}
if( bWriteHeader )
{
CSG_String sHeader;
for(size_t i=0; i<vCol.size(); i++)
{
sHeader += CSG_String::Format(SG_T("%s"), pPoints->Get_Field_Name(vCol.at(i)));
if( i < vCol.size()-1 )
sHeader += fieldSep.c_str();
}
sHeader += SG_T("\n");
pTabStream->Write(sHeader);
}
for(int iPoint=0; iPoint<pPoints->Get_Count() && Set_Progress(iPoint, pPoints->Get_Count()); iPoint++)
{
CSG_String sLine;
for(size_t i=0; i<vCol.size(); i++)
{
switch (pPoints->Get_Field_Type(vCol.at(i)))
{
case SG_DATATYPE_Double:
case SG_DATATYPE_Float:
sLine += SG_Get_String(pPoints->Get_Value(iPoint, vCol.at(i)), vPrecision.at(i), false);
break;
default:
sLine += CSG_String::Format(SG_T("%d"), (int)pPoints->Get_Value(iPoint, vCol.at(i)));
break;
}
if( i < vCol.size()-1 )
sLine += fieldSep.c_str();
}
sLine += SG_T("\n");
pTabStream->Write(sLine);
}
pTabStream->Close();
delete (pTabStream);
return( true );
}
//---------------------------------------------------------
bool CPolygonStatisticsFromPoints::On_Execute(void)
{
int i, j, n, Offset, *bAttribute;
CSG_Simple_Statistics *Statistics;
CSG_Parameters *pParameters;
CSG_Shapes *pPolygons, *pPoints;
//-----------------------------------------------------
pPoints = Parameters("POINTS") ->asShapes();
pPolygons = Parameters("POLYGONS") ->asShapes();
if( pPolygons->Get_Count() <= 0 || pPoints->Get_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
pParameters = Get_Parameters("ATTRIBUTES");
pParameters->Del_Parameters();
for(i=0; i<pPoints->Get_Field_Count(); i++)
{
if( SG_Data_Type_is_Numeric(pPoints->Get_Field_Type(i)) )
{
CSG_Parameter *pNode = pParameters->Add_Node(NULL, CSG_String::Format(SG_T("%d"), i), pPoints->Get_Field_Name(i), _TL(""));
for(j=0; j<STAT_Count; j++)
{
pParameters->Add_Value(pNode,
CSG_String::Format(SG_T("%d|%d"), i, j),
CSG_String::Format(SG_T("[%s]"), STAT_Name[j].c_str()),
_TL(""), PARAMETER_TYPE_Bool, false
);
}
}
}
if( !Dlg_Parameters("ATTRIBUTES") )
{
return( false );
}
//-----------------------------------------------------
if( Parameters("STATISTICS")->asShapes() == NULL )
{
Parameters("STATISTICS")->Set_Value(pPolygons);
}
else if( pPolygons != Parameters("STATISTICS")->asShapes() )
{
Parameters("STATISTICS")->asShapes()->Assign(pPolygons);
pPolygons = Parameters("STATISTICS")->asShapes();
}
//-----------------------------------------------------
bAttribute = new int[pPoints->Get_Field_Count()];
Offset = pPolygons->Get_Field_Count();
for(i=0, n=0; i<pPoints->Get_Field_Count(); i++)
{
bAttribute[i] = 0;
if( SG_Data_Type_is_Numeric(pPoints->Get_Field_Type(i)) )
{
for(j=0; j<STAT_Count; j++)
{
CSG_Parameter *pParameter = pParameters->Get_Parameter(CSG_String::Format(SG_T("%d|%d"), i, j));
if( pParameter && pParameter->asBool() )
{
bAttribute[i] |= STAT_Flag[j];
pPolygons->Add_Field(CSG_String::Format(SG_T("%s_%s"), pPoints->Get_Field_Name(i), STAT_Name[j].c_str()), SG_DATATYPE_Double);
n++;
}
}
}
}
if( n == 0 )
{
delete[](bAttribute);
return( false );
}
//-----------------------------------------------------
Statistics = new CSG_Simple_Statistics[pPoints->Get_Field_Count()];
for(int iPolygon=0; iPolygon<pPolygons->Get_Count() && Set_Progress(iPolygon, pPolygons->Get_Count()); iPolygon++)
{
CSG_Shape_Polygon *pPolygon = (CSG_Shape_Polygon *)pPolygons->Get_Shape(iPolygon);
//-------------------------------------------------
for(i=0; i<pPoints->Get_Field_Count(); i++)
{
Statistics[i].Invalidate();
}
//-------------------------------------------------
for(int iPoint=0; iPoint<pPoints->Get_Count() && Process_Get_Okay(); iPoint++)
{
CSG_Shape *pPoint = pPoints->Get_Shape(iPoint);
if( pPolygon->is_Containing(pPoint->Get_Point(0)) )
{
for(i=0; i<pPoints->Get_Field_Count(); i++)
{
if( bAttribute[i] )
{
Statistics[i].Add_Value(pPoint->asDouble(i));
}
}
}
}
//-------------------------------------------------
for(i=0, n=Offset; i<pPoints->Get_Field_Count(); i++)
{
if( bAttribute[i] )
{
if( Statistics[i].Get_Count() > 0 )
{
if( bAttribute[i] & STAT_Flag[STAT_Sum] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Sum()); }
if( bAttribute[i] & STAT_Flag[STAT_Avg] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Mean()); }
if( bAttribute[i] & STAT_Flag[STAT_Var] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Variance()); }
if( bAttribute[i] & STAT_Flag[STAT_Dev] ) { pPolygon->Set_Value(n++, Statistics[i].Get_StdDev()); }
if( bAttribute[i] & STAT_Flag[STAT_Min] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Minimum()); }
if( bAttribute[i] & STAT_Flag[STAT_Max] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Maximum()); }
if( bAttribute[i] & STAT_Flag[STAT_Num] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Count()); }
}
else
{
if( bAttribute[i] & STAT_Flag[STAT_Sum] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Avg] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Var] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Dev] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Min] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Max] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Num] ) { pPolygon->Set_NoData(n++); }
}
}
}
}
//-----------------------------------------------------
delete[](Statistics);
delete[](bAttribute);
DataObject_Update(pPolygons);
return( true );
}
//---------------------------------------------------------
bool CPointCloud_From_Text_File::On_Execute(void)
{
CSG_String fileName;
int iField, iType;
TSG_Data_Type Type;
CSG_String Name, Types, s;
CSG_PointCloud *pPoints;
CSG_Parameters P;
CSG_Parameter *pNode;
int xField, yField, zField, nAttribs, max_iField;
bool bSkipHeader;
char fieldSep;
std::vector<int> vCol;
std::ifstream tabStream;
std::string tabLine;
double lines;
long cntPt, cntInvalid;
double x, y, z, value;
//-----------------------------------------------------
fileName = Parameters("FILE") ->asString();
xField = Parameters("XFIELD") ->asInt() - 1;
yField = Parameters("YFIELD") ->asInt() - 1;
zField = Parameters("ZFIELD") ->asInt() - 1;
nAttribs = Parameters("ATTRIBS") ->asInt();
bSkipHeader = Parameters("SKIP_HEADER") ->asBool();
switch (Parameters("FIELDSEP")->asInt())
{
default:
case 0: fieldSep = '\t'; break;
case 1: fieldSep = ' '; break;
case 2: fieldSep = ','; break;
}
Types.Printf(SG_T("%s|%s|%s|%s|%s|"),
_TL("1 byte integer"),
_TL("2 byte integer"),
_TL("4 byte integer"),
_TL("4 byte floating point"),
_TL("8 byte floating point")
);
P.Set_Name(_TL("Attribute Field Properties"));
for(iField=1; iField<=nAttribs; iField++)
{
s.Printf(SG_T("NODE_%03d") , iField);
pNode = P.Add_Node(NULL, s, CSG_String::Format(SG_T("%d. %s"), iField, _TL("Field")), _TL(""));
s.Printf(SG_T("FIELD_%03d"), iField);
P.Add_String(pNode, s, _TL("Name"), _TL(""), s);
s.Printf(SG_T("COLUMN_%03d"), iField);
P.Add_Value(pNode, s, _TL("Attribute is Column ..."), _TL(""), PARAMETER_TYPE_Int, iField+3, 1, true);
s.Printf(SG_T("TYPE_%03d") , iField);
P.Add_Choice(pNode, s, _TL("Type"), _TL(""), Types, 3);
}
//-----------------------------------------------------
if( nAttribs > 0 )
{
if( Dlg_Parameters(&P, _TL("Field Properties")) )
{
pPoints = SG_Create_PointCloud();
pPoints->Set_Name(SG_File_Get_Name(fileName, false));
Parameters("POINTS")->Set_Value(pPoints);
for(iField=0; iField<nAttribs; iField++)
{
Name = P(CSG_String::Format(SG_T("FIELD_%03d" ), iField + 1).c_str())->asString();
iType = P(CSG_String::Format(SG_T("TYPE_%03d" ), iField + 1).c_str())->asInt();
vCol.push_back(P(CSG_String::Format(SG_T("COLUMN_%03d"), iField + 1).c_str())->asInt() - 1);
switch( iType )
{
default:
case 0: Type = SG_DATATYPE_Char; break;
case 1: Type = SG_DATATYPE_Short; break;
case 2: Type = SG_DATATYPE_Int; break;
case 3: Type = SG_DATATYPE_Float; break;
case 4: Type = SG_DATATYPE_Double; break;
}
pPoints->Add_Field(Name, Type);
}
}
else
return( false );
}
else
{
pPoints = SG_Create_PointCloud();
pPoints->Create();
pPoints->Set_Name(SG_File_Get_Name(fileName, false));
Parameters("POINTS")->Set_Value(pPoints);
}
max_iField = M_GET_MAX(xField, yField);
max_iField = M_GET_MAX(max_iField, zField);
for( unsigned int i=0; i<vCol.size(); i++ )
{
if( max_iField < vCol.at(i) )
max_iField = vCol.at(i);
}
// open input stream
//---------------------------------------------------------
tabStream.open(fileName.b_str(), std::ifstream::in);
if( !tabStream )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to open input file!")));
return (false);
}
tabStream.seekg(0, std::ios::end); // get length of file
lines = (double)tabStream.tellg();
tabStream.seekg(0, std::ios::beg);
std::getline(tabStream, tabLine); // as a workaround we assume the number of lines from the length of the first line
lines = lines / (double)tabStream.tellg();
if( !bSkipHeader )
{
tabStream.clear(); // let's forget we may have reached the EOF
tabStream.seekg(0, std::ios::beg); // and rewind to the beginning
}
// import
//---------------------------------------------------------
cntPt = cntInvalid = 0;
SG_UI_Process_Set_Text(CSG_String::Format(_TL("Importing data ...")));
while( std::getline(tabStream, tabLine) )
{
std::istringstream stream(tabLine);
std::vector<std::string> tabCols;
std::string tabEntry;
if( cntPt%10000 == 0 )
SG_UI_Process_Set_Progress((double)cntPt, lines);
cntPt++;
while( std::getline(stream, tabEntry, fieldSep) ) // read every column in this line and fill vector
{
if (tabEntry.length() == 0)
continue;
tabCols.push_back(tabEntry);
}
if ((int)tabCols.size() < max_iField - 1 )
{
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: Skipping misformatted line (%.0f)!"), cntPt), true);
cntInvalid++;
continue;
}
x = strtod(tabCols[xField].c_str(), NULL);
y = strtod(tabCols[yField].c_str(), NULL);
z = strtod(tabCols[zField].c_str(), NULL);
pPoints->Add_Point(x, y, z);
for( int i=0; i<nAttribs; i++ )
{
value = strtod(tabCols.at(vCol.at(i)).c_str(), NULL);
pPoints->Set_Attribute(i, value);
}
}
// finalize
//---------------------------------------------------------
tabStream.close();
CSG_Parameters sParms;
DataObject_Get_Parameters(pPoints, sParms);
if (sParms("COLORS_ATTRIB") && sParms("COLORS_TYPE") && sParms("METRIC_COLORS")
&& sParms("METRIC_ZRANGE") && sParms("COLORS_AGGREGATE"))
{
sParms("COLORS_AGGREGATE")->Set_Value(3); // highest z
sParms("COLORS_TYPE")->Set_Value(2); // graduated color
sParms("METRIC_COLORS")->asColors()->Set_Count(255); // number of colors
sParms("COLORS_ATTRIB")->Set_Value(2); // z attrib
sParms("METRIC_ZRANGE")->asRange()->Set_Range(pPoints->Get_Minimum(2),pPoints->Get_Maximum(2));
DataObject_Set_Parameters(pPoints, sParms);
DataObject_Update(pPoints);
}
if (cntInvalid > 0)
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: Skipped %d invalid points!"), cntInvalid), true);
SG_UI_Msg_Add(CSG_String::Format(_TL("%d points sucessfully imported."), (cntPt-cntInvalid)), true);
return( true );
}
//---------------------------------------------------------
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
);
}
//---------------------------------------------------------
CCollect_Points::CCollect_Points(void)
{
//-----------------------------------------------------
Set_Name (_TL("Create Reference Points"));
Set_Author (SG_T("O.Conrad (c) 2013"));
Set_Description (_TW(
"Digitize reference points for georeferencing grids, images and shapes. "
"Click with the mouse on known locations in the map window "
"and add the reference coordinates. "
"After choosing 4 or more points, stop the interactive module execution "
"by unchecking it in the in the modules menu."
));
//-----------------------------------------------------
Parameters.Add_Shapes(
NULL , "REF_SOURCE" , _TL("Reference Points (Origin)"),
_TL(""),
PARAMETER_OUTPUT, SHAPE_TYPE_Point
);
Parameters.Add_Shapes(
NULL , "REF_TARGET" , _TL("Reference Points (Projection)"),
_TL(""),
PARAMETER_OUTPUT_OPTIONAL, SHAPE_TYPE_Point
);
Parameters.Add_Choice(
NULL , "METHOD" , _TL("Method"),
_TL(""),
GEOREF_METHODS_CHOICE, 0
);
Parameters.Add_Value(
NULL , "ORDER" ,_TL("Polynomial Order"),
_TL(""),
PARAMETER_TYPE_Int, 3, 1, true
);
Parameters.Add_Value(
NULL , "REFRESH" , _TL("Clear Reference Points"),
_TL(""),
PARAMETER_TYPE_Bool, false
);
//-----------------------------------------------------
CSG_Parameters *pParameters = Add_Parameters("REFERENCE", _TL("Point Position"), _TL(""));
pParameters->Add_Value(
NULL , "X" , _TL("x Position"),
_TL(""),
PARAMETER_TYPE_Double
);
pParameters->Add_Value(
NULL , "Y" , _TL("y Position"),
_TL(""),
PARAMETER_TYPE_Double
);
}
//---------------------------------------------------------
bool CWMS_Import::Get_Map(wxHTTP *pServer, const CSG_String &Directory, CWMS_Capabilities &Cap)
{
bool bResult = false;
int i, n;
CSG_Rect r(Cap.m_Extent);
CSG_Parameters p;
//-----------------------------------------------------
// if( Cap.m_MaxWidth > 2 && NX > Cap.m_MaxWidth ) NX = Cap.m_MaxWidth;
// if( Cap.m_MaxHeight > 2 && NY > Cap.m_MaxHeight ) NY = Cap.m_MaxHeight;
p.Add_Range (NULL , "X_RANGE" , _TL("X Range") , _TL(""), r.Get_XMin(), r.Get_XMax(), r.Get_XMin(), r.Get_XRange() > 0.0, r.Get_XMax(), r.Get_XRange() > 0.0);
p.Add_Range (NULL , "Y_RANGE" , _TL("Y Range") , _TL(""), r.Get_YMin(), r.Get_YMax(), r.Get_YMin(), r.Get_YRange() > 0.0, r.Get_YMax(), r.Get_YRange() > 0.0);
p.Add_Value (NULL , "CELLSIZE", _TL("Cellsize") , _TL(""), PARAMETER_TYPE_Double, r.Get_XRange() / 2001.0, 0.0, true);
p.Add_Choice(NULL , "FORMAT" , _TL("Format") , _TL(""), Cap.m_Formats);
p.Add_Choice(NULL , "PROJ" , _TL("Projections"), _TL(""), Cap.m_Projections);
CSG_Parameter *pNode = p("FORMAT");
for(i=0; i<pNode->asChoice()->Get_Count(); i++)
{
CSG_String s(pNode->asChoice()->Get_Item(i));
if( !s.CmpNoCase(SG_T("image/png")) )
pNode->Set_Value(i);
}
for(i=0; i<Cap.m_Layers_Name.Get_Count(); i++)
{
p.Add_Value(NULL, Cap.m_Layers_Name[i], Cap.m_Layers_Title[i], "", PARAMETER_TYPE_Bool, false);
}
//-----------------------------------------------------
if( pServer && Dlg_Parameters(&p, _TL("WMS Import")) )
{
int NX, NY;
double Cellsize;
CSG_String Layers, Format;
//-------------------------------------------------
r.Assign(
p("X_RANGE")->asRange()->Get_LoVal(),
p("Y_RANGE")->asRange()->Get_LoVal(),
p("X_RANGE")->asRange()->Get_HiVal(),
p("Y_RANGE")->asRange()->Get_HiVal()
);
Cellsize = p("CELLSIZE") ->asDouble();
NX = 1 + (int)(r.Get_XRange() / Cellsize);
NY = 1 + (int)(r.Get_YRange() / Cellsize);
//-------------------------------------------------
Layers.Clear();
for(i=0, n=0; i<Cap.m_Layers_Name.Get_Count(); i++)
{
if( p(Cap.m_Layers_Name[i])->asBool() )
{
if( n++ > 0 ) Layers += ",";
Layers += Cap.m_Layers_Name[i];
}
}
if( n == 0 )
{
return( false );
}
//-------------------------------------------------
wxBitmapType tFormat;
Format = p("FORMAT")->asString();
if( Format.Contains(SG_T("image/gif" )) ) tFormat = wxBITMAP_TYPE_GIF ;
else if( Format.Contains(SG_T("image/jpeg")) ) tFormat = wxBITMAP_TYPE_JPEG;
else if( Format.Contains(SG_T("image/png" )) ) tFormat = wxBITMAP_TYPE_PNG ;
else if( Format.Contains(SG_T("image/wbmp")) ) tFormat = wxBITMAP_TYPE_BMP ;
else if( Format.Contains(SG_T("image/bmp" )) ) tFormat = wxBITMAP_TYPE_BMP ;
else if( Format.Contains(SG_T("image/tiff")) ) tFormat = wxBITMAP_TYPE_TIF ;
else if( Format.Contains(SG_T("GIF" )) ) tFormat = wxBITMAP_TYPE_GIF ;
else if( Format.Contains(SG_T("JPEG" )) ) tFormat = wxBITMAP_TYPE_JPEG;
else if( Format.Contains(SG_T("PNG" )) ) tFormat = wxBITMAP_TYPE_PNG ;
else
{
return( false );
}
//-------------------------------------------------
CSG_String sRequest(Directory);
sRequest += SG_T("?SERVICE=WMS");
sRequest += SG_T("&VERSION=") + Cap.m_Version;
sRequest += SG_T("&REQUEST=GetMap");
sRequest += SG_T("&LAYERS=") + Layers;
if( Cap.m_Projections.Length() > 0 )
sRequest += CSG_String(S_SRS(Cap.m_Version)) + p("PROJ")->asString();
sRequest += SG_T("&FORMAT=") + Format;
sRequest += CSG_String::Format(SG_T("&WIDTH=%d&HEIGHT=%d"), NX, NY);
sRequest += CSG_String::Format(SG_T("&BBOX=%f,%f,%f,%f"), r.m_rect.xMin, r.m_rect.yMin, r.m_rect.xMax, r.m_rect.yMax);
Message_Add(sRequest, true);
//-------------------------------------------------
wxInputStream *pStream;
if( (pStream = pServer->GetInputStream(sRequest.c_str())) == NULL )
{
Message_Add(_TL("could not open GetMap stream"));
}
else
{
wxImage Image;
if( Image.LoadFile(*pStream, tFormat) == false )
{
Message_Add(_TL("could not read image"));
CSG_String s = SG_T("\n");
pStream->SeekI(0, wxFromStart);
while( !pStream->Eof() )
{
s += (char)pStream->GetC();
}
Message_Add(s);
}
else
{
CSG_Grid *pGrid = SG_Create_Grid(SG_DATATYPE_Int, Image.GetWidth(), Image.GetHeight(), Cellsize, r.m_rect.xMin, r.m_rect.yMin);
for(int y=0, yy=pGrid->Get_NY()-1; y<pGrid->Get_NY() && Set_Progress(y, pGrid->Get_NY()); y++, yy--)
{
for(int x=0; x<pGrid->Get_NX(); x++)
{
pGrid->Set_Value(x, y, SG_GET_RGB(Image.GetRed(x, yy), Image.GetGreen(x, yy), Image.GetBlue(x, yy)));
}
}
//-----------------------------------------
pGrid->Set_Name(Cap.m_Title);
Parameters("MAP")->Set_Value(pGrid);
DataObject_Set_Colors(pGrid, 100, SG_COLORS_BLACK_WHITE);
CSG_Parameters Parms;
if( DataObject_Get_Parameters(pGrid, Parms) && Parms("COLORS_TYPE") )
{
Parms("COLORS_TYPE")->Set_Value(3); // Color Classification Type: RGB
DataObject_Set_Parameters(pGrid, Parms);
}
bResult = true;
}
delete(pStream);
}
}
return( bResult );
}
bool CFit::On_Execute(void)
{
int i, j, NrVars;
vector < double> x, y, StartValue, Result;
CSG_String msg;
CSG_Parameters StartParameters;
const SG_Char *formel = Parameters("FORMEL")->asString();
Formel.Add_Function(SG_T("NUG"), (TSG_PFNC_Formula_1) NUG, 1, 0);
Formel.Add_Function(SG_T("SPH"), (TSG_PFNC_Formula_1) SPH, 2, 0);
Formel.Add_Function(SG_T("EXP"), (TSG_PFNC_Formula_1) EXP, 2, 0);
Formel.Add_Function(SG_T("LIN"), (TSG_PFNC_Formula_1) LIN, 2, 0);
Formel.Set_Formula(formel);
if (Formel.Get_Error(msg))
{
Message_Add(msg);
return false;
}
const SG_Char *uservars = NULL;
uservars = Formel.Get_Used_Variables();
NrVars = 0;
for (i = 0; i < SG_STR_LEN(uservars); i++)
{
if (uservars[i] >='a' && uservars[i] <= 'z')
{
if (uservars[i] != 'x')
vars[NrVars++] = uservars[i];
}
}
vars[NrVars] =(char) 0;
StartParameters.Add_Info_String(NULL, _TL(""), _TL("Formula"), _TL("Formula"), formel);
for (i = 0; i < strlen(vars); i++)
{
CSG_String c(vars[i]);
StartParameters.Add_Value(NULL, c, c, _TL("Start Value"), PARAMETER_TYPE_Double, 1.0);
}
Dlg_Parameters(&StartParameters, _TL("Start Values"));
for (i = 0; i < strlen(vars); i++)
{
char c[3];
sprintf(c, "%c", vars[i]);
StartValue.push_back(StartParameters(c)->asDouble());
}
CSG_Table *pTable = Parameters("SOURCE")->asTable();
int Record_Count = pTable->Get_Record_Count();
int yField = Parameters("YFIELD")->asInt();
int xField = Parameters("XFIELD")->asInt();
bool Use_X = Parameters("USE_X")->asBool();
pTable->Add_Field(_TL("Fit") , SG_DATATYPE_Double);
for (i = 0; i < Record_Count; i++)
{
CSG_Table_Record * Record = pTable->Get_Record(i);
if (Use_X)
{
x.push_back(Record->asDouble(xField));
}
else
{
x.push_back(i);
}
y.push_back(Record->asDouble(yField));
}
TLMFit *Fit;
Fit = new TLMFit(x, y, StartValue, FitFunc);
int max_iter = Parameters("ITER")->asInt();
double Max_lamda = Parameters("LAMDA")->asInt();
int iter = 0;
try
{
Fit->Fit();
while ((Fit->Alamda() < Max_lamda) &&(iter < max_iter) &&Process_Get_Okay(true))
{
Fit->Fit();
iter++;
}
}
catch (ESingularMatrix &E)
{
if (E.Type == 1 || E.Type == 2)
{
msg.Printf(_TL("Matrix signular\n"));
Message_Add(msg);
return false;
}
}
Result = Fit->Param();
for (i = 0; i < NrVars; i++)
{
Formel.Set_Variable(vars[i], (double) Result[i]);
}
msg.Printf(_TL("Model Parameters:"));
Message_Add(msg);
for (i = 0; i < NrVars; i++)
{
msg.Printf(SG_T("%c = %f\n"), vars[i], Result[i]);
Message_Add(msg);
}
msg.Printf(_TL("\nRMS of Residuals (stdfit):\t%f\n"), sqrt(Fit->Chisq()/x.size()));
Message_Add(msg);
msg.Printf(_TL("Correlation Matrix of the Fit Parameters:\n"));
Message_Add(msg);
vector< vector < double> > covar = Fit->Covar();
msg.Printf(_TL(""));
for (j = 0; j < NrVars; j++)
msg.Printf(SG_T("%s\t%c"), msg.c_str(), vars[j]);
msg.Printf(SG_T("%s\n"), msg.c_str());
Message_Add(msg);
for (i = 0; i < NrVars; i++)
{
msg.Printf(SG_T("%c"), vars[i]);
for (j = 0; j <= i; j++)
{
msg.Printf(SG_T("%s\t%f"), msg.c_str(), covar[i][j]/covar[i][i]);
}
msg.Printf(SG_T("%s\n"), msg.c_str());
Message_Add(msg);
}
int Field_Count = pTable->Get_Field_Count();
for (i = 0; i < Record_Count; i++)
{
CSG_Table_Record * Record = pTable->Get_Record(i);
Record->Set_Value(Field_Count - 1, Formel.Get_Value(x[i]));
}
// API_FREE (uservars);
return (true);
}
//---------------------------------------------------------
C_Kriging_Base::C_Kriging_Base(void)
{
CSG_Parameter *pNode;
CSG_Parameters *pParameters;
//-----------------------------------------------------
Parameters.Add_Grid_Output(
NULL , "GRID" , _TL("Grid"),
_TL("")
);
Parameters.Add_Grid_Output(
NULL , "VARIANCE" , _TL("Variance"),
_TL("")
);
pNode = Parameters.Add_Shapes(
NULL , "SHAPES" , _TL("Points"),
_TL(""),
PARAMETER_INPUT
);
Parameters.Add_Table_Field(
pNode , "FIELD" , _TL("Attribute"),
_TL("")
);
Parameters.Add_Value(
NULL , "BVARIANCE" , _TL("Create Variance Grid"),
_TL(""),
PARAMETER_TYPE_Bool , true
);
Parameters.Add_Choice(
NULL , "TARGET" , _TL("Target Grid"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|%s|"),
_TL("user defined"),
_TL("grid system"),
_TL("grid")
), 0
);
Parameters.Add_Choice(
NULL , "MODEL" , _TL("Variogram Model"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|%s|%s|%s|%s|"),
_TL("Spherical Model"),
_TL("Exponential Model"),
_TL("Gaussian Model"),
_TL("Linear Regression"),
_TL("Exponential Regression"),
_TL("Power Function Regression")
), 3
);
Parameters.Add_Value(
NULL , "BLOCK" , _TL("Block Kriging"),
_TL(""),
PARAMETER_TYPE_Bool , false
);
Parameters.Add_Value(
NULL , "DBLOCK" , _TL("Block Size"),
_TL(""),
PARAMETER_TYPE_Double , 100.0, 0.0, true
);
Parameters.Add_Value(
NULL , "BLOG" , _TL("Logarithmic Transformation"),
_TL(""),
PARAMETER_TYPE_Bool
);
Parameters.Add_Value(
NULL , "NUGGET" , _TL("Nugget"),
_TL(""),
PARAMETER_TYPE_Double, 0.0, 0.0, true
);
Parameters.Add_Value(
NULL , "SILL" , _TL("Sill"),
_TL(""),
PARAMETER_TYPE_Double, 10.0, 0.0, true
);
Parameters.Add_Value(
NULL , "RANGE" , _TL("Range"),
_TL(""),
PARAMETER_TYPE_Double, 100.0, 0.0, true
);
pNode = Parameters.Add_Node(
NULL , "PARMS" , _TL("Additional Parameters"),
_TL("")
);
Parameters.Add_Value(
pNode , "LIN_B" , _TL("Linear Regression"),
_TL("Parameter B for Linear Regression:\n y = Nugget + B * x"),
PARAMETER_TYPE_Double, 1.0
);
Parameters.Add_Value(
pNode , "EXP_B" , _TL("Exponential Regression"),
_TL("Parameter B for Exponential Regression:\n y = Nugget * e ^ (B * x)"),
PARAMETER_TYPE_Double, 0.1
);
Parameters.Add_Value(
pNode , "POW_A" , _TL("Power Function - A"),
_TL("Parameter A for Power Function Regression:\n y = A * x ^ B"),
PARAMETER_TYPE_Double, 1.0
);
Parameters.Add_Value(
pNode , "POW_B" , _TL("Power Function - B"),
_TL("Parameter B for Power Function Regression:\n y = A * x ^ B"),
PARAMETER_TYPE_Double, 0.5
);
//-----------------------------------------------------
pParameters = Add_Parameters(SG_T("USER") , _TL("User defined grid") , _TL(""));
pParameters->Add_Value(
NULL , "CELL_SIZE" , _TL("Grid Size"),
_TL(""),
PARAMETER_TYPE_Double, 100.0, 0.0, true
);
pNode = pParameters->Add_Value(
NULL , "FIT_EXTENT" , _TL("Fit Extent"),
_TL("Automatically fits the grid to the shapes layers extent."),
PARAMETER_TYPE_Bool , true
);
pParameters->Add_Range(
pNode , "X_EXTENT" , _TL("X-Extent"),
_TL("")
);
pParameters->Add_Range(
pNode , "Y_EXTENT" , _TL("Y-Extent"),
_TL("")
);
//-----------------------------------------------------
pParameters = Add_Parameters(SG_T("SYSTEM") , _TL("Choose Grid System") , _TL(""));
pParameters->Add_Grid_System(
NULL , "SYSTEM" , _TL("Grid System"),
_TL("")
);
//-----------------------------------------------------
pParameters = Add_Parameters(SG_T("GRID") , _TL("Choose Grid") , _TL(""));
pNode = pParameters->Add_Grid_System(
NULL , "SYSTEM" , _TL("Grid System"),
_TL("")
);
pParameters->Add_Grid(
pNode , "GRID" , _TL("Grid"),
_TL(""),
PARAMETER_INPUT , false
);
pParameters->Add_Grid(
pNode , "VARIANCE" , _TL("Variance"),
_TL(""),
PARAMETER_INPUT_OPTIONAL, false
);
}
//---------------------------------------------------------
CKriging_Base::CKriging_Base(void)
{
CSG_Parameter *pNode;
CSG_Parameters *pParameters;
//-----------------------------------------------------
pNode = Parameters.Add_Shapes(
NULL , "POINTS" , _TL("Points"),
_TL(""),
PARAMETER_INPUT, SHAPE_TYPE_Point
);
Parameters.Add_Table_Field(
pNode , "ZFIELD" , _TL("Attribute"),
_TL("")
);
//-----------------------------------------------------
Parameters.Add_Choice(
NULL , "TARGET" , _TL("Target Grid"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|"),
_TL("user defined"),
_TL("grid")
), 0
);
Parameters.Add_Choice(
NULL , "TQUALITY" , _TL("Type of Quality Measure"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|"),
_TL("standard deviation"),
_TL("variance")
), 0
);
//-----------------------------------------------------
Parameters.Add_Value(
NULL , "LOG" , _TL("Logarithmic Transformation"),
_TL(""),
PARAMETER_TYPE_Bool
);
pNode = Parameters.Add_Value(
NULL , "BLOCK" , _TL("Block Kriging"),
_TL(""),
PARAMETER_TYPE_Bool , false
);
Parameters.Add_Value(
pNode , "DBLOCK" , _TL("Block Size"),
_TL(""),
PARAMETER_TYPE_Double , 100.0, 0.0, true
);
///////////////////////////////////////////////////////
//-----------------------------------------------------
if( !SG_UI_Get_Window_Main() )
{
Parameters.Add_Value(
NULL , "VAR_MAXDIST" , _TL("Maximum Distance"),
_TL(""),
PARAMETER_TYPE_Double , -1.0
);
Parameters.Add_Value(
NULL , "VAR_NCLASSES" , _TL("Lag Distance Classes"),
_TL("initial number of lag distance classes"),
PARAMETER_TYPE_Int , 100, 1, true
);
Parameters.Add_Value(
NULL , "VAR_NSKIP" , _TL("Skip"),
_TL(""),
PARAMETER_TYPE_Int, 1, 1, true
);
Parameters.Add_String(
NULL , "VAR_MODEL" , _TL("Model"),
_TL(""),
SG_T("a + b * x")
);
}
///////////////////////////////////////////////////////
//-----------------------------------------------------
pParameters = Add_Parameters("USER", _TL("User Defined Grid") , _TL(""));
pParameters->Add_Value(
NULL , "BVARIANCE" , _TL("Create Quality Grid"),
_TL(""),
PARAMETER_TYPE_Bool, true
);
m_Grid_Target.Add_Parameters_User(pParameters);
//-----------------------------------------------------
pParameters = Add_Parameters("GRID", _TL("Choose Grid") , _TL(""));
m_Grid_Target.Add_Parameters_Grid(pParameters);
//-----------------------------------------------------
m_Grid_Target.Add_Grid_Parameter(SG_T("VARIANCE"), _TL("Quality Measure"), true);
}
//---------------------------------------------------------
bool CSG_Direct_Georeferencer::Add_Parameters(CSG_Parameters &Parameters)
{
CSG_Parameter *pNode;
//-----------------------------------------------------
pNode = Parameters.Add_Node(
NULL , "NODE_POS" , _TL("Position"),
_TL("")
);
Parameters.Add_Value(
pNode , "X" , _TL("X"),
_TL(""),
PARAMETER_TYPE_Double , 0.0
);
Parameters.Add_Value(
pNode , "Y" , _TL("Y"),
_TL(""),
PARAMETER_TYPE_Double , 0.0
);
Parameters.Add_Value(
pNode , "Z" , _TL("Flying Height"),
_TL(""),
PARAMETER_TYPE_Double , 1000.0
);
//-----------------------------------------------------
pNode = Parameters.Add_Node(
NULL , "NODE_DIR" , _TL("Orientation"),
_TL("")
);
Parameters.Add_Choice(
pNode , "ORIENTATION" , _TL("Orientation"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|"),
_TL("BLUH"),
_TL("PATB")
), 0
);
Parameters.Add_Value(
pNode , "OMEGA" , _TL("Omega [degree]"),
_TL("rotation around the X axis (roll)"),
PARAMETER_TYPE_Double , 0.0
);
Parameters.Add_Value(
pNode , "PHI" , _TL("Phi [degree]"),
_TL("rotation around the Y axis (pitch)"),
PARAMETER_TYPE_Double , 0.0
);
Parameters.Add_Value(
pNode , "KAPPA" , _TL("Kappa [degree]"),
_TL("rotation around the Z axis (heading)"),
PARAMETER_TYPE_Double , 0.0
);
Parameters.Add_Value(
pNode , "KAPPA_OFF" , _TL("Kappa Offset [degree]"),
_TL("origin adjustment for Z axis (heading)"),
PARAMETER_TYPE_Double , 90.0
);
//-----------------------------------------------------
pNode = Parameters.Add_Node(
NULL , "NODE_CAMERA" , _TL("Camera"),
_TL("")
);
Parameters.Add_Value(
pNode , "CFL" , _TL("Focal Length [mm]"),
_TL(""),
PARAMETER_TYPE_Double , 80, 0.0, true
);
Parameters.Add_Value(
pNode , "PXSIZE" , _TL("CCD Physical Pixel Size [micron]"),
_TL(""),
PARAMETER_TYPE_Double , 5.2, 0.0, true
);
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
CShapes_Cut_Interactive::CShapes_Cut_Interactive(void)
{
Set_Name (_TL("Cut Shapes Layer"));
Set_Author (SG_T("(c) 2006 by O.Conrad"));
Set_Description (_TW(
""
));
Set_Drag_Mode (MODULE_INTERACTIVE_DRAG_BOX);
//-----------------------------------------------------
Parameters.Add_Shapes(
NULL , "SHAPES" , _TL("Shapes"),
_TL(""),
PARAMETER_INPUT
);
Parameters.Add_Shapes(
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
);
//-----------------------------------------------------
CSG_Parameters *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
);
}
