//--------------------------------------------------------- bool DLG_Get_FILE_Filter_GDAL_Read(int Type, wxString &Filter) { bool bResult; CSG_Table Formats; SG_UI_ProgressAndMsg_Lock(true); SG_RUN_TOOL(bResult, "io_gdal", 10, // GDAL Formats SG_TOOL_PARAMETER_SET("FORMATS" , &Formats) && SG_TOOL_PARAMETER_SET("TYPE" , Type ) // all (rasters and vectors) && SG_TOOL_PARAMETER_SET("ACCESS" , 0 ) // read && SG_TOOL_PARAMETER_SET("RECOGNIZED", true ) // add an entry for all recognized files ); SG_UI_ProgressAndMsg_Lock(false); if( bResult && Formats.Get_Count() > 0 ) { Filter += Formats[Formats.Get_Count() - 1].asString(2); Filter.Replace("*.sdat;", ""); // we go for *.sgrd Filter.Replace("*.xml;" , ""); // too much noise } return( bResult ); }
//--------------------------------------------------------- bool CTable_Running_Average::On_Execute(void) { int iValue, nValues; CSG_Table *pTable; //----------------------------------------------------- pTable = Parameters("INPUT") ->asTable(); iValue = Parameters("FIELD") ->asInt(); nValues = Parameters("COUNT") ->asInt(); if( Parameters("OUTPUT")->asTable() && Parameters("OUTPUT")->asTable() != pTable ) { pTable = Parameters("OUTPUT") ->asTable(); pTable->Create(*Parameters("INPUT")->asTable()); } //----------------------------------------------------- if( pTable->is_Valid() ) { int i, iLo, iHi, nRange, iAverage; double sValues; iAverage = pTable->Get_Field_Count(); pTable->Add_Field(CSG_String::Format(SG_T("%s [%s]"), pTable->Get_Field_Name(iValue), _TL("Average")), SG_DATATYPE_Double); nRange = nValues / 2; sValues = 0.0; for(iLo=-nValues, i=-nRange, iHi=0; i<pTable->Get_Count() && Set_Progress(i, pTable->Get_Count() + nRange); iLo++, i++, iHi++) { sValues += pTable->Get_Record(iHi < pTable->Get_Count() ? iHi : pTable->Get_Count() - 1)->asDouble(iValue); if( i < 0 ) { sValues += pTable->Get_Record( 0 )->asDouble(iValue); } else { if( iLo < 0 ) { sValues -= pTable->Get_Record( 0 )->asDouble(iValue); } else if( iLo >= 0 ) { sValues -= pTable->Get_Record(iLo)->asDouble(iValue); } pTable->Get_Record(i)->Set_Value(iAverage, sValues / (double)nValues); } } return( true ); } //----------------------------------------------------- return( false ); }
//--------------------------------------------------------- bool CFilter_Rank::Get_Value(int x, int y, double Rank, double &Value) { if( m_pInput->is_InGrid(x, y) ) { CSG_Table Values; Values.Add_Field("Z", SG_DATATYPE_Double); for(int i=0; i<m_Kernel.Get_Count(); i++) { int ix = m_Kernel.Get_X(i, x); int iy = m_Kernel.Get_Y(i, y); if( m_pInput->is_InGrid(ix, iy) ) { Values.Add_Record()->Set_Value(0, m_pInput->asDouble(ix, iy)); } } switch( Values.Get_Count() ) { case 0: return( false ); case 1: Value = Values[0].asDouble(0); return( true ); case 2: Value = (Values[0].asDouble(0) + Values[1].asDouble(0)) / 2.0; return( true ); default: { Values.Set_Index(0, TABLE_INDEX_Ascending); Rank = Rank * (Values.Get_Count() - 1.0); int i = (int)Rank; Value = Values.Get_Record_byIndex(i)->asDouble(0); if( Rank - i > 0.0 && i < Values.Get_Count() - 1 ) { Value = (Value + Values.Get_Record_byIndex(i + 1)->asDouble(0)) / 2.0; } } return( true ); } } return( false ); }
//--------------------------------------------------------- void CData_Source_PgSQL::Update_Sources(const wxTreeItemId &Root) { Freeze(); //----------------------------------------------------- wxTreeItemIdValue Cookie; wxTreeItemId Item = GetFirstChild(Root, Cookie); while( Item.IsOk() ) { Update_Source(Item); Item = GetNextChild(Item, Cookie); } //----------------------------------------------------- CSG_Table Connections; RUN_MODULE(DB_PGSQL_Get_Connections, false, SET_PARAMETER("CONNECTIONS", &Connections)); // CGet_Connections for(int i=0; i<Connections.Get_Count(); i++) { if( !Find_Source(Connections[i].asString(0)) ) { Update_Source(Connections[i].asString(0)); } } //----------------------------------------------------- SortChildren(Root); Expand (Root); Thaw(); }
//--------------------------------------------------------- bool CShapes_SRID_Update::On_Execute(void) { if( !Get_Connection()->has_PostGIS() ) { Error_Set(_TL("no PostGIS layer")); return( false ); } //----------------------------------------------------- CSG_String Select; CSG_Table Table; Select.Printf(SG_T("f_table_name='%s'"), Parameters("TABLES")->asString()); if( !Get_Connection()->Table_Load(Table, "geometry_columns", "*", Select) || Table.Get_Count() != 1 ) { return( false ); } Select.Printf(SG_T("SELECT UpdateGeometrySRID('%s', '%s', %d)"), Parameters("TABLES")->asString(), Table[0].asString("f_geometry_column"), Get_SRID() ); //----------------------------------------------------- if( !Get_Connection()->Execute(Select) ) { return( false ); } return( true ); }
//--------------------------------------------------------- void CData_Source_PgSQL::Append_Table(const wxTreeItemId &Parent, const SG_Char *Name, int Type, int Image) { CData_Source_PgSQL_Data *pData = Parent.IsOk() ? (CData_Source_PgSQL_Data *)GetItemData(Parent) : NULL; if( pData == NULL ) return; wxTreeItemId Item = AppendItem(Parent, Name, Image, Image, new CData_Source_PgSQL_Data(Type, Name, pData->Get_Server())); if( Type == TYPE_GRIDS ) { CSG_Table Grids; RUN_MODULE(DB_PGSQL_Table_Query, false, // CTable_Query SET_PARAMETER("CONNECTION", pData->Get_Server()) && SET_PARAMETER("TABLES" , Name) && SET_PARAMETER("TABLE" , &Grids) && SET_PARAMETER("FIELDS" , SG_T("rid, name")) ); if( bResult ) { for(int i=0; i<Grids.Get_Count(); i++) { AppendItem(Item, Grids[i].asString(1), IMG_GRID, IMG_GRID, new CData_Source_PgSQL_Data(TYPE_GRID, CSG_String::Format("%s:rid=%d", Name, Grids[i].asInt(0)), pData->Get_Server()) ); } } } }
//--------------------------------------------------------- void CData_Source_PgSQL::Update_Source(const wxTreeItemId &Item) { CData_Source_PgSQL_Data *pData = Item.IsOk() ? (CData_Source_PgSQL_Data *)GetItemData(Item) : NULL; if( pData == NULL ) return; if( pData->Get_Type() != TYPE_SOURCE ) { return; } Freeze(); DeleteChildren(Item); //----------------------------------------------------- if( !pData->is_Connected() ) { SetItemImage(Item, IMG_SRC_CLOSED, wxTreeItemIcon_Normal); SetItemImage(Item, IMG_SRC_CLOSED, wxTreeItemIcon_Selected); } else { SetItemImage(Item, IMG_SRC_OPENED, wxTreeItemIcon_Normal); SetItemImage(Item, IMG_SRC_OPENED, wxTreeItemIcon_Selected); CSG_Table Tables; RUN_MODULE(DB_PGSQL_Table_List, false, // CTable_List SET_PARAMETER("CONNECTION", pData->Get_Value()) && SET_PARAMETER("TABLES" , &Tables) ); Tables.Set_Index(1, TABLE_INDEX_Ascending, 0, TABLE_INDEX_Ascending); for(int i=0; i<Tables.Get_Count(); i++) { CSG_String s(Tables[i].asString(1)); TSG_Shape_Type Shape; TSG_Vertex_Type Vertex; if( CSG_Shapes_OGIS_Converter::to_ShapeType(s, Shape, Vertex) ) { switch( Shape ) { case SHAPE_TYPE_Point: Append_Table(Item, Tables[i].asString(0), TYPE_SHAPES, IMG_POINT ); break; case SHAPE_TYPE_Points: Append_Table(Item, Tables[i].asString(0), TYPE_SHAPES, IMG_POINTS ); break; case SHAPE_TYPE_Line: Append_Table(Item, Tables[i].asString(0), TYPE_SHAPES, IMG_LINE ); break; case SHAPE_TYPE_Polygon: Append_Table(Item, Tables[i].asString(0), TYPE_SHAPES, IMG_POLYGON); break; } } else if( !s.Cmp("RASTER" ) ) Append_Table(Item, Tables[i].asString(0), TYPE_GRIDS , IMG_GRIDS ); else if( !s.Cmp("TABLE" ) ) Append_Table(Item, Tables[i].asString(0), TYPE_TABLE , IMG_TABLE ); } Expand(Item); } Thaw(); }
//--------------------------------------------------------- bool CSG_mRMR::Set_Data(CSG_Table &Data, int ClassField, double Threshold) { if( !Get_Memory(Data.Get_Field_Count(), Data.Get_Count()) ) { return( false ); } //----------------------------------------------------- if( ClassField < 0 || ClassField >= m_nVars ) { ClassField = 0; } Data.Set_Index(ClassField, TABLE_INDEX_Ascending); CSG_String s; for(int iSample=0, Class=0; iSample<m_nSamples; iSample++) { double *pData = m_Samples[iSample] = m_Samples[0] + iSample * m_nVars; if( s.Cmp(Data[iSample].asString(ClassField)) ) { s = Data[iSample].asString(ClassField); Class++; } *pData++ = Class; for(int iVar=0; iVar<m_nVars; iVar++) { if( iVar != ClassField ) { *pData++ = Data[iSample].asDouble(iVar); } } } Data.Del_Index(); m_VarNames += Data.Get_Field_Name(ClassField); for(int iVar=0; iVar<m_nVars; iVar++) { if( iVar != ClassField ) { m_VarNames += Data.Get_Field_Name(iVar); } } //----------------------------------------------------- if( Threshold >= 0.0 ) // discretization { Discretize(Threshold); } return( true ); }
//--------------------------------------------------------- bool CShapes_Split_by_Attribute::On_Execute(void) { int iField; CSG_Table *pTable; //----------------------------------------------------- pTable = Parameters("TABLE") ->asTable(); iField = Parameters("FIELD") ->asInt(); Parameters("CUTS")->asTableList()->Del_Items(); //----------------------------------------------------- if( pTable->is_Valid() && pTable->Set_Index(iField, TABLE_INDEX_Ascending) ) { CSG_String sValue; CSG_Table *pCut = NULL; for(int iRecord=0; iRecord<pTable->Get_Count() && Set_Progress(iRecord, pTable->Get_Count()); iRecord++) { CSG_Table_Record *pRecord = pTable->Get_Record_byIndex(iRecord); if( !pCut || sValue.Cmp(pRecord->asString(iField)) ) { pCut = pTable->Get_ObjectType() == DATAOBJECT_TYPE_Shapes ? SG_Create_Shapes(((CSG_Shapes *)pTable)->Get_Type(), SG_T(""), pTable) : SG_Create_Table(pTable); pCut->Set_Name(CSG_String::Format(SG_T("%s [%s = %s]"), pTable->Get_Name(), pTable->Get_Field_Name(iField), pRecord->asString(iField) )); Parameters("CUTS")->asTableList()->Add_Item(pCut); sValue = pRecord->asString(iField); } pCut->Add_Record(pRecord); } return( pCut != NULL ); } return( false ); }
//--------------------------------------------------------- int CChange_Detection::Get_Class(CSG_Table &Classes, double Value) { int a, b, i, c; if( Classes.Get_Count() > 0 ) { if( Classes.Get_Index_Field(0) != CLASS_MIN || Classes.Get_Index_Order(0) != TABLE_INDEX_Ascending ) { Classes.Set_Index(CLASS_MIN, TABLE_INDEX_Ascending); } for(a=0, b=Classes.Get_Record_Count()-1; a < b; ) { i = a + (b - a) / 2; c = Cmp_Class(Classes, Value, i); if( c > 0 ) { b = b > i ? i : b - 1; } else if( c < 0 ) { a = a < i ? i : a + 1; } else { return( Classes.Get_Record_byIndex(i)->Get_Index() ); } } if( Cmp_Class(Classes, Value, a) == 0 ) { return( Classes.Get_Record_byIndex(a)->Get_Index() ); } if( a != b && Cmp_Class(Classes, Value, b) == 0 ) { return( Classes.Get_Record_byIndex(b)->Get_Index() ); } } return( Classes.Get_Count() ); // := unclassified }
//--------------------------------------------------------- int CGrid_Class_Statistics_For_Polygons::Get_Class(double Value, const CSG_Table &LUT, int fMin, int fMax) { for(int i=0; i<LUT.Get_Count(); i++) { if( LUT[i].asDouble(fMin) <= Value && Value <= LUT[i].asDouble(fMax) ) { return( i ); } } return( -1 ); }
//--------------------------------------------------------- CSG_String CSG_ODBC_Connection::Get_Field_Names(const CSG_String &Table_Name) const { CSG_Table Fields = Get_Field_Desc(Table_Name); CSG_String Names; for(int i=0; i<Fields.Get_Count(); i++) { Names += Fields[i].asString(3); Names += SG_T("|"); } return( Names ); }
//--------------------------------------------------------- void CShapes_Load::On_Connection_Changed(CSG_Parameters *pParameters) { CSG_String s; CSG_Table t; if( Get_Connection()->Table_Load(t, SG_T("geometry_columns")) ) { for(int i=0; i<t.Get_Count(); i++) { s += t[i].asString(SG_T("f_table_name")) + CSG_String("|"); } } Parameters("TABLES")->asChoice()->Set_Items(s); }
//--------------------------------------------------------- bool PGSQL_is_Connected (const CSG_String &Server) { CSG_Table Connections; RUN_MODULE(DB_PGSQL_Get_Connections, false, SET_PARAMETER("CONNECTIONS", &Connections)); // CGet_Connections for(int i=0; bResult && i<Connections.Get_Count(); i++) { if( !Server.Cmp(Connections[i].asString(0)) ) { return( true ); } } return( false ); }
//--------------------------------------------------------- bool PGSQL_Get_Connections (CSG_Strings &Servers, double vPostGIS) { Servers.Clear(); CSG_Table Connections; RUN_MODULE(DB_PGSQL_Get_Connections, false, SET_PARAMETER("CONNECTIONS", &Connections)); // CGet_Connections for(int i=0; bResult && i<Connections.Get_Count(); i++) { if( vPostGIS <= 0.0 || vPostGIS <= Connections[i].asDouble("PostGIS") ) { Servers += Connections[i].asString(0); } } return( Servers.Get_Count() > 0 ); }
//--------------------------------------------------------- bool CChange_Detection::Get_Changes(CSG_Table &Initial, CSG_Table &Final, CSG_Table *pChanges, CSG_Matrix &Identity) { int iInitial, iFinal; //----------------------------------------------------- Identity.Create(Final.Get_Count() + 1, Initial.Get_Count() + 1); for(iInitial=0; iInitial<Initial.Get_Count(); iInitial++) { CSG_String s = Initial[iInitial].asString(CLASS_NAM); for(iFinal=0; iFinal<Final.Get_Count(); iFinal++) { Identity[iInitial][iFinal] = s.Cmp(Final[iFinal].asString(CLASS_NAM)) ? 0 : 1; } } Identity[Initial.Get_Count()][Final.Get_Count()] = 1; // unclassified //----------------------------------------------------- pChanges->Destroy(); pChanges->Add_Field(_TL("Name"), SG_DATATYPE_String); for(iFinal=0; iFinal<Final.Get_Count(); iFinal++) { pChanges->Add_Field(Final[iFinal].asString(CLASS_NAM), SG_DATATYPE_Double); } pChanges->Add_Field(_TL("Unclassified"), SG_DATATYPE_Double); //----------------------------------------------------- for(iInitial=0; iInitial<Initial.Get_Count(); iInitial++) { pChanges->Add_Record()->Set_Value(0, Initial[iInitial].asString(CLASS_NAM)); } pChanges->Add_Record()->Set_Value(0, _TL("Unclassified")); return( true ); }
//--------------------------------------------------------- bool CTable_List::On_Execute(void) { CSG_Table *pTables = Parameters("TABLES")->asTable(); pTables->Destroy(); pTables->Set_Name(Get_Connection()->Get_Connection() + " [" + _TL("Tables") + "]"); pTables->Add_Field(_TL("Table"), SG_DATATYPE_String); pTables->Add_Field(_TL("Type" ), SG_DATATYPE_String); CSG_Strings Tables; if( Get_Connection()->Get_Tables(Tables) ) { CSG_Table t; for(int i=0; i<Tables.Get_Count(); i++) { CSG_Table_Record *pTable = pTables->Add_Record(); pTable->Set_Value(0, Tables[i]); if( Get_Connection()->Table_Load(t, "geometry_columns", "type", CSG_String::Format("f_table_name='%s'", Tables[i].c_str())) && t.Get_Count() == 1 ) { pTable->Set_Value(1, t[0][0].asString()); } else if( Get_Connection()->Table_Load(t, "raster_columns", "*", CSG_String::Format("r_table_name='%s'", Tables[i].c_str())) && t.Get_Count() == 1 ) { pTable->Set_Value(1, "RASTER"); } else { pTable->Set_Value(1, "TABLE"); } } } return( pTables->Get_Count() > 0 ); }
bool Del_Edge (int ID) { int n = 0; for(int i=m_Edges.Get_Count()-1; i>=0; i--) { if( m_Edges[i].asInt(0) == ID ) { m_Edges.Del_Record(i); n++; } } if( n > 0 ) { m_Edges.Set_Index(1, TABLE_INDEX_Ascending); return( true ); } return( false ); }
//--------------------------------------------------------- int CTable_Query_GUI::On_Parameter_Changed(CSG_Parameters *pParameters, CSG_Parameter *pParameter) { if( pParameter->Cmp_Identifier("TABLES") ) { CSG_Parameters &Tables = *pParameters->Get_Parameter("TABLES")->asParameters(); CSG_Parameters &Fields = *pParameters->Get_Parameter("FIELDS")->asParameters(); CSG_Parameters &Group = *pParameters->Get_Parameter("GROUP" )->asParameters(); for(int i=0; i<Tables.Get_Count(); i++) { CSG_String Table = Tables[i].Get_Identifier(); if( Tables[i].asBool() && !Fields(Table) ) { CSG_Table Desc = Get_Connection()->Get_Field_Desc(Table); CSG_Parameter *pFields = Fields.Add_Node("", Table, Table, ""); CSG_Parameter *pGroup = Group .Add_Node("", Table, Table, ""); for(int j=0; j<Desc.Get_Count(); j++) { CSG_String ID = Table + "." + Desc[j].asString(0); Fields.Add_Bool(pFields, ID, Desc[j].asString(0), ""); Group .Add_Bool(pGroup , ID, Desc[j].asString(0), ""); } } else if( !Tables[i].asBool() && Fields(Table) ) { Fields.Del_Parameter(Table); Group .Del_Parameter(Table); } } } return( CSG_PG_Tool::On_Parameter_Changed(pParameters, pParameter) ); }
//--------------------------------------------------------- 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 CSG_Shapes::Create(const CSG_String &File_Name) { Destroy(); SG_UI_Msg_Add(CSG_String::Format("%s: %s...", _TL("Load shapes"), File_Name.c_str()), true); //----------------------------------------------------- bool bResult = File_Name.BeforeFirst(':').Cmp("PGSQL") && SG_File_Exists(File_Name) && _Load_ESRI(File_Name); if( bResult ) { Set_File_Name(File_Name, true); } //----------------------------------------------------- else if( File_Name.BeforeFirst(':').Cmp("PGSQL") == 0 ) // database source { CSG_String s(File_Name); s = s.AfterFirst(':'); CSG_String Host (s.BeforeFirst(':')); s = s.AfterFirst(':'); CSG_String Port (s.BeforeFirst(':')); s = s.AfterFirst(':'); CSG_String DBName(s.BeforeFirst(':')); s = s.AfterFirst(':'); CSG_String Table (s.BeforeFirst(':')); CSG_Tool *pTool = SG_Get_Tool_Library_Manager().Get_Tool("db_pgsql", 0); // CGet_Connections if( pTool != NULL ) { SG_UI_ProgressAndMsg_Lock(true); //--------------------------------------------- CSG_Table Connections; CSG_String Connection = DBName + " [" + Host + ":" + Port + "]"; pTool->Settings_Push(); if( pTool->On_Before_Execution() && SG_TOOL_PARAMETER_SET("CONNECTIONS", &Connections) && pTool->Execute() ) // CGet_Connections { for(int i=0; !bResult && i<Connections.Get_Count(); i++) { if( !Connection.Cmp(Connections[i].asString(0)) ) { bResult = true; } } } pTool->Settings_Pop(); //--------------------------------------------- if( bResult && (bResult = (pTool = SG_Get_Tool_Library_Manager().Get_Tool("db_pgsql", 20)) != NULL) == true ) // CPGIS_Shapes_Load { pTool->Settings_Push(); bResult = pTool->On_Before_Execution() && SG_TOOL_PARAMETER_SET("CONNECTION", Connection) && SG_TOOL_PARAMETER_SET("TABLES" , Table) && SG_TOOL_PARAMETER_SET("SHAPES" , this) && pTool->Execute(); pTool->Settings_Pop(); } SG_UI_ProgressAndMsg_Lock(false); } } //----------------------------------------------------- if( bResult ) { Set_Modified(false); Set_Update_Flag(); SG_UI_Process_Set_Ready(); SG_UI_Msg_Add(_TL("okay"), false, SG_UI_MSG_STYLE_SUCCESS); return( true ); } for(int iShape=Get_Count()-1; iShape>=0; iShape--) // be kind, keep at least those shapes that have been loaded successfully { if( !Get_Shape(iShape)->is_Valid() ) { Del_Shape(iShape); } } if( Get_Count() <= 0 ) { Destroy(); } SG_UI_Process_Set_Ready(); SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE); return( false ); }
//--------------------------------------------------------- bool CTable_Fill_Record_Gaps::On_Execute(void) { int Method; CSG_Table *pTable; //----------------------------------------------------- pTable = Parameters("TABLE") ->asTable(); m_pNoGaps = Parameters("NOGAPS") ->asTable(); m_fOrder = Parameters("ORDER") ->asInt(); Method = Parameters("METHOD") ->asInt(); if( pTable->Get_Count() == 0 || !pTable->Set_Index(m_fOrder, TABLE_INDEX_Ascending) ) { return( false ); } //----------------------------------------------------- CSG_Table_Record *pA, *pB; m_pNoGaps->Create(pTable); m_pNoGaps->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pTable->Get_Name(), _TL("no gaps"))); m_pNoGaps->Add_Record(pB = pTable->Get_Record(0)); //----------------------------------------------------- for(int iRecord=1; iRecord<pTable->Get_Count() && Set_Progress(iRecord, pTable->Get_Count()-1); iRecord++) { pA = pB; pB = pTable->Get_Record(iRecord); int iA = pA->asInt(m_fOrder); int iB = pB->asInt(m_fOrder); if( iB - iA > 1 ) { int iStart = m_pNoGaps->Get_Count(); for(int i=iA+1; i<iB; i++) { m_pNoGaps->Add_Record()->Set_Value(m_fOrder, i); } for(int iField=0; iField<pTable->Get_Field_Count(); iField++) { if( iField != m_fOrder && ::SG_Data_Type_is_Numeric(pTable->Get_Field_Type(iField)) ) { switch( Method ) { case 0: Set_Nearest (iStart, iField, pA, pB); break; case 1: Set_Linear (iStart, iField, pA, pB); break; case 2: Set_Spline (iStart, iField, pTable->Get_Record(iRecord - 2), pA, pB, pTable->Get_Record(iRecord + 1)); break; } } } } m_pNoGaps->Add_Record(pB); } //----------------------------------------------------- return( true ); }
//--------------------------------------------------------- bool CGrid_Value_Replace::On_Execute(void) { //----------------------------------------------------- CSG_Grid *pGrid = Parameters("OUTPUT")->asGrid(); if( !pGrid || pGrid == Parameters("INPUT")->asGrid() ) { pGrid = Parameters("INPUT")->asGrid(); } else { pGrid->Assign(Parameters("INPUT")->asGrid()); DataObject_Set_Parameters(pGrid, Parameters("INPUT")->asGrid()); pGrid->Fmt_Name("%s [%s]", Parameters("INPUT")->asGrid()->Get_Name(), _TL("Changed")); } //----------------------------------------------------- int Method = Parameters("METHOD")->asInt(); CSG_Table LUT; switch( Method ) { default: LUT.Create(*Parameters("IDENTITY")->asTable()); break; case 1: LUT.Create(*Parameters("RANGE" )->asTable()); break; case 2: LUT.Create( Parameters("RANGE" )->asTable()); if( SG_UI_Get_Window_Main() // gui only && DataObject_Get_Parameter(Parameters("GRID" )->asGrid(), "LUT") && DataObject_Get_Parameter(Parameters("INPUT")->asGrid(), "LUT") ) { CSG_Table LUTs[2]; LUTs[0].Create(*DataObject_Get_Parameter(Parameters("GRID" )->asGrid(), "LUT")->asTable()); LUTs[1].Create(*DataObject_Get_Parameter(Parameters("INPUT")->asGrid(), "LUT")->asTable()); for(int i=0; i<LUTs[0].Get_Count(); i++) { CSG_String Name = LUTs[0][i].asString(1); for(int j=LUTs[1].Get_Count()-1; j>=0; j--) { if( !Name.Cmp(LUTs[1][j].asString(1)) ) { CSG_Table_Record *pReplace = LUT.Add_Record(); pReplace->Set_Value(0, LUTs[0][i].asDouble(3)); pReplace->Set_Value(1, LUTs[1][j].asDouble(3)); pReplace->Set_Value(2, LUTs[1][j].asDouble(4)); LUTs[1].Del_Record(j); break; } } } for(int j=0; j<LUTs[1].Get_Count(); j++) { LUTs[0].Add_Record(LUTs[1].Get_Record(j)); } DataObject_Add(pGrid); CSG_Parameter *pLUT = DataObject_Get_Parameter(pGrid, "LUT"); pLUT->asTable()->Assign_Values(&LUTs[0]); DataObject_Set_Parameter(pGrid, pLUT); } break; } //----------------------------------------------------- if( LUT.Get_Count() == 0 ) { Error_Set(_TL("empty look-up table, nothing to replace")); return( false ); } //----------------------------------------------------- for(int y=0; y<Get_NY() && Set_Progress(y); y++) { #ifndef _DEBUG #pragma omp parallel for #endif for(int x=0; x<Get_NX(); x++) { double Value = pGrid->asDouble(x, y); for(int i=0; i<LUT.Get_Count(); i++) { if( Method == 0 ) { if( LUT[i].asDouble(1) == Value ) { pGrid->Set_Value(x, y, LUT[i].asDouble(0)); break; } } else { if( LUT[i].asDouble(1) <= Value && Value <= LUT[i].asDouble(2) ) { pGrid->Set_Value(x, y, LUT[i].asDouble(0)); break; } } } } } //----------------------------------------------------- if( pGrid == Parameters("INPUT")->asGrid() ) { DataObject_Update(pGrid); } return( true ); }
//--------------------------------------------------------- bool CSG_ODBC_Connection::Table_Insert(const CSG_String &Table_Name, const CSG_Table &Table, bool bCommit) { //----------------------------------------------------- if( !is_Connected() ) { _Error_Message(_TL("no database connection")); return( false ); } if( !Table_Exists(Table_Name) ) { return( false ); } CSG_Table Fields = Get_Field_Desc(Table_Name); if( Fields.Get_Count() != Table.Get_Field_Count() ) { return( false ); } //----------------------------------------------------- try { bool bLOB = false; int iField, iRecord; CSG_String Insert; otl_stream Stream; //------------------------------------------------- Insert.Printf(SG_T("INSERT INTO %s VALUES("), Table_Name.c_str()); for(iField=0; iField<Table.Get_Field_Count(); iField++) { if( iField > 0 ) { Insert += SG_T(","); } Insert += CSG_String::Format(SG_T(":f%d"), 1 + iField); switch( Table.Get_Field_Type(iField) ) { default: case SG_DATATYPE_String: Insert += SG_T("<varchar>"); break; case SG_DATATYPE_Date: Insert += SG_T("<char[12]>"); break; case SG_DATATYPE_Char: Insert += SG_T("<char>"); break; case SG_DATATYPE_Short: Insert += SG_T("<short>"); break; case SG_DATATYPE_Int: Insert += SG_T("<int>"); break; case SG_DATATYPE_Color: Insert += SG_T("<long>"); break; case SG_DATATYPE_Long: Insert += SG_T("<long>"); break; case SG_DATATYPE_Float: Insert += SG_T("<float>"); break; case SG_DATATYPE_Double: Insert += SG_T("<double>"); break; } } Insert += SG_T(")"); Stream.set_all_column_types(otl_all_date2str); Stream.set_lob_stream_mode(bLOB); Stream.open(bLOB ? 1 : m_Size_Buffer, Insert, m_Connection); std_string valString; //------------------------------------------------- for(iRecord=0; iRecord<Table.Get_Count() && SG_UI_Process_Set_Progress(iRecord, Table.Get_Count()); iRecord++) { CSG_Table_Record *pRecord = Table.Get_Record(iRecord); for(iField=0; iField<Table.Get_Field_Count(); iField++) { if( pRecord->is_NoData(iField) ) { Stream << otl_null(); } else switch( Table.Get_Field_Type(iField) ) { default: case SG_DATATYPE_String: case SG_DATATYPE_Date: valString = CSG_String(pRecord->asString(iField)); Stream << valString; break; case SG_DATATYPE_Char: Stream << (char)pRecord->asChar (iField); break; case SG_DATATYPE_Short: Stream << pRecord->asShort (iField); break; case SG_DATATYPE_Int: Stream << pRecord->asInt (iField); break; case SG_DATATYPE_Color: case SG_DATATYPE_Long: Stream << (long)pRecord->asInt (iField); break; case SG_DATATYPE_Float: Stream << pRecord->asFloat (iField); break; case SG_DATATYPE_Double: Stream << pRecord->asDouble(iField); break; } } } } //----------------------------------------------------- catch( otl_exception &e ) { _Error_Message(e); return( false ); } return( true ); }
//--------------------------------------------------------- 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 CLine_Dissolve::On_Execute(void) { CSG_Shapes *pLines = Parameters("LINES")->asShapes(); if( !pLines->is_Valid() || pLines->Get_Count() < 2 ) { Error_Set(_TL("invalid or empty lines layer")); return( false ); } //----------------------------------------------------- CSG_Shapes *pDissolved = Parameters("DISSOLVED")->asShapes(); pDissolved->Create(SHAPE_TYPE_Line); CSG_Parameter_Table_Fields &Fields = *Parameters("FIELDS")->asTableFields(); CSG_Table Dissolve; //----------------------------------------------------- if( Fields.Get_Count() == 0 ) { pDissolved->Fmt_Name("%s [%s]", pLines->Get_Name(), _TL("Dissolved")); } else { Dissolve.Add_Field("INDEX", SG_DATATYPE_Int ); Dissolve.Add_Field("VALUE", SG_DATATYPE_String); Dissolve.Set_Record_Count(pLines->Get_Count()); for(int i=0; i<pLines->Get_Count() && Set_Progress(i, pLines->Get_Count()); i++) { CSG_Shape *pLine = pLines->Get_Shape(i); CSG_String Value; for(int iField=0; iField<Fields.Get_Count(); iField++) { Value += pLine->asString(Fields.Get_Index(iField)); } Dissolve[i].Set_Value(0, i); Dissolve[i].Set_Value(1, Value); } Dissolve.Set_Index(1, TABLE_INDEX_Ascending); //------------------------------------------------- CSG_String Name; for(int iField=0; iField<Fields.Get_Count(); iField++) { if( iField > 0 ) { Name += "; "; } Name += pLines->Get_Field_Name(Fields.Get_Index(iField)); pDissolved->Add_Field( pLines->Get_Field_Name(Fields.Get_Index(iField)), pLines->Get_Field_Type(Fields.Get_Index(iField)) ); } pDissolved->Fmt_Name("%s [%s: %s]", pLines->Get_Name(), _TL("Dissolved"), Name.c_str()); } //----------------------------------------------------- Statistics_Initialize(pDissolved, pLines); //----------------------------------------------------- CSG_String Value; CSG_Shape *pDissolve = NULL; for(int i=0; i<pLines->Get_Count() && Set_Progress(i, pLines->Get_Count()); i++) { CSG_Shape *pLine = pLines->Get_Shape(!Dissolve.Get_Count() ? i : Dissolve[i].asInt(0)); if( !pDissolve || (Dissolve.Get_Count() && Value.Cmp(Dissolve[i].asString(1))) ) { if( Dissolve.Get_Count() ) { Value = Dissolve[i].asString(1); } pDissolve = pDissolved->Add_Shape(pLine, SHAPE_COPY_GEOM); for(int iField=0; iField<Fields.Get_Count(); iField++) { *pDissolve->Get_Value(iField) = *pLine->Get_Value(Fields.Get_Index(iField)); } Statistics_Add(pDissolve, pLine, true); } else { Add_Line(pDissolve, pLine); Statistics_Add(pDissolve, pLine, false); } } //----------------------------------------------------- return( pDissolved->is_Valid() ); }
//--------------------------------------------------------- bool CTable_Record_Statistics_Base::On_Execute(void) { //----------------------------------------------------- CSG_Table *pTable = Parameters("TABLE")->asTable(); if( !pTable->is_Valid() || pTable->Get_Field_Count() <= 0 || pTable->Get_Record_Count() <= 0 ) { Error_Set(_TL("invalid table")); return( false ); } //----------------------------------------------------- CSG_Array_Int _Fields; int *Fields = (int *)Parameters("FIELDS")->asPointer(); int nFields = Parameters("FIELDS")->asInt (); if( nFields == 0 ) { for(int i=0; i<pTable->Get_Field_Count(); i++) { if( SG_Data_Type_is_Numeric(pTable->Get_Field_Type(i)) ) { _Fields.Inc_Array(); _Fields[nFields++] = i; } } if( nFields == 0 ) { Error_Set(_TL("could not find any numeric attribute field")); return( false ); } Fields = _Fields.Get_Array(); } //----------------------------------------------------- if( Parameters("RESULT")->asTable() && Parameters("RESULT")->asTable() != pTable ) { pTable = Parameters("RESULT")->asTable(); pTable->Create( *Parameters("TABLE")->asTable()); pTable->Set_Name(Parameters("TABLE")->asTable()->Get_Name()); } //----------------------------------------------------- double Quantile = Parameters("PCTL_VAL")->asDouble(); int offResult = pTable->Get_Field_Count(); bool bStats[STATS_COUNT]; { for(int i=0; i<STATS_COUNT; i++) { if( (bStats[i] = Parameters(STATS[i][0])->asBool()) == true ) { pTable->Add_Field(STATS[i][1], SG_DATATYPE_Double); } } if( pTable->Get_Field_Count() == offResult ) { Error_Set(_TL("no statistical measure has been selected")); return( false ); } } //----------------------------------------------------- for(int iRecord=0; iRecord<pTable->Get_Count() && Set_Progress(iRecord, pTable->Get_Count()); iRecord++) { CSG_Table_Record *pRecord = pTable->Get_Record(iRecord); CSG_Simple_Statistics s(bStats[STATS_PCTL]); for(int iField=0; iField<nFields; iField++) { if( !pRecord->is_NoData(Fields[iField]) ) { s += pRecord->asDouble(Fields[iField]); } } //------------------------------------------------- int iField = offResult; if( s.Get_Count() > 0 ) { if( bStats[STATS_MEAN ] ) pRecord->Set_Value(iField++, s.Get_Mean ()); if( bStats[STATS_MIN ] ) pRecord->Set_Value(iField++, s.Get_Minimum ()); if( bStats[STATS_MAX ] ) pRecord->Set_Value(iField++, s.Get_Maximum ()); if( bStats[STATS_RANGE] ) pRecord->Set_Value(iField++, s.Get_Range ()); if( bStats[STATS_SUM ] ) pRecord->Set_Value(iField++, s.Get_Sum ()); if( bStats[STATS_NUM ] ) pRecord->Set_Value(iField++, s.Get_Count ()); if( bStats[STATS_VAR ] ) pRecord->Set_Value(iField++, s.Get_Variance()); if( bStats[STATS_STDV ] ) pRecord->Set_Value(iField++, s.Get_StdDev ()); if( bStats[STATS_PCTL ] ) pRecord->Set_Value(iField++, s.Get_Quantile(Quantile)); } else { for(int i=0; i<STATS_COUNT; i++) { if( bStats[i] ) { pRecord->Set_NoData(iField++); } } } } //----------------------------------------------------- if( pTable == Parameters("TABLE")->asTable() ) { DataObject_Update(pTable); } return( true ); }
//--------------------------------------------------------- bool CChange_Detection::Get_Classes(CSG_Table &Classes, CSG_Grid *pGrid, bool bInitial) { CSG_Table *pClasses; Classes.Destroy(); Classes.Add_Field(_TL("NAME") , SG_DATATYPE_String); Classes.Add_Field(_TL("MIN") , SG_DATATYPE_Double); Classes.Add_Field(_TL("MAX") , SG_DATATYPE_Double); //----------------------------------------------------- if( (pClasses = Parameters(bInitial ? "INI_LUT" : "FIN_LUT")->asTable()) != NULL ) { int fNam = Parameters(bInitial ? "INI_LUT_NAM" : "FIN_LUT_NAM")->asInt(); int fMin = Parameters(bInitial ? "INI_LUT_MIN" : "FIN_LUT_MIN")->asInt(); int fMax = Parameters(bInitial ? "INI_LUT_MAX" : "FIN_LUT_MAX")->asInt(); if( fNam < 0 || fNam >= pClasses->Get_Field_Count() ) { fNam = fMin; } if( fMax < 0 || fMax >= pClasses->Get_Field_Count() ) { fMax = fMin; } for(int iClass=0; iClass<pClasses->Get_Count(); iClass++) { CSG_Table_Record *pClass = Classes.Add_Record(); pClass->Set_Value(CLASS_NAM, pClasses->Get_Record(iClass)->asString(fNam)); pClass->Set_Value(CLASS_MIN, pClasses->Get_Record(iClass)->asDouble(fMin)); pClass->Set_Value(CLASS_MAX, pClasses->Get_Record(iClass)->asDouble(fMax)); } } //----------------------------------------------------- else if( DataObject_Get_Parameter(pGrid, "LUT") ) { pClasses = DataObject_Get_Parameter(pGrid, "LUT")->asTable(); for(int iClass=0; iClass<pClasses->Get_Count(); iClass++) { CSG_Table_Record *pClass = Classes.Add_Record(); pClass->Set_Value(CLASS_NAM, pClasses->Get_Record(iClass)->asString(1)); pClass->Set_Value(CLASS_MIN, pClasses->Get_Record(iClass)->asDouble(3)); pClass->Set_Value(CLASS_MAX, pClasses->Get_Record(iClass)->asDouble(4)); } } //----------------------------------------------------- else { double z; for(sLong i=0; i<Get_NCells() && Set_Progress_NCells(i); i++) { double iz = pGrid->asDouble(pGrid->Get_Sorted(i, false, false)); if( i == 0 || iz != z ) { CSG_Table_Record *pClass = Classes.Add_Record(); pClass->Set_Value(CLASS_NAM, z = iz); pClass->Set_Value(CLASS_MIN, z); pClass->Set_Value(CLASS_MAX, z); } } } //----------------------------------------------------- return( Classes.Get_Count() > 0 ); }
//--------------------------------------------------------- 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 CGridsFromTableAndGrid::On_Execute(void) { int iField, iRecord, iAttribute, nAttributes, *Attribute; sLong iCell, jCell; CSG_Parameter_Grid_List *pGrids; CSG_Grid *pClasses; CSG_Table *pTable; //----------------------------------------------------- pClasses = Parameters("CLASSES" )->asGrid(); pGrids = Parameters("GRIDS" )->asGridList(); pTable = Parameters("TABLE" )->asTable(); iField = Parameters("ID_FIELD")->asInt(); pGrids->Del_Items(); if( !pClasses->Set_Index() ) { Error_Set(_TL("index creation failed")); return( false ); } //----------------------------------------------------- if( pTable->Get_Field_Count() == 0 || pTable->Get_Count() == 0 ) { Message_Add(_TL("selected table contains no valid records")); return( false ); } //----------------------------------------------------- if( !pTable->Set_Index(iField, TABLE_INDEX_Ascending) ) { Message_Add(_TL("failed to create index for table")); return( false ); } //----------------------------------------------------- Attribute = new int[pTable->Get_Field_Count()]; for(iAttribute=0, nAttributes=0; iAttribute<pTable->Get_Field_Count(); iAttribute++) { if( iAttribute != iField && pTable->Get_Field_Type(iAttribute) != SG_DATATYPE_String ) { Attribute[nAttributes++] = iAttribute; CSG_Grid *pGrid = SG_Create_Grid(*Get_System()); pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pClasses->Get_Name(), pTable->Get_Field_Name(iAttribute))); pGrids->Add_Item(pGrid); } } if( nAttributes == 0 ) { delete[](Attribute); Message_Add(_TL("selected table does not have numeric attributes")); return( false ); } //----------------------------------------------------- CSG_Table_Record *pRecord = pTable->Get_Record_byIndex(0); for(iCell=0, iRecord=0; iCell<Get_NCells() && pRecord && Set_Progress_NCells(iCell); iCell++) { if( pClasses->Get_Sorted(iCell, jCell, false, true) ) { double valClass = pClasses->asDouble(jCell); while( pRecord && pRecord->asDouble(iField) < valClass ) { pRecord = pTable->Get_Record_byIndex(++iRecord); } if( !pRecord || pRecord->asDouble(iField) > valClass ) { for(iAttribute=0; iAttribute<nAttributes; iAttribute++) { pGrids->asGrid(iAttribute)->Set_NoData(jCell); } } else { for(iAttribute=0; iAttribute<nAttributes; iAttribute++) { pGrids->asGrid(iAttribute)->Set_Value(jCell, pRecord->asDouble(Attribute[iAttribute])); } } } } //----------------------------------------------------- delete[](Attribute); return true; }