//---------------------------------------------------------
bool CWKSP_Project::_Compatibility_Data(TSG_Data_Type Type, CSG_Parameters *pParameters, const CSG_String &Version)
{
if( !pParameters )
{
return( false );
}
if( !Version.Cmp(SAGA_VERSION) )
{
return( true );
}
//-----------------------------------------------------
if( Version.is_Empty() )
{
CSG_Parameter *pParameter;
if( Type == SG_DATAOBJECT_TYPE_Grid )
{
if( (pParameter = pParameters->Get_Parameter("COLORS_TYPE")) != NULL )
{
if( pParameter->asInt() == 3 )
{ // 0:Single >> 1:LUT >> 2:Discrete >> 3:Graduated >> 4:RGB Overlay >> 5:RGB Composite >> 6:Shade
pParameter->Set_Value(5); // RGB moved to position 5
}
}
}
}
return( true );
}
//---------------------------------------------------------
bool CSG_CURL::Create(const CSG_String &Server, const SG_Char *Username, const SG_Char *Password)
{
Destroy();
if( Server.is_Empty() || (m_pCURL = curl_easy_init()) == NULL )
{
return( false );
}
m_Server = Server;
if( m_Server.Find("://") < 0 )
{
m_Server.Prepend("http://");
}
if( Username && *Username ) { CSG_String s(Username); curl_easy_setopt(m_pCURL, CURLOPT_USERNAME, s.b_str()); }
if( Password && *Password ) { CSG_String s(Password); curl_easy_setopt(m_pCURL, CURLOPT_PASSWORD, s.b_str()); }
CURL_SET_OPT(2, CURLOPT_URL , m_Server.b_str());
CURL_SET_OPT(0, CURLOPT_SSL_VERIFYPEER, 0L);
CURL_SET_OPT(0, CURLOPT_SSL_VERIFYHOST, 0L);
CURL_SET_OPT(0, CURLOPT_USERAGENT , "libcurl-agent/1.0");
return( true );
}
//---------------------------------------------------------
bool CSG_MetaData::Add_Property(const CSG_String &Name, const CSG_String &Value)
{
if( !Value.is_Empty() &&_Get_Property(Name) < 0 )
{
m_Prop_Names .Add(Name );
m_Prop_Values.Add(Value);
return( true );
}
return( false );
}
//---------------------------------------------------------
void CMD_Print (const CSG_String &Text, const CSG_String &XML_Tag)
{
if( g_bXML )
{
if( !XML_Tag.is_Empty() )
{
SG_Printf("<%s>%s</%s>\n", XML_Tag.c_str(), Text.c_str(), XML_Tag.c_str());
}
}
else
{
SG_Printf("%s\n", Text.c_str());
}
std::cout << std::flush;
}
//---------------------------------------------------------
void CMD_Print (FILE *Stream, const CSG_String &Text, const CSG_String &XML_Tag)
{
if( Stream )
{
if( g_bXML )
{
if( !XML_Tag.is_Empty() )
{
SG_FPrintf(Stream, "<%s>%s</%s>\n", XML_Tag.c_str(), Text.c_str(), XML_Tag.c_str());
}
}
else
{
SG_FPrintf(Stream, "%s\n", Text.c_str());
}
}
fflush(Stream);
}
//---------------------------------------------------------
CSG_String CTable_Query_GUI::Get_Selection(const CSG_String &Parameter)
{
CSG_String s;
if( Parameters(Parameter) && Parameters(Parameter)->asParameters() )
{
CSG_Parameters &P = *Parameters(Parameter)->asParameters();
for(int i=0; i<P.Get_Count(); i++)
{
if( P[i].Get_Type() == PARAMETER_TYPE_Bool && P[i].asBool() )
{
if( !s.is_Empty() )
{
s += ",";
}
s += P[i].Get_Identifier();
}
}
}
return( s );
}
//---------------------------------------------------------
bool CDirect_Georeferencing_WorldFile::On_Execute(void)
{
//-----------------------------------------------------
int nx = Parameters("NX")->asInt();
int ny = Parameters("NY")->asInt();
if( !m_Georeferencer.Set_Transformation(Parameters, nx, ny) )
{
return( false );
}
//-----------------------------------------------------
CSG_String File = Parameters("FILE")->asString();
if( File.is_Empty() )
{
return( false );
}
//-----------------------------------------------------
CSG_File Stream;
if( !Stream.Open(File, SG_FILE_W, false) )
{
return( false );
}
//-----------------------------------------------------
CSG_Matrix R(m_Georeferencer.Get_Transformation());
R *= 0.001 * Parameters("Z")->asDouble() / Parameters("CFL")->asDouble() * Parameters("PXSIZE")->asDouble();
TSG_Point p = m_Georeferencer.Image_to_World(0, ny);
Stream.Printf(SG_T("%.10f\n%.10f\n%.10f\n%.10f\n%.10f\n%.10f\n"),
R[0][0], // A: pixel size in the x-direction in map units/pixel
R[1][0], // D: rotation about y-axis
-R[0][1], // B: rotation about x-axis
-R[1][1], // E: pixel size in the y-direction in map units, almost always negative
p.x, // X: top left pixel center
p.y // Y: top left pixel center
);
//-----------------------------------------------------
CSG_Shapes *pExtents = Parameters("EXTENT")->asShapes();
if( pExtents )
{
pExtents->Create(SHAPE_TYPE_Polygon, SG_File_Get_Name(File, false));
pExtents->Add_Field(_TL("NAME"), SG_DATATYPE_String);
CSG_Shape *pExtent = pExtents->Add_Shape();
p = m_Georeferencer.Image_to_World( 0, 0); pExtent->Add_Point(p.x, p.y);
p = m_Georeferencer.Image_to_World( 0, ny); pExtent->Add_Point(p.x, p.y);
p = m_Georeferencer.Image_to_World(nx, ny); pExtent->Add_Point(p.x, p.y);
p = m_Georeferencer.Image_to_World(nx, 0); pExtent->Add_Point(p.x, p.y);
pExtent->Set_Value(0, SG_File_Get_Name(File, false));
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGDAL_Formats::On_Execute(void)
{
CSG_Table *pFormats = Parameters("FORMATS")->asTable();
pFormats->Destroy();
pFormats->Set_Name(_TL("GDAL Formats"));
pFormats->Add_Field("ID" , SG_DATATYPE_String);
pFormats->Add_Field("NAME" , SG_DATATYPE_String);
pFormats->Add_Field("FILTER", SG_DATATYPE_String);
pFormats->Add_Field("TYPE" , SG_DATATYPE_String);
pFormats->Add_Field("ACCESS", SG_DATATYPE_String);
//-----------------------------------------------------
int Type = Parameters("TYPE" )->asInt();
int Access = Parameters("ACCESS")->asInt();
//-----------------------------------------------------
if( Type != 1 ) // not vectors only
{
for(int i=0; i<SG_Get_GDAL_Drivers().Get_Count(); i++)
{
if( SG_Get_GDAL_Drivers().is_Raster(i) )
{
CSG_String R(SG_Get_GDAL_Drivers().Can_Read (i) ? "R" : "");
CSG_String W(SG_Get_GDAL_Drivers().Can_Write(i) ? "W" : "");
if( (Access != 0 || !R.is_Empty()) && (Access != 1 || !W.is_Empty()) )
{
CSG_Table_Record *pFormat = pFormats->Add_Record();
pFormat->Set_Value(GDAL_LIST_FMT_ID , SG_Get_GDAL_Drivers().Get_Description(i));
pFormat->Set_Value(GDAL_LIST_FMT_NAME , SG_Get_GDAL_Drivers().Get_Name (i));
pFormat->Set_Value(GDAL_LIST_FMT_FILTER, SG_Get_GDAL_Drivers().Get_Extension (i));
pFormat->Set_Value(GDAL_LIST_FMT_TYPE , "RASTER");
pFormat->Set_Value(GDAL_LIST_FMT_ACCESS, R + W);
}
}
}
}
//-----------------------------------------------------
if( Type != 0 ) // not rasters only
{
for(int i=0; i<SG_Get_OGR_Drivers().Get_Count(); i++)
{
if( SG_Get_OGR_Drivers().is_Vector(i) )
{
CSG_String R(SG_Get_OGR_Drivers().Can_Read (i) ? "R" : "");
CSG_String W(SG_Get_OGR_Drivers().Can_Write(i) ? "W" : "");
if( (Access != 0 || !R.is_Empty()) && (Access != 1 || !W.is_Empty()) )
{
CSG_Table_Record *pFormat = pFormats->Add_Record();
pFormat->Set_Value(GDAL_LIST_FMT_ID , SG_Get_OGR_Drivers().Get_Description(i));
pFormat->Set_Value(GDAL_LIST_FMT_NAME , SG_Get_OGR_Drivers().Get_Name (i));
pFormat->Set_Value(GDAL_LIST_FMT_FILTER, SG_Get_OGR_Drivers().Get_Extension (i));
pFormat->Set_Value(GDAL_LIST_FMT_TYPE , "VECTOR");
pFormat->Set_Value(GDAL_LIST_FMT_ACCESS, R + W);
}
}
}
}
//-----------------------------------------------------
if( Parameters("RECOGNIZED")->asBool() )
{
CSG_String Filter_All;
for(int i=0; i<pFormats->Get_Count(); i++)
{
CSG_String Filter = pFormats->Get_Record(i)->asString(GDAL_LIST_FMT_FILTER);
if( !Filter.is_Empty() )
{
Filter.Replace("/", ";");
Filter_All += (Filter_All.is_Empty() ? "*." : ";*.") + Filter;
}
}
if( !Filter_All.is_Empty() )
{
CSG_Table_Record *pFormat = pFormats->Add_Record();
pFormat->Set_Value(GDAL_LIST_FMT_NAME , _TL("All Recognized Files"));
pFormat->Set_Value(GDAL_LIST_FMT_FILTER, Filter_All);
pFormat->Set_Value(GDAL_LIST_FMT_TYPE , Type == 0 ? "RASTER" : Type == 1 ? "VECTOR" : "RASTER/VECTOR");
pFormat->Set_Value(GDAL_LIST_FMT_ACCESS, Access == 0 ? "R" : Access == 1 ? "W" : "RW" );
}
}
//-----------------------------------------------------
return( pFormats->Get_Count() > 0 );
}
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
bool SG_FTP_Download(const CSG_String &Target_Directory, const CSG_String &Source, const SG_Char *Username, const SG_Char *Password, unsigned short Port, bool bBinary, bool bVerbose)
{
CSG_String _Source(Source); _Source.Trim();
if( _Source.Find("ftp://") == 0 )
{
_Source = _Source.Right(_Source.Length() - CSG_String("ftp://").Length());
}
CSG_String ftpHost = _Source.BeforeFirst('/');
CSG_String ftpDir = _Source.AfterFirst ('/').BeforeLast('/'); // ftpDir.Prepend("/");
CSG_String ftpFile = _Source.AfterLast ('/');
//-----------------------------------------------------
wxFTP ftp;
if( Username && *Username ) { ftp.SetUser (Username); }
if( Password && *Password ) { ftp.SetPassword(Password); }
if( !ftp.Connect(ftpHost.c_str(), Port) )
{
if( bVerbose )
{
SG_UI_Msg_Add_Error(_TL("Couldn't connect"));
}
return( false );
}
//-----------------------------------------------------
if( !ftpDir.is_Empty() && !ftp.ChDir(ftpDir.c_str()) )
{
if( bVerbose )
{
SG_UI_Msg_Add_Error(CSG_String::Format("%s [%s]", _TL("Couldn't change to directory"), ftpDir.c_str()));
}
return( false );
}
if( ftp.GetFileSize(ftpFile.c_str()) == -1 )
{
if( bVerbose )
{
SG_UI_Msg_Add_Error(CSG_String::Format("%s [%s]", _TL("Couldn't get the file size"), ftpFile.c_str()));
}
}
//-----------------------------------------------------
wxInputStream *pStream = ftp.GetInputStream(ftpFile.c_str());
if( !pStream )
{
if( bVerbose )
{
SG_UI_Msg_Add_Error(CSG_String::Format("%s [%s]", _TL("Couldn't get the file"), ftpFile.c_str()));
}
return( false );
}
//-----------------------------------------------------
wxFileOutputStream *pFile = new wxFileOutputStream(SG_File_Make_Path(Target_Directory, ftpFile).c_str());
if( !pFile )
{
if( bVerbose )
{
SG_UI_Msg_Add_Error(CSG_String::Format("%s [%s]", _TL("Couldn't create target file"), SG_File_Make_Path(Target_Directory, ftpFile).c_str()));
}
delete(pStream);
return( false );
}
//-----------------------------------------------------
pFile->Write(*pStream);
delete(pFile);
delete(pStream);
return( true );
}
//---------------------------------------------------------
bool CSG_MetaData::from_JSON(const CSG_String &JSON)
{
Destroy();
Set_Name("root");
CSG_MetaData *pNode = this;
const SG_Char *pc = JSON.c_str();
while( *pc )
{
CSG_String Element;
for(bool bQuota=false;;)
{
SG_Char c = *pc++;
if( !c || c == '\n' ) { break; } else
{
if( c == '\"' )
{
Element += c; bQuota = !bQuota;
}
else if( bQuota || (c != ' ' && c != '\t' && c != ',') )
{
Element += c;
}
}
}
//-------------------------------------------------
if( Element.is_Empty() )
{
// nop
}
else if( Element.Find('[') >= 0 ) // array begins
{
pNode = pNode->Add_Child(Element.AfterFirst('\"').BeforeFirst('\"'));
pNode->Add_Property("array", 1);
}
else if( Element.Find(']') >= 0 ) // array ends
{
if( pNode != this )
{
pNode = pNode->Get_Parent();
}
}
else if( Element.Find('{') >= 0 ) // object begins
{
Element = Element.AfterFirst('\"').BeforeFirst('\"');
if( !Element.is_Empty() )
{
pNode = pNode->Add_Child(Element);
}
else if( pNode->Get_Property("array") )
{
pNode = pNode->Add_Child(CSG_String::Format("%d", pNode->Get_Children_Count()));
}
}
else if( Element.Find('}') >= 0 ) // object ends
{
if( pNode != this )
{
pNode = pNode->Get_Parent();
}
}
else
{
CSG_String Key (Element.AfterFirst('\"').BeforeFirst('\"'));
CSG_String Value(Element.AfterFirst(':'));
if( Value.Find('\"') > -1 )
{
Value = Value.AfterFirst('\"').BeforeFirst('\"');
}
pNode->Add_Child(Key, Value);
}
}
return( true );
}