//---------------------------------------------------------
bool CFilter_3x3::On_Execute(void)
{
//-----------------------------------------------------
CSG_Table *pFilter = Parameters("FILTER")->asTable()
? Parameters("FILTER" )->asTable()
: Parameters("FILTER_3X3")->asTable();
if( pFilter->Get_Count() < 1 || pFilter->Get_Field_Count() < 1 )
{
Error_Set(_TL("invalid filter matrix"));
return( false );
}
//-----------------------------------------------------
CSG_Matrix Filter(pFilter->Get_Field_Count(), pFilter->Get_Count());
{
for(int iy=0; iy<Filter.Get_NY(); iy++)
{
CSG_Table_Record *pRecord = pFilter->Get_Record(iy);
for(int ix=0; ix<Filter.Get_NX(); ix++)
{
Filter[iy][ix] = pRecord->asDouble(ix);
}
}
}
int nx = (Filter.Get_NX() - 1) / 2;
int ny = (Filter.Get_NY() - 1) / 2;
//-----------------------------------------------------
CSG_Grid *pInput = Parameters("INPUT" )->asGrid();
CSG_Grid *pResult = Parameters("RESULT")->asGrid();
if( !pResult || pResult == pInput )
{
pResult = SG_Create_Grid(pInput);
}
else
{
pResult->Fmt_Name("%s [%s]", pInput->Get_Name(), _TL("Filter"));
pResult->Set_NoData_Value(pInput->Get_NoData_Value());
}
//-----------------------------------------------------
bool bAbsolute = Parameters("ABSOLUTE")->asBool();
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
double s = 0.0;
double n = 0.0;
if( pInput->is_InGrid(x, y) )
{
for(int iy=0, jy=y-ny; iy<Filter.Get_NY(); iy++, jy++)
{
for(int ix=0, jx=x-nx; ix<Filter.Get_NX(); ix++, jx++)
{
if( pInput->is_InGrid(jx, jy) )
{
s += Filter[iy][ix] * pInput->asDouble(jx, jy);
n += fabs(Filter[iy][ix]);
}
}
}
}
if( n > 0.0 )
{
pResult->Set_Value(x, y, bAbsolute ? s : s / n);
}
else
{
pResult->Set_NoData(x, y);
}
}
}
//-----------------------------------------------------
if( !Parameters("RESULT")->asGrid() || Parameters("RESULT")->asGrid() == pInput )
{
pInput->Assign(pResult);
delete(pResult);
DataObject_Update(pInput);
}
return( true );
}
//---------------------------------------------------------
bool CGSGrid_Statistics_To_Table::On_Execute(void)
{
//-----------------------------------------------------
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS")->asGridList();
if( pGrids->Get_Count() < 1 )
{
Error_Set(_TL("no grids in selection"));
return( false );
}
//-----------------------------------------------------
CSG_Table *pTable = Parameters("STATS")->asTable();
pTable->Destroy();
pTable->Set_Name(_TL("Statistics for Grids"));
pTable->Add_Field(_TL("NAME"), SG_DATATYPE_String);
if( Parameters("DATA_CELLS" )->asBool() ) pTable->Add_Field(_TL("DATA_CELLS" ), SG_DATATYPE_Int);
if( Parameters("NODATA_CELLS")->asBool() ) pTable->Add_Field(_TL("NODATA_CELLS"), SG_DATATYPE_Int);
if( Parameters("CELLSIZE" )->asBool() ) pTable->Add_Field(_TL("CELLSIZE" ), SG_DATATYPE_Double);
if( Parameters("MEAN" )->asBool() ) pTable->Add_Field(_TL("MEAN" ), SG_DATATYPE_Double);
if( Parameters("MIN" )->asBool() ) pTable->Add_Field(_TL("MIN" ), SG_DATATYPE_Double);
if( Parameters("MAX" )->asBool() ) pTable->Add_Field(_TL("MAX" ), SG_DATATYPE_Double);
if( Parameters("RANGE" )->asBool() ) pTable->Add_Field(_TL("RANGE" ), SG_DATATYPE_Double);
if( Parameters("VAR" )->asBool() ) pTable->Add_Field(_TL("VAR" ), SG_DATATYPE_Double);
if( Parameters("STDDEV" )->asBool() ) pTable->Add_Field(_TL("STDDEV" ), SG_DATATYPE_Double);
if( Parameters("STDDEVLO" )->asBool() ) pTable->Add_Field(_TL("STDDEVLO" ), SG_DATATYPE_Double);
if( Parameters("STDDEVHI" )->asBool() ) pTable->Add_Field(_TL("STDDEVHI" ), SG_DATATYPE_Double);
if( Parameters("PCTL" )->asBool() ) pTable->Add_Field(_TL("PCTL" ), SG_DATATYPE_Double);
if( pTable->Get_Field_Count() <= 1 )
{
Error_Set(_TL("no parameter output specified"));
return( false );
}
double dRank = Parameters("PCTL")->asBool() ? Parameters("PCTL_VAL")->asDouble() : -1.0;
//-----------------------------------------------------
for(int i=0; i<pGrids->Get_Count() && Process_Get_Okay(); i++)
{
CSG_Grid *pGrid = pGrids->asGrid(i);
CSG_Table_Record *pRecord = pTable->Add_Record();
pRecord->Set_Value("NAME" , pGrid->Get_Name());
pRecord->Set_Value("DATA_CELLS" , pGrid->Get_NCells() - pGrid->Get_NoData_Count());
pRecord->Set_Value("NODATA_CELLS", pGrid->Get_NoData_Count());
pRecord->Set_Value("CELLSIZE" , pGrid->Get_Cellsize());
pRecord->Set_Value("MEAN" , pGrid->Get_ArithMean());
pRecord->Set_Value("MIN" , pGrid->Get_ZMin());
pRecord->Set_Value("MAX" , pGrid->Get_ZMax());
pRecord->Set_Value("RANGE" , pGrid->Get_ZRange());
pRecord->Set_Value("VAR" , pGrid->Get_Variance());
pRecord->Set_Value("STDDEV" , pGrid->Get_StdDev());
pRecord->Set_Value("STDDEVLO" , pGrid->Get_ArithMean() - pGrid->Get_StdDev());
pRecord->Set_Value("STDDEVHI" , pGrid->Get_ArithMean() + pGrid->Get_StdDev());
if( dRank > 0.0 && dRank < 100.0 )
{
pRecord->Set_Value("PCTL", pGrid->Get_Percentile(dRank)); // this is a time consuming operation
}
}
if( dRank > 0.0 && dRank < 100.0 )
{
pTable->Set_Field_Name(pTable->Get_Field_Count() - 1, CSG_String::Format(SG_T("%s%02d"), _TL("PCTL"), (int)dRank));
}
return( true );
}
//---------------------------------------------------------
bool CSG_Table::_Load_Text(const CSG_String &File_Name, bool bHeadline, const SG_Char *Separator)
{
int i, iField, fLength;
CSG_String sLine, sField;
CSG_File Stream;
CSG_Table Table;
//-----------------------------------------------------
if( Stream.Open(File_Name, SG_FILE_R, false) == false )
{
return( false );
}
if( !Stream.Read_Line(sLine) )
{
return( false );
}
//-----------------------------------------------------
sLine += Separator;
while( (i = sLine.Find(Separator)) >= 0 )
{
sField = bHeadline ? sLine.Left(i) : CSG_String::Format(SG_T("FIELD_%02d"), Table.Get_Field_Count() + 1);
if( sField[0] == SG_T('\"') && sField[(int)(sField.Length() - 1)] == SG_T('\"') ) // remove quota
{
sField = sField.AfterFirst('\"').BeforeLast('\"');
}
Table.Add_Field(sField, SG_DATATYPE_String);
sLine.Remove(0, i + 1);
}
//-----------------------------------------------------
TSG_Data_Type *Type = new TSG_Data_Type[Table.Get_Field_Count()];
for(iField=0; iField<Table.Get_Field_Count(); iField++)
{
Type[iField] = SG_DATATYPE_Int;
}
if( !bHeadline )
{
Stream.Seek_Start();
}
fLength = Stream.Length();
while( Stream.Read_Line(sLine) && sLine.Length() > 0 && SG_UI_Process_Set_Progress(Stream.Tell(), fLength) )
{
CSG_Table_Record *pRecord = Table._Add_Record();
sLine += Separator;
for(iField=0; iField<Table.Get_Field_Count(); iField++)
{
if( (i = sLine.Find(Separator)) >= 0 )
{
sField = sLine.Left(i);
if( sField[0] == SG_T('\"') && sField[(int)(sField.Length() - 1)] == SG_T('\"') ) // remove quota
{
sField = sField.AfterFirst('\"').BeforeLast('\"');
}
if( Type[iField] != SG_DATATYPE_String )
{
double Value;
if( SG_SSCANF(sField, SG_T("%lf"), &Value) != 1 )
{
Type[iField] = SG_DATATYPE_String;
}
else if( Type[iField] != SG_DATATYPE_Double && Value - (int)Value != 0.0 )
{
Type[iField] = SG_DATATYPE_Double;
}
}
pRecord->Set_Value(iField, sField);
sLine.Remove(0, i + 1);
}
else
{
break;
}
}
}
//-----------------------------------------------------
if( Table.Get_Count() > 0 )
{
for(iField=0; iField<Table.Get_Field_Count(); iField++)
{
Add_Field(Table.Get_Field_Name(iField), Type[iField]);
}
for(int iRecord=0; iRecord<Table.Get_Count() && SG_UI_Process_Set_Progress(iRecord, Table.Get_Count()); iRecord++)
{
CSG_Table_Record *pRecord = _Add_Record();
for(iField=0; iField<Get_Field_Count(); iField++)
{
switch( Get_Field_Type(iField) )
{
default: pRecord->Set_Value(iField, Table[iRecord].asString(iField)); break;
case SG_DATATYPE_Int: pRecord->Set_Value(iField, Table[iRecord].asInt (iField)); break;
case SG_DATATYPE_Double: pRecord->Set_Value(iField, Table[iRecord].asDouble(iField)); break;
}
}
}
}
delete[](Type);
SG_UI_Process_Set_Ready();
return( Get_Field_Count() > 0 );
}
//---------------------------------------------------------
bool CTable_Trend_Base::On_Execute(void)
{
int i, j, xField, yField;
CSG_String Name;
CSG_Table_Record *pRecord;
CSG_Table *pTable;
pTable = Parameters("TABLE") ->asTable();
xField = Parameters("FIELD_X") ->asInt();
yField = Parameters("FIELD_Y") ->asInt();
//-----------------------------------------------------
if( m_Trend.Set_Formula(Parameters("FORMULA")->asString()) )
{
m_Trend.Clr_Data();
for(i=0; i<pTable->Get_Record_Count(); i++)
{
pRecord = pTable->Get_Record(i);
m_Trend.Add_Data(pRecord->asDouble(xField), pRecord->asDouble(yField));
}
//-------------------------------------------------
if( m_Trend.Get_Trend() )
{
Message_Fmt("\n%s\n%s: %f", m_Trend.Get_Formula().c_str(), SG_T("r\xb2"), 100.0 * m_Trend.Get_R2());
if( Parameters("TREND")->asTable() == NULL )
{
pTable->Add_Field("TREND" , SG_DATATYPE_Double);
for(i=0, j=pTable->Get_Field_Count()-1; i<m_Trend.Get_Data_Count(); i++)
{
pRecord = pTable->Get_Record(i);
pRecord->Set_Value(j, m_Trend.Get_Value(m_Trend.Get_Data_X(i)));
}
}
else
{
Name.Printf("%s [%s]", pTable->Get_Name(), _TL("Trend"));
pTable = Parameters("TREND")->asTable();
pTable->Destroy();
pTable->Set_Name(Name);
pTable->Add_Field("X" , SG_DATATYPE_Double);
pTable->Add_Field("Y" , SG_DATATYPE_Double);
pTable->Add_Field("Y_TREND", SG_DATATYPE_Double);
for(i=0; i<m_Trend.Get_Data_Count(); i++)
{
pRecord = pTable->Add_Record();
pRecord->Set_Value(0, m_Trend.Get_Data_X(i));
pRecord->Set_Value(1, m_Trend.Get_Data_Y(i));
pRecord->Set_Value(2, m_Trend.Get_Value(m_Trend.Get_Data_X(i)));
}
}
return( true );
}
}
return( false );
}
//---------------------------------------------------------
bool CGSGrid_Statistics::On_Execute(void)
{
//-----------------------------------------------------
CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS")->asGridList();
if( pGrids->Get_Count() <= 1 )
{
Error_Set(_TL("no grids in selection"));
return( false );
}
//-----------------------------------------------------
CSG_Grid *pMean = Parameters("MEAN" )->asGrid();
CSG_Grid *pMin = Parameters("MIN" )->asGrid();
CSG_Grid *pMax = Parameters("MAX" )->asGrid();
CSG_Grid *pRange = Parameters("RANGE" )->asGrid();
CSG_Grid *pSum = Parameters("SUM" )->asGrid();
CSG_Grid *pVar = Parameters("VAR" )->asGrid();
CSG_Grid *pStdDev = Parameters("STDDEV" )->asGrid();
CSG_Grid *pStdDevLo = Parameters("STDDEVLO")->asGrid();
CSG_Grid *pStdDevHi = Parameters("STDDEVHI")->asGrid();
CSG_Grid *pPercentile = Parameters("PCTL" )->asGrid();
if( !pMean && !pMin && !pMax && !pRange && !pSum && !pVar && !pStdDev && !pStdDevLo && !pStdDevHi && !pPercentile )
{
Error_Set(_TL("no parameter output specified"));
return( false );
}
double dRank = Parameters("PCTL_VAL")->asDouble() / 100.0;
//-----------------------------------------------------
for(int y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
CSG_Table Values;
CSG_Simple_Statistics s;
for(int i=0; i<pGrids->Get_Count(); i++)
{
if( !pGrids->asGrid(i)->is_NoData(x, y) )
{
double z = pGrids->asGrid(i)->asDouble(x, y);
s.Add_Value(z);
if( pPercentile )
{
if( Values.Get_Field_Count() == 0 )
{
Values.Add_Field("Z", SG_DATATYPE_Double);
}
Values.Add_Record()->Set_Value(0, z);
}
}
}
//-----------------------------------------
if( s.Get_Count() <= 0 )
{
if( pMean ) pMean ->Set_NoData(x, y);
if( pMin ) pMin ->Set_NoData(x, y);
if( pMax ) pMax ->Set_NoData(x, y);
if( pRange ) pRange ->Set_NoData(x, y);
if( pSum ) pSum ->Set_NoData(x, y);
if( pVar ) pVar ->Set_NoData(x, y);
if( pStdDev ) pStdDev ->Set_NoData(x, y);
if( pStdDevLo ) pStdDevLo ->Set_NoData(x, y);
if( pStdDevHi ) pStdDevHi ->Set_NoData(x, y);
if( pPercentile ) pPercentile ->Set_NoData(x, y);
}
else
{
if( pMean ) pMean ->Set_Value(x, y, s.Get_Mean());
if( pMin ) pMin ->Set_Value(x, y, s.Get_Minimum());
if( pMax ) pMax ->Set_Value(x, y, s.Get_Maximum());
if( pRange ) pRange ->Set_Value(x, y, s.Get_Range());
if( pSum ) pSum ->Set_Value(x, y, s.Get_Sum());
if( pVar ) pVar ->Set_Value(x, y, s.Get_Variance());
if( pStdDev ) pStdDev ->Set_Value(x, y, s.Get_StdDev());
if( pStdDevLo ) pStdDevLo ->Set_Value(x, y, s.Get_Mean() - s.Get_StdDev());
if( pStdDevHi ) pStdDevHi ->Set_Value(x, y, s.Get_Mean() + s.Get_StdDev());
if( pPercentile )
{
Values.Set_Index(0, TABLE_INDEX_Ascending);
pPercentile->Set_Value(x, y, Values.Get_Record_byIndex((int)(dRank * s.Get_Count()))->asDouble(0));
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CTable_Text_Export::On_Execute(void)
{
CSG_String StrFormat, Separator;
CSG_File Stream;
CSG_Table *pTable;
//-----------------------------------------------------
pTable = Parameters("TABLE" )->asTable();
StrFormat = Parameters("STRQUOTA")->asBool() ? SG_T("\"%s\"") : SG_T("%s");
switch( Parameters("SEPARATOR")->asInt() )
{
case 0:
Separator = "\t";
break;
case 1:
Separator = ";";
break;
case 2:
Separator = ",";
break;
case 3:
Separator = " ";
break;
default:
Separator = Parameters("SEP_OTHER")->asString();
break;
}
//-----------------------------------------------------
if( !Stream.Open(Parameters("FILENAME")->asString(), SG_FILE_W, false) )
{
Message_Add(_TL("file could not be opened."));
}
//-----------------------------------------------------
else
{
if( Parameters("HEADLINE")->asBool() )
{
for(int iField=0; iField<pTable->Get_Field_Count(); iField++)
{
Stream.Printf(StrFormat.c_str(), pTable->Get_Field_Name(iField));
Stream.Printf(iField < pTable->Get_Field_Count() - 1 ? Separator.c_str() : SG_T("\n"));
}
}
//-------------------------------------------------
for(int iRecord=0; iRecord<pTable->Get_Record_Count() && Set_Progress(iRecord, pTable->Get_Record_Count()); iRecord++)
{
CSG_Table_Record *pRecord = pTable->Get_Record(iRecord);
for(int iField=0; iField<pTable->Get_Field_Count(); iField++)
{
switch( pTable->Get_Field_Type(iField) )
{
default:
case SG_DATATYPE_Char:
case SG_DATATYPE_String:
case SG_DATATYPE_Date:
Stream.Printf(StrFormat.c_str(), pRecord->asString(iField));
break;
case SG_DATATYPE_Short:
case SG_DATATYPE_Int:
case SG_DATATYPE_Color:
Stream.Printf(SG_T("%d") , pRecord->asInt(iField));
break;
case SG_DATATYPE_Long:
Stream.Printf(SG_T("%ld") , (long)pRecord->asDouble(iField));
break;
case SG_DATATYPE_ULong:
Stream.Printf(SG_T("%lu") , (unsigned long)pRecord->asDouble(iField));
break;
case SG_DATATYPE_Float:
case SG_DATATYPE_Double:
Stream.Printf(SG_T("%f") , pRecord->asDouble(iField));
break;
}
Stream.Printf(iField < pTable->Get_Field_Count() - 1 ? Separator.c_str() : SG_T("\n"));
}
}
//-------------------------------------------------
Stream.Close();
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CTable_Text_Import_Numbers::On_Execute(void)
{
CSG_String sHead, sLine, Separator;
CSG_File Stream;
//-----------------------------------------------------
if( !Stream.Open(Parameters("FILENAME")->asString(), SG_FILE_R, false) )
{
Error_Set(_TL("file could not be opened"));
return( false );
}
if( Parameters("SKIP")->asInt() > 0 )
{
int i = Parameters("SKIP")->asInt();
while( i > 0 && Stream.Read_Line(sLine) ) {
i--;
}
}
if( !Stream.Read_Line(sHead) || sHead.Length() == 0 )
{
Error_Set(_TL("empty or corrupted file"));
return( false );
}
if( !Parameters("HEADLINE")->asBool() )
{
sLine = sHead;
}
else if( !Stream.Read_Line(sLine) || sLine.Length() == 0 )
{
Error_Set(_TL("empty or corrupted file"));
return( false );
}
//-----------------------------------------------------
switch( Parameters("SEPARATOR")->asInt() )
{
case 0:
Separator = "\t";
break;
case 1:
Separator = ";";
break;
case 2:
Separator = ",";
break;
case 3:
Separator = " ";
break;
default:
Separator = Parameters("SEP_OTHER")->asString();
break;
}
//-----------------------------------------------------
CSG_Table *pTable = Parameters("TABLE")->asTable();
pTable->Destroy();
pTable->Set_Name(SG_File_Get_Name(Parameters("FILENAME")->asString(), false));
sHead.Trim(true);
sHead.Replace(Separator, "\t");
while( sHead.Length() > 0 )
{
sHead.Trim();
if( Parameters("HEADLINE")->asBool() )
{
pTable->Add_Field(sHead.BeforeFirst('\t'), SG_DATATYPE_Double);
}
else
{
pTable->Add_Field(CSG_String::Format("FIELD%02d", 1 + pTable->Get_Field_Count()), SG_DATATYPE_Double);
}
sHead = sHead.AfterFirst('\t');
}
if( pTable->Get_Field_Count() <= 0 )
{
Error_Set(_TL("empty or corrupted file"));
return( false );
}
//-----------------------------------------------------
int fLength = Stream.Length();
bool bOkay = true;
do
{
sLine.Replace(Separator, "\t");
CSG_Table_Record *pRecord = pTable->Add_Record();
for(int i=0; bOkay && i<pTable->Get_Field_Count(); i++)
{
double Value;
sLine.Trim();
if( (bOkay = sLine.asDouble(Value)) == true )
{
pRecord->Set_Value(i, Value);
sLine = sLine.AfterFirst('\t');
}
else
{
pTable->Del_Record(pTable->Get_Count() - 1);
}
}
}
while( bOkay && Stream.Read_Line(sLine) && Set_Progress(Stream.Tell(), fLength) );
return( pTable->Get_Count() > 0 );
}
//---------------------------------------------------------
bool CTable_Field_Deletion::On_Execute(void)
{
//-----------------------------------------------------
CSG_Parameter_Table_Fields *pFields = Parameters("FIELDS")->asTableFields();
if( pFields->Get_Count() <= 0 )
{
Error_Set(_TL("no fields in selection"));
return( false );
}
//-----------------------------------------------------
CSG_Table *pTable = Parameters("TABLE")->asTable();
CSG_Table *pOutput = NULL;
if( pTable->Get_ObjectType() == DATAOBJECT_TYPE_Shapes )
{
if( (pOutput = Parameters("OUT_SHAPES")->asShapes()) != NULL && pOutput != pTable )
{
((CSG_Shapes *)pOutput)->Create(((CSG_Shapes *)pTable)->Get_Type(), (const wchar_t*)0, (CSG_Table *)0, ((CSG_Shapes *)pTable)->Get_Vertex_Type());
}
}
else // if( pTable->Get_ObjectType() == DATAOBJECT_TYPE_Table )
{
if( (pOutput = Parameters("OUT_TABLE" )->asTable()) != NULL && pOutput != pTable )
{
pOutput->Destroy();
}
}
//-----------------------------------------------------
if( pOutput )
{
int nFields = pTable->Get_Field_Count() - pFields->Get_Count();
int *pFieldsOut = new int[nFields];
int iField = 0;
for(int i=0; i<pTable->Get_Field_Count(); i++)
{
bool bDelete = false;
for(int j=0; j<pFields->Get_Count(); j++)
{
if( i == pFields->Get_Index(j) )
{
bDelete = true;
break;
}
}
if( !bDelete )
{
pFieldsOut[iField] = i;
iField++;
}
}
pOutput->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pTable->Get_Name(), _TL("Changed")));
for(iField=0; iField<nFields; iField++)
{
pOutput->Add_Field(pTable->Get_Field_Name(pFieldsOut[iField]), pTable->Get_Field_Type(pFieldsOut[iField]));
}
for(int iRecord=0; iRecord<pTable->Get_Count(); iRecord++)
{
CSG_Table_Record *pOut, *pIn = pTable->Get_Record(iRecord);
if( pOutput->Get_ObjectType() == DATAOBJECT_TYPE_Shapes )
{
pOut = ((CSG_Shapes *)pOutput)->Add_Shape(pIn, SHAPE_COPY_GEOM);
if( ((CSG_Shapes *)pOutput)->Get_Vertex_Type() > SG_VERTEX_TYPE_XY )
{
for(int iPart=0; iPart<((CSG_Shape *)pIn)->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<((CSG_Shape *)pIn)->Get_Point_Count(iPart); iPoint++)
{
((CSG_Shape *)pOut)->Set_Z(((CSG_Shape *)pIn)->Get_Z(iPoint, iPart), iPoint, iPart);
if( ((CSG_Shapes *)pOutput)->Get_Vertex_Type() == SG_VERTEX_TYPE_XYZM )
{
((CSG_Shape *)pOut)->Set_M(((CSG_Shape *)pIn)->Get_M(iPoint, iPart), iPoint, iPart);
}
}
}
}
}
else
{
pOut = pOutput->Add_Record();
}
for(iField=0; iField<nFields; iField++)
{
*pOut->Get_Value(iField) = *pIn->Get_Value(pFieldsOut[iField]);
}
}
delete[] pFieldsOut;
}
else
{
for(int iField=pFields->Get_Count()-1; iField>=0; iField--)
{
pTable->Del_Field(pFields->Get_Index(pFields->Get_Index(iField)));
}
DataObject_Update(pTable);
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CSoil_Texture_Table::On_Execute(void)
{
//-----------------------------------------------------
CSG_Table *pTable = Parameters("TABLE")->asTable();
int iSand = Parameters("SAND" )->asInt();
int iSilt = Parameters("SILT" )->asInt();
int iClay = Parameters("CLAY" )->asInt();
int iTexture = Parameters("TEXTURE")->asInt();
//-----------------------------------------------------
if( (iSand >= 0 ? 1 : 0) + (iSilt >= 0 ? 1 : 0) + (iClay >= 0 ? 1 : 0) < 2 )
{
Error_Set(_TL("at least two contents (sand, silt, clay) have to be given"));
return( false );
}
//-----------------------------------------------------
if( iTexture < 0 )
{
iTexture = pTable->Get_Field_Count();
pTable->Add_Field("TEXTURE", SG_DATATYPE_String);
}
//-----------------------------------------------------
for(int i=0; i<pTable->Get_Count() && Set_Progress(i, pTable->Get_Count()); i++)
{
CSG_Table_Record *pRecord = pTable->Get_Record(i);
if( (iSand >= 0 && pRecord->is_NoData(iSand))
|| (iSilt >= 0 && pRecord->is_NoData(iSilt))
|| (iClay >= 0 && pRecord->is_NoData(iClay)) )
{
pRecord->Set_NoData(iTexture);
}
else
{
int Class = -1;
if( iSand >= 0 && iSilt >= 0 && iClay >= 0 )
{
double Sum;
Class = Get_Texture(pRecord->asDouble(iSand), pRecord->asDouble(iSilt), pRecord->asDouble(iClay), Sum);
}
else if( iSilt < 0 )
{
Class = Get_Texture_SandClay(pRecord->asDouble(iSand), pRecord->asDouble(iClay));
}
else if( iClay < 0 )
{
Class = Get_Texture_SandSilt(pRecord->asDouble(iSand), pRecord->asDouble(iSilt));
}
else if( iSand < 0 )
{
Class = Get_Texture_SiltClay(pRecord->asDouble(iSilt), pRecord->asDouble(iClay));
}
pRecord->Set_Value (iTexture, Classes[Class].Key);
}
}
DataObject_Update(pTable);
//-----------------------------------------------------
CSG_Parameter *pLUT = DataObject_Get_Parameter(pTable, "LUT");
if( pLUT && pLUT->asTable() )
{
CSG_Table *pClasses = pLUT->asTable();
for(int iClass=0; iClass<12; iClass++)
{
CSG_Table_Record *pClass = pClasses->Get_Record(iClass);
if( pClass == NULL )
{
pClass = pClasses->Add_Record();
}
pClass->Set_Value(0, Classes[iClass].Color);
pClass->Set_Value(1, Classes[iClass].Name);
pClass->Set_Value(2, Classes[iClass].Name);
pClass->Set_Value(3, Classes[iClass].Key);
pClass->Set_Value(4, Classes[iClass].Key);
}
while( pClasses->Get_Count() > 12 )
{
pClasses->Del_Record(pClasses->Get_Count() - 1);
}
DataObject_Set_Parameter(pTable, pLUT); // Lookup Table
DataObject_Set_Parameter(pTable, "LUT_ATTRIB" , iTexture); // Lookup Table Attribute
DataObject_Set_Parameter(pTable, "COLORS_TYPE", 1 ); // Color Classification Type: Lookup Table
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CJoin_Tables_Base::On_Execute(void)
{
//-----------------------------------------------------
int id_A, id_B;
CSG_Table *pT_A, *pT_B;
pT_A = Parameters("TABLE_A")->asTable();
id_A = Parameters("ID_A" )->asInt();
pT_B = Parameters("TABLE_B")->asTable();
id_B = Parameters("ID_B" )->asInt();
if( id_A < 0 || id_A >= pT_A->Get_Field_Count() || pT_A->Get_Count() <= 0
|| id_B < 0 || id_B >= pT_B->Get_Field_Count() || pT_B->Get_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
if( Parameters("RESULT")->asTable() && Parameters("RESULT")->asTable() != pT_A )
{
pT_A = Parameters("RESULT")->asTable();
if( Parameters("RESULT")->asTable()->Get_ObjectType() == DATAOBJECT_TYPE_Shapes )
{
((CSG_Shapes *)pT_A)->Create(*Parameters("TABLE_A")->asShapes());
}
else
{
pT_A->Create(*Parameters("TABLE_A")->asTable());
}
}
//-----------------------------------------------------
int nJoins, *Join, Offset = pT_A->Get_Field_Count();
if( Parameters("FIELDS_ALL")->asBool() )
{
if( (nJoins = pT_B->Get_Field_Count() - 1) <= 0 )
{
Error_Set(_TL("no fields to add"));
return( false );
}
Join = new int[nJoins];
for(int i=0, j=0; i<pT_B->Get_Field_Count(); i++)
{
if( i != id_B )
{
pT_A->Add_Field(pT_B->Get_Field_Name(i), pT_B->Get_Field_Type(i));
Join[j++] = i;
}
}
}
else
{
CSG_Parameter_Table_Fields *pFields = Parameters("FIELDS")->asTableFields();
if( (nJoins = pFields->Get_Count()) <= 0 )
{
Error_Set(_TL("no fields to add"));
return( false );
}
Join = new int[nJoins];
for(int j=0; j<pFields->Get_Count(); j++)
{
int i = pFields->Get_Index(j);
pT_A->Add_Field(pT_B->Get_Field_Name(i), pT_B->Get_Field_Type(i));
Join[j] = i;
}
}
pT_A->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pT_A->Get_Name(), pT_B->Get_Name()));
//-----------------------------------------------------
bool bCmpNumeric = SG_Data_Type_is_Numeric(pT_A->Get_Field_Type(id_A))
|| SG_Data_Type_is_Numeric(pT_B->Get_Field_Type(id_B));
CSG_Table Delete; if( !Parameters("KEEP_ALL")->asBool() ) Delete.Add_Field("ID", SG_DATATYPE_Int);
pT_A->Set_Index(id_A, TABLE_INDEX_Ascending);
pT_B->Set_Index(id_B, TABLE_INDEX_Ascending);
CSG_Table_Record *pRecord_B = pT_B->Get_Record_byIndex(0);
for(int a=0, b=0, Cmp; pRecord_B && a<pT_A->Get_Count() && Set_Progress(a, pT_A->Get_Count()); a++)
{
CSG_Table_Record *pRecord_A = pT_A->Get_Record_byIndex(a);
while( pRecord_B && (Cmp = Cmp_Keys(pRecord_A->Get_Value(id_A), pRecord_B->Get_Value(id_B), bCmpNumeric)) < 0 )
{
pRecord_B = pT_B->Get_Record_byIndex(++b);
}
if( pRecord_B && Cmp == 0 )
{
for(int i=0; i<nJoins; i++)
{
*pRecord_A->Get_Value(Offset + i) = *pRecord_B->Get_Value(Join[i]);
}
}
else if( Delete.Get_Field_Count() == 0 )
{
for(int i=0; i<nJoins; i++)
{
pRecord_A->Set_NoData(Offset + i);
}
}
else
{
Delete.Add_Record()->Set_Value(0, pRecord_A->Get_Index());
}
}
//-----------------------------------------------------
delete[](Join);
pT_A->Set_Index(id_A, TABLE_INDEX_None);
pT_B->Set_Index(id_B, TABLE_INDEX_None);
if( Delete.Get_Count() > 0 )
{
Delete.Set_Index(0, TABLE_INDEX_Descending);
for(int i=0; i<Delete.Get_Count(); i++)
{
// ((CSG_Shapes *)pT_A)->Del_Shape(Delete[i].asInt(0));
pT_A->Del_Record(Delete[i].asInt(0));
}
Message_Add(CSG_String::Format(SG_T("%d %s"), pT_A->Get_Selection_Count(), _TL("unjoined records have been removed")));
}
if( pT_A == Parameters("TABLE_A")->asTable() )
{
DataObject_Update(pT_A);
}
return( pT_A->Get_Count() > 0 );
}
//---------------------------------------------------------
bool CGrid_Class_Statistics_For_Polygons::Get_Classes(CSG_Grid *pGrid, CSG_Shapes *pPolygons)
{
m_Classes.Destroy();
//-----------------------------------------------------
if( Parameters("GRID_VALUES")->asInt() == 0 )
{
sLong iCell;
CSG_Category_Statistics Classes(pGrid->Get_Type());
for(iCell=0; iCell<pGrid->Get_NCells(); iCell++)
{
if( !pGrid->is_NoData(iCell) )
{
Classes += pGrid->asDouble(iCell);
}
}
//-------------------------------------------------
if( Classes.Get_Count() > 0 )
{
Classes.Sort();
for(int iClass=0; iClass<Classes.Get_Count(); iClass++)
{
pPolygons->Add_Field(Classes.asString(iClass), SG_DATATYPE_Double);
}
m_Classes.Create(*Get_System(), SG_DATATYPE_Short);
for(iCell=0; iCell<pGrid->Get_NCells(); iCell++)
{
m_Classes.Set_Value(iCell, pGrid->is_NoData(iCell) ? -1 : Classes.Get_Category(pGrid->asDouble(iCell)));
}
}
}
//-----------------------------------------------------
else
{
int fNam, fMin, fMax;
CSG_Table *pLUT = NULL;
if( (pLUT = Parameters("GRID_LUT")->asTable()) != NULL )
{
fNam = Parameters("GRID_LUT_NAM")->asInt();
fMin = Parameters("GRID_LUT_MIN")->asInt();
fMax = Parameters("GRID_LUT_MAX")->asInt();
if( fNam < 0 || fNam >= pLUT->Get_Field_Count() ) { fNam = fMin; }
if( fMax < 0 || fMax >= pLUT->Get_Field_Count() ) { fMax = fMin; }
}
else if( DataObject_Get_Parameter(pGrid, "LUT") && (pLUT = DataObject_Get_Parameter(pGrid, "LUT")->asTable()) != NULL )
{
fNam = 1;
fMin = 3;
fMax = 4;
}
//-------------------------------------------------
if( pLUT && pLUT->Get_Count() > 0 )
{
for(int iClass=0; iClass<pLUT->Get_Count(); iClass++)
{
pPolygons->Add_Field((*pLUT)[iClass].asString(fNam), SG_DATATYPE_Double);
}
m_Classes.Create(*Get_System(), SG_DATATYPE_Short);
for(sLong iCell=0; iCell<pGrid->Get_NCells(); iCell++)
{
m_Classes.Set_Value(iCell, Get_Class(pGrid->asDouble(iCell), *pLUT, fMin, fMax));
}
}
}
//-----------------------------------------------------
return( m_Classes.is_Valid() );
}
bool CAHP::On_Execute(void){
int i,j;
int x,y;
float *pCoefs;
float fValue;
float **pMatrix;
float fSum;
CSG_Grid *pOutputGrid;
CSG_Grid **pGrids;
CSG_Table_Record *pRecord;
CSG_Table *pTable;
CSG_Parameter_Grid_List* pGridsList;
CSG_String sMessage;
pTable = Parameters("TABLE")->asTable();
pOutputGrid = Parameters("OUTPUT")->asGrid();
if( (pGridsList = (CSG_Parameter_Grid_List *)Parameters("GRIDS")->Get_Data()) !=
NULL && pGridsList->Get_Count() > 0 ){
if (pTable->Get_Field_Count() != pGridsList->Get_Count() ||
pTable->Get_Record_Count() < pGridsList->Get_Count()){
Message_Add(_TL("Error : Wrong table. Check table dimensions"));
return false;
}//if
pMatrix = new float*[pGridsList->Get_Count()];
for (i = 0; i<pGridsList->Get_Count(); i++){
pMatrix[i] = new float[pGridsList->Get_Count()];
pRecord = pTable->Get_Record(i);
for (j = 0; j<pGridsList->Get_Count(); j++){
pMatrix[i][j] = pRecord->asFloat(j);
}//for
}//for
for (i = 0; i<pGridsList->Get_Count(); i++){
fSum = 0;
for (j = 0; j<pGridsList->Get_Count(); j++){
fSum += pMatrix[j][i];
}//for
for (j = 0; j<pGridsList->Get_Count(); j++){
pMatrix[j][i] /= fSum;
}//for
}//for
pCoefs = new float[pGridsList->Get_Count()];
for (i = 0; i<pGridsList->Get_Count(); i++){
fSum = 0;
for (j = 0; j<pGridsList->Get_Count(); j++){
fSum += pMatrix[i][j];
}//for
pCoefs[i] = fSum / (float) pGridsList->Get_Count();
sMessage = _TL("Weight for grid ") + SG_Get_String(i,0) + " = " + SG_Get_String(pCoefs[i]);
Message_Add(sMessage.c_str());
}//for
pGrids = new CSG_Grid* [pGridsList->Get_Count()];
for (i = 0; i<pGridsList->Get_Count(); i++){
pGrids[i] = pGridsList->asGrid(i);
}//for
for(y=0; y<Get_NY() && Set_Progress(y); y++){
for(x=0; x<Get_NX(); x++){
fValue = 0;
for (i = 0; i<pGridsList->Get_Count(); i++){
fValue = pCoefs[i] * pGrids[i]->asFloat(x,y);
}//for
pOutputGrid->Set_Value(x,y,fValue);
}//for
}//for
}//if
for (i = 0; i<pGridsList->Get_Count(); i++){
delete [] pMatrix[i];
}//for
delete []pMatrix;
delete[] pCoefs;
return true;
}//method
