//--------------------------------------------------------- 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 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 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 ); }
//--------------------------------------------------------- bool DLG_Table_Fields(const wxString &Caption, CSG_Parameter_Table_Fields *pFields) { CSG_Table *pTable = pFields->Get_Table(); if( pTable ) { int i; CSG_Parameters P; for(i=0; i<pTable->Get_Field_Count(); i++) { P.Add_Value(NULL, SG_Get_String(i), pTable->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false); } for(i=0; i<pFields->Get_Count(); i++) { CSG_Parameter *pParameter = P(pFields->Get_Index(i)); if( pParameter ) { pParameter->Set_Value(true); } } if( DLG_Parameters(&P) ) { CSG_String s; for(i=0; i<pTable->Get_Field_Count(); i++) { if( P(i)->asBool() ) { s += CSG_String::Format(s.Length() ? SG_T(",%d") : SG_T("%d"), i); } } pFields->Set_Value(s); return( true ); } } return( false ); }
//--------------------------------------------------------- int CTable_PCA::On_Parameter_Changed(CSG_Parameters *pParameters, CSG_Parameter *pParameter) { if( !SG_STR_CMP(pParameter->Get_Identifier(), SG_T("TABLE")) ) { CSG_Table *pTable = pParameter->asTable(); CSG_Parameters *pFields = pParameters->Get_Parameter("FIELDS")->asParameters(); pFields->Del_Parameters(); if( pTable && pTable->Get_Field_Count() > 0 ) { for(int i=0; i<pTable->Get_Field_Count(); i++) { if( SG_Data_Type_is_Numeric(pTable->Get_Field_Type(i)) ) { pFields->Add_Value(NULL, CSG_String::Format(SG_T("%d"), i), pTable->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false); } } } } return( 0 ); }
//--------------------------------------------------------- bool CSG_ODBC_Connection::Table_Create(const CSG_String &Table_Name, const CSG_Table &Table, const CSG_Buffer &Flags, bool bCommit) { if( Table.Get_Field_Count() <= 0 ) { _Error_Message(_TL("no attributes in table")); return( false ); } //----------------------------------------------------- int iField; CSG_String SQL; SQL.Printf(SG_T("CREATE TABLE \"%s\"("), Table_Name.c_str()); for(iField=0; iField<Table.Get_Field_Count(); iField++) { CSG_String s; switch( Table.Get_Field_Type(iField) ) { default: case SG_DATATYPE_String: s = CSG_String::Format(SG_T("VARCHAR(%d)"), Table.Get_Field_Length(iField)); break; case SG_DATATYPE_Char: s = SG_T("SMALLINT"); break; case SG_DATATYPE_Short: s = SG_T("SMALLINT"); break; case SG_DATATYPE_Int: s = SG_T("INT"); break; case SG_DATATYPE_Color: s = SG_T("INT"); break; case SG_DATATYPE_Long: s = SG_T("INT"); break; case SG_DATATYPE_Float: s = SG_T("FLOAT"); break; case SG_DATATYPE_Double: s = is_PostgreSQL() ? SG_T("DOUBLE PRECISION") : SG_T("DOUBLE"); break; case SG_DATATYPE_Binary: s = is_PostgreSQL() ? SG_T("BYTEA") : is_Access() ? SG_T("IMAGE") : SG_T("VARBINARY"); break; } //------------------------------------------------- char Flag = (int)Flags.Get_Size() == Table.Get_Field_Count() ? Flags[iField] : 0; if( (Flag & SG_ODBC_PRIMARY_KEY) == 0 ) { if( (Flag & SG_ODBC_UNIQUE) != 0 ) { s += SG_T(" UNIQUE"); } if( (Flag & SG_ODBC_NOT_NULL) != 0 ) { s += SG_T(" NOT NULL"); } } //------------------------------------------------- if( iField > 0 ) { SQL += SG_T(", "); } SQL += CSG_String::Format(SG_T("%s %s"), Table.Get_Field_Name(iField), s.c_str()); } //----------------------------------------------------- if( (int)Flags.Get_Size() == Table.Get_Field_Count() ) { CSG_String s; for(iField=0; iField<Table.Get_Field_Count(); iField++) { if( (Flags[iField] & SG_ODBC_PRIMARY_KEY) != 0 ) { s += s.Length() == 0 ? SG_T(", PRIMARY KEY(") : SG_T(", "); s += Table.Get_Field_Name(iField); } } if( s.Length() > 0 ) { SQL += s + SG_T(")"); } } //----------------------------------------------------- SQL += SG_T(")"); //----------------------------------------------------- return( Execute(SQL, bCommit) ); }
//--------------------------------------------------------- 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; }
//--------------------------------------------------------- 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_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_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 ); }