//---------------------------------------------------------
bool C_Kriging_Base::_Get_Grid(void)
{
CSG_Shapes *pShapes = Parameters("SHAPES")->asShapes();
m_pGrid = NULL;
m_pVariance = NULL;
//-------------------------------------------------
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( Dlg_Parameters("USER") )
{
m_pGrid = _Get_Grid(pShapes->Get_Extent());
}
break;
case 1: // grid system...
if( Dlg_Parameters("SYSTEM") )
{
m_pGrid = SG_Create_Grid(*Get_Parameters("SYSTEM")->Get_Parameter("SYSTEM")->asGrid_System(), SG_DATATYPE_Float);
}
break;
case 2: // grid...
if( Dlg_Parameters("GRID") )
{
m_pGrid = Get_Parameters("GRID")->Get_Parameter("GRID") ->asGrid();
m_pVariance = Get_Parameters("GRID")->Get_Parameter("VARIANCE") ->asGrid();
}
break;
}
//-------------------------------------------------
if( m_pGrid )
{
if( !m_pVariance && Parameters("BVARIANCE")->asBool() )
{
m_pVariance = SG_Create_Grid(m_pGrid, SG_DATATYPE_Float);
}
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s (%s)"), pShapes->Get_Name(), Get_Name()));
Parameters("GRID")->Set_Value(m_pGrid);
if( m_pVariance )
{
m_pVariance->Set_Name(CSG_String::Format(SG_T("%s (%s - %s)"), pShapes->Get_Name(), Get_Name(), _TL("Variance")));
Parameters("VARIANCE")->Set_Value(m_pVariance);
}
if( Parameters("TARGET")->asInt() == 2 )
{
Get_Parameters("GRID")->Get_Parameter("VARIANCE")->Set_Value(m_pVariance);
}
}
//-----------------------------------------------------
return( m_pGrid != NULL );
}
//---------------------------------------------------------
bool CGridding_Spline_Base::_Get_Grid(void)
{
CSG_Grid *pGrid = m_bGridPoints ? Parameters("GRIDPOINTS")->asGrid () : NULL;
CSG_Shapes *pShapes = !m_bGridPoints ? Parameters("SHAPES") ->asShapes() : NULL;
//-----------------------------------------------------
m_pGrid = NULL;
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(m_bGridPoints ? pGrid->Get_Extent() : pShapes->Get_Extent()) && Dlg_Parameters("USER") )
{
m_pGrid = m_Grid_Target.Get_User();
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
m_pGrid = m_Grid_Target.Get_Grid();
}
break;
}
//-------------------------------------------------
if( m_pGrid )
{
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s (%s)"), m_bGridPoints ? pGrid->Get_Name() : pShapes->Get_Name(), Get_Name()));
m_pGrid->Assign_NoData();
}
//-----------------------------------------------------
return( m_pGrid != NULL );
}
//---------------------------------------------------------
bool CShapes_Cut_Interactive::Get_Extent(CSG_Rect &r)
{
CSG_Parameters *pParameters = Get_Parameters("CUT");
pParameters->Get_Parameter("AX")->Set_Value(r.Get_XMin());
pParameters->Get_Parameter("AY")->Set_Value(r.Get_YMin());
pParameters->Get_Parameter("BX")->Set_Value(r.Get_XMax());
pParameters->Get_Parameter("BY")->Set_Value(r.Get_YMax());
pParameters->Get_Parameter("DX")->Set_Value(r.Get_XRange());
pParameters->Get_Parameter("DY")->Set_Value(r.Get_YRange());
if( Dlg_Parameters("CUT") )
{
r.Assign(
pParameters->Get_Parameter("AX")->asDouble(),
pParameters->Get_Parameter("AY")->asDouble(),
pParameters->Get_Parameter("BX")->asDouble(),
pParameters->Get_Parameter("BY")->asDouble()
);
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGEOTRANS_Grid::On_Execute_Conversion(void)
{
int Interpolation;
TSG_Data_Type Type;
TSG_Rect Extent;
CSG_Grid *pSource, *pGrid;
//-----------------------------------------------------
pSource = Parameters("SOURCE" )->asGrid();
Interpolation = Parameters("INTERPOLATION")->asInt();
Type = Interpolation == 0 ? pSource->Get_Type() : SG_DATATYPE_Float;
//-----------------------------------------------------
if( Get_Target_Extent(pSource, Extent, true) )
{
m_Grid_Target.Set_User_Defined(Get_Parameters("TARGET"), Extent, pSource->Get_NY());
}
if( Dlg_Parameters("TARGET") && (pGrid = m_Grid_Target.Get_Grid(Type)) != NULL )
{
return( Set_Grid(pSource, pGrid, Interpolation) );
}
return( false );
}
bool CCreateChartLayer::GetExtraParameters(){
int i;
CSG_Shapes *pInput;
CSG_Parameter *pParam;
CSG_String sName;
bool bIsValidSelection = false;
pInput = Parameters("INPUT")->asShapes();
m_pExtraParameters->Create(this, _TL("Fields for diagram"), _TL(""), SG_T("EXTRA"));
m_bIncludeParam = new bool [pInput->Get_Field_Count() ];
for (i = 0; i < pInput->Get_Field_Count(); i++)
{
switch( pInput->Get_Field_Type(i) )
{
default:
break;
case SG_DATATYPE_Byte:
case SG_DATATYPE_Char:
case SG_DATATYPE_Word:
case SG_DATATYPE_Short:
case SG_DATATYPE_DWord:
case SG_DATATYPE_Int:
case SG_DATATYPE_ULong:
case SG_DATATYPE_Long:
case SG_DATATYPE_Float:
case SG_DATATYPE_Double: // is numeric field
m_pExtraParameters->Add_Value(
NULL, SG_Get_String(i,0).c_str(), pInput->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false
);
break;
}
}//for
if(Dlg_Parameters("EXTRA")){
for (i = 0; i < pInput->Get_Field_Count(); i++){
sName = SG_Get_String(i,0);
if (pParam = Get_Parameters("EXTRA")->Get_Parameter(sName.c_str())){
m_bIncludeParam[i] = pParam->asBool();
bIsValidSelection = true;
}//try
else{
m_bIncludeParam[i] = false;
}//else
}//for
m_pExtraParameters->Destroy();
return bIsValidSelection;
}//if
m_pExtraParameters->Destroy();
return false;
}//method
//---------------------------------------------------------
bool CGEOTRANS_Grid::On_Execute_Conversion(void)
{
TSG_Data_Type Type;
TSG_Rect Extent;
CSG_Grid *pSource, *pGrid;
//-----------------------------------------------------
TSG_Grid_Resampling Resampling;
switch( Parameters("RESAMPLING")->asInt() )
{
default: Resampling = GRID_RESAMPLING_NearestNeighbour; break;
case 1: Resampling = GRID_RESAMPLING_Bilinear ; break;
case 2: Resampling = GRID_RESAMPLING_BicubicSpline ; break;
case 3: Resampling = GRID_RESAMPLING_BSpline ; break;
}
//-----------------------------------------------------
pSource = Parameters("SOURCE")->asGrid();
Type = Resampling == GRID_RESAMPLING_NearestNeighbour ? pSource->Get_Type() : SG_DATATYPE_Float;
//-----------------------------------------------------
if( Get_Target_Extent(pSource, Extent, true) )
{
m_Grid_Target.Set_User_Defined(Get_Parameters("TARGET"), Extent, pSource->Get_NY());
}
if( Dlg_Parameters("TARGET") && (pGrid = m_Grid_Target.Get_Grid(Type)) != NULL )
{
return( Set_Grid(pSource, pGrid, Resampling) );
}
return( false );
}
//---------------------------------------------------------
bool CInterpolation::On_Execute(void)
{
bool bResult = false;
//-----------------------------------------------------
m_pShapes = Parameters("SHAPES") ->asShapes();
m_zField = Parameters("FIELD") ->asInt();
//-----------------------------------------------------
m_pGrid = NULL;
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(m_pShapes->Get_Extent()) && Dlg_Parameters("USER") )
{
m_pGrid = m_Grid_Target.Get_User();
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
m_pGrid = m_Grid_Target.Get_Grid();
}
break;
}
//-----------------------------------------------------
if( m_pGrid )
{
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), Parameters("FIELD")->asString(), Get_Name().c_str()));
bResult = Interpolate();
}
//-----------------------------------------------------
m_Search.Destroy();
if( m_pShapes != Parameters("SHAPES")->asShapes() )
{
delete(m_pShapes);
}
return( bResult );
}
//---------------------------------------------------------
bool CKriging_Base::_Initialise_Grids(void)
{
m_pGrid = NULL;
m_pVariance = NULL;
//-----------------------------------------------------
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(m_pPoints->Get_Extent()) && Dlg_Parameters("USER") )
{
m_pGrid = m_Grid_Target.Get_User();
if( Get_Parameters("USER")->Get_Parameter("BVARIANCE")->asBool() )
{
m_pVariance = m_Grid_Target.Get_User(SG_T("VARIANCE"));
}
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
m_pGrid = m_Grid_Target.Get_Grid();
m_pVariance = m_Grid_Target.Get_Grid(SG_T("VARIANCE"));
}
break;
}
if( !m_pGrid )
{
return( false );
}
//-----------------------------------------------------
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), Parameters("ZFIELD")->asString(), Get_Name().c_str()));
if( m_pVariance )
{
m_pVariance->Set_Name(CSG_String::Format(SG_T("%s [%s %s]"), Parameters("ZFIELD")->asString(), Get_Name().c_str(), m_bStdDev ? _TL("Standard Deviation") : _TL("Variance")));
}
return( true );
}
//---------------------------------------------------------
bool CCRS_Transform_Grid::Transform(CSG_Grid *pGrid)
{
if( pGrid->Get_Projection().is_Okay() && m_Projector.Set_Source(pGrid->Get_Projection()) )
{
TSG_Data_Type Type = m_Interpolation == 0 ? pGrid->Get_Type() : SG_DATATYPE_Float;
switch( Parameters("TARGET_TYPE")->asInt() )
{
case 0: // create user defined grid...
if( Get_Target_System(pGrid->Get_System(), true) )
{
return( Transform(pGrid, m_Grid_Target.Get_User(Type)) );
}
break;
case 1: // select existing grid system...
if( Dlg_Parameters("GET_GRID") )
{
return( Transform(pGrid, m_Grid_Target.Get_Grid(Type)) );
}
break;
case 2: // points as target...
if( Dlg_Parameters("POINTS") )
{
CSG_Shapes *pPoints = Get_Parameters("POINTS")->Get_Parameter("POINTS")->asShapes();
if( pPoints == DATAOBJECT_NOTSET || pPoints == DATAOBJECT_CREATE )
{
Get_Parameters("POINTS")->Get_Parameter("POINTS")->Set_Value(pPoints = SG_Create_Shapes(SHAPE_TYPE_Point));
}
return( Transform(pGrid, pPoints) );
}
break;
}
}
return( false );
}
//---------------------------------------------------------
bool CCRS_Transform_Grid::Transform(CSG_Parameter_Grid_List *pGrids)
{
if( pGrids->Get_Count() > 0 && m_Projector.Set_Source(pGrids->asGrid(0)->Get_Projection()) )
{
CSG_Grid_System System;
switch( Parameters("TARGET_TYPE")->asInt() )
{
case 0: // create user defined grid system...
if( Get_Target_System(pGrids->asGrid(0)->Get_System(), true) && m_Grid_Target.Get_System_User(System) )
{
return( Transform(pGrids, Parameters("TARGET")->asGridList(), System) );
}
break;
case 1: // select existing grid system...
if( Dlg_Parameters("GET_SYSTEM") && m_Grid_Target.Get_System(System) )
{
return( Transform(pGrids, Parameters("TARGET")->asGridList(), System) );
}
break;
case 2: // points as target...
if( Dlg_Parameters("POINTS") )
{
CSG_Shapes *pPoints = Get_Parameters("POINTS")->Get_Parameter("POINTS")->asShapes();
if( pPoints == DATAOBJECT_NOTSET || pPoints == DATAOBJECT_CREATE )
{
Get_Parameters("POINTS")->Get_Parameter("POINTS")->Set_Value(pPoints = SG_Create_Shapes());
}
return( Transform(pGrids, pPoints) );
}
break;
}
}
return( false );
}
//---------------------------------------------------------
bool CCollect_Points::On_Execute_Position(CSG_Point ptWorld, TSG_Module_Interactive_Mode Mode)
{
if( Mode == MODULE_INTERACTIVE_LUP )
{
TSG_Point ptTarget;
if( m_Engine.Get_Converted(ptTarget = ptWorld) )
{
Get_Parameters("REFERENCE")->Get_Parameter("X")->Set_Value(ptTarget.x);
Get_Parameters("REFERENCE")->Get_Parameter("Y")->Set_Value(ptTarget.y);
}
if( Dlg_Parameters("REFERENCE") )
{
int Method = Parameters("METHOD")->asInt();
int Order = Parameters("ORDER" )->asInt();
CSG_Shape *pPoint = m_pPoints->Add_Shape();
pPoint->Add_Point(ptWorld);
pPoint->Set_Value(0, ptWorld.Get_X());
pPoint->Set_Value(1, ptWorld.Get_Y());
pPoint->Set_Value(2, ptTarget.x = Get_Parameters("REFERENCE")->Get_Parameter("X")->asDouble());
pPoint->Set_Value(3, ptTarget.y = Get_Parameters("REFERENCE")->Get_Parameter("Y")->asDouble());
if( m_Engine.Add_Reference(ptWorld, ptTarget) && m_Engine.Evaluate(Method, Order) && m_pPoints->Get_Count() == m_Engine.Get_Reference_Count() )
{
for(int i=0; i<m_pPoints->Get_Count(); i++)
{
m_pPoints->Get_Shape(i)->Set_Value(4, m_Engine.Get_Reference_Residual(i));
}
}
DataObject_Update(m_pPoints);
}
}
return( true );
}
//---------------------------------------------------------
FILE * CSRTM30_Import::Tile_Open(const SG_Char *sTile)
{
const SG_Char *sPath;
FILE *Stream;
CSG_String fName;
CSG_Parameters *pParameters;
fName = sTile;
if( (Stream = fopen(fName.b_str(), "rb")) == NULL )
{
pParameters = Get_Parameters("TILE");
pParameters->Get_Parameter("INFO")->Set_Value(sTile);
if( Dlg_Parameters(pParameters, _TL("Locate STRM30 Data File")) && (sPath = pParameters->Get_Parameter("PATH")->asString()) != NULL )
{
fName = sPath;
Stream = fopen(fName.b_str(), "rb");
}
}
return( Stream );
}
//---------------------------------------------------------
bool CCRS_Transform_Grid::Get_Target_System(const CSG_Grid_System &System, bool bEdge)
{
int x, y, Resolution;
TSG_Rect Extent;
Extent.xMin = Extent.yMin = 1.0;
Extent.xMax = Extent.yMax = 0.0;
Get_MinMax(Extent, System.Get_XMin(), System.Get_YMin());
Get_MinMax(Extent, System.Get_XMax(), System.Get_YMin());
Get_MinMax(Extent, System.Get_XMin(), System.Get_YMax());
Get_MinMax(Extent, System.Get_XMax(), System.Get_YMax());
Resolution = 256;
switch( 1 )
{
case 1: // edges
{
double d;
int yStep = 1 + System.Get_NY() / Resolution;
for(y=0, d=System.Get_YMin(); y<System.Get_NY(); y+=yStep, d+=yStep*System.Get_Cellsize())
{
Get_MinMax(Extent, System.Get_XMin(), d);
Get_MinMax(Extent, System.Get_XMax(), d);
}
int xStep = 1 + System.Get_NX() / Resolution;
for(x=0, d=System.Get_XMin(); x<System.Get_NX(); x+=xStep, d+=xStep*System.Get_Cellsize())
{
Get_MinMax(Extent, d, System.Get_YMin());
Get_MinMax(Extent, d, System.Get_YMax());
}
}
break;
case 2: // all cells
{
TSG_Point p;
int xStep = 1 + System.Get_NX() / Resolution;
int yStep = 1 + System.Get_NY() / Resolution;
for(y=0, p.y=System.Get_YMin(); y<System.Get_NY() && Set_Progress(y, System.Get_NY()); y+=yStep, p.y+=yStep*System.Get_Cellsize())
{
for(x=0, p.x=System.Get_XMin(); x<System.Get_NX(); x+=xStep, p.x+=xStep*System.Get_Cellsize())
{
Get_MinMax(Extent, p.x, p.y);
}
}
}
break;
}
return( is_Progress() && Extent.xMin < Extent.xMax && Extent.yMin < Extent.yMax
&& m_Grid_Target.Init_User(Extent, System.Get_NY())
&& Dlg_Parameters("GET_USER")
);
}
//---------------------------------------------------------
bool CTable_Text_Import_Fixed_Cols::On_Execute(void)
{
bool bHeader;
int i, nChars, iField, nFields, *iFirst, *iLength;
CSG_String sLine;
CSG_File Stream;
CSG_Table *pTable;
//-----------------------------------------------------
pTable = Parameters("TABLE") ->asTable();
bHeader = Parameters("HEADLINE") ->asBool();
//-----------------------------------------------------
if( !Stream.Open(Parameters("FILENAME")->asString(), SG_FILE_R, true) )
{
Message_Add(_TL("file could not be opened"));
return( false );
}
if( !Stream.Read_Line(sLine) || (nChars = (int)sLine.Length()) <= 0 )
{
Message_Add(_TL("empty or corrupted file"));
return( false );
}
//-----------------------------------------------------
pTable->Destroy();
pTable->Set_Name(SG_File_Get_Name(Parameters("FILENAME")->asString(), false));
switch( Parameters("FIELDDEF")->asInt() )
{
//-----------------------------------------------------
case 0:
{
CSG_Parameters *pBreaks = Get_Parameters("BREAKS");
pBreaks->Del_Parameters();
for(i=0; i<nChars; i++)
{
pBreaks->Add_Value(NULL,
CSG_String::Format(SG_T("%03d"), i),
CSG_String::Format(SG_T("%03d %c"), i + 1, sLine[i]),
_TL(""), PARAMETER_TYPE_Bool, false
);
}
if( !Dlg_Parameters("BREAKS") )
{
return( false );
}
//-------------------------------------------------
for(i=0, nFields=1; i<pBreaks->Get_Count(); i++)
{
if( pBreaks->Get_Parameter(i)->asBool() )
{
nFields++;
}
}
//-------------------------------------------------
iFirst = new int[nFields];
iLength = new int[nFields];
iFirst[0] = 0;
for(i=0, iField=1; i<pBreaks->Get_Count() && iField<nFields; i++)
{
if( pBreaks->Get_Parameter(i)->asBool() )
{
iFirst[iField++] = i + 1;
}
}
//-------------------------------------------------
for(iField=0; iField<nFields; iField++)
{
iLength[iField] = (iField < nFields - 1 ? iFirst[iField + 1] : (int)sLine.Length()) - iFirst[iField];
pTable->Add_Field(bHeader ? sLine.Mid(iFirst[iField], iLength[iField]) : CSG_String::Format(SG_T("FIELD%03d"), iField + 1), SG_DATATYPE_String);
}
}
break;
//-----------------------------------------------------
case 1:
{
CSG_Parameters *pFields = Get_Parameters("FIELDS");
pFields->Del_Parameters();
nFields = Parameters("NFIELDS")->asInt();
for(iField=0; iField<nFields; iField++)
{
CSG_String s = CSG_String::Format(SG_T("%03d"), iField);
CSG_Parameter *pNode = pFields->Add_Node(NULL, SG_T("NODE") + s, _TL("Field") + s, _TL(""));
pFields->Add_Value (pNode, SG_T("LENGTH") + s, _TL("Length"), _TL(""), PARAMETER_TYPE_Int, 1, 1, true);
// pFields->Add_Value (pNode, SG_T("IMPORT") + s, _TL("Import"), _TL(""), PARAMETER_TYPE_Bool, true);
pFields->Add_Choice (pNode, SG_T("TYPE") + s, _TL("Type") , _TL(""), CSG_String::Format(SG_T("%s|%s|%s|%s|%s|"),
_TL("text"),
_TL("2 byte integer"),
_TL("4 byte integer"),
_TL("4 byte float"),
_TL("8 byte float"))
);
}
if( !Dlg_Parameters("FIELDS") )
{
return( false );
}
//-------------------------------------------------
iFirst = new int[nFields];
iLength = new int[nFields];
iFirst[0] = 0;
for(iField=0, i=0; iField<nFields && i<nChars; iField++)
{
CSG_String s = CSG_String::Format(SG_T("%03d"), iField);
iFirst [iField] = i;
iLength[iField] = pFields->Get_Parameter(SG_T("LENGTH") + s)->asInt();
i += iLength[iField];
CSG_String Name = bHeader ? sLine.Mid(iFirst[iField], iLength[iField]) : CSG_String::Format(SG_T("FIELD%03d"), iField + 1);
switch( pFields->Get_Parameter(SG_T("TYPE") + s)->asInt() )
{
default:
case 0:
pTable->Add_Field(Name, SG_DATATYPE_String);
break;
case 1:
pTable->Add_Field(Name, SG_DATATYPE_Short);
break;
case 2:
pTable->Add_Field(Name, SG_DATATYPE_Int);
break;
case 3:
pTable->Add_Field(Name, SG_DATATYPE_Float);
break;
case 4:
pTable->Add_Field(Name, SG_DATATYPE_Double);
break;
}
}
}
break;
//-----------------------------------------------------
case 2:
{
CSG_Table *pList = Parameters("LIST")->asTable();
nFields = pList->Get_Count();
//-------------------------------------------------
iFirst = new int[nFields];
iLength = new int[nFields];
iFirst[0] = 0;
for(iField=0, i=0; iField<nFields && i<nChars; iField++)
{
iFirst [iField] = i;
iLength[iField] = pList->Get_Record(iField)->asInt(1);
i += iLength[iField];
CSG_String Name = bHeader ? sLine.Mid(iFirst[iField], iLength[iField]) : CSG_String(pList->Get_Record(iField)->asString(0));
switch( pList->Get_Record(iField)->asInt(2) )
{
case 0:
pTable->Add_Field(Name, SG_DATATYPE_String);
break;
case 1:
pTable->Add_Field(Name, SG_DATATYPE_Short);
break;
case 2:
pTable->Add_Field(Name, SG_DATATYPE_Int);
break;
case 3:
pTable->Add_Field(Name, SG_DATATYPE_Float);
break;
default:
case 4:
pTable->Add_Field(Name, SG_DATATYPE_Double);
break;
}
}
}
break;
}
//-----------------------------------------------------
if( bHeader )
{
Stream.Read_Line(sLine);
}
//-----------------------------------------------------
int fLength = Stream.Length();
do
{
if( sLine.Length() == nChars )
{
CSG_Table_Record *pRecord = pTable->Add_Record();
for(iField=0; iField<nFields; iField++)
{
pRecord->Set_Value(iField, sLine.Mid(iFirst[iField], iLength[iField]));
}
}
}
while( Stream.Read_Line(sLine) && Set_Progress(Stream.Tell(), fLength) );
//-----------------------------------------------------
delete[](iFirst);
delete[](iLength);
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGW_Multi_Regression::On_Execute(void)
{
int i;
//-----------------------------------------------------
m_pPoints = Parameters("POINTS") ->asShapes();
m_iDependent = Parameters("DEPENDENT") ->asInt();
m_Radius = Parameters("RANGE") ->asInt() == 0 ? Parameters("RADIUS") ->asDouble() : 0.0;
m_Mode = Parameters("MODE") ->asInt();
m_nPoints_Max = Parameters("NPOINTS") ->asInt() == 0 ? Parameters("MAXPOINTS")->asInt() : 0;
m_nPoints_Min = Parameters("MINPOINTS") ->asInt();
m_Weighting.Set_Parameters(Parameters("WEIGHTING")->asParameters());
//-----------------------------------------------------
if( !Get_Predictors() )
{
Finalize();
return( false );
}
if( (m_nPoints_Max > 0 || m_Radius > 0.0) && !m_Search.Create(m_pPoints, -1) )
{
Finalize();
return( false );
}
//-----------------------------------------------------
m_pQuality = NULL;
m_pIntercept = NULL;
m_pSlopes = (CSG_Grid **)SG_Calloc(m_nPredictors, sizeof(CSG_Grid *));
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(m_pPoints->Get_Extent()) && Dlg_Parameters("USER") )
{
m_pQuality = m_Grid_Target.Get_User(SG_T("QUALITY" ));
m_pIntercept = m_Grid_Target.Get_User(SG_T("INTERCEPT"));
for(i=0; i<m_nPredictors; i++)
{
m_pSlopes[i] = m_Grid_Target.Get_User(SG_Get_String(i, 0));
}
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
m_pQuality = m_Grid_Target.Get_Grid(SG_T("QUALITY" ));
m_pIntercept = m_Grid_Target.Get_Grid(SG_T("INTERCEPT"));
for(i=0; i<m_nPredictors; i++)
{
m_pSlopes[i] = m_Grid_Target.Get_Grid(SG_Get_String(i, 0));
}
}
break;
}
if( m_pQuality == NULL )
{
Finalize();
return( false );
}
m_pQuality ->Set_Name(CSG_String::Format(SG_T("%s (%s)"), m_pPoints->Get_Name(), _TL("GWR Quality")));
m_pIntercept->Set_Name(CSG_String::Format(SG_T("%s (%s)"), m_pPoints->Get_Name(), _TL("GWR Intercept")));
for(i=0; i<m_nPredictors; i++)
{
m_pSlopes[i]->Set_Name(CSG_String::Format(SG_T("%s (%s)"), m_pPoints->Get_Name(), m_pPoints->Get_Field_Name(m_iPredictor[i])));
}
//-----------------------------------------------------
int nPoints_Max = m_nPoints_Max > 0 ? m_nPoints_Max : m_pPoints->Get_Count();
m_y.Create(1 + m_nPredictors, nPoints_Max);
m_z.Create(nPoints_Max);
m_w.Create(nPoints_Max);
//-----------------------------------------------------
for(int y=0; y<m_pIntercept->Get_NY() && Set_Progress(y, m_pIntercept->Get_NY()); y++)
{
for(int x=0; x<m_pIntercept->Get_NX(); x++)
{
if( !Get_Regression(x, y) )
{
m_pQuality ->Set_NoData(x, y);
m_pIntercept->Set_NoData(x, y);
for(i=0; i<m_nPredictors; i++)
{
m_pSlopes[i]->Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
Finalize();
return( true );
}
//---------------------------------------------------------
bool CPointcloud_To_Text_File::On_Execute(void)
{
CSG_PointCloud *pPoints;
CSG_String fileName;
CSG_File *pTabStream = NULL;
bool bWriteHeader;
CSG_String fieldSep;
CSG_Parameters P;
CSG_Parameter *pNode;
CSG_String s;
std::vector<int> vCol, vPrecision;
//-----------------------------------------------------
pPoints = Parameters("POINTS") ->asPointCloud();
fileName = Parameters("FILE") ->asString();
bWriteHeader = Parameters("WRITE_HEADER")->asBool();
switch (Parameters("FIELDSEP")->asInt())
{
default:
case 0: fieldSep = "\t"; break;
case 1: fieldSep = " "; break;
case 2: fieldSep = ","; break;
}
if( fileName.Length() == 0 )
{
SG_UI_Msg_Add_Error(_TL("Please provide an output file name!"));
return( false );
}
if (SG_UI_Get_Window_Main())
{
P.Set_Name(_TL("Check the fields to export"));
for(int iField=0; iField<pPoints->Get_Field_Count(); iField++)
{
s.Printf(SG_T("NODE_%03d") , iField + 1);
pNode = P.Add_Node(NULL, s, CSG_String::Format(_TL("%d. %s"), iField + 1, _TL("Field")), _TL(""));
s.Printf(SG_T("FIELD_%03d"), iField);
P.Add_Value(pNode, s, CSG_String::Format(SG_T("%s"), pPoints->Get_Field_Name(iField)), _TL(""), PARAMETER_TYPE_Bool, false);
s.Printf(SG_T("PRECISION_%03d"), iField);
P.Add_Value(pNode, s, _TL("Decimal Precision"), _TL(""), PARAMETER_TYPE_Int, 2.0, 0.0, true);
}
//-----------------------------------------------------
if( Dlg_Parameters(&P, _TL("Field Properties")) )
{
vCol.clear();
vPrecision.clear();
for(int iField=0; iField<pPoints->Get_Field_Count(); iField++)
{
if( P(CSG_String::Format(SG_T("FIELD_%03d" ), iField).c_str())->asBool() )
{
vCol.push_back(iField);
vPrecision.push_back(P(CSG_String::Format(SG_T("PRECISION_%03d" ), iField).c_str())->asInt());
}
}
}
else
return( false );
}
else // CMD
{
CSG_String sFields, sPrecision;
CSG_String token;
int iValue;
sFields = Parameters("FIELDS")->asString();
sPrecision = Parameters("PRECISIONS")->asString();
CSG_String_Tokenizer tkz_fields(sFields, ";", SG_TOKEN_STRTOK);
while( tkz_fields.Has_More_Tokens() )
{
token = tkz_fields.Get_Next_Token();
if( token.Length() == 0 )
break;
if( !token.asInt(iValue) )
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: can't convert to number"));
return( false );
}
iValue -= 1;
if( iValue < 0 || iValue > pPoints->Get_Field_Count() - 1 )
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: field index out of range"));
return( false );
}
else
vCol.push_back(iValue);
}
CSG_String_Tokenizer tkz_precisons(sPrecision.c_str(), ";", SG_TOKEN_STRTOK);
while( tkz_precisons.Has_More_Tokens() )
{
token = tkz_precisons.Get_Next_Token();
if( token.Length() == 0 )
break;
if( !token.asInt(iValue) )
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: can't convert to number"));
return( false );
}
vPrecision.push_back(iValue);
}
}
if( vCol.size() == 0 )
{
SG_UI_Msg_Add_Error(_TL("Please provide at least one column to export!"));
return( false );
}
if( vCol.size() != vPrecision.size() )
{
SG_UI_Msg_Add_Error(_TL("Number of fields and precisions must be equal!"));
return( false );
}
//-----------------------------------------------------
pTabStream = new CSG_File();
if( !pTabStream->Open(fileName, SG_FILE_W, false) )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to open output file %s!"), fileName.c_str()));
delete (pTabStream);
return (false);
}
if( bWriteHeader )
{
CSG_String sHeader;
for(size_t i=0; i<vCol.size(); i++)
{
sHeader += CSG_String::Format(SG_T("%s"), pPoints->Get_Field_Name(vCol.at(i)));
if( i < vCol.size()-1 )
sHeader += fieldSep.c_str();
}
sHeader += SG_T("\n");
pTabStream->Write(sHeader);
}
for(int iPoint=0; iPoint<pPoints->Get_Count() && Set_Progress(iPoint, pPoints->Get_Count()); iPoint++)
{
CSG_String sLine;
for(size_t i=0; i<vCol.size(); i++)
{
switch (pPoints->Get_Field_Type(vCol.at(i)))
{
case SG_DATATYPE_Double:
case SG_DATATYPE_Float:
sLine += SG_Get_String(pPoints->Get_Value(iPoint, vCol.at(i)), vPrecision.at(i), false);
break;
default:
sLine += CSG_String::Format(SG_T("%d"), (int)pPoints->Get_Value(iPoint, vCol.at(i)));
break;
}
if( i < vCol.size()-1 )
sLine += fieldSep.c_str();
}
sLine += SG_T("\n");
pTabStream->Write(sLine);
}
pTabStream->Close();
delete (pTabStream);
return( true );
}
//---------------------------------------------------------
bool CShapes2Grid::On_Execute(void)
{
int iField, iShape, iType;
//-----------------------------------------------------
m_pShapes = Parameters("INPUT") ->asShapes();
m_Method_Lines = Parameters("LINE_TYPE") ->asInt();
iField = Parameters("FIELD") ->asInt();
iType = Parameters("GRID_TYPE") ->asInt();
if( iField < 0 || iField >= m_pShapes->Get_Field_Count() || m_pShapes->Get_Field_Type(iField) == SG_DATATYPE_String )
{
iField = -1;
Message_Add(_TL("WARNING: selected attribute is not numeric; generating unique identifiers instead."));
}
//-----------------------------------------------------
m_pGrid = NULL;
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(m_pShapes->Get_Extent()) && Dlg_Parameters("USER") )
{
m_pGrid = m_Grid_Target.Get_User(Get_Grid_Type(iType));
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
m_pGrid = m_Grid_Target.Get_Grid(Get_Grid_Type(iType));
}
break;
}
if( m_pGrid == NULL )
{
return( false );
}
//-------------------------------------------------
m_pGrid->Set_Name(CSG_String::Format(SG_T("%s [%s]"), m_pShapes->Get_Name(), iField < 0 ? _TL("ID") : m_pShapes->Get_Field_Name(iField)));
m_pGrid->Assign_NoData();
m_pLock = m_pShapes->Get_Type() == SHAPE_TYPE_Point ? NULL : SG_Create_Grid(m_pGrid, SG_DATATYPE_Byte);
//-----------------------------------------------------
for(iShape=0, m_Lock_ID=1; iShape<m_pShapes->Get_Count() && Set_Progress(iShape, m_pShapes->Get_Count()); iShape++, m_Lock_ID++)
{
CSG_Shape *pShape = m_pShapes->Get_Shape(iShape);
if( m_pShapes->Get_Selection_Count() <= 0 || pShape->is_Selected() )
{
if( iField < 0 || !pShape->is_NoData(iField) )
{
m_Value = iField < 0 ? iShape + 1 : pShape->asDouble(iField);
if( pShape->Intersects(m_pGrid->Get_Extent().m_rect) )
{
switch( m_pShapes->Get_Type() )
{
case SHAPE_TYPE_Point:
case SHAPE_TYPE_Points: Set_Points (pShape); break;
case SHAPE_TYPE_Line: Set_Line (pShape); break;
case SHAPE_TYPE_Polygon: Set_Polygon (pShape); break;
}
}
}
}
}
//-----------------------------------------------------
if( m_pLock )
{
delete(m_pLock);
}
return( true );
}
//---------------------------------------------------------
bool CPolygonStatisticsFromPoints::On_Execute(void)
{
int i, j, n, Offset, *bAttribute;
CSG_Simple_Statistics *Statistics;
CSG_Parameters *pParameters;
CSG_Shapes *pPolygons, *pPoints;
//-----------------------------------------------------
pPoints = Parameters("POINTS") ->asShapes();
pPolygons = Parameters("POLYGONS") ->asShapes();
if( pPolygons->Get_Count() <= 0 || pPoints->Get_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
pParameters = Get_Parameters("ATTRIBUTES");
pParameters->Del_Parameters();
for(i=0; i<pPoints->Get_Field_Count(); i++)
{
if( SG_Data_Type_is_Numeric(pPoints->Get_Field_Type(i)) )
{
CSG_Parameter *pNode = pParameters->Add_Node(NULL, CSG_String::Format(SG_T("%d"), i), pPoints->Get_Field_Name(i), _TL(""));
for(j=0; j<STAT_Count; j++)
{
pParameters->Add_Value(pNode,
CSG_String::Format(SG_T("%d|%d"), i, j),
CSG_String::Format(SG_T("[%s]"), STAT_Name[j].c_str()),
_TL(""), PARAMETER_TYPE_Bool, false
);
}
}
}
if( !Dlg_Parameters("ATTRIBUTES") )
{
return( false );
}
//-----------------------------------------------------
if( Parameters("STATISTICS")->asShapes() == NULL )
{
Parameters("STATISTICS")->Set_Value(pPolygons);
}
else if( pPolygons != Parameters("STATISTICS")->asShapes() )
{
Parameters("STATISTICS")->asShapes()->Assign(pPolygons);
pPolygons = Parameters("STATISTICS")->asShapes();
}
//-----------------------------------------------------
bAttribute = new int[pPoints->Get_Field_Count()];
Offset = pPolygons->Get_Field_Count();
for(i=0, n=0; i<pPoints->Get_Field_Count(); i++)
{
bAttribute[i] = 0;
if( SG_Data_Type_is_Numeric(pPoints->Get_Field_Type(i)) )
{
for(j=0; j<STAT_Count; j++)
{
CSG_Parameter *pParameter = pParameters->Get_Parameter(CSG_String::Format(SG_T("%d|%d"), i, j));
if( pParameter && pParameter->asBool() )
{
bAttribute[i] |= STAT_Flag[j];
pPolygons->Add_Field(CSG_String::Format(SG_T("%s_%s"), pPoints->Get_Field_Name(i), STAT_Name[j].c_str()), SG_DATATYPE_Double);
n++;
}
}
}
}
if( n == 0 )
{
delete[](bAttribute);
return( false );
}
//-----------------------------------------------------
Statistics = new CSG_Simple_Statistics[pPoints->Get_Field_Count()];
for(int iPolygon=0; iPolygon<pPolygons->Get_Count() && Set_Progress(iPolygon, pPolygons->Get_Count()); iPolygon++)
{
CSG_Shape_Polygon *pPolygon = (CSG_Shape_Polygon *)pPolygons->Get_Shape(iPolygon);
//-------------------------------------------------
for(i=0; i<pPoints->Get_Field_Count(); i++)
{
Statistics[i].Invalidate();
}
//-------------------------------------------------
for(int iPoint=0; iPoint<pPoints->Get_Count() && Process_Get_Okay(); iPoint++)
{
CSG_Shape *pPoint = pPoints->Get_Shape(iPoint);
if( pPolygon->is_Containing(pPoint->Get_Point(0)) )
{
for(i=0; i<pPoints->Get_Field_Count(); i++)
{
if( bAttribute[i] )
{
Statistics[i].Add_Value(pPoint->asDouble(i));
}
}
}
}
//-------------------------------------------------
for(i=0, n=Offset; i<pPoints->Get_Field_Count(); i++)
{
if( bAttribute[i] )
{
if( Statistics[i].Get_Count() > 0 )
{
if( bAttribute[i] & STAT_Flag[STAT_Sum] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Sum()); }
if( bAttribute[i] & STAT_Flag[STAT_Avg] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Mean()); }
if( bAttribute[i] & STAT_Flag[STAT_Var] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Variance()); }
if( bAttribute[i] & STAT_Flag[STAT_Dev] ) { pPolygon->Set_Value(n++, Statistics[i].Get_StdDev()); }
if( bAttribute[i] & STAT_Flag[STAT_Min] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Minimum()); }
if( bAttribute[i] & STAT_Flag[STAT_Max] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Maximum()); }
if( bAttribute[i] & STAT_Flag[STAT_Num] ) { pPolygon->Set_Value(n++, Statistics[i].Get_Count()); }
}
else
{
if( bAttribute[i] & STAT_Flag[STAT_Sum] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Avg] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Var] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Dev] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Min] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Max] ) { pPolygon->Set_NoData(n++); }
if( bAttribute[i] & STAT_Flag[STAT_Num] ) { pPolygon->Set_NoData(n++); }
}
}
}
}
//-----------------------------------------------------
delete[](Statistics);
delete[](bAttribute);
DataObject_Update(pPolygons);
return( true );
}
//---------------------------------------------------------
bool CPointCloud_From_Text_File::On_Execute(void)
{
CSG_String fileName;
int iField, iType;
TSG_Data_Type Type;
CSG_String Name, Types, s;
CSG_PointCloud *pPoints;
CSG_Parameters P;
CSG_Parameter *pNode;
int xField, yField, zField, nAttribs, max_iField;
bool bSkipHeader;
char fieldSep;
std::vector<int> vCol;
std::ifstream tabStream;
std::string tabLine;
double lines;
long cntPt, cntInvalid;
double x, y, z, value;
//-----------------------------------------------------
fileName = Parameters("FILE") ->asString();
xField = Parameters("XFIELD") ->asInt() - 1;
yField = Parameters("YFIELD") ->asInt() - 1;
zField = Parameters("ZFIELD") ->asInt() - 1;
nAttribs = Parameters("ATTRIBS") ->asInt();
bSkipHeader = Parameters("SKIP_HEADER") ->asBool();
switch (Parameters("FIELDSEP")->asInt())
{
default:
case 0: fieldSep = '\t'; break;
case 1: fieldSep = ' '; break;
case 2: fieldSep = ','; break;
}
Types.Printf(SG_T("%s|%s|%s|%s|%s|"),
_TL("1 byte integer"),
_TL("2 byte integer"),
_TL("4 byte integer"),
_TL("4 byte floating point"),
_TL("8 byte floating point")
);
P.Set_Name(_TL("Attribute Field Properties"));
for(iField=1; iField<=nAttribs; iField++)
{
s.Printf(SG_T("NODE_%03d") , iField);
pNode = P.Add_Node(NULL, s, CSG_String::Format(SG_T("%d. %s"), iField, _TL("Field")), _TL(""));
s.Printf(SG_T("FIELD_%03d"), iField);
P.Add_String(pNode, s, _TL("Name"), _TL(""), s);
s.Printf(SG_T("COLUMN_%03d"), iField);
P.Add_Value(pNode, s, _TL("Attribute is Column ..."), _TL(""), PARAMETER_TYPE_Int, iField+3, 1, true);
s.Printf(SG_T("TYPE_%03d") , iField);
P.Add_Choice(pNode, s, _TL("Type"), _TL(""), Types, 3);
}
//-----------------------------------------------------
if( nAttribs > 0 )
{
if( Dlg_Parameters(&P, _TL("Field Properties")) )
{
pPoints = SG_Create_PointCloud();
pPoints->Set_Name(SG_File_Get_Name(fileName, false));
Parameters("POINTS")->Set_Value(pPoints);
for(iField=0; iField<nAttribs; iField++)
{
Name = P(CSG_String::Format(SG_T("FIELD_%03d" ), iField + 1).c_str())->asString();
iType = P(CSG_String::Format(SG_T("TYPE_%03d" ), iField + 1).c_str())->asInt();
vCol.push_back(P(CSG_String::Format(SG_T("COLUMN_%03d"), iField + 1).c_str())->asInt() - 1);
switch( iType )
{
default:
case 0: Type = SG_DATATYPE_Char; break;
case 1: Type = SG_DATATYPE_Short; break;
case 2: Type = SG_DATATYPE_Int; break;
case 3: Type = SG_DATATYPE_Float; break;
case 4: Type = SG_DATATYPE_Double; break;
}
pPoints->Add_Field(Name, Type);
}
}
else
return( false );
}
else
{
pPoints = SG_Create_PointCloud();
pPoints->Create();
pPoints->Set_Name(SG_File_Get_Name(fileName, false));
Parameters("POINTS")->Set_Value(pPoints);
}
max_iField = M_GET_MAX(xField, yField);
max_iField = M_GET_MAX(max_iField, zField);
for( unsigned int i=0; i<vCol.size(); i++ )
{
if( max_iField < vCol.at(i) )
max_iField = vCol.at(i);
}
// open input stream
//---------------------------------------------------------
tabStream.open(fileName.b_str(), std::ifstream::in);
if( !tabStream )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to open input file!")));
return (false);
}
tabStream.seekg(0, std::ios::end); // get length of file
lines = (double)tabStream.tellg();
tabStream.seekg(0, std::ios::beg);
std::getline(tabStream, tabLine); // as a workaround we assume the number of lines from the length of the first line
lines = lines / (double)tabStream.tellg();
if( !bSkipHeader )
{
tabStream.clear(); // let's forget we may have reached the EOF
tabStream.seekg(0, std::ios::beg); // and rewind to the beginning
}
// import
//---------------------------------------------------------
cntPt = cntInvalid = 0;
SG_UI_Process_Set_Text(CSG_String::Format(_TL("Importing data ...")));
while( std::getline(tabStream, tabLine) )
{
std::istringstream stream(tabLine);
std::vector<std::string> tabCols;
std::string tabEntry;
if( cntPt%10000 == 0 )
SG_UI_Process_Set_Progress((double)cntPt, lines);
cntPt++;
while( std::getline(stream, tabEntry, fieldSep) ) // read every column in this line and fill vector
{
if (tabEntry.length() == 0)
continue;
tabCols.push_back(tabEntry);
}
if ((int)tabCols.size() < max_iField - 1 )
{
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: Skipping misformatted line (%.0f)!"), cntPt), true);
cntInvalid++;
continue;
}
x = strtod(tabCols[xField].c_str(), NULL);
y = strtod(tabCols[yField].c_str(), NULL);
z = strtod(tabCols[zField].c_str(), NULL);
pPoints->Add_Point(x, y, z);
for( int i=0; i<nAttribs; i++ )
{
value = strtod(tabCols.at(vCol.at(i)).c_str(), NULL);
pPoints->Set_Attribute(i, value);
}
}
// finalize
//---------------------------------------------------------
tabStream.close();
CSG_Parameters sParms;
DataObject_Get_Parameters(pPoints, sParms);
if (sParms("COLORS_ATTRIB") && sParms("COLORS_TYPE") && sParms("METRIC_COLORS")
&& sParms("METRIC_ZRANGE") && sParms("COLORS_AGGREGATE"))
{
sParms("COLORS_AGGREGATE")->Set_Value(3); // highest z
sParms("COLORS_TYPE")->Set_Value(2); // graduated color
sParms("METRIC_COLORS")->asColors()->Set_Count(255); // number of colors
sParms("COLORS_ATTRIB")->Set_Value(2); // z attrib
sParms("METRIC_ZRANGE")->asRange()->Set_Range(pPoints->Get_Minimum(2),pPoints->Get_Maximum(2));
DataObject_Set_Parameters(pPoints, sParms);
DataObject_Update(pPoints);
}
if (cntInvalid > 0)
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: Skipped %d invalid points!"), cntInvalid), true);
SG_UI_Msg_Add(CSG_String::Format(_TL("%d points sucessfully imported."), (cntPt-cntInvalid)), true);
return( true );
}
//---------------------------------------------------------
bool CDirect_Georeferencing::On_Execute(void)
{
//-----------------------------------------------------
if( !m_Georeferencer.Set_Transformation(Parameters, Get_NX(), Get_NY()) )
{
return( false );
}
//-----------------------------------------------------
CSG_Grid *pDEM = Parameters("DEM" )->asGrid();
double zRef = Parameters("ZREF" )->asDouble();
bool bFlip = Parameters("ROW_ORDER")->asInt() == 1;
//-----------------------------------------------------
TSG_Grid_Resampling Resampling;
switch( Parameters("RESAMPLING")->asInt() )
{
default: Resampling = GRID_RESAMPLING_NearestNeighbour; break;
case 1: Resampling = GRID_RESAMPLING_Bilinear; break;
case 2: Resampling = GRID_RESAMPLING_BicubicSpline; break;
case 3: Resampling = GRID_RESAMPLING_BSpline; break;
}
//-----------------------------------------------------
TSG_Point p[4];
p[0] = m_Georeferencer.Image_to_World( 0, 0, zRef);
p[1] = m_Georeferencer.Image_to_World(Get_NX(), 0, zRef);
p[2] = m_Georeferencer.Image_to_World(Get_NX(), Get_NY(), zRef);
p[3] = m_Georeferencer.Image_to_World( 0, Get_NY(), zRef);
CSG_Rect r(p[0], p[1]); r.Union(p[2]); r.Union(p[3]);
//-----------------------------------------------------
CSG_Shapes *pShapes = Parameters("EXTENT")->asShapes();
if( pShapes )
{
pShapes->Create(SHAPE_TYPE_Polygon, _TL("Extent"));
pShapes->Add_Field(_TL("OID"), SG_DATATYPE_Int);
CSG_Shape *pExtent = pShapes->Add_Shape();
pExtent->Add_Point(p[0]);
pExtent->Add_Point(p[1]);
pExtent->Add_Point(p[2]);
pExtent->Add_Point(p[3]);
}
//-----------------------------------------------------
double Cellsize = SG_Get_Distance(p[0], p[1]) / Get_NX();
CSG_Grid_System System(Cellsize, r);
m_Grid_Target.Set_User_Defined(Get_Parameters("TARGET"), r, Get_NX());
if( !Dlg_Parameters("TARGET") )
{
return( false );
}
System = m_Grid_Target.Get_System();
if( !System.is_Valid() )
{
return( false );
}
//-----------------------------------------------------
CSG_Parameter_Grid_List *pInput = Parameters("INPUT" )->asGridList();
CSG_Parameter_Grid_List *pOutput = Parameters("OUTPUT")->asGridList();
pOutput->Del_Items();
if( pInput->Get_Count() <= 0 )
{
return( false );
}
else
{
TSG_Data_Type Type;
switch( Parameters("DATA_TYPE")->asInt() )
{
case 0: Type = SG_DATATYPE_Byte; break;
case 1: Type = SG_DATATYPE_Char; break;
case 2: Type = SG_DATATYPE_Word; break;
case 3: Type = SG_DATATYPE_Short; break;
case 4: Type = SG_DATATYPE_DWord; break;
case 5: Type = SG_DATATYPE_Int; break;
case 6: Type = SG_DATATYPE_Float; break;
case 7: Type = SG_DATATYPE_Double; break;
default: Type = SG_DATATYPE_Undefined; break;
}
for(int i=0; i<pInput->Get_Count(); i++)
{
CSG_Grid *pGrid = SG_Create_Grid(System, Type != SG_DATATYPE_Undefined ? Type : pInput->asGrid(i)->Get_Type());
if( !pGrid || !pGrid->is_Valid() )
{
if( pGrid )
{
delete(pGrid);
}
return( false );
}
pOutput->Add_Item(pGrid);
pGrid->Set_Name(pInput->asGrid(i)->Get_Name());
}
}
//-----------------------------------------------------
for(int y=0; y<System.Get_NY() && Set_Progress(y, System.Get_NY()); y++)
{
double py = System.Get_YMin() + y * System.Get_Cellsize();
#pragma omp parallel for
for(int x=0; x<System.Get_NX(); x++)
{
double pz, px = System.Get_XMin() + x * System.Get_Cellsize();
if( !pDEM || !pDEM->Get_Value(px, py, pz) )
{
pz = zRef;
}
TSG_Point p = m_Georeferencer.World_to_Image(px, py, pz);
if( bFlip )
{
p.y = (Get_NY() - 1) - p.y;
}
for(int i=0; i<pInput->Get_Count(); i++)
{
if( pInput->asGrid(i)->Get_Value(p.x, p.y, pz, Resampling) )
{
pOutput->asGrid(i)->Set_Value(x, y, pz);
}
else
{
pOutput->asGrid(i)->Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGeoref_Grid::Get_Conversion(void)
{
//-----------------------------------------------------
CSG_Rect Extent;
CSG_Grid *pSource = Parameters("GRID")->asGrid();
//-----------------------------------------------------
if( !Get_Target_Extent(Extent, true) || !m_Grid_Target.Set_User_Defined(Get_Parameters("TARGET"), Extent, pSource->Get_NY()) )
{
Error_Set(_TL("failed to estimate target extent"));
return( false );
}
if( !Dlg_Parameters("TARGET") )
{
return( false );
}
//-----------------------------------------------------
TSG_Grid_Resampling Resampling;
switch( Parameters("RESAMPLING")->asInt() )
{
default: Resampling = GRID_RESAMPLING_NearestNeighbour; break;
case 1: Resampling = GRID_RESAMPLING_Bilinear; break;
case 2: Resampling = GRID_RESAMPLING_BicubicSpline; break;
case 3: Resampling = GRID_RESAMPLING_BSpline; break;
}
CSG_Grid *pReferenced = m_Grid_Target.Get_Grid(Resampling == GRID_RESAMPLING_NearestNeighbour ? pSource->Get_Type() : SG_DATATYPE_Float);
if( !pReferenced )
{
Error_Set(_TL("failed to initialize target grid"));
return( false );
}
//-----------------------------------------------------
if( !Set_Grid(pSource, pReferenced, Resampling) )
{
Error_Set(_TL("failed to project target grid"));
return( false );
}
//-----------------------------------------------------
CSG_Parameters P;
if( DataObject_Get_Parameters(pSource, P) )
{
DataObject_Add(pReferenced);
DataObject_Set_Parameters(pReferenced, P);
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CBSL_Interpreter::On_Execute(void)
{
//-----------------------------------------------------
Parameters("OUTPUT")->asGridList()->Del_Items();
g_bProgress = Parameters("PROGRESS")->asBool();
if( m_bFile )
{
CSG_File Stream;
if( !Stream.Open(Parameters("BSL")->asString(), SG_FILE_R, false) )
{
return( false );
}
Stream.Read(m_BSL, Stream.Length());
}
else
{
m_BSL = Parameters("BSL")->asString();
}
//-----------------------------------------------------
if( !Parse_Vars(false) )
{
return( false );
}
//-----------------------------------------------------
CSG_Parameters Input(this, _TL("Input"), _TL(""), SG_T("INPUT"), true);
FindMemoryGrids();
for(T_InputText::iterator it=InputGrids.begin(); it!=InputGrids.end(); it++)
{
CSG_String sName(it->c_str());
Input.Add_Grid(NULL, sName, sName, _TL(""), PARAMETER_INPUT, true);
}
DeleteVarList();
DeleteAnweisungList(AnweisungList);
if( Dlg_Parameters(&Input, _TL("Input")) == false )
{
return( false );
}
//-----------------------------------------------------
if( !Parse_Vars(true) )
{
return( false );
}
//-----------------------------------------------------
g_pInterpreter = this;
if( GetMemoryGrids(&Input) )
{
try
{
ausfuehren_anweisung(AnweisungList);
}
catch(BBFehlerAusfuehren x)
{
if( x.Text == "" )
Message_Add(_TL("unknown error: execution"));
else
Message_Add(CSG_String::Format(SG_T("error: %s\n"), CSG_String(x.Text.c_str()).c_str()));
}
catch(BBFehlerUserbreak x)
{
if( x.Text == "" )
Message_Add(_TL("unknown error: user break"));
else
Message_Add(CSG_String::Format(SG_T("error: %s\n"), CSG_String(x.Text.c_str()).c_str()));
}
}
g_pInterpreter = NULL;
DeleteVarList();
DeleteAnweisungList(AnweisungList);
return( true );
}
//---------------------------------------------------------
bool CGrid_Merge::Initialize(void)
{
//-----------------------------------------------------
m_pMosaic = NULL;
m_Overlap = Parameters("OVERLAP" )->asInt();
m_pGrids = Parameters("GRIDS" )->asGridList();
m_dBlend = Parameters("BLEND_DIST")->asDouble();
if( m_pGrids->Get_Count() < 2 )
{
Error_Set(_TL("nothing to do, there are less than two grids in input list."));
return( false );
}
Set_Target(Get_Parameters("TARGET"), m_pGrids); Dlg_Parameters("TARGET"); // if called from saga_cmd
//-----------------------------------------------------
switch( Parameters("INTERPOL")->asInt() )
{
default:
case 0: m_Interpolation = GRID_INTERPOLATION_NearestNeighbour; break; // Nearest Neighbor
case 1: m_Interpolation = GRID_INTERPOLATION_Bilinear; break; // Bilinear Interpolation
case 2: m_Interpolation = GRID_INTERPOLATION_InverseDistance; break; // Inverse Distance Interpolation
case 3: m_Interpolation = GRID_INTERPOLATION_BicubicSpline; break; // Bicubic Spline Interpolation
case 4: m_Interpolation = GRID_INTERPOLATION_BSpline; break; // B-Spline Interpolation
}
//-----------------------------------------------------
TSG_Data_Type Type;
switch( Parameters("TYPE")->asInt() )
{
default: Type = SG_DATATYPE_Float; break;
case 0: Type = SG_DATATYPE_Bit; break;
case 1: Type = SG_DATATYPE_Byte; break;
case 2: Type = SG_DATATYPE_Char; break;
case 3: Type = SG_DATATYPE_Word; break;
case 4: Type = SG_DATATYPE_Short; break;
case 5: Type = SG_DATATYPE_DWord; break;
case 6: Type = SG_DATATYPE_Int; break;
case 7: Type = SG_DATATYPE_Float; break;
case 8: Type = SG_DATATYPE_Double; break;
}
if( (m_pMosaic = m_Grid_Target.Get_Grid(Type)) == NULL )
{
return( false );
}
if( m_pMosaic->Get_Type() != Type && !m_pMosaic->Create(m_pMosaic->Get_System(), Type) )
{
return( false );
}
//-----------------------------------------------------
m_pMosaic->Set_Name(Parameters("NAME")->asString());
m_pMosaic->Assign_NoData();
//-----------------------------------------------------
switch( m_Overlap )
{
case 4: // mean
if( !m_Weights.Create(m_pMosaic->Get_System(), m_pGrids->Get_Count() < 256 ? SG_DATATYPE_Byte : SG_DATATYPE_Word) )
{
Error_Set(_TL("could not create weights grid"));
return( false );
}
break;
case 6: // feathering
if( !m_Weights.Create(m_pMosaic->Get_System(), SG_DATATYPE_Word) )
{
Error_Set(_TL("could not create weights grid"));
return( false );
}
m_Weights.Set_Scaling(m_pMosaic->Get_Cellsize());
break;
}
return( true );
}
//---------------------------------------------------------
bool CWMS_Import::Get_Map(wxHTTP *pServer, const CSG_String &Directory, CWMS_Capabilities &Cap)
{
bool bResult = false;
int i, n;
CSG_Rect r(Cap.m_Extent);
CSG_Parameters p;
//-----------------------------------------------------
// if( Cap.m_MaxWidth > 2 && NX > Cap.m_MaxWidth ) NX = Cap.m_MaxWidth;
// if( Cap.m_MaxHeight > 2 && NY > Cap.m_MaxHeight ) NY = Cap.m_MaxHeight;
p.Add_Range (NULL , "X_RANGE" , _TL("X Range") , _TL(""), r.Get_XMin(), r.Get_XMax(), r.Get_XMin(), r.Get_XRange() > 0.0, r.Get_XMax(), r.Get_XRange() > 0.0);
p.Add_Range (NULL , "Y_RANGE" , _TL("Y Range") , _TL(""), r.Get_YMin(), r.Get_YMax(), r.Get_YMin(), r.Get_YRange() > 0.0, r.Get_YMax(), r.Get_YRange() > 0.0);
p.Add_Value (NULL , "CELLSIZE", _TL("Cellsize") , _TL(""), PARAMETER_TYPE_Double, r.Get_XRange() / 2001.0, 0.0, true);
p.Add_Choice(NULL , "FORMAT" , _TL("Format") , _TL(""), Cap.m_Formats);
p.Add_Choice(NULL , "PROJ" , _TL("Projections"), _TL(""), Cap.m_Projections);
CSG_Parameter *pNode = p("FORMAT");
for(i=0; i<pNode->asChoice()->Get_Count(); i++)
{
CSG_String s(pNode->asChoice()->Get_Item(i));
if( !s.CmpNoCase(SG_T("image/png")) )
pNode->Set_Value(i);
}
for(i=0; i<Cap.m_Layers_Name.Get_Count(); i++)
{
p.Add_Value(NULL, Cap.m_Layers_Name[i], Cap.m_Layers_Title[i], "", PARAMETER_TYPE_Bool, false);
}
//-----------------------------------------------------
if( pServer && Dlg_Parameters(&p, _TL("WMS Import")) )
{
int NX, NY;
double Cellsize;
CSG_String Layers, Format;
//-------------------------------------------------
r.Assign(
p("X_RANGE")->asRange()->Get_LoVal(),
p("Y_RANGE")->asRange()->Get_LoVal(),
p("X_RANGE")->asRange()->Get_HiVal(),
p("Y_RANGE")->asRange()->Get_HiVal()
);
Cellsize = p("CELLSIZE") ->asDouble();
NX = 1 + (int)(r.Get_XRange() / Cellsize);
NY = 1 + (int)(r.Get_YRange() / Cellsize);
//-------------------------------------------------
Layers.Clear();
for(i=0, n=0; i<Cap.m_Layers_Name.Get_Count(); i++)
{
if( p(Cap.m_Layers_Name[i])->asBool() )
{
if( n++ > 0 ) Layers += ",";
Layers += Cap.m_Layers_Name[i];
}
}
if( n == 0 )
{
return( false );
}
//-------------------------------------------------
wxBitmapType tFormat;
Format = p("FORMAT")->asString();
if( Format.Contains(SG_T("image/gif" )) ) tFormat = wxBITMAP_TYPE_GIF ;
else if( Format.Contains(SG_T("image/jpeg")) ) tFormat = wxBITMAP_TYPE_JPEG;
else if( Format.Contains(SG_T("image/png" )) ) tFormat = wxBITMAP_TYPE_PNG ;
else if( Format.Contains(SG_T("image/wbmp")) ) tFormat = wxBITMAP_TYPE_BMP ;
else if( Format.Contains(SG_T("image/bmp" )) ) tFormat = wxBITMAP_TYPE_BMP ;
else if( Format.Contains(SG_T("image/tiff")) ) tFormat = wxBITMAP_TYPE_TIF ;
else if( Format.Contains(SG_T("GIF" )) ) tFormat = wxBITMAP_TYPE_GIF ;
else if( Format.Contains(SG_T("JPEG" )) ) tFormat = wxBITMAP_TYPE_JPEG;
else if( Format.Contains(SG_T("PNG" )) ) tFormat = wxBITMAP_TYPE_PNG ;
else
{
return( false );
}
//-------------------------------------------------
CSG_String sRequest(Directory);
sRequest += SG_T("?SERVICE=WMS");
sRequest += SG_T("&VERSION=") + Cap.m_Version;
sRequest += SG_T("&REQUEST=GetMap");
sRequest += SG_T("&LAYERS=") + Layers;
if( Cap.m_Projections.Length() > 0 )
sRequest += CSG_String(S_SRS(Cap.m_Version)) + p("PROJ")->asString();
sRequest += SG_T("&FORMAT=") + Format;
sRequest += CSG_String::Format(SG_T("&WIDTH=%d&HEIGHT=%d"), NX, NY);
sRequest += CSG_String::Format(SG_T("&BBOX=%f,%f,%f,%f"), r.m_rect.xMin, r.m_rect.yMin, r.m_rect.xMax, r.m_rect.yMax);
Message_Add(sRequest, true);
//-------------------------------------------------
wxInputStream *pStream;
if( (pStream = pServer->GetInputStream(sRequest.c_str())) == NULL )
{
Message_Add(_TL("could not open GetMap stream"));
}
else
{
wxImage Image;
if( Image.LoadFile(*pStream, tFormat) == false )
{
Message_Add(_TL("could not read image"));
CSG_String s = SG_T("\n");
pStream->SeekI(0, wxFromStart);
while( !pStream->Eof() )
{
s += (char)pStream->GetC();
}
Message_Add(s);
}
else
{
CSG_Grid *pGrid = SG_Create_Grid(SG_DATATYPE_Int, Image.GetWidth(), Image.GetHeight(), Cellsize, r.m_rect.xMin, r.m_rect.yMin);
for(int y=0, yy=pGrid->Get_NY()-1; y<pGrid->Get_NY() && Set_Progress(y, pGrid->Get_NY()); y++, yy--)
{
for(int x=0; x<pGrid->Get_NX(); x++)
{
pGrid->Set_Value(x, y, SG_GET_RGB(Image.GetRed(x, yy), Image.GetGreen(x, yy), Image.GetBlue(x, yy)));
}
}
//-----------------------------------------
pGrid->Set_Name(Cap.m_Title);
Parameters("MAP")->Set_Value(pGrid);
DataObject_Set_Colors(pGrid, 100, SG_COLORS_BLACK_WHITE);
CSG_Parameters Parms;
if( DataObject_Get_Parameters(pGrid, Parms) && Parms("COLORS_TYPE") )
{
Parms("COLORS_TYPE")->Set_Value(3); // Color Classification Type: RGB
DataObject_Set_Parameters(pGrid, Parms);
}
bResult = true;
}
delete(pStream);
}
}
return( bResult );
}
//---------------------------------------------------------
bool CGW_Regression::On_Execute(void)
{
//-----------------------------------------------------
m_pPoints = Parameters("POINTS") ->asShapes();
m_iDependent = Parameters("DEPENDENT") ->asInt();
m_iPredictor = Parameters("PREDICTOR") ->asInt();
m_Radius = Parameters("RANGE") ->asInt() == 0 ? Parameters("RADIUS") ->asDouble() : 0.0;
m_Mode = Parameters("MODE") ->asInt();
m_nPoints_Max = Parameters("NPOINTS") ->asInt() == 0 ? Parameters("MAXPOINTS")->asInt() : 0;
m_nPoints_Min = Parameters("MINPOINTS") ->asInt();
m_Weighting.Set_Parameters(Parameters("WEIGHTING")->asParameters());
//-----------------------------------------------------
if( (m_nPoints_Max > 0 || m_Radius > 0.0) && !m_Search.Create(m_pPoints, -1) )
{
return( false );
}
//-----------------------------------------------------
m_pIntercept = NULL;
m_pSlope = NULL;
m_pQuality = NULL;
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(m_pPoints->Get_Extent()) && Dlg_Parameters("USER") )
{
m_pIntercept = m_Grid_Target.Get_User(SG_T("INTERCEPT"));
m_pSlope = m_Grid_Target.Get_User(SG_T("SLOPE"));
m_pQuality = m_Grid_Target.Get_User(SG_T("QUALITY"));
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
m_pIntercept = m_Grid_Target.Get_Grid(SG_T("INTERCEPT"));
m_pSlope = m_Grid_Target.Get_Grid(SG_T("SLOPE"));
m_pQuality = m_Grid_Target.Get_Grid(SG_T("QUALITY"));
}
break;
}
if( m_pIntercept == NULL )
{
m_Search.Destroy();
return( false );
}
m_pIntercept->Set_Name(CSG_String::Format(SG_T("%s (%s)"), m_pPoints->Get_Name(), _TL("GWR Intercept")));
m_pSlope ->Set_Name(CSG_String::Format(SG_T("%s (%s)"), m_pPoints->Get_Name(), _TL("GWR Slope")));
m_pQuality ->Set_Name(CSG_String::Format(SG_T("%s (%s)"), m_pPoints->Get_Name(), _TL("GWR Quality")));
//-----------------------------------------------------
int nPoints_Max = m_nPoints_Max > 0 ? m_nPoints_Max : m_pPoints->Get_Count();
m_y.Create(nPoints_Max);
m_z.Create(nPoints_Max);
m_w.Create(nPoints_Max);
//-----------------------------------------------------
for(int y=0; y<m_pIntercept->Get_NY() && Set_Progress(y, m_pIntercept->Get_NY()); y++)
{
for(int x=0; x<m_pIntercept->Get_NX(); x++)
{
if( !Get_Regression(x, y) )
{
m_pIntercept->Set_NoData(x, y);
m_pSlope ->Set_NoData(x, y);
m_pQuality ->Set_NoData(x, y);
}
}
}
//-----------------------------------------------------
m_y.Destroy();
m_z.Destroy();
m_w.Destroy();
m_Search.Destroy();
DataObject_Update(m_pIntercept);
DataObject_Update(m_pSlope);
DataObject_Update(m_pQuality);
return( true );
}
bool CFit::On_Execute(void)
{
int i, j, NrVars;
vector < double> x, y, StartValue, Result;
CSG_String msg;
CSG_Parameters StartParameters;
const SG_Char *formel = Parameters("FORMEL")->asString();
Formel.Add_Function(SG_T("NUG"), (TSG_PFNC_Formula_1) NUG, 1, 0);
Formel.Add_Function(SG_T("SPH"), (TSG_PFNC_Formula_1) SPH, 2, 0);
Formel.Add_Function(SG_T("EXP"), (TSG_PFNC_Formula_1) EXP, 2, 0);
Formel.Add_Function(SG_T("LIN"), (TSG_PFNC_Formula_1) LIN, 2, 0);
Formel.Set_Formula(formel);
if (Formel.Get_Error(msg))
{
Message_Add(msg);
return false;
}
const SG_Char *uservars = NULL;
uservars = Formel.Get_Used_Variables();
NrVars = 0;
for (i = 0; i < SG_STR_LEN(uservars); i++)
{
if (uservars[i] >='a' && uservars[i] <= 'z')
{
if (uservars[i] != 'x')
vars[NrVars++] = uservars[i];
}
}
vars[NrVars] =(char) 0;
StartParameters.Add_Info_String(NULL, _TL(""), _TL("Formula"), _TL("Formula"), formel);
for (i = 0; i < strlen(vars); i++)
{
CSG_String c(vars[i]);
StartParameters.Add_Value(NULL, c, c, _TL("Start Value"), PARAMETER_TYPE_Double, 1.0);
}
Dlg_Parameters(&StartParameters, _TL("Start Values"));
for (i = 0; i < strlen(vars); i++)
{
char c[3];
sprintf(c, "%c", vars[i]);
StartValue.push_back(StartParameters(c)->asDouble());
}
CSG_Table *pTable = Parameters("SOURCE")->asTable();
int Record_Count = pTable->Get_Record_Count();
int yField = Parameters("YFIELD")->asInt();
int xField = Parameters("XFIELD")->asInt();
bool Use_X = Parameters("USE_X")->asBool();
pTable->Add_Field(_TL("Fit") , SG_DATATYPE_Double);
for (i = 0; i < Record_Count; i++)
{
CSG_Table_Record * Record = pTable->Get_Record(i);
if (Use_X)
{
x.push_back(Record->asDouble(xField));
}
else
{
x.push_back(i);
}
y.push_back(Record->asDouble(yField));
}
TLMFit *Fit;
Fit = new TLMFit(x, y, StartValue, FitFunc);
int max_iter = Parameters("ITER")->asInt();
double Max_lamda = Parameters("LAMDA")->asInt();
int iter = 0;
try
{
Fit->Fit();
while ((Fit->Alamda() < Max_lamda) &&(iter < max_iter) &&Process_Get_Okay(true))
{
Fit->Fit();
iter++;
}
}
catch (ESingularMatrix &E)
{
if (E.Type == 1 || E.Type == 2)
{
msg.Printf(_TL("Matrix signular\n"));
Message_Add(msg);
return false;
}
}
Result = Fit->Param();
for (i = 0; i < NrVars; i++)
{
Formel.Set_Variable(vars[i], (double) Result[i]);
}
msg.Printf(_TL("Model Parameters:"));
Message_Add(msg);
for (i = 0; i < NrVars; i++)
{
msg.Printf(SG_T("%c = %f\n"), vars[i], Result[i]);
Message_Add(msg);
}
msg.Printf(_TL("\nRMS of Residuals (stdfit):\t%f\n"), sqrt(Fit->Chisq()/x.size()));
Message_Add(msg);
msg.Printf(_TL("Correlation Matrix of the Fit Parameters:\n"));
Message_Add(msg);
vector< vector < double> > covar = Fit->Covar();
msg.Printf(_TL(""));
for (j = 0; j < NrVars; j++)
msg.Printf(SG_T("%s\t%c"), msg.c_str(), vars[j]);
msg.Printf(SG_T("%s\n"), msg.c_str());
Message_Add(msg);
for (i = 0; i < NrVars; i++)
{
msg.Printf(SG_T("%c"), vars[i]);
for (j = 0; j <= i; j++)
{
msg.Printf(SG_T("%s\t%f"), msg.c_str(), covar[i][j]/covar[i][i]);
}
msg.Printf(SG_T("%s\n"), msg.c_str());
Message_Add(msg);
}
int Field_Count = pTable->Get_Field_Count();
for (i = 0; i < Record_Count; i++)
{
CSG_Table_Record * Record = pTable->Get_Record(i);
Record->Set_Value(Field_Count - 1, Formel.Get_Value(x[i]));
}
// API_FREE (uservars);
return (true);
}
//---------------------------------------------------------
bool CShapes_Cut::Get_Extent(CSG_Rect &r)
{
m_pPolygons = NULL;
switch( Parameters("TARGET")->asInt() )
{
//-----------------------------------------------------
case 0: // user defined
Get_Parameters("CUT")->Get_Parameter("AX")->Set_Value(r.Get_XMin());
Get_Parameters("CUT")->Get_Parameter("AY")->Set_Value(r.Get_YMin());
Get_Parameters("CUT")->Get_Parameter("BX")->Set_Value(r.Get_XMax());
Get_Parameters("CUT")->Get_Parameter("BY")->Set_Value(r.Get_YMax());
Get_Parameters("CUT")->Get_Parameter("DX")->Set_Value(r.Get_XRange());
Get_Parameters("CUT")->Get_Parameter("DY")->Set_Value(r.Get_YRange());
if( Dlg_Parameters("CUT") )
{
r.Assign(
Get_Parameters("CUT")->Get_Parameter("AX")->asDouble(),
Get_Parameters("CUT")->Get_Parameter("AY")->asDouble(),
Get_Parameters("CUT")->Get_Parameter("BX")->asDouble(),
Get_Parameters("CUT")->Get_Parameter("BY")->asDouble()
);
return( true );
}
break;
//-----------------------------------------------------
case 1: // grid project
if( Dlg_Parameters("GRID") )
{
r.Assign(Get_Parameters("GRID")->Get_Parameter("GRID")->asGrid_System()->Get_Extent());
return( true );
}
break;
//-----------------------------------------------------
case 2: // shapes extent
if( Dlg_Parameters("SHAPES") )
{
r.Assign(Get_Parameters("SHAPES")->Get_Parameter("SHAPES")->asShapes()->Get_Extent());
return( true );
}
break;
//-----------------------------------------------------
case 3: // polygons
if( Dlg_Parameters("POLYGONS") )
{
r.Assign(Get_Parameters("POLYGONS")->Get_Parameter("POLYGONS")->asShapes()->Get_Extent());
m_pPolygons = Get_Parameters("POLYGONS")->Get_Parameter("POLYGONS")->asShapes();
return( true );
}
break;
}
return( false );
}
//---------------------------------------------------------
bool CPROJ4_Grid::On_Execute_Conversion(void)
{
TSG_Data_Type Type;
TSG_Rect Extent;
CSG_Grid *pSource, *pGrid;
CSG_Shapes *pShapes;
m_Interpolation = Parameters("INTERPOLATION")->asInt();
//-----------------------------------------------------
if( m_bInputList )
{
CSG_Parameter_Grid_List *pSources = Parameters("SOURCE")->asGridList();
CSG_Parameter_Grid_List *pTargets = Parameters("TARGET")->asGridList();
if( pSources->Get_Count() < 1 )
{
return( false );
}
pSource = pSources->asGrid(0);
pGrid = NULL;
pShapes = NULL;
Type = m_Interpolation == 0 ? pSource->Get_Type() : SG_DATATYPE_Float;
switch( Parameters("TARGET_TYPE")->asInt() )
{
case 0: // create new user defined grid...
if( Get_Target_Extent(pSource, Extent) && m_Grid_Target.Init_User(Extent, pSource->Get_NY()) && Dlg_Parameters("GET_USER") )
{
pGrid = m_Grid_Target.Get_User(Type);
}
break;
case 1: // select grid system...
if( Dlg_Parameters("<") && Get_Parameters("GET_SYSTEM")->Get_Parameter("SYSTEM")->asGrid_System()->is_Valid() )
{
pGrid = SG_Create_Grid(*Get_Parameters("GET_SYSTEM")->Get_Parameter("SYSTEM")->asGrid_System(), Type);
}
break;
case 2: // shapes...
if( Dlg_Parameters("GET_SHAPES") )
{
pShapes = Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->asShapes();
if( pShapes == DATAOBJECT_NOTSET || pShapes == DATAOBJECT_CREATE )
{
Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->Set_Value(pShapes = SG_Create_Shapes());
}
}
break;
}
//-------------------------------------------------
if( pShapes )
{
Parameters("SHAPES")->Set_Value(pShapes);
return( Set_Shapes(pSources, pShapes) );
}
if( pGrid )
{
pTargets->Del_Items();
pTargets->Add_Item(pGrid);
Init_Target(pSource, pGrid);
for(int i=1; i<pSources->Get_Count(); i++)
{
pTargets->Add_Item(SG_Create_Grid(pGrid->Get_System(), m_Interpolation == 0 ? pSources->asGrid(i)->Get_Type() : SG_DATATYPE_Float));
Init_Target(pSources->asGrid(i), pTargets->asGrid(i));
}
return( Set_Grids(pSources, pTargets) );
}
}
//-----------------------------------------------------
else
{
pSource = Parameters("SOURCE")->asGrid();
pGrid = NULL;
pShapes = NULL;
Type = m_Interpolation == 0 ? pSource->Get_Type() : SG_DATATYPE_Float;
switch( Parameters("TARGET_TYPE")->asInt() )
{
case 0: // create new user defined grid...
if( Get_Target_Extent(pSource, Extent) && m_Grid_Target.Init_User(Extent, pSource->Get_NY()) && Dlg_Parameters("GET_USER") )
{
pGrid = m_Grid_Target.Get_User(Type);
}
break;
case 1: // select grid...
if( Dlg_Parameters("GET_GRID") )
{
pGrid = m_Grid_Target.Get_Grid(Type);
}
break;
case 2: // shapes...
if( Dlg_Parameters("GET_SHAPES") )
{
pShapes = Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->asShapes();
if( pShapes == DATAOBJECT_NOTSET || pShapes == DATAOBJECT_CREATE )
{
Get_Parameters("GET_SHAPES")->Get_Parameter("SHAPES")->Set_Value(pShapes = SG_Create_Shapes());
}
}
break;
}
//-------------------------------------------------
if( pShapes )
{
Parameters("SHAPES")->Set_Value(pShapes);
return( Set_Shapes(pSource, pShapes) );
}
if( pGrid )
{
return( Set_Grid(pSource, pGrid) );
}
}
//-----------------------------------------------------
return( false );
}
//---------------------------------------------------------
bool CPointCloud_From_Text_File::On_Execute(void)
{
CSG_String fileName;
int iField, iType;
CSG_String Name, Types, s;
CSG_PointCloud *pPoints;
CSG_Parameters P;
CSG_Parameter *pNode;
int xField, yField, zField, nAttribs;
bool bSkipHeader;
char fieldSep;
std::vector<int> vCol;
std::ifstream tabStream;
std::string tabLine;
double lines;
long cntPt, cntInvalid;
double x, y, z;
//-----------------------------------------------------
fileName = Parameters("FILE") ->asString();
xField = Parameters("XFIELD") ->asInt() - 1;
yField = Parameters("YFIELD") ->asInt() - 1;
zField = Parameters("ZFIELD") ->asInt() - 1;
bSkipHeader = Parameters("SKIP_HEADER") ->asBool();
switch (Parameters("FIELDSEP")->asInt())
{
default:
case 0: fieldSep = '\t'; break;
case 1: fieldSep = ' '; break;
case 2: fieldSep = ','; break;
}
pPoints = SG_Create_PointCloud();
pPoints->Create();
pPoints->Set_Name(SG_File_Get_Name(fileName, false));
Parameters("POINTS")->Set_Value(pPoints);
DataObject_Add(pPoints);
//-----------------------------------------------------
if (SG_UI_Get_Window_Main())
{
nAttribs = Parameters("ATTRIBS") ->asInt();
Types.Printf(SG_T("%s|%s|%s|%s|%s|"),
_TL("1 byte integer"),
_TL("2 byte integer"),
_TL("4 byte integer"),
_TL("4 byte floating point"),
_TL("8 byte floating point")
);
P.Set_Name(_TL("Attribute Field Properties"));
for(iField=1; iField<=nAttribs; iField++)
{
s.Printf(SG_T("NODE_%03d") , iField);
pNode = P.Add_Node(NULL, s, CSG_String::Format(SG_T("%d. %s"), iField, _TL("Field")), _TL(""));
s.Printf(SG_T("FIELD_%03d"), iField);
P.Add_String(pNode, s, _TL("Name"), _TL(""), s);
s.Printf(SG_T("COLUMN_%03d"), iField);
P.Add_Value(pNode, s, _TL("Attribute is Column ..."), _TL(""), PARAMETER_TYPE_Int, iField+3, 1, true);
s.Printf(SG_T("TYPE_%03d") , iField);
P.Add_Choice(pNode, s, _TL("Type"), _TL(""), Types, 3);
}
//-----------------------------------------------------
if( nAttribs > 0 )
{
if( Dlg_Parameters(&P, _TL("Field Properties")) )
{
for(iField=0; iField<nAttribs; iField++)
{
Name = P(CSG_String::Format(SG_T("FIELD_%03d" ), iField + 1).c_str())->asString();
iType = P(CSG_String::Format(SG_T("TYPE_%03d" ), iField + 1).c_str())->asInt();
vCol.push_back(P(CSG_String::Format(SG_T("COLUMN_%03d"), iField + 1).c_str())->asInt() - 1);
pPoints->Add_Field(Name, Get_Data_Type(iType));
}
}
else
return( false );
}
}
else // CMD
{
CSG_String sFields, sNames, sTypes;
CSG_String token;
int iValue;
std::vector<int> vTypes;
sFields = Parameters("FIELDS")->asString();
sNames = Parameters("FIELDNAMES")->asString();
sTypes = Parameters("FIELDTYPES")->asString();
CSG_String_Tokenizer tkz_fields(sFields, ";", SG_TOKEN_STRTOK);
while( tkz_fields.Has_More_Tokens() )
{
token = tkz_fields.Get_Next_Token();
if( token.Length() == 0 )
break;
if( !token.asInt(iValue) )
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: can't convert to number"));
return( false );
}
iValue -= 1;
if( iValue < 1)
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: field index out of range"));
return( false );
}
else
vCol.push_back(iValue);
}
CSG_String_Tokenizer tkz_datatypes(sTypes, ";", SG_TOKEN_STRTOK);
while( tkz_datatypes.Has_More_Tokens() )
{
token = tkz_datatypes.Get_Next_Token();
if( token.Length() == 0 )
break;
if( !token.asInt(iValue) )
{
SG_UI_Msg_Add_Error(_TL("Error parsing field type: can't convert to number"));
return( false );
}
vTypes.push_back(iValue);
}
CSG_String_Tokenizer tkz_datanames(sNames, ";", SG_TOKEN_STRTOK);
int iter = 0;
while( tkz_datanames.Has_More_Tokens() )
{
token = tkz_datanames.Get_Next_Token();
if( token.Length() == 0 )
break;
pPoints->Add_Field(token, Get_Data_Type(vTypes.at(iter)));
iter++;
}
if( vCol.size() != vTypes.size() || (int)vCol.size() != iter )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Number of arguments for attribute fields (%d), names (%d) and types (%d) do not match!"), vCol.size(), iter, vTypes.size()));
return( false );
}
}
// open input stream
//---------------------------------------------------------
tabStream.open(fileName.b_str(), std::ifstream::in);
if( !tabStream )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to open input file!")));
return (false);
}
tabStream.seekg(0, std::ios::end); // get length of file
lines = (double)tabStream.tellg();
tabStream.seekg(0, std::ios::beg);
std::getline(tabStream, tabLine); // as a workaround we assume the number of lines from the length of the first line
lines = lines / (double)tabStream.tellg();
if( !bSkipHeader )
{
tabStream.clear(); // let's forget we may have reached the EOF
tabStream.seekg(0, std::ios::beg); // and rewind to the beginning
}
// import
//---------------------------------------------------------
cntPt = cntInvalid = 0;
SG_UI_Process_Set_Text(CSG_String::Format(_TL("Importing data ...")));
while( std::getline(tabStream, tabLine) )
{
std::istringstream stream(tabLine);
std::vector<std::string> tabCols;
std::string tabEntry;
if( cntPt%10000 == 0 )
{
SG_UI_Process_Set_Progress((double)cntPt, lines);
}
cntPt++;
while( std::getline(stream, tabEntry, fieldSep) ) // read every column in this line and fill vector
{
if (tabEntry.length() == 0)
continue;
tabCols.push_back(tabEntry);
}
if ((int)tabCols.size() < (vCol.size() + 3) )
{
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: Skipping misformatted line: %d!"), cntPt), true);
cntInvalid++;
continue;
}
//parse line tokens
std::vector<double> fieldValues;
fieldValues.resize(vCol.size());
x = strtod(tabCols[xField].c_str(), NULL);
y = strtod(tabCols[yField].c_str(), NULL);
z = strtod(tabCols[zField].c_str(), NULL);
for( int i=0; i<(int)vCol.size(); i++ )
{
fieldValues[i] = strtod(tabCols.at(vCol.at(i)).c_str(), NULL);
}
pPoints->Add_Point(x, y, z);
for( int i=0; i<(int)vCol.size(); i++ )
{
pPoints->Set_Attribute(i, fieldValues[i]);
}
}
// finalize
//---------------------------------------------------------
tabStream.close();
CSG_Parameters sParms;
DataObject_Get_Parameters(pPoints, sParms);
if (sParms("METRIC_ATTRIB") && sParms("COLORS_TYPE") && sParms("METRIC_COLORS")
&& sParms("METRIC_ZRANGE") && sParms("DISPLAY_VALUE_AGGREGATE"))
{
sParms("DISPLAY_VALUE_AGGREGATE")->Set_Value(3); // highest z
sParms("COLORS_TYPE")->Set_Value(2); // graduated color
sParms("METRIC_COLORS")->asColors()->Set_Count(255); // number of colors
sParms("METRIC_ATTRIB")->Set_Value(2); // z attrib
sParms("METRIC_ZRANGE")->asRange()->Set_Range(pPoints->Get_Minimum(2),pPoints->Get_Maximum(2));
DataObject_Set_Parameters(pPoints, sParms);
DataObject_Update(pPoints);
}
if (cntInvalid > 0)
SG_UI_Msg_Add(CSG_String::Format(SG_T("%s: %d %s"), _TL("WARNING"), cntInvalid, _TL("invalid points have been skipped")), true);
SG_UI_Msg_Add(CSG_String::Format(SG_T("%d %s"), (cntPt-cntInvalid), _TL("points have been imported with success")), true);
return( true );
}
//---------------------------------------------------------
bool CPoint_Trend_Surface::On_Execute(void)
{
int iAttribute;
CSG_Shapes *pPoints, *pResiduals;
CSG_Grid *pRegression;
//-----------------------------------------------------
pPoints = Parameters("POINTS") ->asShapes();
pResiduals = Parameters("RESIDUALS") ->asShapes();
iAttribute = Parameters("ATTRIBUTE") ->asInt();
switch( Parameters("POLYNOM")->asInt() )
{
case 0: m_xOrder = 1; m_yOrder = 1; m_tOrder = 1; break; // simple planar surface // a + bx + cy
case 1: m_xOrder = 1; m_yOrder = 1; m_tOrder = 2; break; // bi-linear saddle"), // a + bx + cy + dxy
case 2: m_xOrder = 2; m_yOrder = 2; m_tOrder = 2; break; // quadratic surface"), // a + bx + cy + dxy + ex2 + fy2
case 3: m_xOrder = 3; m_yOrder = 3; m_tOrder = 3; break; // cubic surface"), // a + bx + cy + dxy + ex2 + fy2 + gx2y + hxy2 + ix3 + iy3
case 4:
m_xOrder = Parameters("XORDER")->asInt();
m_yOrder = Parameters("YORDER")->asInt();
m_tOrder = Parameters("TORDER")->asInt();
break;
}
//-----------------------------------------------------
if( !Get_Regression(pPoints, iAttribute) )
{
return( false );
}
Set_Message();
//-----------------------------------------------------
pRegression = NULL;
switch( Parameters("TARGET")->asInt() )
{
case 0: // user defined...
if( m_Grid_Target.Init_User(pPoints->Get_Extent()) && Dlg_Parameters("USER") )
{
pRegression = m_Grid_Target.Get_User();
}
break;
case 1: // grid...
if( Dlg_Parameters("GRID") )
{
pRegression = m_Grid_Target.Get_Grid();
}
break;
}
if( pRegression == NULL )
{
return( false );
}
//-----------------------------------------------------
pRegression->Set_Name(CSG_String::Format(SG_T("%s [%s]"), Parameters("ATTRIBUTE")->asString(), _TL("Trend Surface")));
Set_Regression(pRegression);
Set_Residuals(pPoints, iAttribute, pResiduals, pRegression);
m_Coefficients.Destroy();
return( true );
}
