//---------------------------------------------------------
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 );
}
