//---------------------------------------------------------
bool CGPX_Import::Add_Track(CSG_MetaData *pTrack)
{
// <name> xsd:string
// <cmt> xsd:string
// <desc> xsd:string
// <src> xsd:string
// <link> linkType
// <number> xsd:nonNegativeInteger
// <type> xsd:string
CSG_MetaData *pSegment = pTrack->Get_Child(SG_T("trkseg"));
if( pSegment )
{
CSG_String Name(GET_CONTENT(pTrack, "name", "Track Segment"));
CSG_Shapes *pPoints = SG_Create_Shapes(SHAPE_TYPE_Point, CSG_String::Format(SG_T("%s [%s]"), m_Name.c_str(), Name.c_str()));
m_pShapes->Add_Item(pPoints);
for(int i=0; i<pSegment->Get_Children_Count(); i++)
{
CSG_MetaData *pChild = pSegment->Get_Child(i);
if( pChild->Get_Name().CmpNoCase(SG_T("trkpt")) == 0 )
{
Add_Point(pChild, pPoints);
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGPX_Import::Add_Point(CSG_MetaData *pNode, CSG_Shapes *pPoints)
{
const SG_Char *cString;
TSG_Point Point;
if( (cString = pNode->Get_Property(SG_T("lon"))) != NULL && CSG_String(cString).asDouble(Point.x)
&& (cString = pNode->Get_Property(SG_T("lat"))) != NULL && CSG_String(cString).asDouble(Point.y)
&& Add_Fields(pNode, pPoints) )
{
CSG_Shape *pPoint = pPoints->Add_Shape();
pPoint->Add_Point(Point, 0);
for(int i=0; i<pNode->Get_Children_Count(); i++)
{
CSG_MetaData *pChild = pNode->Get_Child(i);
pPoint->Set_Value(pChild->Get_Name(), pChild->Get_Content());
}
if( m_bTime )
{
double h = CSG_String(pPoint->asString(SG_T("time"))).AfterFirst(SG_T('T')).asDouble();
double m = CSG_String(pPoint->asString(SG_T("time"))).AfterFirst(SG_T(':')).asDouble();
double s = CSG_String(pPoint->asString(SG_T("time"))).AfterLast (SG_T(':')).asDouble();
pPoint->Set_Value(SG_T("dtime"), h + m / 60.0 + s / 3600.0);
}
return( true );
}
return( false );
}
CSG_MetaData * CSG_MetaData::Ins_Child(const CSG_MetaData &MetaData, int Position, bool bAddChildren)
{
CSG_MetaData *pChild = Ins_Child(Position);
if( pChild )
{
pChild->Assign(MetaData, bAddChildren);
}
return( pChild );
}
//---------------------------------------------------------
bool CGPX_Import::On_Execute(void)
{
CSG_Shapes *pWay;
CSG_MetaData GPX;
//-----------------------------------------------------
m_Name = Parameters("FILE") ->asString();
m_pShapes = Parameters("SHAPES") ->asShapesList();
m_bTime = Parameters("TIME") ->asBool();
//-----------------------------------------------------
if( !GPX.Create(m_Name) || GPX.Get_Name().CmpNoCase(SG_T("gpx")) )
{
return( false );
}
//-----------------------------------------------------
pWay = SG_Create_Shapes(SHAPE_TYPE_Point, m_Name);
m_Name = SG_File_Get_Name(m_Name, false);
m_pShapes->Del_Items();
//-----------------------------------------------------
for(int i=0; i<GPX.Get_Children_Count(); i++)
{
CSG_MetaData *pChild = GPX.Get_Child(i);
if( pChild->Get_Name().CmpNoCase(SG_T("wpt")) == 0 )
{
Add_Point(pChild, pWay);
}
else if( pChild->Get_Name().CmpNoCase(SG_T("rte")) == 0 )
{
Add_Route(pChild);
}
else if( pChild->Get_Name().CmpNoCase(SG_T("trk")) == 0 )
{
Add_Track(pChild);
}
}
//-----------------------------------------------------
if( pWay->Get_Count() > 0 )
{
m_pShapes->Add_Item(pWay);
}
else
{
delete(pWay);
}
return( m_pShapes->Get_Count() > 0 );
}
//---------------------------------------------------------
bool CSG_MetaData::Assign(const CSG_MetaData &MetaData, bool bAppend)
{
int i;
if( !bAppend )
{
Destroy();
Set_Name (MetaData.Get_Name ());
Set_Content (MetaData.Get_Content());
//-------------------------------------------------
for(i=0; i<MetaData.Get_Property_Count(); i++)
{
Add_Property(MetaData.Get_Property_Name(i), MetaData.Get_Property(i));
}
}
//-----------------------------------------------------
for(i=0; i<MetaData.Get_Children_Count(); i++)
{
Add_Child()->Assign(*MetaData.Get_Child(i), false);
}
return( true );
}
//---------------------------------------------------------
int CTL_Extract::Read_ToolChain(const SG_Char *File, CSG_Table &Elements)
{
//-----------------------------------------------------
CSG_MetaData Chain;
if( Chain.Load(File) )
{
Process_Set_Text(CSG_String::Format("%s: %s", SG_T("scanning"), File));
//-------------------------------------------------
if( Chain.Cmp_Name("toolchains") )
{
GET_XML_CONTENT(Chain, "name" );
GET_XML_CONTENT(Chain, "menu" );
// GET_XML_CONTENT(Chain, "description");
return( 1 );
}
//-------------------------------------------------
if( Chain.Cmp_Name("toolchain") )
{
GET_XML_CONTENT(Chain, "name" );
GET_XML_CONTENT(Chain, "menu" );
// GET_XML_CONTENT(Chain, "description");
if( Chain("parameters") )
{
for(int i=0; i<Chain["parameters"].Get_Children_Count(); i++)
{
const CSG_MetaData &Parameter = Chain["parameters"][i];
GET_XML_CONTENT(Parameter, "name" );
GET_XML_CONTENT(Parameter, "description");
}
}
return( 1 );
}
}
return( 0 );
}
//---------------------------------------------------------
bool CSG_HTTP::Request(const CSG_String &Request, CSG_MetaData &Answer)
{
wxInputStream *pStream = _Request(Request); if( !pStream ) { return( false ); }
wxXmlDocument XML;
if( !XML.Load(*pStream) )
{
delete(pStream);
return( false );
}
Answer.Destroy(); Answer._Load(XML.GetRoot());
delete(pStream);
return( true );
}
//---------------------------------------------------------
bool CWKSP_Project::_Save_Map(CSG_MetaData &Entry, const wxString &ProjectDir, CWKSP_Map *pMap)
{
if( !pMap )
{
return( false );
}
CSG_MetaData *pEntry = Entry.Add_Child("MAP");
pEntry->Add_Child("XMIN", pMap->Get_Extent().Get_XMin());
pEntry->Add_Child("XMAX", pMap->Get_Extent().Get_XMax());
pEntry->Add_Child("YMIN", pMap->Get_Extent().Get_YMin());
pEntry->Add_Child("YMAX", pMap->Get_Extent().Get_YMax());
pMap->Get_Parameters()->Serialize(*pEntry->Add_Child("PARAMETERS"), true);
pEntry = pEntry->Add_Child("LAYERS");
for(int i=pMap->Get_Count()-1; i>=0; i--)
{
if( pMap->Get_Item(i)->Get_Type() == WKSP_ITEM_Map_Layer )
{
CSG_Data_Object *pObject = ((CWKSP_Map_Layer *)pMap->Get_Item(i))->Get_Layer()->Get_Object();
if( pObject && pObject->Get_File_Name(false) && *pObject->Get_File_Name(false) )
{
wxString FileName(pObject->Get_File_Name(false));
if( FileName.Find("PGSQL") == 0 )
{
pEntry->Add_Child("FILE", &FileName);
}
else if( wxFileExists(FileName) )
{
pEntry->Add_Child("FILE", SG_File_Get_Path_Relative(&ProjectDir, &FileName));
}
}
}
else if( pMap->Get_Item(i)->Get_Type() == WKSP_ITEM_Map_Graticule )
{
((CWKSP_Map_Graticule *)pMap->Get_Item(i))->Save(*pEntry);
}
else if( pMap->Get_Item(i)->Get_Type() == WKSP_ITEM_Map_BaseMap )
{
((CWKSP_Map_BaseMap *)pMap->Get_Item(i))->Save(*pEntry);
}
}
return( true );
}
//---------------------------------------------------------
bool CSG_MetaData::Add_Children(const CSG_MetaData &MetaData)
{
if( &MetaData != this )
{
for(int i=0; i<MetaData.Get_Children_Count(); i++)
{
Add_Child(MetaData[i], true);
}
}
return( true );
}
//---------------------------------------------------------
bool CSG_MetaData::Assign(const CSG_MetaData &MetaData, bool bAddChildren)
{
if( &MetaData != this )
{
Destroy();
Set_Name (MetaData.Get_Name ());
Set_Content (MetaData.Get_Content());
for(int i=0; i<MetaData.Get_Property_Count(); i++)
{
Add_Property(MetaData.Get_Property_Name(i), MetaData.Get_Property(i));
}
if( bAddChildren )
{
Add_Children(MetaData);
}
}
return( true );
}
//---------------------------------------------------------
bool CWKSP_Project::_Load_DBConnections(CSG_MetaData &Data)
{
int i;
CSG_Strings Connections;
for(i=0; i<Data.Get_Children_Count(); i++)
{
CSG_String Connection(Data[i].Get_Child("FILE") ? Data[i].Get_Child("FILE")->Get_Content() : "");
if( !Connection.BeforeFirst(':').CmpNoCase("PGSQL") )
{
Connection = Connection.AfterFirst(':'); CSG_String Host (Connection.BeforeFirst(':'));
Connection = Connection.AfterFirst(':'); CSG_String Port (Connection.BeforeFirst(':'));
Connection = Connection.AfterFirst(':'); CSG_String DBName(Connection.BeforeFirst(':'));
Connection = Host + ":" + Port + ":" + DBName;
bool bAdd = true;
for(int j=0; j<Connections.Get_Count() && bAdd; j++)
{
if( !Connection.Cmp(Connections[j]) )
{
bAdd = false;
}
}
if( bAdd )
{
Connections += Connection;
}
}
}
for(i=0; i<Connections.Get_Count(); i++)
{
CSG_String Host (Connections[i].BeforeFirst(':'));
CSG_String Port (Connections[i].AfterFirst (':').BeforeLast(':'));
CSG_String DBName(Connections[i].AfterLast (':'));
if( !PGSQL_Connect(Host, Port, DBName) )
{
return( false );
}
}
return( true );
}
//---------------------------------------------------------
bool CSG_CURL::Request(const CSG_String &Request, CSG_MetaData &Answer)
{
CSG_String _Answer;
return( CSG_CURL::Request(Request, _Answer) && Answer.from_XML(_Answer) );
}
//---------------------------------------------------------
bool CWKSP_Map_Graticule::Save(CSG_MetaData &Entry)
{
return( m_Parameters.Serialize(*Entry.Add_Child("GRATICULE"), 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 );
}
//---------------------------------------------------------
bool CWMS_Capabilities::Create(const CSG_String &Server, const CSG_String &Version)
{
Destroy();
int i;
CSG_String s = "http://" + Server;
s += "?SERVICE=WMS";
s += "&VERSION=" + Version;
s += "&REQUEST=GetCapabilities";
CSG_MetaData Capabilities;
if( !Capabilities.Create(s) )
{
return( false );
}
//-----------------------------------------------------
if( !Capabilities.Get_Property("version", m_Version) || !Capabilities("Service") || !Capabilities("Capability") )
{
return( false );
}
const CSG_MetaData &Service = Capabilities["Service"];
CAP_GET_STRING(Service, "Name" , m_Name , true);
CAP_GET_STRING(Service, "Title" , m_Title , true);
CAP_GET_STRING(Service, "Abstract" , m_Abstract , true);
CAP_GET____INT(Service, "LayerLimit", m_LayerLimit, false);
CAP_GET____INT(Service, "MaxWidth" , m_MaxWidth , false);
CAP_GET____INT(Service, "MaxHeight" , m_MaxHeight , false);
//-----------------------------------------------------
if( !Capabilities["Capability"]("Request") || !Capabilities["Capability"]["Request"](V_MAP(m_Version)) )
{
return( false );
}
const CSG_MetaData &GetMap = Capabilities["Capability"]["Request"][V_MAP(m_Version)];
for(i=0; i<GetMap.Get_Children_Count(); i++)
{
if( GetMap[i].Cmp_Name ("Format" )
&& (GetMap[i].Cmp_Content("image/png" )
|| GetMap[i].Cmp_Content("image/jpeg")
|| GetMap[i].Cmp_Content("image/gif" )
|| GetMap[i].Cmp_Content("image/tiff")) )
{
m_Formats += GetMap[i].Get_Content() + "|";
}
}
//-----------------------------------------------------
if( !Capabilities["Capability"]("Layer") )
{
return( false );
}
const CSG_MetaData &Layer = Capabilities["Capability"]["Layer"];
if( m_Version.Cmp("1.3.0") == 0 )
{
if( !Layer("EX_GeographicBoundingBox") )
{
return( false );
}
CAP_GET_DOUBLE(Layer["EX_GeographicBoundingBox"], "westBoundLongitude", m_Extent.xMin, true);
CAP_GET_DOUBLE(Layer["EX_GeographicBoundingBox"], "eastBoundLongitude", m_Extent.xMax, true);
CAP_GET_DOUBLE(Layer["EX_GeographicBoundingBox"], "southBoundLatitude", m_Extent.yMin, true);
CAP_GET_DOUBLE(Layer["EX_GeographicBoundingBox"], "northBoundLatitude", m_Extent.yMax, true);
}
else // version < 1.3.0
{
if( !Layer("LatLonBoundingBox")
|| !Layer["LatLonBoundingBox"].Get_Property("minx", m_Extent.xMin)
|| !Layer["LatLonBoundingBox"].Get_Property("maxx", m_Extent.xMax)
|| !Layer["LatLonBoundingBox"].Get_Property("miny", m_Extent.yMin)
|| !Layer["LatLonBoundingBox"].Get_Property("maxy", m_Extent.yMax) )
{
return( false );
}
}
for(i=0; i<Layer.Get_Children_Count(); i++)
{
if( Layer[i].Cmp_Name(V_SRS(m_Version)) )
{
m_Projections += Layer[i].Get_Content() + "|";
}
else if( Layer[i].Cmp_Name("Layer") )
{
m_Layers_Name += Layer[i].Get_Content("Name" );
m_Layers_Title += Layer[i].Get_Content("Title");
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CPointCloud_Create_Tileshape_From_SPCVF::On_Execute(void)
{
CSG_String sFileName;
CSG_Shapes *pShapes;
CSG_MetaData SPCVF;
CSG_String sPathSPCVF, sFilePath;
int iPoints;
double dBBoxXMin, dBBoxYMin, dBBoxXMax, dBBoxYMax;
//-----------------------------------------------------
sFileName = Parameters("FILENAME")->asString();
pShapes = Parameters("TILE_SHP")->asShapes();
//-----------------------------------------------------
if( !SPCVF.Create(sFileName) || SPCVF.Get_Name().CmpNoCase(SG_T("SPCVFDataset")) )
{
SG_UI_Msg_Add_Error(_TL("Please provide a valid *.scpvf file!"));
return( false );
}
//-----------------------------------------------------
CSG_String sMethodPaths;
SPCVF.Get_Property(SG_T("Paths"), sMethodPaths);
if( !sMethodPaths.CmpNoCase(SG_T("absolute")) )
{
sPathSPCVF = SG_T("");
}
else if( !sMethodPaths.CmpNoCase(SG_T("relative")) )
{
sPathSPCVF = SG_File_Get_Path(sFileName);
sPathSPCVF.Replace(SG_T("\\"), SG_T("/"));
}
else
{
SG_UI_Msg_Add_Error(_TL("Encountered invalid path description in *.spcvf file!"));
return( false );
}
//-----------------------------------------------------
pShapes->Destroy();
pShapes->Add_Field(_TL("ID"), SG_DATATYPE_Int);
pShapes->Add_Field(_TL("Filepath"), SG_DATATYPE_String);
pShapes->Add_Field(_TL("File"), SG_DATATYPE_String);
pShapes->Add_Field(_TL("Points"), SG_DATATYPE_Int);
pShapes->Set_Name(CSG_String::Format(_TL("Tileshape_%s"), SG_File_Get_Name(sFileName, false).c_str()));
//-----------------------------------------------------
CSG_MetaData *pDatasets = SPCVF.Get_Child(SG_T("Datasets"));
for(int i=0; i<pDatasets->Get_Children_Count(); i++)
{
CSG_MetaData *pDataset = pDatasets->Get_Child(i);
CSG_MetaData *pBBox = pDataset->Get_Child(SG_T("BBox"));
pDataset->Get_Property(SG_T("File"), sFilePath);
pDataset->Get_Property(SG_T("Points"), iPoints);
pBBox->Get_Property(SG_T("XMin"), dBBoxXMin);
pBBox->Get_Property(SG_T("YMin"), dBBoxYMin);
pBBox->Get_Property(SG_T("XMax"), dBBoxXMax);
pBBox->Get_Property(SG_T("YMax"), dBBoxYMax);
//-----------------------------------------------------
CSG_Shape *pShape = pShapes->Add_Shape();
pShape->Add_Point(dBBoxXMin, dBBoxYMin);
pShape->Add_Point(dBBoxXMin, dBBoxYMax);
pShape->Add_Point(dBBoxXMax, dBBoxYMax);
pShape->Add_Point(dBBoxXMax, dBBoxYMin);
pShape->Set_Value(0, i + 1);
if( sPathSPCVF.Length() == 0 ) // absolute paths
{
pShape->Set_Value(1, sFilePath.BeforeLast('/'));
pShape->Set_Value(2, sFilePath.AfterLast('/'));
}
else // relative paths
{
pShape->Set_Value(1, sPathSPCVF);
pShape->Set_Value(2, sFilePath);
}
pShape->Set_Value(3, iPoints);
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CWKSP_Project::_Load_Data(CSG_MetaData &Entry, const wxString &ProjectDir, bool bLoad, const CSG_String &Version)
{
if( Entry.Get_Name().Cmp("DATASET") || !Entry.Get_Child("FILE") || Entry.Get_Child("FILE")->Get_Content().is_Empty() )
{
return( false );
}
TSG_Data_Object_Type Type =
Entry.Cmp_Property("type", "GRID" ) ? DATAOBJECT_TYPE_Grid
: Entry.Cmp_Property("type", "TABLE" ) ? DATAOBJECT_TYPE_Table
: Entry.Cmp_Property("type", "SHAPES") ? DATAOBJECT_TYPE_Shapes
: Entry.Cmp_Property("type", "TIN" ) ? DATAOBJECT_TYPE_TIN
: Entry.Cmp_Property("type", "POINTS") ? DATAOBJECT_TYPE_PointCloud
: DATAOBJECT_TYPE_Undefined;
if( Type == DATAOBJECT_TYPE_Undefined )
{
return( false );
}
//-----------------------------------------------------
wxString File = Entry.Get_Child("FILE")->Get_Content().c_str();
if( File.Find("PGSQL") != 0 && wxFileExists(Get_FilePath_Absolute(ProjectDir, File)) )
{
File = Get_FilePath_Absolute(ProjectDir, File);
}
CWKSP_Base_Item *pItem = bLoad ? g_pData->Open(File, Type) : _Get_byFileName(File);
if( !pItem || !pItem->Get_Parameters() || !Entry.Get_Child("PARAMETERS") )
{
if( bLoad )
{
MSG_Error_Add(wxString::Format("%s [%s]", _TL("failed to load data"), File.c_str()));
}
return( false );
}
//-----------------------------------------------------
CSG_MetaData *pEntry = Entry("PARAMETERS");
for(int i=0; i<pEntry->Get_Children_Count(); i++)
{
if( !pEntry->Get_Child(i)->Get_Name().CmpNoCase("DATA") && !pEntry->Get_Child(i)->Get_Content().is_Empty() && pEntry->Get_Child(i)->Get_Content().BeforeFirst(':').Cmp("PGSQL") )
{
wxString File(Get_FilePath_Absolute(ProjectDir, pEntry->Get_Child(i)->Get_Content().w_str()));
pEntry->Get_Child(i)->Set_Content(&File);
// if( SG_Compare_SAGA_Version(Version) < 0 )
{
if( pEntry->Get_Child(i)->Cmp_Property("id", "OVERLAY_1") )
{
pEntry->Get_Child(i)->Set_Property("id", "OVERLAY_G");
}
if( pEntry->Get_Child(i)->Cmp_Property("id", "OVERLAY_2") )
{
pEntry->Get_Child(i)->Set_Property("id", "OVERLAY_B");
}
}
}
}
pItem->Get_Parameters()->Serialize(*Entry.Get_Child("PARAMETERS"), false);
pItem->Parameters_Changed();
return( true );
}
//---------------------------------------------------------
bool CWKSP_Project::_Load_Data(CSG_MetaData &Entry, const wxString &ProjectDir, bool bLoad, const CSG_String &Version)
{
if( !Entry.Cmp_Name("DATASET") || !Entry("FILE") || Entry["FILE"].Get_Content().is_Empty() )
{
return( false );
}
TSG_Data_Object_Type Type =
Entry.Cmp_Property("type", "GRID" ) ? SG_DATAOBJECT_TYPE_Grid
: Entry.Cmp_Property("type", "GRIDS" ) ? SG_DATAOBJECT_TYPE_Grids
: Entry.Cmp_Property("type", "TABLE" ) ? SG_DATAOBJECT_TYPE_Table
: Entry.Cmp_Property("type", "SHAPES") ? SG_DATAOBJECT_TYPE_Shapes
: Entry.Cmp_Property("type", "TIN" ) ? SG_DATAOBJECT_TYPE_TIN
: Entry.Cmp_Property("type", "POINTS") ? SG_DATAOBJECT_TYPE_PointCloud
: SG_DATAOBJECT_TYPE_Undefined;
if( Type == SG_DATAOBJECT_TYPE_Undefined )
{
return( false );
}
//-----------------------------------------------------
wxString File = Entry("FILE")->Get_Content().c_str();
if( File.Find("PGSQL") != 0 && wxFileExists(Get_FilePath_Absolute(ProjectDir, File)) )
{
File = Get_FilePath_Absolute(ProjectDir, File);
}
//-----------------------------------------------------
CWKSP_Base_Item *pItem = NULL;
if( bLoad )
{
if( Type == SG_DATAOBJECT_TYPE_Grid && Entry("PARAMETERS"))
{
for(int i=0; i<Entry["PARAMETERS"].Get_Children_Count() && !pItem; i++)
{
if( Entry["PARAMETERS"][i].Cmp_Property("id", "FILE_CACHE") )
{
bool bCached = Entry["PARAMETERS"][i].Cmp_Content("TRUE", true);
pItem = g_pData->Add(SG_Create_Grid(&File, SG_DATATYPE_Undefined, bCached));
}
}
}
}
if( !pItem )
{
pItem = bLoad ? g_pData->Open(File, Type) : _Get_byFileName(File);
}
//-----------------------------------------------------
if( !pItem || !pItem->Get_Parameters() || !Entry.Get_Child("PARAMETERS") )
{
if( bLoad )
{
MSG_Error_Add(wxString::Format("%s [%s]", _TL("failed to load data"), File.c_str()));
}
return( false );
}
//-----------------------------------------------------
CSG_MetaData *pEntry = Entry("PARAMETERS");
for(int i=0; i<pEntry->Get_Children_Count(); i++)
{
if( !pEntry->Get_Child(i)->Get_Name().CmpNoCase("DATA") && !pEntry->Get_Child(i)->Get_Content().is_Empty() && pEntry->Get_Child(i)->Get_Content().BeforeFirst(':').CmpNoCase("PGSQL") )
{
wxString File(Get_FilePath_Absolute(ProjectDir, pEntry->Get_Child(i)->Get_Content().w_str()));
pEntry->Get_Child(i)->Set_Content(&File);
// if( SG_Compare_SAGA_Version(Version) < 0 )
{
if( pEntry->Get_Child(i)->Cmp_Property("id", "OVERLAY_1") )
{
pEntry->Get_Child(i)->Set_Property("id", "OVERLAY_G");
}
if( pEntry->Get_Child(i)->Cmp_Property("id", "OVERLAY_2") )
{
pEntry->Get_Child(i)->Set_Property("id", "OVERLAY_B");
}
}
}
}
pItem->Get_Parameters()->Serialize(*Entry.Get_Child("PARAMETERS"), false);
//-----------------------------------------------------
if( SG_Compare_Version(Version, "7.0.0") < 0 ) // inter-version-compatibility
{
CSG_Parameter *pParameter = pItem->Get_Parameter("COLORS_TYPE");
if( pParameter && Type == SG_DATAOBJECT_TYPE_Grid )
{
if( pParameter->asInt() == 4 ) { pParameter->Set_Value(6); } // Shade
if( pParameter->asInt() == 5 ) { pParameter->Set_Value(4); } // RGB Overlay
if( pParameter->asInt() == 6 ) { pParameter->Set_Value(5); } // RGB Composite
}
}
//-----------------------------------------------------
if( Type == SG_DATAOBJECT_TYPE_Grid )
{
pItem->Get_Parameter("FILE_CACHE")->Set_Value(((CWKSP_Grid *)pItem)->Get_Grid()->is_Cached());
}
pItem->Parameters_Changed();
return( true );
}
//---------------------------------------------------------
bool CWKSP_Project::_Load_Map(CSG_MetaData &Entry, const wxString &ProjectDir)
{
TSG_Rect Extent;
if( !Entry.Cmp_Name("MAP")
|| !Entry.Get_Child("XMIN") || !Entry.Get_Child("XMIN")->Get_Content().asDouble(Extent.xMin)
|| !Entry.Get_Child("XMAX") || !Entry.Get_Child("XMAX")->Get_Content().asDouble(Extent.xMax)
|| !Entry.Get_Child("YMIN") || !Entry.Get_Child("YMIN")->Get_Content().asDouble(Extent.yMin)
|| !Entry.Get_Child("YMAX") || !Entry.Get_Child("YMAX")->Get_Content().asDouble(Extent.yMax) )
{
return( false );
}
//-----------------------------------------------------
CSG_MetaData *pNode = Entry.Get_Child("LAYERS");
if( pNode == NULL || pNode->Get_Children_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
int i, n;
for(i=0, n=0; i<pNode->Get_Children_Count(); i++)
{
if( pNode->Get_Child(i)->Cmp_Name("FILE") )
{
wxString FileName(pNode->Get_Child(i)->Get_Content().w_str());
if( FileName.Find("PGSQL") != 0 )
{
FileName = Get_FilePath_Absolute(ProjectDir, FileName);
}
CWKSP_Base_Item *pItem = _Get_byFileName(FileName);
if( pItem &&
( pItem->Get_Type() == WKSP_ITEM_Grid
|| pItem->Get_Type() == WKSP_ITEM_Grids
|| pItem->Get_Type() == WKSP_ITEM_TIN
|| pItem->Get_Type() == WKSP_ITEM_PointCloud
|| pItem->Get_Type() == WKSP_ITEM_Shapes) )
{
n++;
}
}
}
if( n == 0 )
{
return( false );
}
//-----------------------------------------------------
CWKSP_Map *pMap = new CWKSP_Map;
pMap->Get_Parameter("CRS_CHECK")->Set_Value(false);
for(int i=0; i<pNode->Get_Children_Count(); i++)
{
if( pNode->Get_Child(i)->Cmp_Name("FILE") )
{
wxString FileName(pNode->Get_Child(i)->Get_Content().w_str());
if( FileName.Find("PGSQL") != 0 )
{
FileName = Get_FilePath_Absolute(ProjectDir, FileName);
}
CWKSP_Base_Item *pItem = _Get_byFileName(FileName);
if( pItem &&
( pItem->Get_Type() == WKSP_ITEM_Grid
|| pItem->Get_Type() == WKSP_ITEM_Grids
|| pItem->Get_Type() == WKSP_ITEM_TIN
|| pItem->Get_Type() == WKSP_ITEM_PointCloud
|| pItem->Get_Type() == WKSP_ITEM_Shapes) )
{
g_pMaps->Add((CWKSP_Layer *)pItem, pMap);
}
}
else if( pNode->Get_Child(i)->Cmp_Name("PARAMETERS") )
{
if( pNode->Get_Child(i)->Cmp_Property("name", "GRATICULE") )
{
pMap->Add_Graticule(pNode->Get_Child(i));
}
if( pNode->Get_Child(i)->Cmp_Property("name", "BASEMAP") )
{
pMap->Add_BaseMap (pNode->Get_Child(i));
}
}
}
pMap->Get_Parameter("CRS_CHECK")->Set_Value(true);
//-----------------------------------------------------
if( Entry.Get_Child("PARAMETERS") && pMap->Get_Parameters()->Serialize(*Entry.Get_Child("PARAMETERS"), false) )
{
pMap->Parameters_Changed();
}
pMap->Set_Extent(Extent, true);
pMap->View_Show(true);
return( true );
}
//---------------------------------------------------------
bool CWKSP_Project::_Save_Data(CSG_MetaData &Entry, const wxString &ProjectDir, CSG_Data_Object *pDataObject, CSG_Parameters *pParameters)
{
if( !pDataObject || !pDataObject->Get_File_Name(false) || SG_STR_LEN(pDataObject->Get_File_Name(false)) == 0 )
{
return( false );
}
CSG_MetaData *pEntry = Entry.Add_Child("DATASET");
switch( pDataObject->Get_ObjectType() )
{
default: return( false );
case SG_DATAOBJECT_TYPE_Grid : pEntry->Add_Property("type", "GRID" ); break;
case SG_DATAOBJECT_TYPE_Grids : pEntry->Add_Property("type", "GRIDS" ); break;
case SG_DATAOBJECT_TYPE_Table : pEntry->Add_Property("type", "TABLE" ); break;
case SG_DATAOBJECT_TYPE_Shapes : pEntry->Add_Property("type", "SHAPES"); break;
case SG_DATAOBJECT_TYPE_TIN : pEntry->Add_Property("type", "TIN" ); break;
case SG_DATAOBJECT_TYPE_PointCloud: pEntry->Add_Property("type", "POINTS"); break;
}
if( wxFileExists(pDataObject->Get_File_Name(false)) )
{
pEntry->Add_Child("FILE", SG_File_Get_Path_Relative(&ProjectDir, pDataObject->Get_File_Name(false)));
}
else if( pDataObject->Get_MetaData_DB().Get_Children_Count() > 0 )
{
pEntry->Add_Child("FILE", pDataObject->Get_File_Name(false));
}
else
{
return( false );
}
if( pParameters )
{
pParameters->DataObjects_Check(true);
pParameters->Serialize(*pEntry->Add_Child("PARAMETERS"), true);
//-------------------------------------------------
pEntry = pEntry->Get_Child("PARAMETERS");
for(int i=0; i<pEntry->Get_Children_Count(); i++)
{
if( !pEntry->Get_Child(i)->Get_Name().CmpNoCase("DATA") )
{
CSG_String File = pEntry->Get_Child(i)->Get_Content();
if( File.BeforeFirst(':').CmpNoCase("PGSQL") && SG_File_Exists(File) )
{
pEntry->Get_Child(i)->Set_Content(SG_File_Get_Path_Relative(&ProjectDir, File.w_str()));
}
}
}
}
return( 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 CACTIVE_History::_Add_History_OLD(wxTreeItemId Parent, CSG_MetaData &Data)
{
if( !Parent.IsOk() )
{
return( false );
}
//-----------------------------------------------------
CSG_MetaData *pTool = Data("MODULE");
if( !pTool )
{
if( Data.Get_Children_Count() > 0 )
{
for(int i=0; i<Data.Get_Children_Count(); i++)
{
CSG_MetaData *pEntry = Data.Get_Child(i);
if( pEntry->Get_Children_Count() > 0 )
{
_Add_History_OLD(AppendItem(Parent, wxString::Format("%s", pEntry->Get_Name().c_str()), IMG_NODE), *pEntry);
}
else if( !pEntry->Get_Name().Cmp(SG_T("FILE")) )
{
AppendItem(Parent, wxString::Format("%s", pEntry->Get_Content().c_str()), IMG_FILE);
}
else
{
AppendItem(Parent, wxString::Format("[%s] %s", pEntry->Get_Name().c_str(), pEntry->Get_Content().c_str()), IMG_ENTRY);
}
}
}
else
{
AppendItem(Parent, Data.Get_Name().c_str(), IMG_FILE);
}
}
//-----------------------------------------------------
else
{
int i;
wxTreeItemId Tool = AppendItem(Parent, pTool->Get_Content().c_str(), IMG_TOOL);
//-------------------------------------------------
wxTreeItemId Options = AppendItem(Tool, _TL("Options"), IMG_ENTRY);
for(i=0; i<Data.Get_Children_Count(); i++) // Options
{
CSG_MetaData *pEntry = Data.Get_Child(i);
CSG_String Name = pEntry->Get_Property("name");
TSG_Parameter_Type Type = SG_Parameter_Type_Get_Type(pEntry->Get_Property("type"));
if( !pEntry->Get_Name().Cmp("OPTION") )
{
switch( Type )
{
case PARAMETER_TYPE_Bool:
case PARAMETER_TYPE_Int:
case PARAMETER_TYPE_Double:
case PARAMETER_TYPE_Degree:
case PARAMETER_TYPE_Date:
case PARAMETER_TYPE_Choice:
case PARAMETER_TYPE_Range:
case PARAMETER_TYPE_Table_Field:
case PARAMETER_TYPE_Table_Fields:
case PARAMETER_TYPE_String:
case PARAMETER_TYPE_Text:
case PARAMETER_TYPE_FilePath:
AppendItem(Options, wxString::Format("%s [%s]", Name.c_str(), pEntry->Get_Content().c_str()), IMG_ENTRY);
break;
case PARAMETER_TYPE_Grid_System:
if( pEntry->Get_Children_Count() == 0 )
{
AppendItem(Options, wxString::Format("%s [%s]", Name.c_str(), pEntry->Get_Content().c_str()), IMG_ENTRY);
}
break;
case PARAMETER_TYPE_FixedTable:
case PARAMETER_TYPE_Parameters:
break;
default:
break;
}
}
}
if( ItemHasChildren(Options) )
{
Expand(Options);
}
else
{
// Delete(Options);
SetItemText(Options, _TL("No Options"));
}
//-------------------------------------------------
for(i=0; i<Data.Get_Children_Count(); i++) // Input Data
{
CSG_MetaData *pEntry = Data.Get_Child(i);
CSG_String Name = pEntry->Get_Property("name");
TSG_Parameter_Type Type = SG_Parameter_Type_Get_Type(pEntry->Get_Property("type"));
if( !pEntry->Get_Name().Cmp("DATA") )
{
_Add_History_OLD(AppendItem(Tool, wxString::Format("%s", Name.c_str()), _Get_Image(Type)), *pEntry);
}
else if( !pEntry->Get_Name().Cmp("DATA_LIST") )
{
if( pEntry->Get_Children_Count() > 0 )
{
wxTreeItemId List = AppendItem(Tool, wxString::Format("%s %s", Name.c_str(), _TL("List")), _Get_Image(Type));
for(int j=0; j<pEntry->Get_Children_Count(); j++)
{
_Add_History_OLD(List, *pEntry->Get_Child(j));
}
Expand(List);
}
}
}
Expand(Tool);
}
Expand(Parent);
return( true );
}
//---------------------------------------------------------
bool CGPX_Export::On_Execute(void)
{
int iEle, iName, iCmt, iDesc;
CSG_String File;
CSG_MetaData GPX;
CSG_Shapes *pShapes;
//-----------------------------------------------------
File = Parameters("FILE") ->asString();
pShapes = Parameters("SHAPES") ->asShapes();
iEle = Parameters("ELE") ->asInt(); if( iEle >= pShapes->Get_Field_Count() ) iEle = -1;
iName = Parameters("NAME") ->asInt(); if( iName >= pShapes->Get_Field_Count() ) iName = -1;
iCmt = Parameters("CMT") ->asInt(); if( iCmt >= pShapes->Get_Field_Count() ) iCmt = -1;
iDesc = Parameters("DESC") ->asInt(); if( iDesc >= pShapes->Get_Field_Count() ) iDesc = -1;
//-----------------------------------------------------
GPX.Set_Name(SG_T("gpx"));
GPX.Add_Property(SG_T("version") , SG_T("1.0"));
GPX.Add_Property(SG_T("creator") , SG_T("SAGA - System for Automated Geoscientific Analyses - http://www.saga-gis.org"));
GPX.Add_Property(SG_T("xmlns:xsi") , SG_T("http://www.w3.org/2001/XMLSchema-instance"));
GPX.Add_Property(SG_T("xmlns") , SG_T("http://www.topografix.com/GPX/1/0"));
GPX.Add_Property(SG_T("xsi:schemaLocation") , SG_T("http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd"));
for(int iShape=0; iShape<pShapes->Get_Count(); iShape++)
{
CSG_Shape *pShape = pShapes->Get_Shape(iShape);
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
CSG_MetaData *pPoint = GPX.Add_Child(SG_T("wpt"));
pPoint->Add_Property(SG_T("lon"), pShape->Get_Point(iPoint, iPart).x);
pPoint->Add_Property(SG_T("lat"), pShape->Get_Point(iPoint, iPart).y);
if( iEle > 0 ) pPoint->Add_Child(SG_T("ele" ), pShape->asString(iEle));
if( iName > 0 ) pPoint->Add_Child(SG_T("name"), pShape->asString(iName));
if( iCmt > 0 ) pPoint->Add_Child(SG_T("cmt" ), pShape->asString(iCmt));
if( iDesc > 0 ) pPoint->Add_Child(SG_T("desc"), pShape->asString(iDesc));
}
}
}
//-----------------------------------------------------
if( !GPX.Save(File) )
{
return( false );
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CPointCloud_Create_SPCVF::On_Execute(void)
{
CSG_Strings sFiles;
CSG_String sFileInputList, sFileName;
int iMethodPaths;
CSG_MetaData SPCVF;
CSG_Projection projSPCVF;
double dNoData;
std::vector<TSG_Data_Type> vFieldTypes;
std::vector<CSG_String> vFieldNames;
double dBBoxXMin = std::numeric_limits<int>::max();
double dBBoxYMin = std::numeric_limits<int>::max();
double dBBoxXMax = std::numeric_limits<int>::min();
double dBBoxYMax = std::numeric_limits<int>::min();
int iSkipped = 0, iEmpty = 0;
int iDatasetCount = 0;
double dPointCount = 0.0;
double dZMin = std::numeric_limits<double>::max();
double dZMax = -std::numeric_limits<double>::max();
//-----------------------------------------------------
sFileName = Parameters("FILENAME")->asString();
iMethodPaths = Parameters("METHOD_PATHS")->asInt();
sFileInputList = Parameters("INPUT_FILE_LIST")->asString();
//-----------------------------------------------------
if( !Parameters("FILES")->asFilePath()->Get_FilePaths(sFiles) && sFileInputList.Length() <= 0 )
{
SG_UI_Msg_Add_Error(_TL("Please provide some input files!"));
return( false );
}
//-----------------------------------------------------
if( sFiles.Get_Count() <= 0 )
{
CSG_Table *pTable = new CSG_Table();
if( !pTable->Create(sFileInputList, TABLE_FILETYPE_Text_NoHeadLine) )
{
SG_UI_Msg_Add_Error(_TL("Input file list could not be opened!"));
delete( pTable );
return( false );
}
sFiles.Clear();
for (int i=0; i<pTable->Get_Record_Count(); i++)
{
sFiles.Add(pTable->Get_Record(i)->asString(0));
}
delete( pTable );
}
//-----------------------------------------------------
SPCVF.Set_Name(SG_T("SPCVFDataset"));
SPCVF.Add_Property(SG_T("Version"), SG_T("1.1"));
switch( iMethodPaths )
{
default:
case 0: SPCVF.Add_Property(SG_T("Paths"), SG_T("absolute")); break;
case 1: SPCVF.Add_Property(SG_T("Paths"), SG_T("relative")); break;
}
//-----------------------------------------------------
CSG_MetaData *pSPCVFHeader = SPCVF.Add_Child( SG_T("Header"));
CSG_MetaData *pSPCVFFiles = pSPCVFHeader->Add_Child( SG_T("Datasets"));
CSG_MetaData *pSPCVFPoints = pSPCVFHeader->Add_Child( SG_T("Points"));
CSG_MetaData *pSRS = pSPCVFHeader->Add_Child( SG_T("SRS"));
CSG_MetaData *pSPCVFBBox = pSPCVFHeader->Add_Child( SG_T("BBox"));
CSG_MetaData *pSPCVFZStats = pSPCVFHeader->Add_Child( SG_T("ZStats"));
CSG_MetaData *pSPCVFNoData = pSPCVFHeader->Add_Child( SG_T("NoData"));
CSG_MetaData *pSPCVFAttr = pSPCVFHeader->Add_Child( SG_T("Attributes"));
CSG_MetaData *pSPCVFDatasets = NULL;
//-----------------------------------------------------
for(int i=0; i<sFiles.Get_Count() && Set_Progress(i, sFiles.Get_Count()); i++)
{
CSG_PointCloud *pPC = SG_Create_PointCloud(sFiles[i]);
//-----------------------------------------------------
if( i==0 ) // first dataset determines projection, NoData value and table structure
{
projSPCVF = pPC->Get_Projection();
dNoData = pPC->Get_NoData_Value();
pSPCVFNoData->Add_Property(SG_T("Value"), dNoData);
pSPCVFAttr->Add_Property(SG_T("Count"), pPC->Get_Field_Count());
for(int iField=0; iField<pPC->Get_Field_Count(); iField++)
{
vFieldTypes.push_back(pPC->Get_Field_Type(iField));
vFieldNames.push_back(pPC->Get_Field_Name(iField));
CSG_MetaData *pSPCVFField = pSPCVFAttr->Add_Child(CSG_String::Format(SG_T("Field_%d"), iField + 1));
pSPCVFField->Add_Property(SG_T("Name"), pPC->Get_Field_Name(iField));
pSPCVFField->Add_Property(SG_T("Type"), gSG_Data_Type_Identifier[pPC->Get_Field_Type(iField)]);
}
if( projSPCVF.is_Okay() )
{
pSRS->Add_Property(SG_T("Projection"), projSPCVF.Get_Name());
pSRS->Add_Property(SG_T("WKT"), projSPCVF.Get_WKT());
}
else
{
pSRS->Add_Property(SG_T("Projection"), SG_T("Undefined Coordinate System"));
}
pSPCVFDatasets = SPCVF.Add_Child(SG_T("Datasets"));
}
else // validate projection, NoData value and table structure
{
bool bSkip = false;
if( pPC->Get_Field_Count() != (int)vFieldTypes.size() )
{
bSkip = true;
}
if( !bSkip && projSPCVF.is_Okay() )
{
if ( !pPC->Get_Projection().is_Okay() || SG_STR_CMP(pPC->Get_Projection().Get_WKT(), projSPCVF.Get_WKT()) )
{
bSkip = true;
}
}
if( !bSkip )
{
for(int iField=0; iField<pPC->Get_Field_Count(); iField++)
{
if( pPC->Get_Field_Type(iField) != vFieldTypes.at(iField) )
{
bSkip = true;
break;
}
if( SG_STR_CMP(pPC->Get_Field_Name(iField), vFieldNames.at(iField)) )
{
bSkip = true;
break;
}
}
}
if( bSkip )
{
SG_UI_Msg_Add(CSG_String::Format(_TL("Skipping dataset %s because of incompatibility with the first input dataset!"), sFiles[i].c_str()), true);
delete( pPC );
iSkipped++;
continue;
}
}
//-----------------------------------------------------
if( pPC->Get_Point_Count() <= 0 )
{
delete( pPC );
iEmpty++;
continue;
}
//-----------------------------------------------------
CSG_MetaData *pDataset = pSPCVFDatasets->Add_Child(SG_T("PointCloud"));
CSG_String sFilePath;
switch( iMethodPaths )
{
default:
case 0: sFilePath = SG_File_Get_Path_Absolute(sFiles.Get_String(i)); break;
case 1: sFilePath = SG_File_Get_Path_Relative(SG_File_Get_Path(sFileName), sFiles.Get_String(i)); break;
}
sFilePath.Replace(SG_T("\\"), SG_T("/"));
pDataset->Add_Property(SG_T("File"), sFilePath);
pDataset->Add_Property(SG_T("Points"), pPC->Get_Point_Count());
pDataset->Add_Property(SG_T("ZMin"), pPC->Get_ZMin());
pDataset->Add_Property(SG_T("ZMax"), pPC->Get_ZMax());
//-----------------------------------------------------
CSG_MetaData *pBBox = pDataset->Add_Child(SG_T("BBox"));
pBBox->Add_Property(SG_T("XMin"), pPC->Get_Extent().Get_XMin());
pBBox->Add_Property(SG_T("YMin"), pPC->Get_Extent().Get_YMin());
pBBox->Add_Property(SG_T("XMax"), pPC->Get_Extent().Get_XMax());
pBBox->Add_Property(SG_T("YMax"), pPC->Get_Extent().Get_YMax());
if( dBBoxXMin > pPC->Get_Extent().Get_XMin() )
dBBoxXMin = pPC->Get_Extent().Get_XMin();
if( dBBoxYMin > pPC->Get_Extent().Get_YMin() )
dBBoxYMin = pPC->Get_Extent().Get_YMin();
if( dBBoxXMax < pPC->Get_Extent().Get_XMax() )
dBBoxXMax = pPC->Get_Extent().Get_XMax();
if( dBBoxYMax < pPC->Get_Extent().Get_YMax() )
dBBoxYMax = pPC->Get_Extent().Get_YMax();
iDatasetCount += 1;
dPointCount += pPC->Get_Point_Count();
if( dZMin > pPC->Get_ZMin() )
dZMin = pPC->Get_ZMin();
if( dZMax < pPC->Get_ZMax() )
dZMax = pPC->Get_ZMax();
delete( pPC );
}
//-----------------------------------------------------
pSPCVFBBox->Add_Property(SG_T("XMin"), dBBoxXMin);
pSPCVFBBox->Add_Property(SG_T("YMin"), dBBoxYMin);
pSPCVFBBox->Add_Property(SG_T("XMax"), dBBoxXMax);
pSPCVFBBox->Add_Property(SG_T("YMax"), dBBoxYMax);
pSPCVFFiles->Add_Property(SG_T("Count"), iDatasetCount);
pSPCVFPoints->Add_Property(SG_T("Count"), CSG_String::Format(SG_T("%.0f"), dPointCount));
pSPCVFZStats->Add_Property(SG_T("ZMin"), dZMin);
pSPCVFZStats->Add_Property(SG_T("ZMax"), dZMax);
//-----------------------------------------------------
if( !SPCVF.Save(sFileName) )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to save %s file!"), sFileName.c_str()));
return( false );
}
//-----------------------------------------------------
if( iSkipped > 0 )
{
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: %d dataset(s) skipped because of incompatibilities!"), iSkipped), true);
}
if( iEmpty > 0 )
{
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: %d dataset(s) skipped because they are empty!"), iEmpty), true);
}
SG_UI_Msg_Add(CSG_String::Format(_TL("SPCVF successfully created from %d dataset(s)."), iDatasetCount), true);
//-----------------------------------------------------
return( true );
}
