//--------------------------------------------------------- void CDXF_Import::addLayer(const DL_LayerData &data) { CSG_Table_Record *pRecord = m_pLayers->Add_Record(); pRecord->Set_Value(TBL_LAYERS_NAME , CSG_String(data.name.c_str())); pRecord->Set_Value(TBL_LAYERS_FLAGS , data.flags); }
//--------------------------------------------------------- void CVIEW_ScatterPlot::On_AsTable(wxCommandEvent &event) { if( m_Trend.Get_Data_Count() > 1 ) { CSG_Table *pTable = new CSG_Table; pTable->Fmt_Name("%s: [%s]-[%s]", _TL("Scatterplot"), m_sX.c_str(), m_sY.c_str()); pTable->Add_Field("ID", SG_DATATYPE_Int ); pTable->Add_Field(m_sX, SG_DATATYPE_Double); pTable->Add_Field(m_sY, SG_DATATYPE_Double); for(int i=0; i<m_Trend.Get_Data_Count() && PROGRESSBAR_Set_Position(i, m_Trend.Get_Data_Count()); i++) { CSG_Table_Record *pRecord = pTable->Add_Record(); pRecord->Set_Value(0, i + 1); pRecord->Set_Value(1, m_Trend.Get_Data_X(i)); pRecord->Set_Value(2, m_Trend.Get_Data_Y(i)); } PROGRESSBAR_Set_Position(0); g_pData->Add(pTable); } }
//--------------------------------------------------------- bool CKinWav_D8::Gauges_Set_Flow(double Time) { if( m_pGauges_Flow && m_pGauges_Flow->Get_Field_Count() == m_pGauges->Get_Count() + 1 ) { CSG_Table_Record *pRecord = m_pGauges_Flow->Add_Record(); pRecord->Set_Value(0, Time); for(int i=0; i<m_pGauges->Get_Count(); i++) { double Flow; if( m_pFlow->Get_Value(m_pGauges->Get_Shape(i)->Get_Point(0), Flow) ) { pRecord->Set_Value(i + 1, Flow); } } DataObject_Update(m_pGauges_Flow); return( true ); } return( false ); }
//--------------------------------------------------------- int CDecision_Tree::Get_Class(CSG_Parameters *pDecision, CSG_Table *pTable) { CSG_String ID_Root = pDecision->Get_Identifier(); if( !ID_Root.Cmp(SG_T("ROOT")) ) ID_Root.Clear(); for(int Child=0; Child<=1; Child++) { CSG_String ID = ID_Root + (Child == 0 ? SG_T("A") : SG_T("B")); if( pDecision->Get_Parameter(ID + SG_T("|NODE"))->asBool() ) { Get_Class(pDecision->Get_Parameter(ID)->asParameters(), pTable); } else { CSG_Table_Record *pRecord = pTable->Add_Record(); pRecord->Set_Value(0, SG_GET_RGB(rand() * 255.0 / RAND_MAX, rand() * 255.0 / RAND_MAX, rand() * 255.0 / RAND_MAX)); pRecord->Set_Value(1, pDecision->Get_Parameter(ID + SG_T("|NAME"))->asString()); pRecord->Set_Value(2, pDecision->Get_Parameter(ID + SG_T("|NAME"))->asString()); pRecord->Set_Value(3, Get_Class(ID)); pRecord->Set_Value(4, Get_Class(ID)); } } return( pTable->Get_Count() ); }
//--------------------------------------------------------- bool CWKSP_Shapes::Edit_Set_Index(int Index) { m_Edit_Attributes.Del_Records(); if( Index > Get_Shapes()->Get_Selection_Count() ) { Index = Get_Shapes()->Get_Selection_Count(); } CSG_Table_Record *pSelection = Get_Shapes()->Get_Selection(Index); if( pSelection ) { m_Edit_Index = Index; for(int i=0; i<Get_Shapes()->Get_Field_Count(); i++) { CSG_Table_Record *pRecord = m_Edit_Attributes.Add_Record(); pRecord->Set_Value(0, pSelection->Get_Table()->Get_Field_Name(i)); pRecord->Set_Value(1, pSelection->asString(i)); } } else { m_Edit_Index = 0; } return( true ); }
//--------------------------------------------------------- bool CMine_Sweeper::MakeBoard(int level) { int i, x, y; CSG_Colors Colors; switch( level ) { case 0: Mine_NX = 8; Mine_NY = 8; N_Mines=10; break; case 1: Mine_NX = 16; Mine_NY = 16; N_Mines=40; break; case 2: Mine_NX = 30; Mine_NY = 16; N_Mines=99; break; } pInput = SG_Create_Grid(SG_DATATYPE_Int,SPRITE_SIZE*Mine_NX, SPRITE_SIZE*Mine_NY); pInput->Set_Name(_TL("Mine Sweeper")); Parameters("GRID")->Set_Value(pInput); //----------------------------------------------------- CSG_Parameter *pLUT = DataObject_Get_Parameter(pInput, "LUT"); if( pLUT && pLUT->asTable() ) { pLUT->asTable()->Del_Records(); for(i=0; i<16; i++) { CSG_Table_Record *pRecord = pLUT->asTable()->Add_Record(); pRecord->Set_Value(0, SG_GET_RGB(mine_res_color[i*3], mine_res_color[i*3+1], mine_res_color[i*3+2])); pRecord->Set_Value(3, i); } DataObject_Set_Parameter(pInput, pLUT); DataObject_Set_Parameter(pInput, "COLORS_TYPE", 1); // Color Classification Type: Lookup Table } Colors.Set_Count(16); for ( i=0;i<16; i++) { Colors.Set_Color(i, SG_GET_RGB(mine_res_color[i*3], mine_res_color[i*3+1], mine_res_color[i*3+2])); } DataObject_Set_Colors(pInput, Colors); DataObject_Update(pInput, 0.0, 15.0, true); //----------------------------------------------------- for( y = 0; y < Mine_NY; y++) for( x = 0; x < Mine_NX; x++) { SetSprite(x,y,SPRITE_CLOSE); } pInput->Set_Value(0, 0); return true; }
//--------------------------------------------------------- void CGrid_Cluster_Analysis::Save_Statistics(CSG_Parameter_Grid_List *pGrids, bool bNormalize, const CSG_Cluster_Analysis &Analysis) { int iCluster, iFeature; CSG_String s; CSG_Table *pTable = Parameters("STATISTICS")->asTable(); pTable->Destroy(); pTable->Set_Name(_TL("Cluster Analysis")); pTable->Add_Field(_TL("ClusterID") , SG_DATATYPE_Int); pTable->Add_Field(_TL("Elements") , SG_DATATYPE_Int); pTable->Add_Field(_TL("Std.Dev.") , SG_DATATYPE_Double); s.Printf(SG_T("\n%s:\t%d \n%s:\t%ld \n%s:\t%d \n%s:\t%d \n%s:\t%f\n\n%s\t%s\t%s"), _TL("Number of Iterations") , Analysis.Get_Iteration(), _TL("Number of Elements") , Analysis.Get_nElements(), _TL("Number of Variables") , Analysis.Get_nFeatures(), _TL("Number of Clusters") , Analysis.Get_nClusters(), _TL("Standard Deviation") , sqrt(Analysis.Get_SP()), _TL("Cluster"), _TL("Elements"), _TL("Std.Dev.") ); for(iFeature=0; iFeature<Analysis.Get_nFeatures(); iFeature++) { s += CSG_String::Format(SG_T("\t%s"), pGrids->asGrid(iFeature)->Get_Name()); pTable->Add_Field(pGrids->asGrid(iFeature)->Get_Name(), SG_DATATYPE_Double); } Message_Add(s); for(iCluster=0; iCluster<Analysis.Get_nClusters(); iCluster++) { s.Printf(SG_T("\n%d\t%d\t%f"), iCluster, Analysis.Get_nMembers(iCluster), sqrt(Analysis.Get_Variance(iCluster))); CSG_Table_Record *pRecord = pTable->Add_Record(); pRecord->Set_Value(0, iCluster); pRecord->Set_Value(1, Analysis.Get_nMembers(iCluster)); pRecord->Set_Value(2, sqrt(Analysis.Get_Variance(iCluster))); for(iFeature=0; iFeature<Analysis.Get_nFeatures(); iFeature++) { double Centroid = Analysis.Get_Centroid(iCluster, iFeature); if( bNormalize ) { Centroid = pGrids->asGrid(iFeature)->Get_Mean() + Centroid * pGrids->asGrid(iFeature)->Get_StdDev(); } s += CSG_String::Format(SG_T("\t%f"), Centroid); pRecord->Set_Value(iFeature + 3, Centroid); } Message_Add(s, false); } }
//--------------------------------------------------------- void CDXF_Import::addBlock(const DL_BlockData &data) { CSG_Table_Record *pRecord = m_pBlocks->Add_Record(); pRecord->Set_Value(TBL_BLOCKS_NAME , CSG_String(data.name.c_str())); pRecord->Set_Value(TBL_BLOCKS_FLAGS , data.flags); pRecord->Set_Value(TBL_BLOCKS_X , data.bpx); pRecord->Set_Value(TBL_BLOCKS_Y , data.bpy); pRecord->Set_Value(TBL_BLOCKS_Z , data.bpz); }
bool Add_Edge (int ID, double Direction) { CSG_Table_Record *pEdge = m_Edges.Add_Record(); pEdge->Set_Value(0, ID); pEdge->Set_Value(1, Direction); m_Edges.Set_Index(1, TABLE_INDEX_Ascending); return( true ); }
//--------------------------------------------------------- void CPC_Cluster_Analysis::Write_Result(CSG_Table *pTable, long nElements, int nCluster, double SP) { CSG_String s; CSG_Table_Record *pRecord; pTable->Destroy(); s = CSG_String::Format(_TL("Cluster Analysis PC")); s += CSG_String::Format(SG_T("_%s"), pInput->Get_Name()); pTable->Set_Name(s); pTable->Add_Field(_TL("ClusterID") , SG_DATATYPE_Int); pTable->Add_Field(_TL("Elements") , SG_DATATYPE_Int); pTable->Add_Field(_TL("Variance") , SG_DATATYPE_Double); s.Printf(SG_T("\n%s:\t%ld \n%s:\t%d \n%s:\t%d \n%s:\t%f"), _TL("Number of Elements") , nElements, _TL("\nNumber of Variables") , m_nFeatures, _TL("\nNumber of Clusters") , nCluster, _TL("\nValue of Target Function") , SP ); s.Append(CSG_String::Format(SG_T("%s\t%s\t%s"), _TL("Cluster"), _TL("Elements"), _TL("Variance"))); for( int j=0; j<m_nFeatures; j++ ) { s.Append(CSG_String::Format(SG_T("\t%02d_%s"), j + 1, pInput->Get_Field_Name(m_Features[j]))); pTable->Add_Field(pInput->Get_Field_Name(m_Features[j]), SG_DATATYPE_Double); } Message_Add(s); for( int i=0; i<nCluster; i++ ) { s.Printf(SG_T("%d\t%d\t%f"), i, nMembers[i], Variances[i]); pRecord = pTable->Add_Record(); pRecord->Set_Value(0, i); pRecord->Set_Value(1, nMembers[i]); pRecord->Set_Value(2, Variances[i]); for( int j=0; j<m_nFeatures; j++ ) { s.Append(CSG_String::Format(SG_T("\t%f"), Centroids[i][j])); pRecord->Set_Value(j + 3, Centroids[i][j]); } Message_Add(s); } }
//--------------------------------------------------------- bool CTable_List::On_Execute(void) { CSG_Table *pTables = Parameters("TABLES")->asTable(); pTables->Destroy(); pTables->Set_Name(_TL("Tables")); pTables->Add_Field(_TL("Table"), SG_DATATYPE_String); if( Get_Connection() ) { CSG_Strings Tables; Get_Connection()->Get_Tables(Tables); for(int i=0; i<Tables.Get_Count(); i++) { CSG_Table_Record *pTable = pTables->Add_Record(); pTable->Set_Value(0, Tables[i]); } pTables->Set_Name(Get_Connection()->Get_Server() + " [" + _TL("Tables") + "]"); return( true ); } return( false ); }
//--------------------------------------------------------- bool CBifurcation::On_Execute(void) { int i; double p, r, dr, max, min, seed, nValues, nPreIterations; CSG_Table_Record *pRecord; CSG_Table *pTable; nPreIterations = Parameters("ITERATIONS")->asInt(); nValues = Parameters("NVALUES")->asInt(); seed = Parameters("SEED")->asDouble(); min = Parameters("RANGE")->asRange()->Get_Min(); max = Parameters("RANGE")->asRange()->Get_Max(); dr = (max - min) / 1000.0; pTable = Parameters("TABLE")->asTable(); pTable->Destroy(); pTable->Set_Name(_TL("Feigenbaum's Bifurcation")); pTable->Add_Field("Growth" , SG_DATATYPE_Double); for(i=0; i<nValues; i++) { pTable->Add_Field(CSG_String::Format(SG_T("VALUE_%d"), i + 1), SG_DATATYPE_Double); } for(r=min; r<=max; r+=dr) { pRecord = pTable->Add_Record(); pRecord->Set_Value(0, r); p = seed; for(i=0; i<nPreIterations; i++) { p = r * p * (1.0 - p); } for(i=0; i<nValues; i++) { p = r * p * (1.0 - p); pRecord->Set_Value(i + 1, p); } } return( true ); }
//--------------------------------------------------------- CSG_Table CSG_MetaData::asTable(int Flags) const { CSG_Table t; t.Add_Field("NAME" , SG_DATATYPE_String); t.Add_Field("VALUE", SG_DATATYPE_String); for(int i=0; i<Get_Children_Count(); i++) { CSG_Table_Record *r = t.Add_Record(); r->Set_Value(0, Get_Child(i)->Get_Name()); r->Set_Value(1, Get_Child(i)->Get_Content()); } return( t ); }
//--------------------------------------------------------- void CGrid_Cluster_Analysis::Save_LUT(CSG_Grid *pCluster) { CSG_Parameter *pLUT = DataObject_Get_Parameter(pCluster, "LUT"); if( pLUT && pLUT->asTable() ) { CSG_Parameter_Grid_List *pGrids = Parameters("GRIDS")->asGridList(); CSG_Table &Statistics = *Parameters("STATISTICS")->asTable(); bool bRGB = pGrids->Get_Count() >= 3 && Parameters("RGB_COLORS")->asBool(); for(int iCluster=0; iCluster<Statistics.Get_Count(); iCluster++) { CSG_Table_Record *pClass = pLUT->asTable()->Get_Record(iCluster); if( !pClass ) { (pClass = pLUT->asTable()->Add_Record())->Set_Value(0, SG_Color_Get_Random()); } pClass->Set_Value(1, CSG_String::Format("%s %d", _TL("Cluster"), iCluster + 1)); pClass->Set_Value(2, ""); pClass->Set_Value(3, iCluster + 1); pClass->Set_Value(4, iCluster + 1); if( bRGB ) { #define SET_COLOR_COMPONENT(c, i) c = (int)(127 + (Statistics[iCluster].asDouble(3 + i) - pGrids->asGrid(i)->Get_Mean()) * 127 / pGrids->asGrid(i)->Get_StdDev()); if( c < 0 ) c = 0; else if( c > 255 ) c = 255; int r; SET_COLOR_COMPONENT(r, 2); int g; SET_COLOR_COMPONENT(g, 1); int b; SET_COLOR_COMPONENT(b, 0); pClass->Set_Value(0, SG_GET_RGB(r, g, b)); } } pLUT->asTable()->Set_Record_Count(Statistics.Get_Count()); DataObject_Set_Parameter(pCluster, pLUT); DataObject_Set_Parameter(pCluster, "COLORS_TYPE", 1); // Color Classification Type: Lookup Table } }
//--------------------------------------------------------- void CVIEW_Table_Control::On_LClick(wxGridEvent &event) { int iField = m_Field_Offset + event.GetCol(); CSG_Table_Record *pRecord = m_pRecords[event.GetRow()]; //----------------------------------------------------- if( event.AltDown() ) { if( m_pTable->Get_Field_Type(iField) == SG_DATATYPE_String ) { if( event.ControlDown() ) { g_pData->Open (pRecord->asString(iField)); } else { Open_Application(pRecord->asString(iField)); } } } //----------------------------------------------------- else if( event.ControlDown() ) { m_pTable->Select(pRecord, true); Update_Selection(); } else if( event.ShiftDown() ) { SelectBlock(event.GetRow(), 0, GetGridCursorRow(), GetNumberCols(), false); } else { SelectRow(event.GetRow(), false); if( pRecord && iField >= m_Field_Offset && iField < m_pTable->Get_Field_Count() && m_pTable->Get_Field_Type(iField) == SG_DATATYPE_Color ) { long lValue; if( DLG_Color(lValue = pRecord->asInt(iField)) ) { pRecord->Set_Value(iField, lValue); SetCellBackgroundColour(event.GetRow(), event.GetCol(), Get_Color_asWX(pRecord->asInt(iField))); ForceRefresh(); } } } //----------------------------------------------------- SetGridCursor(event.GetRow(), event.GetCol()); }
CCombineGrids::CCombineGrids(void){ CSG_Table *pLookup; CSG_Table_Record *pRecord; Parameters.Set_Name(_TL("Combine Grids")); Parameters.Set_Description(_TW( "(c) 2005 by Victor Olaya.")); Parameters.Add_Grid(NULL, "GRID1", _TL("Grid 1"), _TL(""), PARAMETER_INPUT); Parameters.Add_Grid(NULL, "GRID2", _TL("Grid 2"), _TL(""), PARAMETER_INPUT); Parameters.Add_Grid(NULL, "RESULT", _TL("Result"), _TL(""), PARAMETER_OUTPUT); pLookup = Parameters.Add_FixedTable(NULL, "LOOKUP", _TL("LookUp Table"), _TL(""))->asTable(); pLookup->Add_Field(_TL("Value in Grid 1"), SG_DATATYPE_Double); pLookup->Add_Field(_TL("Value in Grid 2"), SG_DATATYPE_Double); pLookup->Add_Field(_TL("Resulting Value"), SG_DATATYPE_Double); pRecord = pLookup->Add_Record(); pRecord->Set_Value(0, 0.0); pRecord->Set_Value(1, 0.0); pRecord->Set_Value(2, 0.0); }//constructor
//--------------------------------------------------------- bool CTable_Enumerate::On_Execute(void) { int iField, iField_ID, iID, iRecord, old_Field; TSG_Table_Index_Order old_Order; CSG_String Value; CSG_Table *pTable, *pOutput; CSG_Table_Record *pRecord; //----------------------------------------------------- pTable = Parameters("INPUT") ->asTable(); pOutput = Parameters("OUTPUT") ->asTable(); iField = Parameters("FIELD") ->asInt(); //----------------------------------------------------- if( iField >= 0 && iField < pTable->Get_Field_Count() && pTable->Get_Record_Count() > 0 ) { if( pOutput != NULL && pOutput != pTable ) { pOutput->Create (*pTable); pOutput->Set_Name ( pTable->Get_Name()); pTable = pOutput; } //------------------------------------------------- pTable->Add_Field(_TL("ENUM_ID"), SG_DATATYPE_Int); iField_ID = pTable->Get_Field_Count() - 1; old_Order = pTable->Get_Index_Order(0); old_Field = pTable->Get_Index_Field(0); pTable->Set_Index(iField, TABLE_INDEX_Descending); Value = pTable->Get_Record_byIndex(0)->asString(iField); for(iRecord=0, iID=1; iRecord<pTable->Get_Record_Count(); iRecord++) { pRecord = pTable->Get_Record_byIndex(iRecord); if( Value.Cmp(pRecord->asString(iField)) ) { Value = pRecord->asString(iField); iID++; } pRecord->Set_Value(iField_ID, iID); } pTable->Set_Index(old_Field, old_Order); return( true ); } return( false ); }
void Cihacres_elev::_CreateTableSim() { int i = 0; // used in function Get_Record(i) CSG_Table_Record *pRecord; CSG_String tmpName; double sim_eb, sim; // creating the column titles m_pTable->Add_Field("Date", SG_DATATYPE_String); m_pTable->Add_Field("Flow_OBS", SG_DATATYPE_Double); for (int eb = 0; eb < m_nElevBands; eb++) { tmpName = SG_T("ELEVB_"); tmpName += convert_sl::Int2String(eb+1).c_str(); m_pTable->Add_Field(tmpName.c_str(), SG_DATATYPE_Double); } m_pTable->Add_Field(SG_T("Flow_SIM"), SG_DATATYPE_Double); for (int j = 0; j < m_nValues; j++) { m_pTable->Add_Record(); pRecord = m_pTable->Get_Record(i); // writing the data into the rows pRecord->Set_Value(0,CSG_String(m_vec_date[j].c_str())); pRecord->Set_Value(1,m_p_Q_obs_m3s[j]); sim_eb = 0.0; sim = 0.0; for (int eb = 0; eb < m_nElevBands; eb++) { sim_eb = model_tools::mmday_to_m3s(m_p_elevbands[eb].m_p_streamflow_sim[j],m_p_elevbands[eb].m_area); //pRecord->Set_Value(3+eb,model_tools::mmday_to_m3s(m_p_elevbands[eb].m_p_streamflow_sim[j],m_p_elevbands[eb].m_area)); pRecord->Set_Value(2+eb, sim_eb); sim += sim_eb; } pRecord->Set_Value(2+m_nElevBands,sim); i++; } }
//--------------------------------------------------------- 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 ); }
//--------------------------------------------------------- int CTL_Extract::Read_File(const SG_Char *File, CSG_Table &Elements) { //----------------------------------------------------- CSG_File Stream; if( !Stream.Open(File, SG_FILE_R, false) ) { return( 0 ); } Process_Set_Text(CSG_String::Format("%s: %s", SG_T("scanning"), File)); //----------------------------------------------------- CSG_String String, Text; if( !Stream.Read(String, Stream.Length()) ) { return( 0 ); } //----------------------------------------------------- const SG_Char Function[2][4] = { SG_T("_TL"), SG_T("_TW") }; const SG_Char *p = String; bool bLong = Parameters("LONG")->asBool(); while( *p != '\0' ) { if( !(p[0] == Function[0][0] && p[1] == Function[0][1] && p[2] == Function[0][2]) && !(p[0] == Function[1][0] && p[1] == Function[1][1] && p[2] == Function[1][2] && bLong) ) { p ++; } else { p += Read_Text(p, Text); if( Text.Length() > 0 ) { CSG_Table_Record *pRecord = Elements.Add_Record(); pRecord->Set_Value(0, Text); pRecord->Set_Value(1, File); } } } return( 1 ); }
//--------------------------------------------------------- bool CSG_Translator::Create(class CSG_Table *pTranslations, int iText, int iTranslation, bool bCmpNoCase) { SG_UI_Msg_Lock(true); Destroy(); if( iText != iTranslation && pTranslations && pTranslations->Get_Field_Count() > iText && pTranslations->Get_Field_Count() > iTranslation && pTranslations->Get_Record_Count() > 0 ) { int i; m_bCmpNoCase = bCmpNoCase; if( m_bCmpNoCase ) { for(i=0; i<pTranslations->Get_Record_Count(); i++) { CSG_Table_Record *pRecord = pTranslations->Get_Record(i); CSG_String s = pRecord->asString(iText); pRecord->Set_Value(iText, s.Make_Lower().c_str()); } } pTranslations->Set_Index(iText, TABLE_INDEX_Ascending); m_Translations = (CSG_Translation **)SG_Malloc(pTranslations->Get_Record_Count() * sizeof(CSG_Translation *)); for(i=0; i<pTranslations->Get_Record_Count(); i++) { CSG_Table_Record *pRecord = pTranslations->Get_Record_byIndex(i); if( *pRecord->asString(iText) && *pRecord->asString(iTranslation) ) { m_Translations[m_nTranslations++] = new CSG_Translation(pRecord->asString(iText), pRecord->asString(iTranslation)); } } if( m_nTranslations < pTranslations->Get_Record_Count() ) { m_Translations = (CSG_Translation **)SG_Realloc(m_Translations, m_nTranslations * sizeof(CSG_Translation *)); } } SG_UI_Msg_Lock(false); return( m_nTranslations > 0 ); }
//--------------------------------------------------------- void CVIEW_Table_Control::On_Changed(wxGridEvent &event) { CSG_Table_Record *pRecord = m_pRecords[event.GetRow()]; if( pRecord ) { int iField = m_Field_Offset + event.GetCol(); if( iField >= m_Field_Offset && iField < m_pTable->Get_Field_Count() ) { pRecord->Set_Value(iField, GetCellValue(event.GetRow(), event.GetCol()).wx_str()); SetCellValue(event.GetRow(), event.GetCol(), pRecord->asString(iField)); } } }
//--------------------------------------------------------- CSG_Table CSG_ODBC_Connection::Get_Field_Desc(const CSG_String &Table_Name) const { CSG_Table Fields; Fields.Set_Name(CSG_String::Format(SG_T("%s [%s]"), Table_Name.c_str(), _TL("Field Description"))); if( is_Connected() ) { try { int i, n; std_string s; otl_column_desc *desc; otl_stream Stream; Stream.set_all_column_types(otl_all_num2str|otl_all_date2str); Stream.open(m_Size_Buffer, CSG_String::Format(SG_T("$SQLColumns $3:'%s'"), Table_Name.c_str()), m_Connection); // get a list of all columns. desc = Stream.describe_select(n); for(i=0; i<n; i++) { Fields.Add_Field(CSG_String(desc[i].name), SG_DATATYPE_String); } while( !Stream.eof() ) { CSG_Table_Record *pField = Fields.Add_Record(); for(i=0; i<n; i++) { Stream >> s; pField->Set_Value(i, CSG_String(s.c_str())); } } } catch( otl_exception &e ) { _Error_Message(e); } } return( Fields ); }
//--------------------------------------------------------- void CActive_Attributes_Control::On_LClick(wxGridEvent &event) { int iField = m_Field_Offset + event.GetCol(); CSG_Table_Record *pRecord = m_pTable->Get_Record(event.GetRow()); //----------------------------------------------------- if( event.AltDown() ) { if( m_pTable->Get_Field_Type(iField) == SG_DATATYPE_String ) { Open_Application(pRecord->asString(iField)); } } //----------------------------------------------------- if( event.ControlDown() ) { if( m_pTable->Get_Field_Type(iField) == SG_DATATYPE_String ) { g_pData->Open (pRecord->asString(iField)); } } //----------------------------------------------------- else { if( pRecord && iField >= m_Field_Offset && iField < m_pTable->Get_Field_Count() && m_pTable->Get_Field_Type(iField) == SG_DATATYPE_Color ) { long lValue; if( DLG_Color(lValue = pRecord->asInt(iField)) ) { pRecord->Set_Value(iField, lValue); SetCellBackgroundColour(event.GetRow(), event.GetCol(), Get_Color_asWX(pRecord->asInt(iField))); ForceRefresh(); } } } //----------------------------------------------------- SetGridCursor(event.GetRow(), event.GetCol()); }
//--------------------------------------------------------- bool CWKSP_Shapes::Edit_Set_Attributes(void) { CSG_Table_Record *pSelection = Get_Shapes()->Get_Selection(m_Edit_Index); if( pSelection ) { for(int i=0; i<m_Edit_Attributes.Get_Record_Count(); i++) { if( !pSelection->Set_Value(i, m_Edit_Attributes.Get_Record(i)->asString(1)) ) { m_Edit_Attributes.Get_Record(i)->Set_Value(1, pSelection->asString(i)); } } Update_Views(false); return( true ); } return( false ); }
//--------------------------------------------------------- void CVIEW_Map_3D::_Play_Pos_Add(void) { CSG_Table_Record *pRecord; if( m_Play_Mode == PLAY_MODE_NONE ) { pRecord = m_Play.Add_Record(); pRecord->Set_Value(PLAY_REC_ROTATE_X , m_pImage->m_xRotate); pRecord->Set_Value(PLAY_REC_ROTATE_Y , m_pImage->m_yRotate); pRecord->Set_Value(PLAY_REC_ROTATE_Z , m_pImage->m_zRotate); pRecord->Set_Value(PLAY_REC_SHIFT_X , m_pImage->m_xShift); pRecord->Set_Value(PLAY_REC_SHIFT_Y , m_pImage->m_yShift); pRecord->Set_Value(PLAY_REC_SHIFT_Z , m_pImage->m_zShift); pRecord->Set_Value(PLAY_REC_EXAGGERATION , m_pImage->m_Exaggeration); pRecord->Set_Value(PLAY_REC_CENTRAL , m_pImage->m_Central); pRecord->Set_Value(PLAY_REC_STEPS , 10); } }
//--------------------------------------------------------- bool CPolygon_Transect::On_Execute(void) { CSG_Table *pTransect_Result; CSG_Shapes *pTheme, *pTransect; CSG_Shape_Line *pLine; CSG_Shape_Polygon *pTheme_Shape; int Theme_Field; pTransect = Parameters("TRANSECT")->asShapes(); pTheme = Parameters("THEME")->asShapes(); pTransect_Result = Parameters("TRANSECT_RESULT")->asTable(); Theme_Field = Parameters("THEME_FIELD")->asInt(); //----------------------------------------------------- // Check for valid parameter settings... //----------------------------------------------------- if (pTheme->Get_Type() != SHAPE_TYPE_Polygon){ Error_Set(CSG_String("[THEME] is not a polygon file")); return(false); } if (pTransect->Get_Type() != SHAPE_TYPE_Line){ Error_Set(CSG_String("[TRANSECT] is not a line shapefile")); return(false); } if (pTheme->Get_Count() ==0 || pTransect->Get_Count()==0) { Error_Set(CSG_String("[TRANSECT] or [THEME] is empty")); return(false); } if (!(pTheme->Get_Extent().Intersects(pTransect->Get_Extent()))) { Error_Set(CSG_String("[TRANSECT] and [THEME] do not intersect")); return(false); } const int LINE_ID = pTransect_Result->Get_Field_Count(); pTransect_Result->Add_Field(SG_T("line_id"), SG_DATATYPE_Int); const int START = pTransect_Result->Get_Field_Count(); pTransect_Result->Add_Field(SG_T("start"), SG_DATATYPE_Double); const int END = pTransect_Result->Get_Field_Count(); pTransect_Result->Add_Field(SG_T("end"), SG_DATATYPE_Double); const int POLY_ID = pTransect_Result->Get_Field_Count(); pTransect_Result->Add_Field(SG_T("poly_id"), SG_DATATYPE_Int); const int FIELD = pTransect_Result->Get_Field_Count(); pTransect_Result->Add_Field(SG_T("field"), pTheme->Get_Field_Type(Theme_Field)); // Short description of the algorithm: // For every line it is checked whether it crosses a polygon. If it does, // the points where it crosses are recorded in the map LineBorders, with // the polygon_id as key. for (int iLine=0; iLine<pTransect->Get_Count() && Set_Progress(iLine, pTransect->Get_Count()); iLine++) { pLine =(CSG_Shape_Line *) pTransect->Get_Shape(iLine); for (int iLinePart=0;iLinePart<pLine->Get_Part_Count();iLinePart++) { CSG_Shape_Part *pLinePart =pLine->Get_Part(iLinePart); CSG_Rect LinePartExtent = pLinePart->Get_Extent(); map<int,list<double> > LineBorders; for (int iShape=0; iShape<pTheme->Get_Count();iShape++) { pTheme_Shape = (CSG_Shape_Polygon *) pTheme->Get_Shape(iShape); if (pLinePart->Get_Extent().Intersects(pTheme_Shape->Get_Extent())>0) { for (int iPart=0; iPart<pTheme_Shape->Get_Part_Count(); iPart++) { CSG_Shape_Polygon_Part *pPart = (CSG_Shape_Polygon_Part *) pTheme_Shape->Get_Part(iPart); if (pPart->Contains(pLinePart->Get_Point(0))) LineBorders[iShape].push_back(0); if (pPart->Contains(pLinePart->Get_Point(pLinePart->Get_Count()))) LineBorders[iShape].push_back(pLine->Get_Length(iLinePart)); for (int iPoint=0; iPoint<pPart->Get_Count();iPoint++) { int iPoint2 = (iPoint!=pPart->Get_Count()-1)?iPoint+1:0; TSG_Point Crossing; double Length=0; for (int iLinePartPoint=0; iLinePartPoint<pLinePart->Get_Count(); iLinePartPoint++) { if (SG_Get_Crossing(Crossing,pPart->Get_Point(iPoint),pPart->Get_Point(iPoint2), pLinePart->Get_Point(iLinePartPoint), pLinePart->Get_Point(iLinePartPoint+1))) { LineBorders[iShape].push_back(Length+SG_Get_Distance(Crossing, pLinePart->Get_Point(iLinePartPoint))); } Length+=SG_Get_Distance(pLinePart->Get_Point(iLinePartPoint), pLinePart->Get_Point(iLinePartPoint+1)); } } } } } // convert LineBorders to the result table // the table contains the lineids and the distance to the origin of the line, // and it is sorted by lineid, polygonid CSG_Table_Record *pRecord; for (map<int,list<double> >::iterator shapeit=LineBorders.begin();shapeit!=LineBorders.end();++shapeit) { //shapeit->second.sort(); bool start=1; for (list<double>::iterator i=shapeit->second.begin(); i!=shapeit->second.end();++i) { if (start){ pRecord =pTransect_Result->Add_Record(); pRecord->Set_Value(LINE_ID, iLine); pRecord->Set_Value(START, *i); pRecord->Set_Value(POLY_ID, shapeit->first); CSG_Table_Record *pTheme_Record =pTheme->Get_Shape(shapeit->first) ; if(pTheme->Get_Field_Type(Theme_Field)== SG_DATATYPE_String ) pRecord->Set_Value(FIELD, pTheme_Record->asString(Theme_Field)); else pRecord->Set_Value(FIELD, pTheme_Record->asDouble(Theme_Field)); start = 0; } else { pRecord->Set_Value(END, *i); start=1; } } } } } return( true ); }
//--------------------------------------------------------- bool CGSPoints_Semi_Variances::On_Execute(void) { int i, j, k, n, nDistances, nSkip, Attribute; double zi, zj, zMean, v, c, maxDistance, lagDistance; TSG_Point Pt_i, Pt_j; CSG_Vector Count, Variance, Covariance; CSG_Table_Record *pRecord; CSG_Table *pTable; CSG_Shape *pPoint; CSG_Shapes *pPoints; //----------------------------------------------------- pPoints = Parameters("POINTS") ->asShapes(); pTable = Parameters("RESULT") ->asTable(); Attribute = Parameters("FIELD") ->asInt(); nSkip = Parameters("NSKIP") ->asInt(); maxDistance = Parameters("DISTMAX") ->asDouble(); nDistances = Parameters("DISTCOUNT") ->asInt(); if( maxDistance <= 0.0 ) { maxDistance = SG_Get_Length(pPoints->Get_Extent().Get_XRange(), pPoints->Get_Extent().Get_YRange()); } lagDistance = maxDistance / nDistances; zMean = pPoints->Get_Mean(Attribute); Count .Create(nDistances); Variance .Create(nDistances); Covariance .Create(nDistances); //----------------------------------------------------- for(i=0, n=0; i<pPoints->Get_Count() && Set_Progress(n, SG_Get_Square(pPoints->Get_Count()/nSkip)/2); i+=nSkip) { pPoint = pPoints->Get_Shape(i); if( !pPoint->is_NoData(Attribute) ) { Pt_i = pPoint->Get_Point(0); zi = pPoint->asDouble(Attribute); for(j=i+nSkip; j<pPoints->Get_Count(); j+=nSkip, n++) { pPoint = pPoints->Get_Shape(j); if( !pPoint->is_NoData(Attribute) ) { Pt_j = pPoint->Get_Point(0); k = (int)(SG_Get_Distance(Pt_i, Pt_j) / lagDistance); if( k < nDistances ) { zj = pPoint->asDouble(Attribute); v = SG_Get_Square(zi - zj); c = (zi - zMean) * (zj - zMean); Count [k] ++; Variance [k] += v; Covariance[k] += c; } } } } } //----------------------------------------------------- pTable->Destroy(); pTable->Set_Name(CSG_String::Format(SG_T("%s [%s: %s]"), pPoints->Get_Name(), _TL("Variogram"), pPoints->Get_Field_Name(Attribute))); pTable->Add_Field(_TL("Class") , SG_DATATYPE_Int); // FIELD_CLASSNR pTable->Add_Field(_TL("Distance") , SG_DATATYPE_Double); // FIELD_DISTANCE pTable->Add_Field(_TL("Count") , SG_DATATYPE_Int); // FIELD_COUNT pTable->Add_Field(_TL("Variance") , SG_DATATYPE_Double); // FIELD_VARIANCE pTable->Add_Field(_TL("Cum.Var.") , SG_DATATYPE_Double); // FIELD_VARCUMUL pTable->Add_Field(_TL("Covariance") , SG_DATATYPE_Double); // FIELD_COVARIANCE pTable->Add_Field(_TL("Cum.Covar.") , SG_DATATYPE_Double); // FIELD_COVARCUMUL for(i=0, v=0.0, c=0.0, n=0; i<nDistances; i++) { if( Count[i] > 0 ) { n += (int)Count[i]; v += Variance [i]; c += Covariance[i]; pRecord = pTable->Add_Record(); pRecord->Set_Value(FIELD_CLASSNR , (i + 1)); pRecord->Set_Value(FIELD_DISTANCE , (i + 1) * lagDistance); pRecord->Set_Value(FIELD_COUNT , Count[i]); pRecord->Set_Value(FIELD_VARIANCE , 0.5 * Variance [i] / Count[i]); pRecord->Set_Value(FIELD_VARCUMUL , 0.5 * v / n); pRecord->Set_Value(FIELD_COVARIANCE , 1.0 * Covariance[i] / Count[i]); pRecord->Set_Value(FIELD_COVARCUMUL , 1.0 * c / n); } } return( true ); }
//--------------------------------------------------------- bool CSG_ODBC_Connection::_Table_Load(CSG_Table &Table, const CSG_String &Select, const CSG_String &Name, bool bLOB) { //----------------------------------------------------- if( !is_Connected() ) { _Error_Message(_TL("no database connection")); return( false ); } //----------------------------------------------------- try { int valInt, iField, nFields; long valLong; float valFloat; double valDouble; std_string valString; otl_long_string valRaw(m_Connection.get_max_long_size()); otl_column_desc *Fields; otl_stream Stream; CSG_Bytes BLOB; Stream.set_all_column_types (otl_all_date2str); Stream.set_lob_stream_mode (bLOB); Stream.open (bLOB ? 1 : m_Size_Buffer, Select, m_Connection); Fields = Stream.describe_select(nFields); if( Fields == NULL || nFields <= 0 ) { _Error_Message(_TL("no fields in selection")); return( false ); } //------------------------------------------------- Table.Destroy(); Table.Set_Name(Name); for(iField=0; iField<nFields; iField++) { if( _Get_Type_From_SQL(Fields[iField].otl_var_dbtype) == SG_DATATYPE_Undefined ) { return( false ); } Table.Add_Field(Fields[iField].name, _Get_Type_From_SQL(Fields[iField].otl_var_dbtype)); } //------------------------------------------------- while( !Stream.eof() && SG_UI_Process_Get_Okay() ) // while not end-of-data { CSG_Table_Record *pRecord = Table.Add_Record(); for(iField=0; iField<nFields; iField++) { switch( Table.Get_Field_Type(iField) ) { case SG_DATATYPE_String: Stream >> valString; if( Stream.is_null() ) pRecord->Set_NoData(iField); else pRecord->Set_Value(iField, CSG_String(valString.c_str())); break; case SG_DATATYPE_Short: case SG_DATATYPE_Int: Stream >> valInt; if( Stream.is_null() ) pRecord->Set_NoData(iField); else pRecord->Set_Value(iField, valInt); break; case SG_DATATYPE_DWord: case SG_DATATYPE_Long: Stream >> valLong; if( Stream.is_null() ) pRecord->Set_NoData(iField); else pRecord->Set_Value(iField, valLong); break; case SG_DATATYPE_Float: Stream >> valFloat; if( Stream.is_null() ) pRecord->Set_NoData(iField); else pRecord->Set_Value(iField, valFloat); break; case SG_DATATYPE_Double: Stream >> valDouble; if( Stream.is_null() ) pRecord->Set_NoData(iField); else pRecord->Set_Value(iField, valDouble); break; case SG_DATATYPE_Binary: Stream >> valRaw; if( Stream.is_null() ) pRecord->Set_NoData(iField); else { BLOB.Clear(); for(int i=0; i<valRaw.len(); i++) { BLOB.Add((BYTE)valRaw[i]); } pRecord->Set_Value(iField, BLOB); } break; } } } } //----------------------------------------------------- catch( otl_exception &e ) { _Error_Message(e); return( false ); } 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 ); }