//---------------------------------------------------------
bool CTable_Save::On_Execute(void)
{
bool bResult = false;
CSG_Table *pTable = Parameters("TABLE")->asTable();
CSG_String Name = Parameters("NAME" )->asString(); if( Name.Length() == 0 ) Name = pTable->Get_Name();
//-----------------------------------------------------
if( Get_Connection()->Table_Exists(Name) )
{
Message_Add(CSG_String::Format(SG_T("%s: %s"), _TL("table already exists"), Name.c_str()));
switch( Parameters("EXISTS")->asInt() )
{
case 0: // abort export
break;
case 1: // replace existing table
Message_Add(CSG_String::Format(SG_T("%s: %s"), _TL("dropping table"), Name.c_str()));
if( !Get_Connection()->Table_Drop(Name, false) )
{
Message_Add(CSG_String::Format(SG_T(" ...%s!"), _TL("failed")));
}
else
{
bResult = Get_Connection()->Table_Save(Name, *pTable, Get_Constraints(Parameters("FLAGS")->asParameters(), pTable));
}
break;
case 2: // append records, if table structure allows
Message_Add(CSG_String::Format(SG_T("%s: %s"), _TL("appending to existing table"), Name.c_str()));
if( !(bResult = Get_Connection()->Table_Insert(Name, *pTable)) )
{
Message_Add(CSG_String::Format(SG_T(" ...%s!"), _TL("failed")));
}
break;
}
}
else
{
bResult = Get_Connection()->Table_Save(Name, *pTable, Get_Constraints(Parameters("FLAGS")->asParameters(), pTable));
}
//-----------------------------------------------------
if( bResult )
{
SG_UI_ODBC_Update(Get_Connection()->Get_Server());
}
return( bResult );
}
//---------------------------------------------------------
bool CSG_MetaData::Load_HTTP(const CSG_String &Server, const CSG_String &Path, const SG_Char *Username, const SG_Char *Password)
{
Destroy();
//-----------------------------------------------------
wxHTTP HTTP;
if( Username && *Username ) { HTTP.SetUser (Username); }
if( Password && *Password ) { HTTP.SetPassword(Password); }
wxString s = Server.c_str();
if( s.Find("http://") == 0 )
{
s = s.Right(s.Length() - wxString("http://").Length());
}
if( !HTTP.Connect(s) )
{
return( false );
}
//-----------------------------------------------------
s = Path.c_str();
if( s[0] != '/' )
{
s.Prepend("/");
}
wxInputStream *pStream = HTTP.GetInputStream(s);
if( !pStream )
{
return( false );
}
wxXmlDocument XML;
if( XML.Load(*pStream) )
{
_Load(XML.GetRoot());
delete(pStream);
return( true );
}
delete(pStream);
return( false );
}
//---------------------------------------------------------
void CMD_Print (const CSG_String &Text, const SG_Char *XML_Tag)
{
if( g_bXML )
{
if( XML_Tag && XML_Tag[0] )
{
SG_PRINTF(SG_T("<%s>%s</%s>\n"), XML_Tag, Text.c_str(), XML_Tag);
}
}
else
{
SG_PRINTF(SG_T("%s\n"), Text.c_str());
}
}
//---------------------------------------------------------
CSG_String CLine_Dissolve::Statistics_Get_Name(const CSG_String &Type, const CSG_String &Name)
{
CSG_String s;
switch( Parameters("STAT_NAMING")->asInt() )
{
default: s.Printf("%s_%s", Type.c_str(), Name.c_str()); break;
case 1: s.Printf("%s_%s", Name.c_str(), Type.c_str()); break;
case 2: s.Printf("%s" , Name.c_str() ); break;
case 3: s.Printf("%s" , Type.c_str() ); break;
}
return( s );
}
//---------------------------------------------------------
CSG_String CPolygonStatisticsFromPoints::Get_Field_Name(const CSG_String &Type, const CSG_String &Name)
{
CSG_String s;
switch( Parameters("FIELD_NAME")->asInt() )
{
default:
case 0: s.Printf(SG_T("%s_%s"), Type.c_str(), Name.c_str()); break;
case 1: s.Printf(SG_T("%s_%s"), Name.c_str(), Type.c_str()); break;
case 2: s.Printf(SG_T("%s" ), Name.c_str() ); break;
case 3: s.Printf(SG_T("%s" ), Type.c_str() ); break;
}
return( s );
}
//---------------------------------------------------------
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;
}
bool CCreateChartLayer::GetExtraParameters(){
int i;
CSG_Shapes *pInput;
CSG_Parameter *pParam;
CSG_String sName;
bool bIsValidSelection = false;
pInput = Parameters("INPUT")->asShapes();
m_pExtraParameters->Create(this, _TL("Fields for diagram"), _TL(""), SG_T("EXTRA"));
m_bIncludeParam = new bool [pInput->Get_Field_Count() ];
for (i = 0; i < pInput->Get_Field_Count(); i++)
{
switch( pInput->Get_Field_Type(i) )
{
default:
break;
case SG_DATATYPE_Byte:
case SG_DATATYPE_Char:
case SG_DATATYPE_Word:
case SG_DATATYPE_Short:
case SG_DATATYPE_DWord:
case SG_DATATYPE_Int:
case SG_DATATYPE_ULong:
case SG_DATATYPE_Long:
case SG_DATATYPE_Float:
case SG_DATATYPE_Double: // is numeric field
m_pExtraParameters->Add_Value(
NULL, SG_Get_String(i,0).c_str(), pInput->Get_Field_Name(i), _TL(""), PARAMETER_TYPE_Bool, false
);
break;
}
}//for
if(Dlg_Parameters("EXTRA")){
for (i = 0; i < pInput->Get_Field_Count(); i++){
sName = SG_Get_String(i,0);
if (pParam = Get_Parameters("EXTRA")->Get_Parameter(sName.c_str())){
m_bIncludeParam[i] = pParam->asBool();
bIsValidSelection = true;
}//try
else{
m_bIncludeParam[i] = false;
}//else
}//for
m_pExtraParameters->Destroy();
return bIsValidSelection;
}//if
m_pExtraParameters->Destroy();
return false;
}//method
//---------------------------------------------------------
void CSG_String_Tokenizer::Set_String(const CSG_String &String, const CSG_String &Delimiters, TSG_String_Tokenizer_Mode Mode)
{
wxStringTokenizerMode _Mode;
switch( Mode )
{
default: _Mode = wxTOKEN_DEFAULT ; break;
case SG_TOKEN_INVALID: _Mode = wxTOKEN_INVALID ; break;
case SG_TOKEN_RET_EMPTY: _Mode = wxTOKEN_RET_EMPTY ; break;
case SG_TOKEN_RET_EMPTY_ALL: _Mode = wxTOKEN_RET_EMPTY_ALL; break;
case SG_TOKEN_RET_DELIMS: _Mode = wxTOKEN_RET_DELIMS ; break;
case SG_TOKEN_STRTOK: _Mode = wxTOKEN_STRTOK ; break;
}
m_pTokenizer->SetString(String.c_str(), Delimiters.c_str(), _Mode);
}
//---------------------------------------------------------
bool CImport_Clip_Resample::Load_File(const CSG_String &File)
{
CSG_Data_Manager Grids;
if( !Grids.Add(File) || !Grids.Get_Grid_System(0) || !Grids.Get_Grid_System(0)->Get(0) )
{
Error_Set(CSG_String::Format("%s: %s", _TL("could not load file"), File.c_str()));
return( false );
}
int n = 0;
for(size_t iSystem=0; iSystem<Grids.Grid_System_Count(); iSystem++)
{
for(size_t iGrid=0; iGrid<Grids.Get_Grid_System(iSystem)->Count(); iGrid++)
{
if( Load_Grid((CSG_Grid *)Grids.Get_Grid_System(iSystem)->Get(iGrid)) )
{
n++;
}
}
}
return( n > 0 );
}
//---------------------------------------------------------
CSG_Table CSG_ODBC_Connection::Get_Field_Desc(const CSG_String &Table_Name) const
{
CSG_Table Fields;
Fields.Set_Name(CSG_String::Format(SG_T("%s [%s]"), Table_Name.c_str(), _TL("Field Description")));
if( is_Connected() )
{
try
{
int i, n;
std_string s;
otl_column_desc *desc;
otl_stream Stream;
Stream.set_all_column_types(otl_all_num2str|otl_all_date2str);
Stream.open(m_Size_Buffer, CSG_String::Format(SG_T("$SQLColumns $3:'%s'"), Table_Name.c_str()), m_Connection); // get a list of all columns.
desc = Stream.describe_select(n);
for(i=0; i<n; i++)
{
Fields.Add_Field(CSG_String(desc[i].name), SG_DATATYPE_String);
}
while( !Stream.eof() )
{
CSG_Table_Record *pField = Fields.Add_Record();
for(i=0; i<n; i++)
{
Stream >> s;
pField->Set_Value(i, CSG_String(s.c_str()));
}
}
}
catch( otl_exception &e )
{
_Error_Message(e);
}
}
return( Fields );
}
//---------------------------------------------------------
void 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);
}
//---------------------------------------------------------
bool CSG_Module_Library::Create(const CSG_String &File_Name)
{
Destroy();
TSG_PFNC_MLB_Initialize MLB_Initialize;
TSG_PFNC_MLB_Get_Interface MLB_Get_Interface;
wxString sPath;
wxFileName fName(File_Name.c_str());
fName.MakeAbsolute();
m_File_Name = fName.GetFullPath();
//-----------------------------------------------------
if( wxGetEnv(ENV_LIB_PATH, &sPath) && sPath.Length() > 0 )
{
wxSetEnv(ENV_LIB_PATH, CSG_String::Format(SG_T("%s%c%s"), sPath.c_str(), ENV_LIB_SEPA, SG_File_Get_Path(m_File_Name).c_str()));
}
else
{
wxSetEnv(ENV_LIB_PATH, SG_File_Get_Path(m_File_Name).c_str());
}
//-----------------------------------------------------
if( m_pLibrary->Load(m_File_Name.c_str())
&& (MLB_Get_Interface = (TSG_PFNC_MLB_Get_Interface) m_pLibrary->GetSymbol(SYMBOL_MLB_Get_Interface)) != NULL
&& (MLB_Initialize = (TSG_PFNC_MLB_Initialize) m_pLibrary->GetSymbol(SYMBOL_MLB_Initialize) ) != NULL
&& MLB_Initialize(m_File_Name) )
{
m_pInterface = MLB_Get_Interface();
}
//-----------------------------------------------------
if( sPath.Length() > 0 )
{
wxSetEnv(ENV_LIB_PATH, sPath);
}
else
{
wxUnsetEnv(ENV_LIB_PATH);
}
//-----------------------------------------------------
if( Get_Count() > 0 )
{
for(int i=0; i<Get_Count(); i++)
Get_Module(i)->Set_Managed(false);
return( true );
}
Destroy();
return( false );
}
//---------------------------------------------------------
bool CSG_ODBC_Connection::Table_Drop(const CSG_String &Table_Name, bool bCommit)
{
if( !Table_Exists(Table_Name) )
{
_Error_Message(_TL("database table does not exist"));
return( false );
}
return( Execute(CSG_String::Format(SG_T("DROP TABLE \"%s\""), Table_Name.c_str()), bCommit) );
}
//---------------------------------------------------------
bool CSG_PointCloud::_Save(const CSG_String &File_Name)
{
CSG_File Stream;
SG_UI_Msg_Add(CSG_String::Format(SG_T("%s: %s..."), _TL("Save point cloud"), File_Name.c_str()), true);
CSG_String sFile_Name = SG_File_Make_Path(NULL, File_Name, SG_T("spc"));
if( Stream.Open(sFile_Name, SG_FILE_W, true) == false )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("unable to create file."));
return( false );
}
int i, iBuffer, nPointBytes = m_nPointBytes - 1;
Stream.Write((void *)PC_FILE_VERSION, 6);
Stream.Write(&nPointBytes , sizeof(int));
Stream.Write(&m_nFields , sizeof(int));
for(i=0; i<m_nFields; i++)
{
Stream.Write(&m_Field_Type[i], sizeof(TSG_Data_Type));
iBuffer = (int)m_Field_Name[i]->Length();
if( iBuffer >= 1024 - 1 ) iBuffer = 1024 - 1;
Stream.Write(&iBuffer, sizeof(int));
Stream.Write((void *)m_Field_Name[i]->b_str(), sizeof(char), iBuffer);
}
_Set_Shape(m_Shapes_Index);
for(i=0; i<Get_Count() && SG_UI_Process_Set_Progress(i, Get_Count()); i++)
{
Stream.Write(m_Points[i] + 1, nPointBytes);
}
Set_Modified(false);
Set_File_Name(sFile_Name, true);
Save_MetaData(File_Name);
Get_Projection().Save(SG_File_Make_Path(NULL, File_Name, SG_T("prj")), SG_PROJ_FMT_WKT);
SG_UI_Msg_Add(_TL("okay"), false, SG_UI_MSG_STYLE_SUCCESS);
SG_UI_Process_Set_Ready();
return( true );
}
//---------------------------------------------------------
inline bool CSG_Shapes_OGIS_Converter::_WKT_Read_Point(const CSG_String &Text, CSG_Shape *pShape, int iPart)
{
double x, y, z, m;
switch( ((CSG_Shapes *)pShape->Get_Table())->Get_Vertex_Type() )
{
case SG_VERTEX_TYPE_XY:
if( SG_SSCANF(Text.c_str(), SG_T("%lf %lf"), &x, &y) == 2 )
{
pShape->Add_Point(x, y, iPart);
return( true );
}
break;
case SG_VERTEX_TYPE_XYZ:
if( SG_SSCANF(Text.c_str(), SG_T("%lf %lf %lf"), &x, &y, &z) == 3 )
{
pShape->Add_Point(x, y, iPart);
pShape->Set_Z (z, pShape->Get_Point_Count(iPart) - 1, iPart);
return( true );
}
break;
case SG_VERTEX_TYPE_XYZM:
if( SG_SSCANF(Text.c_str(), SG_T("%lf %lf %lf %lf"), &x, &y, &z, &m) == 4 )
{
pShape->Add_Point(x, y, iPart);
pShape->Set_Z (z, pShape->Get_Point_Count(iPart) - 1, iPart);
pShape->Set_M (m, pShape->Get_Point_Count(iPart) - 1, iPart);
return( true );
}
break;
}
return( false );
}
bool Cdodproperror::DeleteFile(CSG_String path)
{
// Delete file if exists
if (SG_File_Exists(path))
{
if (!SG_File_Delete(path))
{
Error_Set(CSG_String::Format(SG_T("%s: '%s' "), _TL("Failed to delete file: "), path.c_str()));
return false;
}
}
return true;
}
//---------------------------------------------------------
bool CMD_Get_YesNo (const CSG_String &Caption, const CSG_String &Message)
{
if( g_bInteractive )
{
#ifdef _SAGA_MSW
CSG_String sKey, sYes(SG_T("y")), sNo(SG_T("n"));
SG_PRINTF(SG_T("%s: %s\n"), Caption.c_str(), Message.c_str());
SG_PRINTF(SG_T("%s? (%s/%s)\n"), _TL("continue"), sYes.c_str(), sNo.c_str());
do
{
sKey.Printf(SG_T("%c"), _getch());
}
while( sYes.CmpNoCase(sKey) && sNo.CmpNoCase(sKey) );
return( sYes.CmpNoCase(sKey) == 0 );
#endif
}
return( true );
}
//---------------------------------------------------------
bool CWMS_Import::On_Execute(void)
{
CSG_String sServer = Parameters("SERVER")->asString();
//-----------------------------------------------------
CWMS_Capabilities Capabilities;
if( Capabilities.Create(sServer, "1.1.1") == false )
{
Message_Add(_TL("Unable to get capabilities."));
return( false );
}
//-----------------------------------------------------
if( sServer.Find("http://") == 0 )
{
sServer = Parameters("SERVER")->asString() + 7;
}
CSG_String sPath = "/" + sServer.AfterFirst('/');
sServer = sServer.BeforeFirst('/');
wxHTTP Server;
Server.SetUser (Parameters("USERNAME")->asString());
Server.SetPassword(Parameters("PASSWORD")->asString());
if( Server.Connect(sServer.c_str()) == false )
{
Message_Add(_TL("Unable to connect to server."));
return( false );
}
//-----------------------------------------------------
if( Get_Map(&Server, sPath, Capabilities) == false )
{
Message_Add(_TL("Unable to get map."));
return( false );
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CSG_Grid::_Load(const CSG_String &File_Name, TSG_Data_Type Type, TSG_Grid_Memory_Type Memory_Type)
{
bool bResult;
//-----------------------------------------------------
Destroy();
m_Type = Type;
//-----------------------------------------------------
SG_UI_Msg_Add(CSG_String::Format(SG_T("%s: %s..."), LNG("[MSG] Load grid"), File_Name.c_str()), true);
if( SG_File_Cmp_Extension(File_Name, SG_T("grd")) )
{
bResult = _Load_Surfer(File_Name, Memory_Type);
}
else
{
bResult = _Load_Native(File_Name, Memory_Type);
}
//-----------------------------------------------------
if( bResult )
{
Set_Update_Flag();
Set_File_Name(File_Name);
Load_MetaData(File_Name);
m_bCreated = true;
SG_UI_Msg_Add(LNG("[MSG] okay"), false, SG_UI_MSG_STYLE_SUCCESS);
}
else
{
Destroy();
SG_UI_Msg_Add(LNG("[MSG] failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(LNG("[ERR] Grid file could not be opened."));
}
//-----------------------------------------------------
return( bResult );
}
//---------------------------------------------------------
bool CSG_Shapes::Save(const CSG_String &File_Name, int Format)
{
SG_UI_Msg_Add(CSG_String::Format(SG_T("%s: %s..."), _TL("Save shapes"), File_Name.c_str()), true);
if( _Save_ESRI(File_Name) )
{
Set_Modified(false);
Set_File_Name(File_Name, true);
SG_UI_Process_Set_Ready();
SG_UI_Msg_Add(_TL("okay"), false, SG_UI_MSG_STYLE_SUCCESS);
return( true );
}
SG_UI_Process_Set_Ready();
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
return( false );
}
void Cihacres_elev::_CreateTableSim()
{
int i = 0; // used in function Get_Record(i)
CSG_Table_Record *pRecord;
CSG_String tmpName;
double sim_eb, sim;
// creating the column titles
m_pTable->Add_Field("Date", SG_DATATYPE_String);
m_pTable->Add_Field("Flow_OBS", SG_DATATYPE_Double);
for (int eb = 0; eb < m_nElevBands; eb++)
{
tmpName = SG_T("ELEVB_");
tmpName += convert_sl::Int2String(eb+1).c_str();
m_pTable->Add_Field(tmpName.c_str(), SG_DATATYPE_Double);
}
m_pTable->Add_Field(SG_T("Flow_SIM"), SG_DATATYPE_Double);
for (int j = 0; j < m_nValues; j++)
{
m_pTable->Add_Record();
pRecord = m_pTable->Get_Record(i);
// writing the data into the rows
pRecord->Set_Value(0,CSG_String(m_vec_date[j].c_str()));
pRecord->Set_Value(1,m_p_Q_obs_m3s[j]);
sim_eb = 0.0;
sim = 0.0;
for (int eb = 0; eb < m_nElevBands; eb++)
{
sim_eb = model_tools::mmday_to_m3s(m_p_elevbands[eb].m_p_streamflow_sim[j],m_p_elevbands[eb].m_area);
//pRecord->Set_Value(3+eb,model_tools::mmday_to_m3s(m_p_elevbands[eb].m_p_streamflow_sim[j],m_p_elevbands[eb].m_area));
pRecord->Set_Value(2+eb, sim_eb);
sim += sim_eb;
}
pRecord->Set_Value(2+m_nElevBands,sim);
i++;
}
}
//---------------------------------------------------------
bool CSG_HTTP::Create(const CSG_String &Server, const SG_Char *Username, const SG_Char *Password)
{
Destroy();
m_pHTTP = new wxHTTP;
if( Username && *Username ) { m_pHTTP->SetUser (Username); }
if( Password && *Password ) { m_pHTTP->SetPassword(Password); }
wxString Host = Server.c_str();
unsigned short Port = 80;
#define SERVER_TRIM(s, p) { wxString sp(p); sp += "://"; if( s.Find(p) == 0 ) { s = s.Right(s.Length() - sp.Length()); } }
SERVER_TRIM(Host, "https");
SERVER_TRIM(Host, "http");
if( Host.Find(":") >= 0 )
{
long _Port;
if( Host.AfterLast(':').ToLong(&_Port) )
{
Port = (unsigned short)_Port;
}
Host = Host.BeforeLast(':');
}
if( !m_pHTTP->Connect(Host, Port) )
{
Destroy();
return( false );
}
return( true );
}
//---------------------------------------------------------
CData_Source_PgSQL::~CData_Source_PgSQL(void)
{
long Reopen = 0;
CONFIG_Read("/DATA", "PROJECT_DB_REOPEN", Reopen);
CONFIG_Delete(CFG_PGSQL_DIR);
wxTreeItemIdValue srvCookie; wxTreeItemId srvItem = GetFirstChild(GetRootItem(), srvCookie);
for(int i=0; srvItem.IsOk(); )
{
wxTreeItemIdValue Cookie; wxTreeItemId Item = GetFirstChild(srvItem, Cookie);
while( Item.IsOk() )
{
CData_Source_PgSQL_Data *pData = (CData_Source_PgSQL_Data *)GetItemData(Item);
if( pData && pData->Get_Type() == TYPE_SOURCE )
{
CSG_String Connection = pData->Get_Server().c_str();
if( Reopen != 0 && pData->is_Connected() && !pData->Get_Username().is_Empty() ) // store user and password
{
Connection += "|" + pData->Get_Username() + "|" + pData->Get_Password();
}
CONFIG_Write(CFG_PGSQL_DIR, wxString::Format(CFG_PGSQL_SRC, i++), Connection.c_str());
}
Item = GetNextChild(Item, Cookie);
}
srvItem = GetNextChild(srvItem, srvCookie);
}
}
//---------------------------------------------------------
bool CCMD_Module::_Get_Parameters(CSG_Parameters *pParameters)
{
if( !pParameters || m_CMD.Parse(false) != 0 )
{
return( false );
}
//-----------------------------------------------------
int i;
for(i=0; i<pParameters->Get_Count(); i++)
{
CSG_Parameter *pParameter = pParameters->Get_Parameter(i);
if( pParameter->is_Input() )
{
// nop now, loading options first
}
else if( pParameter->is_Output() )
{
if( pParameter->is_DataObject() && pParameter->is_Optional() && !pParameter->asDataObject() && m_CMD.Found(_Get_ID(pParameter)) )
{
pParameter->Set_Value(DATAOBJECT_CREATE);
}
}
else if( pParameter->is_Option() && !pParameter->is_Information() )
{
long l;
double d;
wxString s;
switch( pParameter->Get_Type() )
{
default:
break;
case PARAMETER_TYPE_Parameters:
_Get_Parameters(pParameter->asParameters());
break;
case PARAMETER_TYPE_Bool:
pParameter->Set_Value(m_CMD.Found(_Get_ID(pParameter)) ? 1 : 0);
break;
case PARAMETER_TYPE_Int:
if( m_CMD.Found(_Get_ID(pParameter), &l) )
{
pParameter->Set_Value((int)l);
}
break;
case PARAMETER_TYPE_Choice:
if( m_CMD.Found(_Get_ID(pParameter), &s) )
{
if( s.ToLong(&l) )
{
pParameter->Set_Value((int)l);
}
else
{
pParameter->Set_Value(CSG_String(&s));
}
}
break;
case PARAMETER_TYPE_Double:
case PARAMETER_TYPE_Degree:
if( m_CMD.Found(_Get_ID(pParameter), &s) && s.ToDouble(&d) )
{
pParameter->Set_Value(d);
}
break;
case PARAMETER_TYPE_Range:
if( m_CMD.Found(_Get_ID(pParameter, wxT("MIN")), &s) && s.ToDouble(&d) )
{
pParameter->asRange()->Set_LoVal(d);
}
if( m_CMD.Found(_Get_ID(pParameter, wxT("MAX")), &s) && s.ToDouble(&d) )
{
pParameter->asRange()->Set_HiVal(d);
}
break;
case PARAMETER_TYPE_String:
if( m_CMD.Found(_Get_ID(pParameter), &s) )
{
pParameter->Set_Value(CSG_String(&s));
}
break;
case PARAMETER_TYPE_Text:
if( m_CMD.Found(_Get_ID(pParameter), &s) )
{
CSG_File Stream;
if( Stream.Open(CSG_String(&s)) )
{
CSG_String t;
Stream.Read(t, Stream.Length());
pParameter->Set_Value(t.c_str());
}
else
{
pParameter->Set_Value(CSG_String(&s));
}
}
break;
case PARAMETER_TYPE_FilePath:
if( m_CMD.Found(_Get_ID(pParameter), &s) )
{
if( pParameter->asFilePath()->is_Multiple() )
{
s.Prepend(wxT("\""));
s.Replace(wxT(";"), wxT("\" \""));
s.Append (wxT("\""));
}
pParameter->Set_Value(CSG_String(&s));
}
break;
case PARAMETER_TYPE_FixedTable:
if( m_CMD.Found(_Get_ID(pParameter), &s) )
{
CSG_Table Table(&s);
pParameter->asTable()->Assign_Values(&Table);
}
break;
case PARAMETER_TYPE_Grid_System:
if( pParameter->Get_Children_Count() == 0 )
{
long nx, ny;
double d, x, y;
if( !m_CMD.Found(_Get_ID(pParameter, wxT("NX")), &nx)
|| !m_CMD.Found(_Get_ID(pParameter, wxT("NY")), &ny)
|| !m_CMD.Found(_Get_ID(pParameter, wxT( "X")), &s) || !s.ToDouble(&x)
|| !m_CMD.Found(_Get_ID(pParameter, wxT( "Y")), &s) || !s.ToDouble(&y)
|| !m_CMD.Found(_Get_ID(pParameter, wxT( "D")), &s) || !s.ToDouble(&d) )
{
pParameter->asGrid_System()->Assign(-1, 0.0, 0.0, 0, 0);
}
else
{
pParameter->asGrid_System()->Assign(d, x, y, (int)nx, (int)ny);
}
}
break;
}
}
}
m_pModule->Update_Parameter_States();
//-----------------------------------------------------
for(i=0; i<pParameters->Get_Count(); i++)
{
CSG_Parameter *pParameter = pParameters->Get_Parameter(i);
if( pParameter->is_Input() )
{
if( !_Load_Input(pParameters->Get_Parameter(i)) )
{
CMD_Print_Error(pParameters->Get_Parameter(i)->Get_Name());
return( false );
}
}
else if( pParameter->is_Option() && !pParameter->is_Information() )
{
long l;
wxString s;
switch( pParameter->Get_Type() )
{
case PARAMETER_TYPE_Table_Field:
if( m_CMD.Found(_Get_ID(pParameter), &s) )
{
if( s.ToLong(&l) )
{
pParameter->Set_Value((int)l);
}
else
{
pParameter->Set_Value(CSG_String(&s));
}
}
break;
case PARAMETER_TYPE_Table_Fields:
if( m_CMD.Found(_Get_ID(pParameter), &s) )
{
pParameter->Set_Value(CSG_String(&s));
}
break;
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CCMD_Module::Execute(CSG_String sLibName, int argc, char *argv[])
{
int i;
//-----------------------------------------------------
if( !m_pModule )
{
return( false );
}
if( argc <= 1 )
{
wxString sUsage = m_CMD.GetUsageString();
sUsage = wxString::Format(SG_T("Usage: saga_cmd %s %d %s"), sLibName.c_str(), m_pModule->Get_ID(), sUsage.AfterFirst(' ').AfterFirst(' '));
SG_PRINTF(sUsage);
return( false );
}
//-----------------------------------------------------
// m_CMD.SetCmdLine(argc, argv);
//
// We can't do it this way (passing argv as char**) because then we use an
// overload of the method which (re-)sets the locale from the current
// enviromment; in order to prevent this, we use wxString overload
wxString sCmdLine;
for(i=1; i<argc; i++)
{
wxString sTmp = argv[i];
sCmdLine += wxString::Format(SG_T("\"%s\" "), sTmp.c_str());
}
m_CMD.SetCmdLine(sCmdLine);
//-----------------------------------------------------
bool bResult = _Get_Parameters(m_pModule->Get_Parameters());
for(i=0; bResult && i<m_pModule->Get_Parameters_Count(); i++)
{
_Get_Parameters(m_pModule->Get_Parameters(i));
}
if( !bResult )
{
CMD_Print("");
wxString sUsage = m_CMD.GetUsageString();
sUsage = wxString::Format(SG_T("Usage: saga_cmd %s %d %s"), sLibName.c_str(), m_pModule->Get_ID(), sUsage.AfterFirst(' ').AfterFirst(' '));
SG_PRINTF(sUsage);
}
//-----------------------------------------------------
CMD_Set_Module(this);
if( bResult && m_pModule->On_Before_Execution() )
{
bResult = m_pModule->Execute();
m_pModule->On_After_Execution();
}
CMD_Set_Module(NULL);
//-----------------------------------------------------
if( bResult )
{
_Save_Output(m_pModule->Get_Parameters());
for(i=0; i<m_pModule->Get_Parameters_Count(); i++)
{
_Save_Output(m_pModule->Get_Parameters(i));
}
SG_Get_Data_Manager().Delete_Unsaved(); // remove temporary data to save memory resources
}
else
{
CMD_Print_Error(_TL("executing tool"), m_pModule->Get_Name());
}
return( bResult );
}
//---------------------------------------------------------
bool CPolygon_Dissolve::On_Execute(void)
{
//-----------------------------------------------------
CSG_Shapes *pPolygons = Parameters("POLYGONS")->asShapes();
if( !pPolygons->is_Valid() || pPolygons->Get_Count() < 2 )
{
Error_Set(_TL("invalid or empty polygons layer"));
return( false );
}
//-----------------------------------------------------
CSG_Shapes *pUnions = Parameters("DISSOLVED")->asShapes();
pUnions->Create(SHAPE_TYPE_Polygon);
int Field_1 = Parameters("FIELD_1")->asInt();
int Field_2 = Parameters("FIELD_2")->asInt(); if( Field_1 < 0 ) Field_2 = -1;
int Field_3 = Parameters("FIELD_3")->asInt(); if( Field_2 < 0 ) Field_3 = -1;
if( Field_1 >= 0 )
{
CSG_String s = pPolygons->Get_Field_Name(Field_1);
pUnions->Add_Field(pPolygons->Get_Field_Name(Field_1), pPolygons->Get_Field_Type(Field_1));
if( Field_2 >= 0 )
{
s += CSG_String(" | ") + pPolygons->Get_Field_Name(Field_2);
pUnions->Add_Field(pPolygons->Get_Field_Name(Field_2), pPolygons->Get_Field_Type(Field_2));
if( Field_3 >= 0 )
{
s += CSG_String(" | ") + pPolygons->Get_Field_Name(Field_3);
pUnions->Add_Field(pPolygons->Get_Field_Name(Field_3), pPolygons->Get_Field_Type(Field_3));
}
}
pPolygons->Set_Index(Field_1, TABLE_INDEX_Ascending, Field_2, TABLE_INDEX_Ascending, Field_3, TABLE_INDEX_Ascending);
pUnions->Set_Name(CSG_String::Format(SG_T("%s [%s: %s]"), pPolygons->Get_Name(), _TL("Dissolved"), s.c_str()));
}
else // if( Field_1 < 0 )
{
pUnions->Set_Name(CSG_String::Format(SG_T("%s [%s: %s]"), pPolygons->Get_Name(), _TL("Dissolved"), _TL("All")));
}
Init_Statistics(pUnions, pPolygons);
//-----------------------------------------------------
CSG_String Value;
CSG_Shape *pUnion = NULL;
bool bDissolve = Parameters("BND_KEEP")->asBool() == false;
//-----------------------------------------------------
for(int iPolygon=0; iPolygon<pPolygons->Get_Count() && Set_Progress(iPolygon, pPolygons->Get_Count()); iPolygon++)
{
CSG_Shape *pPolygon = pPolygons->Get_Shape(pPolygons->Get_Record_byIndex(iPolygon)->Get_Index());
CSG_String s;
if( Field_1 >= 0 ) s = pPolygon->asString(Field_1);
if( Field_2 >= 0 ) s += pPolygon->asString(Field_2);
if( Field_3 >= 0 ) s += pPolygon->asString(Field_3);
if( pUnion == NULL || (Field_1 >= 0 && Value.Cmp(s)) )
{
Set_Union(pUnion, bDissolve);
Value = s;
pUnion = pUnions->Add_Shape(pPolygon, SHAPE_COPY_GEOM);
if( Field_1 >= 0 ) pUnion->Set_Value(0, pPolygon->asString(Field_1));
if( Field_2 >= 0 ) pUnion->Set_Value(1, pPolygon->asString(Field_2));
if( Field_3 >= 0 ) pUnion->Set_Value(2, pPolygon->asString(Field_3));
Add_Statistics(pUnion, pPolygon, true);
}
else
{
for(int iPart=0; iPart<pPolygon->Get_Part_Count(); iPart++)
{
for(int iPoint=0, nParts=pUnion->Get_Part_Count(); iPoint<pPolygon->Get_Point_Count(iPart); iPoint++)
{
pUnion->Add_Point(pPolygon->Get_Point(iPoint, iPart), nParts);
}
}
Add_Statistics(pUnion, pPolygon, false);
}
}
Set_Union(pUnion, bDissolve);
//-----------------------------------------------------
if( m_Statistics )
{
delete[](m_Statistics);
}
m_List.Clear();
return( pUnions->is_Valid() );
}
//---------------------------------------------------------
bool CSG_Shapes::Create(const CSG_String &File_Name)
{
Destroy();
SG_UI_Msg_Add(CSG_String::Format("%s: %s...", _TL("Load shapes"), File_Name.c_str()), true);
//-----------------------------------------------------
bool bResult = File_Name.BeforeFirst(':').Cmp("PGSQL") && SG_File_Exists(File_Name) && _Load_ESRI(File_Name);
if( bResult )
{
Set_File_Name(File_Name, true);
}
//-----------------------------------------------------
else if( File_Name.BeforeFirst(':').Cmp("PGSQL") == 0 ) // database source
{
CSG_String s(File_Name);
s = s.AfterFirst(':'); CSG_String Host (s.BeforeFirst(':'));
s = s.AfterFirst(':'); CSG_String Port (s.BeforeFirst(':'));
s = s.AfterFirst(':'); CSG_String DBName(s.BeforeFirst(':'));
s = s.AfterFirst(':'); CSG_String Table (s.BeforeFirst(':'));
CSG_Tool *pTool = SG_Get_Tool_Library_Manager().Get_Tool("db_pgsql", 0); // CGet_Connections
if( pTool != NULL )
{
SG_UI_ProgressAndMsg_Lock(true);
//---------------------------------------------
CSG_Table Connections;
CSG_String Connection = DBName + " [" + Host + ":" + Port + "]";
pTool->Settings_Push();
if( pTool->On_Before_Execution() && SG_TOOL_PARAMETER_SET("CONNECTIONS", &Connections) && pTool->Execute() ) // CGet_Connections
{
for(int i=0; !bResult && i<Connections.Get_Count(); i++)
{
if( !Connection.Cmp(Connections[i].asString(0)) )
{
bResult = true;
}
}
}
pTool->Settings_Pop();
//---------------------------------------------
if( bResult && (bResult = (pTool = SG_Get_Tool_Library_Manager().Get_Tool("db_pgsql", 20)) != NULL) == true ) // CPGIS_Shapes_Load
{
pTool->Settings_Push();
bResult = pTool->On_Before_Execution()
&& SG_TOOL_PARAMETER_SET("CONNECTION", Connection)
&& SG_TOOL_PARAMETER_SET("TABLES" , Table)
&& SG_TOOL_PARAMETER_SET("SHAPES" , this)
&& pTool->Execute();
pTool->Settings_Pop();
}
SG_UI_ProgressAndMsg_Lock(false);
}
}
//-----------------------------------------------------
if( bResult )
{
Set_Modified(false);
Set_Update_Flag();
SG_UI_Process_Set_Ready();
SG_UI_Msg_Add(_TL("okay"), false, SG_UI_MSG_STYLE_SUCCESS);
return( true );
}
for(int iShape=Get_Count()-1; iShape>=0; iShape--) // be kind, keep at least those shapes that have been loaded successfully
{
if( !Get_Shape(iShape)->is_Valid() )
{
Del_Shape(iShape);
}
}
if( Get_Count() <= 0 )
{
Destroy();
}
SG_UI_Process_Set_Ready();
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
return( false );
}
//---------------------------------------------------------
bool CResection::On_Execute(void)
{
CSG_PointCloud *pPoints; // Input Point Cloud
CSG_String fileName;
CSG_File *pTabStream = NULL;
int n = 6; // Number of unknowns
CSG_Vector center(3);
CSG_Vector target(3);
double c = Parameters("F") ->asDouble(); // Focal Length (mm)
double pixWmm = Parameters("W") ->asDouble() / 1000;// Pixel Width (mm)
double ppOffsetX = Parameters("ppX") ->asDouble(); // Principal Point Offset X (pixels)
double ppOffsetY = Parameters("ppY") ->asDouble(); // Principal Point Offset Y (pixels)
pPoints = Parameters("POINTS") ->asPointCloud();
fileName = Parameters("OUTPUT FILE") ->asString();
center[0] = Parameters("Xc") ->asDouble();
center[1] = Parameters("Yc") ->asDouble();
center[2] = Parameters("Zc") ->asDouble();
target[0] = Parameters("Xt") ->asDouble();
target[1] = Parameters("Yt") ->asDouble();
target[2] = Parameters("Zt") ->asDouble();
int pointCount = pPoints->Get_Point_Count();
bool estPPOffsets = false;
if ( Parameters("EST_OFFSETS")->asBool() ) {
estPPOffsets = true;
n = 8; // Increase number of unknowns by 2
}
bool applyDistortions = false;
CSG_Vector K(3);
if ( Parameters("GIVE_DISTORTIONS")->asBool() ) {
applyDistortions = true;
K[0] = Parameters("K1") ->asDouble();
K[1] = Parameters("K2") ->asDouble();
K[2] = Parameters("K3") ->asDouble();
}
double dxapp = center [0] - target [0];
double dyapp = center [1] - target [1];
double dzapp = center [2] - target [2];
double h_d = sqrt (dxapp * dxapp + dyapp * dyapp + dzapp * dzapp); // Distance between Proj. Center & Target (m)
double h_dmm = h_d * 1000; // Convert to mm
if( fileName.Length() == 0 )
{
SG_UI_Msg_Add_Error(_TL("Please provide an output file name!"));
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);
}
CSG_Vector rotns = methods::calcRotations(center,target); // Approx. rotations omega, kappa, alpha
CSG_String msg = "********* Initial Approximate Values *********";
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Rotation Angles:");
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Omega:\t") + SG_Get_String(rotns[0],6,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Kappa:\t") + SG_Get_String(rotns[1],6,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Alpha:\t") + SG_Get_String(rotns[2],6,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Projection Center:");
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Xc:\t") + SG_Get_String(center[0],4,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Yc:\t") + SG_Get_String(center[1],4,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Zc:\t") + SG_Get_String(center[2],4,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
if (estPPOffsets) {
msg = SG_T("Principal Point Offsets:");
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("ppX:\t") + SG_Get_String(ppOffsetX,5,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("ppY:\t") + SG_Get_String(ppOffsetY,5,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
}
double itrNo = 0;
CSG_Matrix invN;
while (true) { // Begin Iterations
itrNo++;
double omega = rotns[0];
double kappa = rotns[1];
double alpha = rotns[2];
CSG_Matrix R = methods::calcRotnMatrix(rotns); // Rotation Matrix from approximate values
CSG_Matrix E(3,3); // [w1;w2;w3] = E * [dw;dk;da]
E[0][0] = -1;
E[0][1] = E[1][0] = E[2][0] = 0;
E[0][2] = sin(kappa);
E[1][1] = -cos(omega);
E[1][2] = -sin(omega) * cos(kappa);
E[2][1] = sin(omega);
E[2][2] = -cos(omega) * cos(kappa);
CSG_Matrix N(n,n); // Transpose(Design Matrix) * I * Design Matrix
CSG_Vector ATL(n); // Transpose(Design Matrix) * I * Shortened obs. vector
double SS = 0;
double sigma_naught = 0;
for (int i = 0; i < pointCount; i++) {
CSG_Vector pqs(3); // Approx. pi, qi, si
for (int j = 0; j < 3; j++) {
pqs[j] = R[j][0] * (pPoints->Get_X(i) - center[0]) +
R[j][1] * (pPoints->Get_Y(i) - center[1]) +
R[j][2] * (pPoints->Get_Z(i) - center[2]);
}
double p_i = pqs[0];
double q_i = pqs[1];
double s_i = pqs[2];
double dR = 0;
// Undistorted
double x_u = c * p_i / q_i;
double y_u = c * s_i / q_i;
double c_hat = c;
if (applyDistortions) {
double r2 = x_u * x_u + y_u * y_u;
dR = K[0] * r2 + K[1] * r2 * r2 + K[2] * r2 * r2 * r2;
c_hat = c * (1 - dR);
}
// Approx. image coordinates (with distortions)
double x_i = (1 - dR) * x_u + ppOffsetX * pixWmm;
double z_i = (1 - dR) * y_u + ppOffsetY * pixWmm;
// Shortened obervation vector: dxi & dzi
double dx_i = pPoints->Get_Attribute(i,0) * pixWmm - x_i;
double dz_i = pPoints->Get_Attribute(i,1) * pixWmm - z_i;
SS += pow(dx_i,2) + pow(dz_i,2);
/*
x_i, z_i in [mm]
p_i,q_i,s_i in [m]
h_d in [m]
c, c_hat in [mm]
h_dmm in [mm]
*/
CSG_Matrix L(3,2); // CSG_Matrix takes columns first and rows second
CSG_Matrix V(3,3);
CSG_Matrix LR(3,2);
CSG_Matrix LVE(3,2);
L[0][0] = L[1][2] = c_hat / (1000 * q_i);
L[0][2] = L[1][0] = 0;
L[0][1] = -x_u * (1 - dR) / (1000 * q_i);
L[1][1] = -y_u * (1 - dR) / (1000 * q_i);
V[0][0] = V[1][1] = V[2][2] = 0;
V[0][1] = s_i / h_d;
V[0][2] = -q_i / h_d;
V[1][0] = -s_i / h_d;
V[1][2] = p_i / h_d;
V[2][0] = q_i / h_d;
V[2][1] = -p_i / h_d;
LVE = ( L * V ) * E;
LR = L * R;
// Design Matrix (J)
CSG_Matrix design(n,2);
for(int j = 0; j < 2; j++) {
for(int k = 0; k < 3; k++) {
design[j][k] = LVE[j][k];
design[j][k+3] = -LR[j][k];
}
}
if ( estPPOffsets ) {
design[0][6] = design[1][7] = 1.0;
}
// Build Normal Matrix
for(int j = 0; j < n; j++) {
for(int k = 0; k < n; k++) {
N[j][k] += (design[0][j] * design[0][k] + design[1][j] * design[1][k]);
}
}
// Build Tranpose (J) * I * (Shortened obs. vector)
for (int m=0; m < n; m++) {
ATL[m] += design[0][m] * dx_i + design[1][m] * dz_i;
}
L.Destroy();
V.Destroy();
LR.Destroy();
LVE.Destroy();
pqs.Destroy();
design.Destroy();
} // end looping over observations
// Eigen values and Eigen Vectors
CSG_Vector eigenVals(n);
CSG_Matrix eigenVecs(n,n);
SG_Matrix_Eigen_Reduction(N, eigenVecs, eigenVals, true);
// One of the Eigen Values is 0
if (std::any_of(eigenVals.cbegin(),
eigenVals.cend(),
[] (double i) { return i == 0; })) {
msg = "The Normal Matrix has a rank defect. Please measure more points.";
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
break;
}
double mx = *std::max_element(eigenVals.cbegin(), eigenVals.cend());
double mn = *std::min_element(eigenVals.cbegin(), eigenVals.cend());
// Ratio of Smallest to the Biggest Eigen value is too small
if ((mn / mx) < pow(10,-12.0)) {
msg = SG_T("Condition of the Matrix of Normal Equations:\t") + CSG_String::Format(SG_T(" %13.5e"), mn/mx);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = "The Normal Matrix is weakly conditioned. Please measure more points.";
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
break;
}
// Calculate the adjustments
double absMax = 0;
invN = N.Get_Inverse();
CSG_Vector est_param_incs = invN * ATL;
for (int i = 0; i < n; i++) {
if (abs(est_param_incs[i]) > absMax) {
absMax = abs(est_param_incs[i]);
}
}
if (absMax < thresh) {
msg = "Solution has converged.";
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
break;
}
for (int a = 0; a < 3; a++) {
rotns[a] += est_param_incs[a] / h_dmm; // New Approx. rotations omega, kappa, alpha
center[a] += est_param_incs[a+3] / 1000; // New Approx. Projection Center
}
if ( estPPOffsets ) {
ppOffsetX += (est_param_incs[6] / pixWmm); // New Approx. Principal Point
ppOffsetY += (est_param_incs[7] / pixWmm);
}
sigma_naught = sqrt(SS / (2 * pointCount - n));
// Writing To Output File & SAGA Console
msg = "********* Iteration: " + SG_Get_String(itrNo,0,false) + " *********";
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = "Sum of Squared Residuals:\t" + SG_Get_String(SS,5,false);
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = "Sigma Naught:\t" + SG_Get_String(sigma_naught,5,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Condition of the Matrix of Normal Equations:\t") + CSG_String::Format(SG_T(" %13.5e"), mn/mx);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
R.Destroy();
E.Destroy();
N.Destroy();
ATL.Destroy();
invN.Destroy();
eigenVals.Destroy();
eigenVecs.Destroy();
est_param_incs.Destroy();
} // end of iterations
msg = "********* Final Estimated Parameters *********";
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Rotation Angles:");
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Omega:\t") + SG_Get_String(rotns[0],6,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Kappa:\t") + SG_Get_String(rotns[1],6,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Alpha:\t") + SG_Get_String(rotns[2],6,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Projection Center:");
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Xc:\t") + SG_Get_String(center[0],4,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Yc:\t") + SG_Get_String(center[1],4,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("Zc:\t") + SG_Get_String(center[2],4,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
if (estPPOffsets) {
msg = SG_T("Principal Point Offsets:");
pTabStream->Write(SG_T("\n") + msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("ppX:\t") + SG_Get_String(ppOffsetX,5,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
msg = SG_T("ppY:\t") + SG_Get_String(ppOffsetY,5,false);
pTabStream->Write(msg + SG_T("\n"));
SG_UI_Msg_Add(msg, true);
}
K.Destroy();
rotns.Destroy();
center.Destroy();
target.Destroy();
pTabStream->Close();
return true;
}
//---------------------------------------------------------
CSG_3DView_Dialog::CSG_3DView_Dialog(const CSG_String &Caption)
: CSGDI_Dialog(Caption.c_str(), SGDI_DLG_STYLE_START_MAXIMISED)
{
SetWindowStyle(wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE);
}
//---------------------------------------------------------
bool CSG_ODBC_Connection::Table_Insert(const CSG_String &Table_Name, const CSG_Table &Table, bool bCommit)
{
//-----------------------------------------------------
if( !is_Connected() )
{
_Error_Message(_TL("no database connection"));
return( false );
}
if( !Table_Exists(Table_Name) )
{
return( false );
}
CSG_Table Fields = Get_Field_Desc(Table_Name);
if( Fields.Get_Count() != Table.Get_Field_Count() )
{
return( false );
}
//-----------------------------------------------------
try
{
bool bLOB = false;
int iField, iRecord;
CSG_String Insert;
otl_stream Stream;
//-------------------------------------------------
Insert.Printf(SG_T("INSERT INTO %s VALUES("), Table_Name.c_str());
for(iField=0; iField<Table.Get_Field_Count(); iField++)
{
if( iField > 0 )
{
Insert += SG_T(",");
}
Insert += CSG_String::Format(SG_T(":f%d"), 1 + iField);
switch( Table.Get_Field_Type(iField) )
{
default:
case SG_DATATYPE_String: Insert += SG_T("<varchar>"); break;
case SG_DATATYPE_Date: Insert += SG_T("<char[12]>"); break;
case SG_DATATYPE_Char: Insert += SG_T("<char>"); break;
case SG_DATATYPE_Short: Insert += SG_T("<short>"); break;
case SG_DATATYPE_Int: Insert += SG_T("<int>"); break;
case SG_DATATYPE_Color: Insert += SG_T("<long>"); break;
case SG_DATATYPE_Long: Insert += SG_T("<long>"); break;
case SG_DATATYPE_Float: Insert += SG_T("<float>"); break;
case SG_DATATYPE_Double: Insert += SG_T("<double>"); break;
}
}
Insert += SG_T(")");
Stream.set_all_column_types(otl_all_date2str);
Stream.set_lob_stream_mode(bLOB);
Stream.open(bLOB ? 1 : m_Size_Buffer, Insert, m_Connection);
std_string valString;
//-------------------------------------------------
for(iRecord=0; iRecord<Table.Get_Count() && SG_UI_Process_Set_Progress(iRecord, Table.Get_Count()); iRecord++)
{
CSG_Table_Record *pRecord = Table.Get_Record(iRecord);
for(iField=0; iField<Table.Get_Field_Count(); iField++)
{
if( pRecord->is_NoData(iField) )
{
Stream << otl_null();
}
else switch( Table.Get_Field_Type(iField) )
{
default:
case SG_DATATYPE_String:
case SG_DATATYPE_Date:
valString = CSG_String(pRecord->asString(iField));
Stream << valString;
break;
case SG_DATATYPE_Char: Stream << (char)pRecord->asChar (iField); break;
case SG_DATATYPE_Short: Stream << pRecord->asShort (iField); break;
case SG_DATATYPE_Int: Stream << pRecord->asInt (iField); break;
case SG_DATATYPE_Color:
case SG_DATATYPE_Long: Stream << (long)pRecord->asInt (iField); break;
case SG_DATATYPE_Float: Stream << pRecord->asFloat (iField); break;
case SG_DATATYPE_Double: Stream << pRecord->asDouble(iField); break;
}
}
}
}
//-----------------------------------------------------
catch( otl_exception &e )
{
_Error_Message(e);
return( false );
}
return( true );
}