//--------------------------------------------------------- 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