//---------------------------------------------------------
CSGDI_Dialog::CSGDI_Dialog(const wxString &Name, int Style)
: wxDialog((wxWindow *)SG_UI_Get_Window_Main(), wxID_ANY, Name, wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER)
{
wxRect r(0, 0, wxSystemSettings::GetMetric(wxSYS_SCREEN_X), wxSystemSettings::GetMetric(wxSYS_SCREEN_Y));
r.Deflate((int)(0.1 * r.GetWidth()), (int)(0.1 * r.GetHeight()));
SetSize(r);
if( Style & SGDI_DLG_STYLE_START_MAXIMISED )
{
Maximize();
}
m_Ctrl_Color = *wxBLACK;
m_pSizer_Ctrl = new wxStaticBoxSizer(wxVERTICAL, this, wxT(""));
m_pSizer_Output = new wxStaticBoxSizer(wxVERTICAL, this, wxT(""));
wxSizer *pSizer = new wxBoxSizer(wxHORIZONTAL);
if( Style & SGDI_DLG_STYLE_CTRLS_RIGHT )
{
pSizer->Add(m_pSizer_Output , 1, wxALIGN_RIGHT|wxALL|wxEXPAND, SGDI_CTRL_SPACE);
pSizer->Add(m_pSizer_Ctrl , 0, wxALIGN_LEFT |wxALL|wxEXPAND, SGDI_CTRL_SPACE);
}
else
{
pSizer->Add(m_pSizer_Ctrl , 0, wxALIGN_LEFT |wxALL|wxEXPAND, SGDI_CTRL_SPACE);
pSizer->Add(m_pSizer_Output , 1, wxALIGN_RIGHT|wxALL|wxEXPAND, SGDI_CTRL_SPACE);
}
pSizer->FitInside(this);
SetSizer(pSizer);
}
//---------------------------------------------------------
bool CPoints_View_Module::On_Execute(void)
{
if( !SG_UI_Get_Window_Main() )
{
Message_Add(_TL("point cloud viewer can only be run from graphical user interface"));
return( false );
}
CSG_PointCloud *pPoints = Parameters("POINTS")->asPointCloud();
if( pPoints->Get_Count() <= 0 )
{
Message_Add(_TL("point cloud viewer will not be started, because point cloud has no points"));
return( false );
}
CPoints_View_Dialog dlg(pPoints);
dlg.ShowModal();
return( true );
}
//---------------------------------------------------------
bool CTIN_View_Module::On_Execute(void)
{
if( !SG_UI_Get_Window_Main() )
{
Message_Add(_TL("point cloud viewer can only be run from graphical user interface"));
return( false );
}
CSG_TIN *pTIN = Parameters("TIN")->asTIN();
if( pTIN->Get_Count() <= 0 )
{
Message_Add(_TL("point cloud viewer will not be started, because point cloud has no points"));
return( false );
}
CTIN_View_Dialog dlg(pTIN, Parameters("HEIGHT")->asInt(), Parameters("COLOR")->asInt(), Parameters("RGB")->asGrid());
dlg.ShowModal();
return( true );
}
//---------------------------------------------------------
bool CPC_Cluster_Analysis::On_Execute(void)
{
int nCluster;
long nElements;
double SP;
CSG_Parameters Parms;
m_bUpdateView = false;
//-----------------------------------------------------
nCluster = Parameters("NCLUSTER")->asInt();
pInput = Parameters("PC_IN") ->asPointCloud();
pResult = Parameters("PC_OUT") ->asPointCloud();
if( SG_UI_Get_Window_Main() )
m_bUpdateView = Parameters("UPDATEVIEW")->asBool();
//-------------------------------------------------
m_Features = (int *)Parameters("FIELDS")->asPointer();
m_nFeatures = Parameters("FIELDS")->asInt ();
if( !m_Features || m_nFeatures <= 0 )
{
Error_Set(_TL("no features in selection"));
return( false );
}
//-----------------------------------------------------
pResult->Create(pInput);
pResult->Set_Name(CSG_String::Format(SG_T("%s_cluster"), pInput->Get_Name()));
pResult->Add_Field(SG_T("CLUSTER"), SG_DATATYPE_Int);
DataObject_Update(pResult);
pResult->Set_NoData_Value(-1.0);
clustField = pResult->Get_Field_Count() - 1;
//-----------------------------------------------------
Process_Set_Text(_TL("Initializing ..."));
for( int i=0; i<m_nFeatures; i++ )
vValues.push_back( std::vector<double>() );
for( int i=0; i<pInput->Get_Record_Count() && SG_UI_Process_Set_Progress(i, pInput->Get_Record_Count()); i++ )
{
pResult->Add_Point(pInput->Get_X(i), pInput->Get_Y(i), pInput->Get_Z(i));
for( int j=0; j<pInput->Get_Attribute_Count(); j++ )
pResult->Set_Attribute(i, j, pInput->Get_Attribute(i, j));
pResult->Set_NoData(i, clustField);
bool bNoData = false;
for( int j=0; j<m_nFeatures; j++)
{
if( pInput->is_NoData(i, m_Features[j]) )
{
bNoData = true;
break;
}
}
if( !bNoData )
{
for( int j=0; j<m_nFeatures; j++ )
{
if( Parameters("NORMALISE")->asBool() )
vValues.at(j).push_back( (pInput->Get_Value(i, m_Features[j]) - pInput->Get_Mean(m_Features[j])) / pInput->Get_StdDev(m_Features[j]) );
else
vValues.at(j).push_back(pInput->Get_Value(i, m_Features[j]));
}
}
else
{
for( int j=0; j<m_nFeatures; j++ )
{
vValues.at(j).push_back(pInput->Get_NoData_Value());
}
}
}
if( m_bUpdateView )
{
if( DataObject_Get_Parameters(pResult, Parms) && Parms("COLORS_TYPE") && Parms("METRIC_ATTRIB") && Parms("METRIC_COLORS") && Parms("METRIC_ZRANGE") )
{
Parms("COLORS_TYPE") ->Set_Value(2); // graduated color
Parms("METRIC_COLORS")->asColors() ->Set_Count(nCluster);
Parms("METRIC_ATTRIB") ->Set_Value(clustField);
Parms("METRIC_ZRANGE")->asRange() ->Set_Range(0, nCluster);
}
DataObject_Set_Parameters(pResult, Parms);
DataObject_Update(pResult, SG_UI_DATAOBJECT_SHOW_LAST_MAP);
}
nMembers = (int *)SG_Malloc(nCluster * sizeof(int));
Variances = (double *)SG_Malloc(nCluster * sizeof(double));
Centroids = (double **)SG_Malloc(nCluster * sizeof(double *));
for( int i=0; i<nCluster; i++ )
{
Centroids[i] = (double *)SG_Malloc(m_nFeatures * sizeof(double));
}
//-------------------------------------------------
nElements = pInput->Get_Point_Count();
switch( Parameters("METHOD")->asInt() )
{
case 0:
SP = MinimumDistance (nElements, nCluster);
break;
case 1:
SP = HillClimbing (nElements, nCluster);
break;
case 2:
SP = MinimumDistance (nElements, nCluster);
nElements = pInput->Get_Point_Count(); // may have been diminished because of no data values...
SP = HillClimbing (nElements, nCluster);
break;
}
//-------------------------------------------------
if( Parameters("NORMALISE")->asBool() )
{
int iv = 0;
for( int i=0; i<m_nFeatures; i++ )
{
for( int j=0; j<nCluster; j++ )
{
Centroids[j][iv] = sqrt(pInput->Get_Variance(m_Features[i])) * Centroids[j][iv] + pInput->Get_Mean(m_Features[i]);
}
iv++;
}
}
Write_Result(Parameters("STATISTICS")->asTable(), nElements, nCluster, SP);
//-------------------------------------------------
if( DataObject_Get_Parameters(pResult, Parms) && Parms("COLORS_TYPE") && Parms("LUT") && Parms("LUT_ATTRIB") )
{
CSG_Table_Record *pClass;
CSG_Table *pLUT = Parms("LUT")->asTable();
for( int i=0; i<nCluster; i++ )
{
if( (pClass = pLUT->Get_Record(i)) == NULL )
{
pClass = pLUT->Add_Record();
pClass->Set_Value(0, SG_GET_RGB(rand() * 255.0 / RAND_MAX, rand() * 255.0 / RAND_MAX, rand() * 255.0 / RAND_MAX));
}
pClass->Set_Value(1, CSG_String::Format(SG_T("%s %d"), _TL("Class"), i));
pClass->Set_Value(2, CSG_String::Format(SG_T("%s %d"), _TL("Class"), i));
pClass->Set_Value(3, i);
pClass->Set_Value(4, i);
}
while( pLUT->Get_Record_Count() > nCluster )
{
pLUT->Del_Record(pLUT->Get_Record_Count() - 1);
}
Parms("COLORS_TYPE") ->Set_Value(1); // Color Classification Type: Lookup Table
Parms("LUT_ATTRIB") ->Set_Value(clustField);
DataObject_Set_Parameters(pResult, Parms);
}
//-------------------------------------------------
for( int i=0; i<nCluster; i++ )
{
SG_Free(Centroids[i]);
}
SG_Free(Centroids);
SG_Free(Variances);
SG_Free(nMembers);
vValues.clear();
return( true );
}
//---------------------------------------------------------
bool CGrid_Import::On_Execute(void)
{
bool bTransform;
int x, y, yy, Method;
double ax, ay, dx, dy, rx, ry, xMin, yMin, Cellsize;
CSG_Colors Colors;
CSG_String fImage, fWorld, Name;
CSG_Grid *pImage;
CSG_File Stream;
wxImage Image;
wxImageHistogram Histogram;
//-----------------------------------------------------
fImage = Parameters("FILE") ->asString();
Method = Parameters("METHOD") ->asInt();
Name = SG_File_Get_Name(fImage, false);
//-----------------------------------------------------
wxImageHandler *pImgHandler = NULL;
if( !SG_UI_Get_Window_Main() )
{
CSG_String fName = SG_File_Get_Name(fImage, true);
if( SG_File_Cmp_Extension(fName, SG_T("jpg")) )
pImgHandler = new wxJPEGHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("pcx")) )
pImgHandler = new wxPCXHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("tif")) )
pImgHandler = new wxTIFFHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("gif")) )
pImgHandler = new wxGIFHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("pnm")) )
pImgHandler = new wxPNMHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("xpm")) )
pImgHandler = new wxXPMHandler;
#ifdef _SAGA_MSW
else if( SG_File_Cmp_Extension(fName, SG_T("bmp")) )
pImgHandler = new wxBMPHandler;
#endif
else // if( SG_File_Cmp_Extension(fName, SG_T("png")) )
pImgHandler = new wxPNGHandler;
wxImage::AddHandler(pImgHandler);
}
if( !Image.LoadFile(fImage.c_str()) )
{
return( false );
}
//-----------------------------------------------------
if( SG_File_Cmp_Extension(fImage, SG_T("bmp")) )
{
fWorld = SG_File_Make_Path(NULL, fImage, SG_T("bpw"));
}
else if( SG_File_Cmp_Extension(fImage, SG_T("jpg")) )
{
fWorld = SG_File_Make_Path(NULL, fImage, SG_T("jgw"));
}
else if( SG_File_Cmp_Extension(fImage, SG_T("png")) )
{
fWorld = SG_File_Make_Path(NULL, fImage, SG_T("pgw"));
}
else if( SG_File_Cmp_Extension(fImage, SG_T("tif")) )
{
fWorld = SG_File_Make_Path(NULL, fImage, SG_T("tfw"));
}
else
{
fWorld = SG_File_Make_Path(NULL, fImage, SG_T("world"));
}
bTransform = false;
xMin = 0.0;
yMin = 0.0;
Cellsize = 1.0;
if( Stream.Open(fWorld, SG_FILE_R, false) && fscanf(Stream.Get_Stream(), "%lf %lf %lf %lf %lf %lf ", &dx, &ry, &rx, &dy, &ax, &ay) == 6 )
{
if( dx != -dy || rx != 0.0 || ry != 0.0 )
{
bTransform = true;
}
else
{
xMin = ax;
yMin = ay + dy * (Image.GetHeight() - 1);
Cellsize = dx;
}
}
//-----------------------------------------------------
// color look-up table...
if( Method == 0 && (yy = Image.ComputeHistogram(Histogram)) <= 256 )
{
Colors.Set_Count(yy);
for(wxImageHistogram::iterator i=Histogram.begin(); i!=Histogram.end(); ++i)
{
Colors.Set_Color(i->second.index, SG_GET_R(i->first), SG_GET_G(i->first), SG_GET_B(i->first));
}
pImage = SG_Create_Grid(yy <= 2 ? SG_DATATYPE_Bit : SG_DATATYPE_Byte, Image.GetWidth(), Image.GetHeight(), Cellsize, xMin, yMin);
for(y=0; y<pImage->Get_NY() && Set_Progress(y, pImage->Get_NY()); y++)
{
yy = bTransform ? y : pImage->Get_NY() - 1 - y;
for(x=0; x<pImage->Get_NX(); x++)
{
pImage->Set_Value(x, y, Histogram[SG_GET_RGB(Image.GetRed(x, yy), Image.GetGreen(x, yy), Image.GetBlue(x, yy))].index);
}
}
if( bTransform )
{
Set_Transformation(&pImage, ax, ay, dx, dy, rx, ry);
}
pImage->Set_Name(Name);
pImage->Get_Projection().Load(SG_File_Make_Path(NULL, fImage, SG_T("prj")));
Parameters("OUT_GRID")->Set_Value(pImage);
DataObject_Set_Colors(pImage, Colors);
DataObject_Update(pImage, 0, Colors.Get_Count() - 1);
}
//-----------------------------------------------------
else // true color...
{
pImage = SG_Create_Grid(SG_DATATYPE_Int, Image.GetWidth(), Image.GetHeight(), Cellsize, xMin, yMin);
pImage ->Set_Name(Name);
for(y=0; y<pImage->Get_NY() && Set_Progress(y, pImage->Get_NY()); y++)
{
yy = bTransform ? y : pImage->Get_NY() - 1 - y;
for(x=0; x<pImage->Get_NX(); x++)
{
pImage->Set_Value(x, y, SG_GET_RGB(Image.GetRed(x, yy), Image.GetGreen(x, yy), Image.GetBlue(x, yy)));
}
}
if( bTransform )
{
Set_Transformation(&pImage, ax, ay, dx, dy, rx, ry);
}
//-------------------------------------------------
if( Method != 1 ) // true color...
{
pImage->Get_Projection().Load(fImage, SG_PROJ_FMT_WKT);
pImage->Set_Name(Name);
pImage->Get_Projection().Load(SG_File_Make_Path(NULL, fImage, SG_T("prj")));
Parameters("OUT_GRID")->Set_Value(pImage);
DataObject_Set_Colors(pImage, 100, SG_COLORS_BLACK_WHITE);
DataObject_Set_Parameter(pImage, "COLORS_TYPE", 6); // Color Classification Type: RGB
}
//-------------------------------------------------
else // split channels...
{
CSG_Grid *pR, *pG, *pB;
pR = SG_Create_Grid(pImage->Get_System(), SG_DATATYPE_Byte);
pG = SG_Create_Grid(pImage->Get_System(), SG_DATATYPE_Byte);
pB = SG_Create_Grid(pImage->Get_System(), SG_DATATYPE_Byte);
for(y=0; y<pImage->Get_NY() && Set_Progress(y, pImage->Get_NY()); y++)
{
for(x=0; x<pImage->Get_NX(); x++)
{
pR->Set_Value(x, y, SG_GET_R(pImage->asInt(x, y)));
pG->Set_Value(x, y, SG_GET_G(pImage->asInt(x, y)));
pB->Set_Value(x, y, SG_GET_B(pImage->asInt(x, y)));
}
}
pR->Get_Projection().Load(fImage, SG_PROJ_FMT_WKT);
pG->Get_Projection().Load(fImage, SG_PROJ_FMT_WKT);
pB->Get_Projection().Load(fImage, SG_PROJ_FMT_WKT);
pR->Set_Name(CSG_String::Format(SG_T("%s [R]"), Name.c_str()));
pG->Set_Name(CSG_String::Format(SG_T("%s [G]"), Name.c_str()));
pB->Set_Name(CSG_String::Format(SG_T("%s [B]"), Name.c_str()));
pR->Get_Projection().Load(SG_File_Make_Path(NULL, fImage, SG_T("prj")));
pG->Get_Projection().Load(SG_File_Make_Path(NULL, fImage, SG_T("prj")));
pB->Get_Projection().Load(SG_File_Make_Path(NULL, fImage, SG_T("prj")));
Parameters("OUT_RED") ->Set_Value(pR);
Parameters("OUT_GREEN") ->Set_Value(pG);
Parameters("OUT_BLUE") ->Set_Value(pB);
DataObject_Set_Colors(pR, 100, SG_COLORS_BLACK_RED);
DataObject_Set_Colors(pG, 100, SG_COLORS_BLACK_GREEN);
DataObject_Set_Colors(pB, 100, SG_COLORS_BLACK_BLUE);
}
}
//-----------------------------------------------------
if( !SG_UI_Get_Window_Main() && pImgHandler != NULL)
{
wxImage::RemoveHandler(pImgHandler->GetName());
}
//-----------------------------------------------------
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 );
}
//---------------------------------------------------------
CPointcloud_To_Text_File::CPointcloud_To_Text_File(void)
{
//-----------------------------------------------------
Set_Name (_TL("Export Point Cloud to Text File"));
Set_Author (SG_T("V. Wichmann, LASERDATA GmbH (c) 2011"));
Set_Description (_TW(
"Exports a point cloud to a text file. Once the module is executed, "
"a pop-up dialog allows to specify the fields to be exported and their "
"decimal precision.\n\n"
"Module usage is different between SAGA GUI and SAGA CMD: With "
"SAGA GUI you will get prompted to choose the fields to export "
"and the decimal precisions to use "
"once you execute the module. With SAGA CMD you have to provide "
"two strings with the -FIELDS and -PRECISIONS parameters. The first one "
"must contain the field numbers, the latter the precisions "
"(separated by semicolon). Field numbers start with 1, e.g. "
"-FIELDS=\"1;2;3;5\" -PRECISIONS=\"2;2;2;0\".\n\n"
));
//-----------------------------------------------------
Parameters.Add_PointCloud(
NULL , "POINTS" , _TL("Point Cloud"),
_TL("The point cloud to export."),
PARAMETER_INPUT
);
Parameters.Add_FilePath(
NULL , "FILE" , _TL("Text File"),
_TL("The file to write the point cloud to."),
CSG_String::Format(SG_T("%s|%s|%s|%s|%s|%s"),
_TL("Text Files (*.txt)") , SG_T("*.txt"),
_TL("CSV Files (*.csv)") , SG_T("*.csv"),
_TL("All Files") , SG_T("*.*")
), NULL, true
);
Parameters.Add_Value(
NULL , "WRITE_HEADER" , _TL("Write Header"),
_TL("Write column names."),
PARAMETER_TYPE_Bool, false
);
Parameters.Add_Choice(
NULL , "FIELDSEP" , _TL("Field Separator"),
_TL("Field Separator"),
CSG_String::Format(SG_T("%s|%s|%s|"),
_TL("tabulator"),
_TL("space"),
_TL("comma")
), 0
);
if (!SG_UI_Get_Window_Main())
{
Parameters.Add_String(
NULL , "FIELDS" , _TL("Fields"),
_TL("The numbers (starting from 1) of the fields to export, separated by semicolon, e.g. \"1;2;3;5\""),
SG_T("")
);
Parameters.Add_String(
NULL , "PRECISIONS" , _TL("Precisions"),
_TL("The decimal precision to use for each field, separated by semicolon, e.g. \"2;2;2;0\""),
SG_T("")
);
}
}
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
CPointCloud_From_Text_File::CPointCloud_From_Text_File(void)
{
//-----------------------------------------------------
Set_Name (_TL("Import Point Cloud from Text File"));
Set_Author (SG_T("V. Wichmann, LASERDATA GmbH (c) 2009"));
Set_Description (_TW(
"Creates a point cloud from a text file.\n"
"The input file must have at least three columns holding the "
"x, y, z coordinates of each point. You must specify the field "
"numbers of these. In case you like to import additional attributes, "
"you have to provide the number of attribute fields. After module "
"execution, you will be prompted to provide their field numbers, "
"names and datatypes.\n"
"You have also to decide on which field separator to use and if "
"the first line of the input file should be skipped (in case it "
"contains column headings).\n"
"The columns in the input file can be in any order, and you can "
"omit columns, but you have to provide the correct field numbers "
"of those you like to import.\n\n"
"Module usage is different between SAGA GUI and SAGA CMD: With "
"SAGA GUI you will get prompted to choose the fields to export, "
"and to provide the field names and datatypes to use "
"once you execute the module.\n"
" With SAGA CMD you have to provide three strings with the "
"-FIELDS, -FIELDNAMES and -FIELDTYPES parameters. The first one "
"must contain the field numbers, the second one the field names "
"and the third one the choices of the datatype (see the GUI which "
"number equals which datatype). Each field entry has to be "
"separated by semicolon. Field numbers start with 1, e.g. "
"-FIELDS=\"5;6;8\" -FIELDNAMES=\"intensity;class;range\" "
"-FIELDTYPES=\"2;2;3\".\n\n"
));
//-----------------------------------------------------
Parameters.Add_PointCloud_Output(
NULL , "POINTS" , _TL("Point Cloud"),
_TL("")
);
Parameters.Add_FilePath(
NULL , "FILE" , _TL("Text File"),
_TL("")
);
Parameters.Add_Value(
NULL , "XFIELD" , _TL("X is Column ..."),
_TL("The column holding the X-coordinate."),
PARAMETER_TYPE_Int, 1, 1, true
);
Parameters.Add_Value(
NULL , "YFIELD" , _TL("Y is Column ..."),
_TL("The column holding the Y-coordinate."),
PARAMETER_TYPE_Int, 2, 1, true
);
Parameters.Add_Value(
NULL , "ZFIELD" , _TL("Z is Column ..."),
_TL("The column holding the Z-coordinate."),
PARAMETER_TYPE_Int, 3, 1, true
);
if (SG_UI_Get_Window_Main())
{
Parameters.Add_Value(
NULL , "ATTRIBS" , _TL("Number of Attributes"),
_TL("Number of additional attributes to import."),
PARAMETER_TYPE_Int, 0, 0, true
);
}
else
{
Parameters.Add_String(
NULL , "FIELDS" , _TL("Fields"),
_TL("The numbers (starting from 1) of the fields to import, separated by semicolon, e.g. \"5;6;8\""),
SG_T("")
);
Parameters.Add_String(
NULL , "FIELDNAMES" , _TL("Field Names"),
_TL("The name to use for each field, separated by semicolon, e.g. \"intensity;class;range\""),
SG_T("")
);
Parameters.Add_String(
NULL , "FIELDTYPES" , _TL("Field Types"),
_TL("The datatype to use for each field, separated by semicolon, e.g. \"2;2;3;\". The number equals the choice selection, see GUI version."),
SG_T("")
);
}
Parameters.Add_Value(
NULL , "SKIP_HEADER" , _TL("Skip first line"),
_TL("Skip first line as it contains column names."),
PARAMETER_TYPE_Bool, false
);
Parameters.Add_Choice(
NULL , "FIELDSEP" , _TL("Field Separator"),
_TL("Field Separator"),
CSG_String::Format(SG_T("%s|%s|%s|"),
_TL("tabulator"),
_TL("space"),
_TL("comma")
), 0
);
}
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
CPC_Cluster_Analysis::CPC_Cluster_Analysis(void)
{
//-----------------------------------------------------
// 1. Info...
Set_Name (_TL("Cluster Analysis for Point Clouds"));
Set_Author (SG_T("Volker Wichmann (c) 2010, LASERDATA GmbH"));
Set_Description (_TW(
"Cluster Analysis for Point Clouds.\n\n"
"References:\n\n"
"This module is a port of the 'Cluster Analysis for Grids' "
"module from the 'Imagery - Classification' module library, "
"Copyright (C) 2003 by Olaf Conrad.\n\n"
"Iterative Minimum Distance:\n"
"- Forgy, E. (1965):\n"
" 'Cluster Analysis of multivariate data: efficiency vs. interpretability of classifications',\n"
" Biometrics 21:768\n\n"
"Hill-Climbing:"
"- Rubin, J. (1967):\n"
" 'Optimal Classification into Groups: An Approach for Solving the Taxonomy Problem',\n"
" J. Theoretical Biology, 15:103-144\n\n"
));
//-----------------------------------------------------
// 2. Datasets...
CSG_Parameter *pNode = Parameters.Add_PointCloud(
NULL , "PC_IN" ,_TL("Point Cloud"),
_TL("Input"),
PARAMETER_INPUT
);
Parameters.Add_Table_Fields(
pNode , "FIELDS" , _TL("Attributes"),
_TL("The attribute fields to cluster")
);
Parameters.Add_PointCloud(
NULL , "PC_OUT" ,_TL("Result"),
_TL("Output"),
PARAMETER_OUTPUT
);
Parameters.Add_Table(
NULL , "STATISTICS" , _TL("Statistics"),
_TL(""),
PARAMETER_OUTPUT
);
//-----------------------------------------------------
// 3. General Parameters...
Parameters.Add_Choice(
NULL , "METHOD" , _TL("Method"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|%s|"),
_TL("Iterative Minimum Distance (Forgy 1965)"),
_TL("Hill-Climbing (Rubin 1967)"),
_TL("Combined Minimum Distance / Hillclimbing")
),1
);
Parameters.Add_Value(
NULL , "NCLUSTER" , _TL("Clusters"),
_TL("Number of clusters"),
PARAMETER_TYPE_Int, 10, 2, true
);
Parameters.Add_Value(
NULL , "NORMALISE" , _TL("Normalise"),
_TL("Automatically normalise attributes by standard deviation before clustering."),
PARAMETER_TYPE_Bool, true
);
if (SG_UI_Get_Window_Main())
{
Parameters.Add_Value(
NULL , "UPDATEVIEW" , _TL("Update View"),
_TL("Update cluster view while clustering."),
PARAMETER_TYPE_Bool, true
);
}
}
//---------------------------------------------------------
bool CSemiVariogram::On_Execute(void)
{
bool bLog, bResult = false;
int Attribute;
CSG_Trend Model;
CSG_Shapes *pPoints;
CSG_Table *pVariogram;
//-----------------------------------------------------
pPoints = Parameters("POINTS") ->asShapes();
Attribute = Parameters("ATTRIBUTE") ->asInt();
bLog = Parameters("LOG") ->asBool();
pVariogram = Parameters("VARIOGRAM") ->asTable();
//-----------------------------------------------------
if( SG_UI_Get_Window_Main() )
{
static CVariogram_Dialog dlg;
if( dlg.Execute(pPoints, Attribute, bLog, pVariogram, &Model) )
{
bResult = true;
}
}
//-----------------------------------------------------
else
{
int nSkip = Parameters("VAR_NSKIP") ->asInt();
int nClasses = Parameters("VAR_NCLASSES") ->asInt();
double maxDistance = Parameters("VAR_MAXDIST") ->asDouble();
Model.Set_Formula(Parameters("VAR_MODEL")->asString());
if( CSG_Variogram::Calculate(pPoints, Attribute, bLog, pVariogram, nClasses, maxDistance, nSkip) )
{
Model.Clr_Data();
for(int i=0; i<pVariogram->Get_Count(); i++)
{
CSG_Table_Record *pRecord = pVariogram->Get_Record(i);
Model.Add_Data(pRecord->asDouble(CSG_Variogram::FIELD_DISTANCE), pRecord->asDouble(CSG_Variogram::FIELD_VAR_EXP));
}
bResult = Model.Get_Trend() || Model.Get_Parameter_Count() == 0;
}
}
//-----------------------------------------------------
if( bResult )
{
Message_Add(Model.Get_Formula(), false);
for(int i=0; i<pVariogram->Get_Count(); i++)
{
CSG_Table_Record *pRecord = pVariogram->Get_Record(i);
pRecord->Set_Value(CSG_Variogram::FIELD_VAR_MODEL, Model.Get_Value(pRecord->asDouble(CSG_Variogram::FIELD_DISTANCE)));
}
}
return( bResult );
}
//---------------------------------------------------------
bool CKriging_Regression::On_Execute(void)
{
//-----------------------------------------------------
CSG_Shapes Points(SHAPE_TYPE_Point);
CSG_Grid *pPrediction = Parameters("PREDICTION")->asGrid();
CSG_Grid *pRegression = Parameters("REGRESSION")->asGrid();
CSG_Grid *pResiduals = Parameters("RESIDUALS" )->asGrid();
CSG_Grid *pVariance = Parameters("VARIANCE" )->asGrid();
//-----------------------------------------------------
if( !pResiduals )
{
pResiduals = pPrediction;
}
//-----------------------------------------------------
SG_RUN_MODULE_ExitOnError("statistics_regression", 1, // Multiple Regression Analysis (Points and Predictor Grids)
SG_MODULE_PARAMETER_SET("PREDICTORS", Parameters("PREDICTORS"))
&& SG_MODULE_PARAMETER_SET("POINTS" , Parameters("POINTS" ))
&& SG_MODULE_PARAMETER_SET("ATTRIBUTE" , Parameters("FIELD" ))
&& SG_MODULE_PARAMETER_SET("INFO_COEFF", Parameters("INFO_COEFF"))
&& SG_MODULE_PARAMETER_SET("INFO_MODEL", Parameters("INFO_MODEL"))
&& SG_MODULE_PARAMETER_SET("INFO_STEPS", Parameters("INFO_STEPS"))
&& SG_MODULE_PARAMETER_SET("RESAMPLING", Parameters("RESAMPLING"))
&& SG_MODULE_PARAMETER_SET("COORD_X" , Parameters("COORD_X" ))
&& SG_MODULE_PARAMETER_SET("COORD_Y" , Parameters("COORD_Y" ))
&& SG_MODULE_PARAMETER_SET("INTERCEPT" , Parameters("INTERCEPT" ))
&& SG_MODULE_PARAMETER_SET("METHOD" , Parameters("METHOD" ))
&& SG_MODULE_PARAMETER_SET("P_VALUE" , Parameters("P_VALUE" ))
&& SG_MODULE_PARAMETER_SET("REGRESSION", pRegression)
&& SG_MODULE_PARAMETER_SET("RESIDUALS" , &Points )
);
//-----------------------------------------------------
Process_Set_Text(m_OK.Get_Name());
m_OK.Set_Manager(NULL);
if( !m_OK.Set_Parameter("POINTS" , &Points)
|| !m_OK.Set_Parameter("FIELD" , 2) // residual
|| !m_OK.Set_Parameter("LOG" , Parameters("LOG" ))
|| !m_OK.Set_Parameter("BLOCK" , Parameters("BLOCK" ))
|| !m_OK.Set_Parameter("DBLOCK" , Parameters("DBLOCK" ))
|| !m_OK.Set_Parameter("SEARCH_RANGE" , Parameters("SEARCH_RANGE" ))
|| !m_OK.Set_Parameter("SEARCH_RADIUS" , Parameters("SEARCH_RADIUS" ))
|| !m_OK.Set_Parameter("SEARCH_POINTS_ALL", Parameters("SEARCH_POINTS_ALL"))
|| !m_OK.Set_Parameter("SEARCH_POINTS_MIN", Parameters("SEARCH_POINTS_MIN"))
|| !m_OK.Set_Parameter("SEARCH_POINTS_MAX", Parameters("SEARCH_POINTS_MAX"))
|| !m_OK.Set_Parameter("SEARCH_DIRECTION" , Parameters("SEARCH_DIRECTION" ))
|| !m_OK.Set_Parameter("TARGET_DEFINITION", 1) // grid or grid system
|| !m_OK.Set_Parameter("PREDICTION" , pResiduals)
|| !m_OK.Set_Parameter("VARIANCE" , pVariance )
|| (!SG_UI_Get_Window_Main() && ( // saga_cmd
!m_OK.Set_Parameter("VAR_MAXDIST" , Parameters("VAR_MAXDIST" ))
|| !m_OK.Set_Parameter("VAR_NCLASSES" , Parameters("VAR_NCLASSES" ))
|| !m_OK.Set_Parameter("VAR_NSKIP" , Parameters("VAR_NSKIP" ))
|| !m_OK.Set_Parameter("VAR_MODEL" , Parameters("VAR_MODEL" )))) )
{
Error_Set(CSG_String::Format(SG_T("%s [%s].[%s]"), _TL("could not initialize tool"), SG_T("statistics_regression"), m_OK.Get_Name().c_str()));
return( false );
}
if( !m_OK.Execute() )
{
Error_Set(CSG_String::Format(SG_T("%s [%s].[%s]"), _TL("could not execute tool"), SG_T("statistics_regression"), m_OK.Get_Name().c_str()));\
return( false );
}
//-----------------------------------------------------
#pragma omp parallel for
for(int y=0; y<Get_NY(); y++)
{
for(int x=0; x<Get_NX(); x++)
{
if( pRegression->is_NoData(x, y) || pResiduals->is_NoData(x, y) )
{
pPrediction->Set_NoData(x, y);
}
else
{
pPrediction->Add_Value(x, y, pRegression->asDouble(x, y) + pResiduals->asDouble(x, y));
}
}
}
//-----------------------------------------------------
pRegression->Set_Name(CSG_String::Format("%s.%s [%s]", Parameters("POINTS")->asGrid()->Get_Name(), Parameters("FIELD")->asString(), _TL("Regression")));
pPrediction->Set_Name(CSG_String::Format("%s.%s [%s]", Parameters("POINTS")->asGrid()->Get_Name(), Parameters("FIELD")->asString(), _TL("Prediction")));
if( Parameters("RESIDUALS")->asGrid() )
{
pResiduals->Set_Name(CSG_String::Format("%s.%s [%s]", Parameters("POINTS")->asGrid()->Get_Name(), Parameters("FIELD")->asString(), _TL("Residuals")));
}
if( pVariance )
{
pVariance ->Set_Name(CSG_String::Format("%s.%s [%s]", Parameters("POINTS")->asGrid()->Get_Name(), Parameters("FIELD")->asString(), _TL("Quality")));
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
CGrid_Export::CGrid_Export(void)
{
Set_Name (_TL("Export Image (bmp, jpg, pcx, png, tif)"));
Set_Author (SG_T("O.Conrad (c) 2005"));
Set_Description (_TW(
"The module allows one to save a grid as image.\n"
"Optionally, a shade grid can be overlayed and it's "
"transparency and brightness can be adjusted.\n\n")
);
Parameters.Add_Grid(
NULL , "GRID" , _TL("Grid"),
_TL(""),
PARAMETER_INPUT
);
Parameters.Add_Grid(
NULL , "SHADE" , _TL("Shade"),
_TL(""),
PARAMETER_INPUT_OPTIONAL
);
Parameters.Add_FilePath(
NULL , "FILE" , _TL("Image File"),
_TL(""),
CSG_String::Format("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s",
_TL("Portable Network Graphics (*.png)") , SG_T("*.png"),
_TL("JPEG - JFIF Compliant (*.jpg, *.jif, *.jpeg)") , SG_T("*.jpg;*.jif;*.jpeg"),
_TL("Tagged Image File Format (*.tif, *.tiff)") , SG_T("*.tif;*.tiff"),
_TL("Windows or OS/2 Bitmap (*.bmp)") , SG_T("*.bmp"),
_TL("Zsoft Paintbrush (*.pcx)") , SG_T("*.pcx")
), NULL, true
);
Parameters.Add_Value(
NULL , "FILE_KML" , _TL("Create KML File"),
_TL(""),
PARAMETER_TYPE_Bool, true
);
if( SG_UI_Get_Window_Main() )
{
Parameters.Add_Choice(
NULL , "COLOURING" , _TL("Colouring"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|%s|%s|%s|%s|"),
_TL("stretch to grid's standard deviation"),
_TL("stretch to grid's value range"),
_TL("stretch to specified value range"),
_TL("lookup table"),
_TL("rgb coded values"),
_TL("same as in graphical user interface")
), 5
);
Parameters.Add_Colors(
NULL , "COL_PALETTE" , _TL("Colours Palette"),
_TL("")
);
}
else
{
Parameters.Add_Choice(
NULL , "COLOURING" , _TL("Colouring"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|%s|%s|%s|"),
_TL("stretch to grid's standard deviation"),
_TL("stretch to grid's value range"),
_TL("stretch to specified value range"),
_TL("lookup table"),
_TL("rgb coded values")
), 0
);
Parameters.Add_Choice(
NULL , "COL_PALETTE" , _TL("Color Palette"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|"),
_TL("DEFAULT"), _TL("DEFAULT_BRIGHT"), _TL("BLACK_WHITE"), _TL("BLACK_RED"),
_TL("BLACK_GREEN"), _TL("BLACK_BLUE"), _TL("WHITE_RED"), _TL("WHITE_GREEN"),
_TL("WHITE_BLUE"), _TL("YELLOW_RED"), _TL("YELLOW_GREEN"), _TL("YELLOW_BLUE"),
_TL("RED_GREEN"), _TL("RED_BLUE"), _TL("GREEN_BLUE"), _TL("RED_GREY_BLUE"),
_TL("RED_GREY_GREEN"), _TL("GREEN_GREY_BLUE"), _TL("RED_GREEN_BLUE"), _TL("RED_BLUE_GREEN"),
_TL("GREEN_RED_BLUE"), _TL("RAINBOW"), _TL("NEON"), _TL("TOPOGRAPHY"),
_TL("ASPECT_1"), _TL("ASPECT_2"), _TL("ASPECT_3")
), 0
);
Parameters.Add_Value(
NULL , "COL_COUNT" , _TL("Number of Colors"),
_TL(""),
PARAMETER_TYPE_Int, 100
);
Parameters.Add_Value(
NULL , "COL_REVERT" , _TL("Revert Palette"),
_TL(""),
PARAMETER_TYPE_Bool, false
);
}
Parameters.Add_Value(
NULL , "STDDEV" , _TL("Standard Deviation"),
_TL(""),
PARAMETER_TYPE_Double, 2.0, 0.0, true
);
Parameters.Add_Range(
NULL , "STRETCH" , _TL("Stretch to Value Range"),
_TL(""),
0.0, 100.0
);
Parameters.Add_Table(
NULL , "LUT" , _TL("Lookup Table"),
_TL(""),
PARAMETER_INPUT_OPTIONAL
);
Parameters.Add_Value(
NULL , "SHADE_TRANS" , _TL("Shade Transparency [%]"),
_TL("The transparency of the shade [%]"),
PARAMETER_TYPE_Double, 40.0, 0.0, true, 100.0, true
);
Parameters.Add_Range(
NULL , "SHADE_BRIGHT", _TL("Shade Brightness [%]"),
_TL("Allows one to scale shade brightness [%]"),
0.0, 100.0, 0.0, true, 100.0, true
);
}
//---------------------------------------------------------
bool CGrid_Export::On_Execute(void)
{
//-----------------------------------------------------
int y, iy, Method;
double dTrans;
CSG_Grid *pGrid, *pShade, Grid, Shade;
//-----------------------------------------------------
pGrid = Parameters("GRID" )->asGrid();
pShade = Parameters("SHADE" )->asGrid();
Method = Parameters("COLOURING" )->asInt ();
dTrans = Parameters("SHADE_TRANS" )->asDouble() / 100.0;
if( !pGrid )
{
return( false );
}
//-----------------------------------------------------
if( Method == 5 ) // same as in graphical user interface
{
if( !SG_UI_DataObject_asImage(pGrid, &Grid) )
{
Error_Set("could not retrieve colour coding from graphical user interface.");
return( false );
}
}
else
{
double zMin, zScale;
CSG_Colors Colors;
CSG_Table LUT;
if( SG_UI_Get_Window_Main() )
{
Colors.Assign(Parameters("COL_PALETTE")->asColors());
}
else
{
Colors.Set_Palette(
Parameters("COL_PALETTE")->asInt (),
Parameters("COL_REVERT" )->asBool(),
Parameters("COL_COUNT" )->asInt ()
);
}
switch( Method )
{
case 0: // stretch to grid's standard deviation
zMin = pGrid->Get_Mean() - Parameters("STDDEV")->asDouble() * pGrid->Get_StdDev();
zScale = Colors.Get_Count() / (2 * Parameters("STDDEV")->asDouble() * pGrid->Get_StdDev());
break;
case 1: // stretch to grid's value range
zMin = pGrid->Get_ZMin();
zScale = Colors.Get_Count() / pGrid->Get_ZRange();
break;
case 2: // stretch to specified value range
zMin = Parameters("STRETCH")->asRange()->Get_LoVal();
if( zMin >= (zScale = Parameters("STRETCH")->asRange()->Get_HiVal()) )
{
Error_Set(_TL("invalid user specified value range."));
return( false );
}
zScale = Colors.Get_Count() / (zScale - zMin);
break;
case 3: // lookup table
if( !Parameters("LUT")->asTable() || Parameters("LUT")->asTable()->Get_Field_Count() < 5 )
{
Error_Set(_TL("invalid lookup table."));
return( false );
}
LUT.Create(*Parameters("LUT")->asTable());
break;
case 4: // rgb coded values
break;
}
//-------------------------------------------------
Grid.Create(*Get_System(), SG_DATATYPE_Int);
for(y=0, iy=Get_NY()-1; y<Get_NY() && Set_Progress(y); y++, iy--)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
double z = pGrid->asDouble(x, y);
if( Method == 3 ) // lookup table
{
int i, iColor = -1;
for(i=0; iColor<0 && i<LUT.Get_Count(); i++)
{
if( z == LUT[i][3] )
{
Grid.Set_Value(x, iy, LUT[iColor = i].asInt(0));
}
}
for(i=0; iColor<0 && i<LUT.Get_Count(); i++)
{
if( z >= LUT[i][3] && z <= LUT[i][4] )
{
Grid.Set_Value(x, iy, LUT[iColor = i].asInt(0));
}
}
if( iColor < 0 )
{
Grid.Set_NoData(x, iy);
}
}
else if( pGrid->is_NoData(x, y) )
{
Grid.Set_NoData(x, iy);
}
else if( Method == 4 ) // rgb coded values
{
Grid.Set_Value(x, iy, z);
}
else
{
int i = (int)(zScale * (z - zMin));
Grid.Set_Value(x, iy, Colors[i < 0 ? 0 : i >= Colors.Get_Count() ? Colors.Get_Count() - 1 : i]);
}
}
}
}
//-----------------------------------------------------
if( !pShade || pShade->Get_ZRange() <= 0.0 )
{
pShade = NULL;
}
else
{
double dMinBright, dMaxBright;
dMinBright = Parameters("SHADE_BRIGHT")->asRange()->Get_LoVal() / 100.0;
dMaxBright = Parameters("SHADE_BRIGHT")->asRange()->Get_HiVal() / 100.0;
if( dMinBright >= dMaxBright )
{
SG_UI_Msg_Add_Error(_TL("Minimum shade brightness must be lower than maximum shade brightness!"));
return( false );
}
int nColors = 100;
CSG_Colors Colors(nColors, SG_COLORS_BLACK_WHITE, true);
//-------------------------------------------------
Shade.Create(*Get_System(), SG_DATATYPE_Int);
for(y=0, iy=Get_NY()-1; y<Get_NY() && Set_Progress(y); y++, iy--)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( pShade->is_NoData(x, y) )
{
Shade.Set_NoData(x, iy);
}
else
{
Shade.Set_Value (x, iy, Colors[(int)(nColors * (dMaxBright - dMinBright) * (pShade->asDouble(x, y) - pShade->Get_ZMin()) / pShade->Get_ZRange() + dMinBright)]);
}
}
}
}
//-----------------------------------------------------
wxImage Image(Get_NX(), Get_NY());
if( Grid.Get_NoData_Count() > 0 )
{
Image.SetAlpha();
}
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( Grid.is_NoData(x, y) || (pShade != NULL && Shade.is_NoData(x, y)) )
{
if( Image.HasAlpha() )
{
Image.SetAlpha(x, y, wxIMAGE_ALPHA_TRANSPARENT);
}
Image.SetRGB(x, y, 255, 255, 255);
}
else
{
if( Image.HasAlpha() )
{
Image.SetAlpha(x, y, wxIMAGE_ALPHA_OPAQUE);
}
int r, g, b, c = Grid.asInt(x, y);
r = SG_GET_R(c);
g = SG_GET_G(c);
b = SG_GET_B(c);
if( pShade )
{
c = Shade.asInt(x, y);
r = dTrans * r + SG_GET_R(c) * (1.0 - dTrans);
g = dTrans * g + SG_GET_G(c) * (1.0 - dTrans);
b = dTrans * b + SG_GET_B(c) * (1.0 - dTrans);
}
Image.SetRGB(x, y, r, g, b);
}
}
}
//-------------------------------------------------
CSG_String fName(Parameters("FILE")->asString());
if( !SG_File_Cmp_Extension(fName, SG_T("bmp"))
&& !SG_File_Cmp_Extension(fName, SG_T("jpg"))
&& !SG_File_Cmp_Extension(fName, SG_T("pcx"))
&& !SG_File_Cmp_Extension(fName, SG_T("png"))
&& !SG_File_Cmp_Extension(fName, SG_T("tif")) )
{
fName = SG_File_Make_Path(NULL, fName, SG_T("png"));
Parameters("FILE")->Set_Value(fName);
}
//-----------------------------------------------------
wxImageHandler *pImgHandler = NULL;
if( !SG_UI_Get_Window_Main() )
{
if( SG_File_Cmp_Extension(fName, SG_T("jpg")) )
pImgHandler = new wxJPEGHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("pcx")) )
pImgHandler = new wxPCXHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("tif")) )
pImgHandler = new wxTIFFHandler;
#ifdef _SAGA_MSW
else if( SG_File_Cmp_Extension(fName, SG_T("bmp")) )
pImgHandler = new wxBMPHandler;
#endif
else // if( SG_File_Cmp_Extension(fName, SG_T("png")) )
pImgHandler = new wxPNGHandler;
wxImage::AddHandler(pImgHandler);
}
if( !Image.SaveFile(fName.c_str()) )
{
Error_Set(CSG_String::Format(SG_T("%s [%s]"), _TL("could not save image file"), fName.c_str()));
return( false );
}
pGrid->Get_Projection().Save(SG_File_Make_Path(NULL, fName, SG_T("prj")), SG_PROJ_FMT_WKT);
//-----------------------------------------------------
CSG_File Stream;
if( SG_File_Cmp_Extension(fName, SG_T("bmp")) ) Stream.Open(SG_File_Make_Path(NULL, fName, SG_T("bpw")), SG_FILE_W, false);
else if( SG_File_Cmp_Extension(fName, SG_T("jpg")) ) Stream.Open(SG_File_Make_Path(NULL, fName, SG_T("jgw")), SG_FILE_W, false);
else if( SG_File_Cmp_Extension(fName, SG_T("pcx")) ) Stream.Open(SG_File_Make_Path(NULL, fName, SG_T("pxw")), SG_FILE_W, false);
else if( SG_File_Cmp_Extension(fName, SG_T("png")) ) Stream.Open(SG_File_Make_Path(NULL, fName, SG_T("pgw")), SG_FILE_W, false);
else if( SG_File_Cmp_Extension(fName, SG_T("tif")) ) Stream.Open(SG_File_Make_Path(NULL, fName, SG_T("tfw")), SG_FILE_W, false);
if( Stream.is_Open() )
{
Stream.Printf(SG_T("%.10f\n%f\n%f\n%.10f\n%.10f\n%.10f\n"),
pGrid->Get_Cellsize(),
0.0, 0.0,
-pGrid->Get_Cellsize(),
pGrid->Get_XMin(),
pGrid->Get_YMax()
);
}
//-----------------------------------------------------
if( Parameters("FILE_KML")->asBool() )
{
CSG_MetaData KML; KML.Set_Name("kml"); KML.Add_Property("xmlns", "http://www.opengis.net/kml/2.2");
// CSG_MetaData *pFolder = KML.Add_Child("Folder");
// pFolder->Add_Child("name" , "Raster exported from SAGA");
// pFolder->Add_Child("description", "System for Automated Geoscientific Analyses - www.saga-gis.org");
// CSG_MetaData *pOverlay = pFolder->Add_Child("GroundOverlay");
CSG_MetaData *pOverlay = KML.Add_Child("GroundOverlay");
pOverlay->Add_Child("name" , pGrid->Get_Name());
pOverlay->Add_Child("description", pGrid->Get_Description());
pOverlay->Add_Child("Icon" )->Add_Child("href", SG_File_Get_Name(fName, true));
pOverlay->Add_Child("LatLonBox" );
pOverlay->Get_Child("LatLonBox" )->Add_Child("north", pGrid->Get_YMax());
pOverlay->Get_Child("LatLonBox" )->Add_Child("south", pGrid->Get_YMin());
pOverlay->Get_Child("LatLonBox" )->Add_Child("east" , pGrid->Get_XMax());
pOverlay->Get_Child("LatLonBox" )->Add_Child("west" , pGrid->Get_XMin());
KML.Save(fName, SG_T("kml"));
}
//-----------------------------------------------------
if( !SG_UI_Get_Window_Main() && pImgHandler != NULL)
{
wxImage::RemoveHandler(pImgHandler->GetName());
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CPointCloud_From_Text_File::On_Execute(void)
{
//-----------------------------------------------------
CSG_File Stream;
if( !Stream.Open(Parameters("FILE")->asString(), SG_FILE_R, false) )
{
Error_Set(_TL("Unable to open input file!"));
return( false );
}
//-----------------------------------------------------
int xField = Parameters("XFIELD")->asInt() - 1;
int yField = Parameters("YFIELD")->asInt() - 1;
int zField = Parameters("ZFIELD")->asInt() - 1;
char Separator;
switch( Parameters("SEPARATOR")->asInt() )
{
default: Separator = '\t'; break;
case 1: Separator = ' '; break;
case 2: Separator = ','; break;
}
//-----------------------------------------------------
CSG_String sLine;
CSG_Strings Values;
if( !Stream.Read_Line(sLine) )
{
Error_Set(_TL("Empty file!"));
return( false );
}
if( Parameters("SKIP_HEADER")->asBool() ) // header contains field names
{
CSG_String_Tokenizer tokValues(sLine, Separator); // read each field name for later use
while( tokValues.Has_More_Tokens() )
{
Values += tokValues.Get_Next_Token();
}
}
else
{
Stream.Seek_Start();
}
//-----------------------------------------------------
CSG_PointCloud *pPoints = SG_Create_PointCloud();
pPoints->Set_Name(SG_File_Get_Name(Parameters("FILE")->asString(), false));
Parameters("POINTS")->Set_Value(pPoints);
CSG_Array_Int Fields;
//-----------------------------------------------------
if( SG_UI_Get_Window_Main() )
{
CSG_Parameters &Fields = *Parameters("FIELDSPECS")->asParameters();
int nFields = Fields.Get_Count() / 2;
CSG_String Names, Types;
for(int iField=0; iField<nFields; iField++)
{
Names += CSG_String::Format("%s;", Fields(CSG_String::Format("NAME%03d", iField))->asString());
Types += CSG_String::Format("%d;", Fields(CSG_String::Format("TYPE%03d", iField))->asInt ());
}
Parameters("FIELDNAMES")->Set_Value(Names);
Parameters("FIELDTYPES")->Set_Value(Types);
}
{
TSG_Data_Type Type = SG_DATATYPE_Float; // default
CSG_String_Tokenizer tokFields(Parameters("FIELDS" )->asString(), ";");
CSG_String_Tokenizer tokTypes (Parameters("FIELDTYPES")->asString(), ";");
CSG_String_Tokenizer tokNames (Parameters("FIELDNAMES")->asString(), ";");
while( tokFields.Has_More_Tokens() )
{
int iField;
if( !tokFields.Get_Next_Token().asInt(iField) || iField < 1 )
{
Error_Set(_TL("Error parsing attribute field index"));
return( false );
}
Fields += iField - 1;
CSG_String Name;
if( tokNames.Has_More_Tokens() )
{
Name = tokNames.Get_Next_Token(); Name.Trim(true); Name.Trim(false);
}
if( Name.is_Empty() )
{
if( iField - 1 < Values.Get_Count() )
{
Name = Values[iField - 1];
}
else
{
Name.Printf("FIELD%02d", iField);
}
}
if( tokTypes.Has_More_Tokens() )
{
Get_Data_Type(Type, tokTypes.Get_Next_Token());
}
pPoints->Add_Field(Name, Type);
}
}
//-----------------------------------------------------
Process_Set_Text(_TL("Importing data ..."));
int nLines = 0;
sLong Length = Stream.Length();
while( Stream.Read_Line(sLine) )
{
nLines++;
if( pPoints->Get_Count() % 10000 == 0 && !Set_Progress((double)Stream.Tell(), (double)Length) )
{
return( true ); // user break
}
//-------------------------------------------------
CSG_String_Tokenizer tokValues(sLine, Separator);
Values.Clear();
while( tokValues.Has_More_Tokens() ) // read every column in this line and fill vector
{
Values += tokValues.Get_Next_Token();
}
//-------------------------------------------------
double x, y, z;
if( xField >= Values.Get_Count() || !Values[xField].asDouble(x)
|| yField >= Values.Get_Count() || !Values[yField].asDouble(y)
|| zField >= Values.Get_Count() || !Values[zField].asDouble(z) )
{
Message_Fmt("\n%s: %s [%d]", _TL("Warning"), _TL("Skipping misformatted line"), nLines);
continue;
}
pPoints->Add_Point(x, y, z);
//-------------------------------------------------
for(int iAttribute=0; iAttribute<pPoints->Get_Attribute_Count(); iAttribute++)
{
if( Fields[iAttribute] >= Values.Get_Count() )
{
pPoints->Set_NoData(3 + iAttribute);
}
else switch( pPoints->Get_Attribute_Type(iAttribute) )
{
case SG_DATATYPE_String:
pPoints->Set_Attribute(iAttribute, Values[Fields[iAttribute]]);
break;
default:
{
double Value;
if( Values[Fields[iAttribute]].asDouble(Value) )
{
pPoints->Set_Attribute(iAttribute, Value);
}
else
{
pPoints->Set_NoData(3 + iAttribute);
}
}
break;
}
}
}
//-----------------------------------------------------
DataObject_Set_Parameter(pPoints, "DISPLAY_VALUE_AGGREGATE", 3); // highest z
DataObject_Set_Parameter(pPoints, "COLORS_TYPE" , 3); // graduated colors
DataObject_Set_Parameter(pPoints, "METRIC_ATTRIB" , 2); // z attrib
DataObject_Set_Parameter(pPoints, "METRIC_ZRANGE", pPoints->Get_Minimum(2), pPoints->Get_Maximum(2));
DataObject_Update(pPoints);
//-----------------------------------------------------
if( nLines > pPoints->Get_Count() )
{
Message_Add(" ", true);
Message_Fmt("%s: %d %s", _TL("Warning"), nLines - pPoints->Get_Count(), _TL("invalid points have been skipped"));
}
Message_Add(" ", true);
Message_Fmt("%d %s", pPoints->Get_Count(), _TL("points have been imported with success"));
return( true );
}
//---------------------------------------------------------
CKriging_Base::CKriging_Base(void)
{
CSG_Parameter *pNode;
CSG_Parameters *pParameters;
//-----------------------------------------------------
pNode = Parameters.Add_Shapes(
NULL , "POINTS" , _TL("Points"),
_TL(""),
PARAMETER_INPUT, SHAPE_TYPE_Point
);
Parameters.Add_Table_Field(
pNode , "ZFIELD" , _TL("Attribute"),
_TL("")
);
//-----------------------------------------------------
Parameters.Add_Choice(
NULL , "TARGET" , _TL("Target Grid"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|"),
_TL("user defined"),
_TL("grid")
), 0
);
Parameters.Add_Choice(
NULL , "TQUALITY" , _TL("Type of Quality Measure"),
_TL(""),
CSG_String::Format(SG_T("%s|%s|"),
_TL("standard deviation"),
_TL("variance")
), 0
);
//-----------------------------------------------------
Parameters.Add_Value(
NULL , "LOG" , _TL("Logarithmic Transformation"),
_TL(""),
PARAMETER_TYPE_Bool
);
pNode = Parameters.Add_Value(
NULL , "BLOCK" , _TL("Block Kriging"),
_TL(""),
PARAMETER_TYPE_Bool , false
);
Parameters.Add_Value(
pNode , "DBLOCK" , _TL("Block Size"),
_TL(""),
PARAMETER_TYPE_Double , 100.0, 0.0, true
);
///////////////////////////////////////////////////////
//-----------------------------------------------------
if( !SG_UI_Get_Window_Main() )
{
Parameters.Add_Value(
NULL , "VAR_MAXDIST" , _TL("Maximum Distance"),
_TL(""),
PARAMETER_TYPE_Double , -1.0
);
Parameters.Add_Value(
NULL , "VAR_NCLASSES" , _TL("Lag Distance Classes"),
_TL("initial number of lag distance classes"),
PARAMETER_TYPE_Int , 100, 1, true
);
Parameters.Add_Value(
NULL , "VAR_NSKIP" , _TL("Skip"),
_TL(""),
PARAMETER_TYPE_Int, 1, 1, true
);
Parameters.Add_String(
NULL , "VAR_MODEL" , _TL("Model"),
_TL(""),
SG_T("a + b * x")
);
}
///////////////////////////////////////////////////////
//-----------------------------------------------------
pParameters = Add_Parameters("USER", _TL("User Defined Grid") , _TL(""));
pParameters->Add_Value(
NULL , "BVARIANCE" , _TL("Create Quality Grid"),
_TL(""),
PARAMETER_TYPE_Bool, true
);
m_Grid_Target.Add_Parameters_User(pParameters);
//-----------------------------------------------------
pParameters = Add_Parameters("GRID", _TL("Choose Grid") , _TL(""));
m_Grid_Target.Add_Parameters_Grid(pParameters);
//-----------------------------------------------------
m_Grid_Target.Add_Grid_Parameter(SG_T("VARIANCE"), _TL("Quality Measure"), true);
}
//---------------------------------------------------------
bool CKriging_Base::On_Execute(void)
{
bool bResult = false;
//-----------------------------------------------------
m_Block = Parameters("BLOCK" )->asBool() ? Parameters("DBLOCK")->asDouble() / 2.0 : 0.0;
m_bStdDev = Parameters("TQUALITY")->asInt() == 0;
m_bLog = Parameters("LOG" )->asBool();
m_pPoints = Parameters("POINTS" )->asShapes();
m_zField = Parameters("ZFIELD" )->asInt();
if( m_pPoints->Get_Count() <= 1 )
{
SG_UI_Msg_Add(_TL("not enough points for interpolation"), true);
return( false );
}
//-----------------------------------------------------
CSG_Table Variogram;
if( SG_UI_Get_Window_Main() )
{
static CVariogram_Dialog dlg;
if( dlg.Execute(m_pPoints, m_zField, m_bLog, &Variogram, &m_Model) )
{
bResult = true;
}
}
else
{
int nSkip = Parameters("VAR_NSKIP" )->asInt();
int nClasses = Parameters("VAR_NCLASSES")->asInt();
double maxDistance = Parameters("VAR_MAXDIST" )->asDouble();
m_Model.Set_Formula(Parameters("VAR_MODEL")->asString());
if( CSG_Variogram::Calculate(m_pPoints, m_zField, m_bLog, &Variogram, nClasses, maxDistance, nSkip) )
{
m_Model.Clr_Data();
for(int i=0; i<Variogram.Get_Count(); i++)
{
CSG_Table_Record *pRecord = Variogram.Get_Record(i);
m_Model.Add_Data(pRecord->asDouble(CSG_Variogram::FIELD_DISTANCE), pRecord->asDouble(CSG_Variogram::FIELD_VAR_EXP));
}
bResult = m_Model.Get_Trend() || m_Model.Get_Parameter_Count() == 0;
}
}
//-----------------------------------------------------
if( bResult && (bResult = _Initialise_Grids() && On_Initialize()) )
{
Message_Add(CSG_String::Format(SG_T("%s: %s"), _TL("variogram model"), m_Model.Get_Formula(SG_TREND_STRING_Formula_Parameters).c_str()), false);
for(int y=0; y<m_pGrid->Get_NY() && Set_Progress(y, m_pGrid->Get_NY()); y++)
{
#pragma omp parallel for
for(int x=0; x<m_pGrid->Get_NX(); x++)
{
double z, v;
if( Get_Value(m_pGrid->Get_System().Get_Grid_to_World(x, y), z, v) )
{
Set_Value(x, y, z, v);
}
else
{
Set_NoData(x, y);
}
}
}
}
//-----------------------------------------------------
m_Model.Clr_Data();
On_Finalize();
return( bResult );
}
