//---------------------------------------------------------
bool CSG_MetaData::Load_JSON(const CSG_String &File)
{
CSG_File Stream; CSG_String JSON;
if( Stream.Open(File, SG_FILE_R, false) && Stream.Read(JSON, (size_t)Stream.Length()) > 0 )
{
return( from_JSON(JSON) );
}
return( false );
}
//---------------------------------------------------------
int CTL_Extract::Read_File(const SG_Char *File, CSG_Table &Elements)
{
//-----------------------------------------------------
CSG_File Stream;
if( !Stream.Open(File, SG_FILE_R, false) )
{
return( 0 );
}
Process_Set_Text(CSG_String::Format("%s: %s", SG_T("scanning"), File));
//-----------------------------------------------------
CSG_String String, Text;
if( !Stream.Read(String, Stream.Length()) )
{
return( 0 );
}
//-----------------------------------------------------
const SG_Char Function[2][4] = { SG_T("_TL"), SG_T("_TW") };
const SG_Char *p = String;
bool bLong = Parameters("LONG")->asBool();
while( *p != '\0' )
{
if( !(p[0] == Function[0][0] && p[1] == Function[0][1] && p[2] == Function[0][2])
&& !(p[0] == Function[1][0] && p[1] == Function[1][1] && p[2] == Function[1][2] && bLong) )
{
p ++;
}
else
{
p += Read_Text(p, Text);
if( Text.Length() > 0 )
{
CSG_Table_Record *pRecord = Elements.Add_Record();
pRecord->Set_Value(0, Text);
pRecord->Set_Value(1, File);
}
}
}
return( 1 );
}
//---------------------------------------------------------
bool CXYZ_Import::On_Execute(void)
{
CSG_File Stream;
if( !Stream.Open(Parameters("FILENAME")->asString(), SG_FILE_R) )
{
Error_Set(_TL("file could not be opened"));
return( false );
}
//-----------------------------------------------------
CSG_Shapes *pPoints = Parameters("POINTS")->asShapes();
pPoints->Create(SHAPE_TYPE_Point, SG_File_Get_Name(Parameters("FILENAME")->asString(), false));
pPoints->Add_Field("Z", SG_DATATYPE_Double);
//-----------------------------------------------------
if( Parameters("HEADLINE")->asBool() )
{
CSG_String sLine;
if( !Stream.Read_Line(sLine) )
{
Error_Set(_TL("could not read headline"));
return( false );
}
}
//-----------------------------------------------------
sLong Length = Stream.Length();
double x, y, z;
while( Stream.Scan(x) && Stream.Scan(y) && Stream.Scan(z) && Set_Progress((double)Stream.Tell(), (double)Length) )
{
CSG_Shape *pPoint = pPoints->Add_Shape();
pPoint->Add_Point(x, y);
pPoint->Set_Value(0, z);
}
return( pPoints->Get_Count() > 0 );
}
//---------------------------------------------------------
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 CBSL_Interpreter::On_Execute(void)
{
//-----------------------------------------------------
Parameters("OUTPUT")->asGridList()->Del_Items();
g_bProgress = Parameters("PROGRESS")->asBool();
if( m_bFile )
{
CSG_File Stream;
if( !Stream.Open(Parameters("BSL")->asString(), SG_FILE_R, false) )
{
return( false );
}
Stream.Read(m_BSL, Stream.Length());
}
else
{
m_BSL = Parameters("BSL")->asString();
}
//-----------------------------------------------------
if( !Parse_Vars(false) )
{
return( false );
}
//-----------------------------------------------------
CSG_Parameters Input(this, _TL("Input"), _TL(""), SG_T("INPUT"), true);
FindMemoryGrids();
for(T_InputText::iterator it=InputGrids.begin(); it!=InputGrids.end(); it++)
{
CSG_String sName(it->c_str());
Input.Add_Grid(NULL, sName, sName, _TL(""), PARAMETER_INPUT, true);
}
DeleteVarList();
DeleteAnweisungList(AnweisungList);
if( Dlg_Parameters(&Input, _TL("Input")) == false )
{
return( false );
}
//-----------------------------------------------------
if( !Parse_Vars(true) )
{
return( false );
}
//-----------------------------------------------------
g_pInterpreter = this;
if( GetMemoryGrids(&Input) )
{
try
{
ausfuehren_anweisung(AnweisungList);
}
catch(BBFehlerAusfuehren x)
{
if( x.Text == "" )
Message_Add(_TL("unknown error: execution"));
else
Message_Add(CSG_String::Format(SG_T("error: %s\n"), CSG_String(x.Text.c_str()).c_str()));
}
catch(BBFehlerUserbreak x)
{
if( x.Text == "" )
Message_Add(_TL("unknown error: user break"));
else
Message_Add(CSG_String::Format(SG_T("error: %s\n"), CSG_String(x.Text.c_str()).c_str()));
}
}
g_pInterpreter = NULL;
DeleteVarList();
DeleteAnweisungList(AnweisungList);
return( true );
}
//---------------------------------------------------------
bool CWASP_MAP_Import::On_Execute(void)
{
int n, Method, nLength;
double z, dz, zMin, rLeft, rRight;
CSG_File Stream;
TSG_Point p, pu[2], pm[2];
CSG_String fName, sLine;
CSG_Shape *pLine;
CSG_Shapes *pLines;
//-----------------------------------------------------
pLines = Parameters("SHAPES")->asShapes();
fName = Parameters("FILE" )->asString();
Method = Parameters("METHOD")->asInt();
//-----------------------------------------------------
if( Stream.Open(fName, SG_FILE_R) )
{
nLength = Stream.Length();
pLines->Create(SHAPE_TYPE_Line, SG_File_Get_Name(fName, false));
switch( Method )
{
case 0: // elevation
pLines->Add_Field("Z" , SG_DATATYPE_Double);
break;
case 1: // roughness
pLines->Add_Field("RLEFT" , SG_DATATYPE_Double);
pLines->Add_Field("RRIGHT" , SG_DATATYPE_Double);
break;
case 2: // elevation and roughness
pLines->Add_Field("Z" , SG_DATATYPE_Double);
pLines->Add_Field("RLEFT" , SG_DATATYPE_Double);
pLines->Add_Field("RRIGHT" , SG_DATATYPE_Double);
break;
}
// 1) Text string identifying the terrain map: + ...
Stream.Read_Line(sLine);
// 2) Fixed point #1 in user and metric [m] coordinates:
// X1(user) Y1(user) X1(metric) Y1(metric)
// fscanf(Stream, "%lf %lf %lf %lf", &pu[0].x, &pu[0].y, &pm[0].x, &pm[0].y);
pu[0].x = Stream.Scan_Double();
pu[0].y = Stream.Scan_Double();
pm[0].x = Stream.Scan_Double();
pm[0].y = Stream.Scan_Double();
// 3) Fixed point #2 in user and metric [m] coordinates:
// X2(user) Y2(user) X2(metric) Y2(metric)
// fscanf(Stream, "%lf %lf %lf %lf", &pu[1].x, &pu[1].y, &pm[1].x, &pm[1].y);
pu[1].x = Stream.Scan_Double();
pu[1].y = Stream.Scan_Double();
pm[1].x = Stream.Scan_Double();
pm[1].y = Stream.Scan_Double();
// 4) Scaling factor and offset for height scale (Z):
// Zmetric = {scaling factor}(Zuser + {offset})
// fscanf(Stream, "%lf %lf", &dz, &zMin);
dz = Stream.Scan_Double();
zMin = Stream.Scan_Double();
while( !Stream.is_EOF() && Set_Progress((int)Stream.Tell(), nLength) )
{
pLine = NULL;
switch( Method )
{
case 0: // elevation
// 5a) Height contour: elevation (Z) and number of points (n) in line:
// Z n
// fscanf(Stream, "%lf %d", &z, &n);
z = Stream.Scan_Double();
n = Stream.Scan_Int ();
if( !Stream.is_EOF() && n > 1 )
{
pLine = pLines->Add_Shape();
pLine->Set_Value(0, zMin + dz * z);
}
break;
case 1: // roughness
// 5b) Roughness change line:
// roughness lengths to the left (z0l) and right (z0r) side of the line,
// respectively, and number of points:
// z0l z0r n
// fscanf(Stream, "%lf %lf %d", &rLeft, &rRight, &n);
rLeft = Stream.Scan_Double();
rRight = Stream.Scan_Double();
n = Stream.Scan_Int ();
if( !Stream.is_EOF() && n > 1 )
{
pLine = pLines->Add_Shape();
pLine->Set_Value(0, rLeft);
pLine->Set_Value(1, rRight);
}
break;
case 2: // elevation and roughness
// 5c) Roughness and contour line:
// roughness lengths to the left and right of the line,
// respectively, elevation and number of points:
// z0l z0r Z n
// fscanf(Stream, "%lf %lf %lf %d", &rLeft, &rRight, &z, &n);
rLeft = Stream.Scan_Double();
rRight = Stream.Scan_Double();
z = Stream.Scan_Double();
n = Stream.Scan_Int ();
if( !Stream.is_EOF() && n > 1 )
{
pLine = pLines->Add_Shape();
pLine->Set_Value(0, zMin + dz * z);
pLine->Set_Value(1, rLeft);
pLine->Set_Value(2, rRight);
}
break;
}
// 6–) Cartesian coordinates (X, Y) of line described in 5a, 5b or 5c:
// X1 Y1 [... Xn Yn]
// Xn+1 Yn+1
// ... where [] embrace optional numbers and n is > 0
for(int i=0; i<n && !Stream.is_EOF() && Process_Get_Okay(false); i++)
{
// fscanf(Stream, "%lf %lf", &p.x, &p.y);
p.x = Stream.Scan_Double();
p.y = Stream.Scan_Double();
pLine->Add_Point(p);
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CSG_PointCloud::_Load(const CSG_String &File_Name)
{
TSG_Data_Type Type;
char ID[6];
int i, iBuffer, nPointBytes, nFields;
char Name[1024];
CSG_File Stream;
SG_UI_Msg_Add(CSG_String::Format(SG_T("%s: %s..."), _TL("Load point cloud"), File_Name.c_str()), true);
//-----------------------------------------------------
if( !Stream.Open(File_Name, SG_FILE_R, true) )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("file could not be opened."));
return( false );
}
if( !Stream.Read(ID, 6) || strncmp(ID, PC_FILE_VERSION, 5) != 0 )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("incompatible file."));
return( false );
}
if( !Stream.Read(&nPointBytes, sizeof(int)) || nPointBytes < (int)(3 * sizeof(float)) )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("incompatible file."));
return( false );
}
if( !Stream.Read(&nFields, sizeof(int)) || nFields < 3 )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("incompatible file."));
return( false );
}
//-----------------------------------------------------
Destroy();
for(i=0; i<nFields; i++)
{
if( !Stream.Read(&Type , sizeof(TSG_Data_Type))
|| !Stream.Read(&iBuffer , sizeof(int)) || !(iBuffer > 0 && iBuffer < 1024)
|| !Stream.Read(Name , iBuffer) )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("incompatible file."));
return( false );
}
if( ID[5] == '0' ) // Data Type Definition changed!!!
{
switch( Type )
{
default:
Type = SG_DATATYPE_Undefined;
break;
case 1:
Type = SG_DATATYPE_Char;
break;
case 2:
Type = SG_DATATYPE_Short;
break;
case 3:
Type = SG_DATATYPE_Int;
break;
case 4:
Type = SG_DATATYPE_Long;
break;
case 5:
Type = SG_DATATYPE_Float;
break;
case 6:
Type = SG_DATATYPE_Double;
break;
}
}
Name[iBuffer] = '\0';
if( !_Add_Field(CSG_String((const char *)Name), Type) )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("incompatible file."));
return( false );
}
}
if( m_nPointBytes != nPointBytes + 1 )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("incompatible file."));
return( false );
}
//-----------------------------------------------------
sLong fLength = Stream.Length();
while( _Inc_Array() && Stream.Read(m_Cursor + 1, nPointBytes) && SG_UI_Process_Set_Progress((double)Stream.Tell(), (double)fLength) )
{}
_Dec_Array();
Set_File_Name(File_Name, true);
Load_MetaData(File_Name);
if( 0 > Get_Count() )
{
SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
SG_UI_Msg_Add_Error(_TL("no records in file."));
return( false );
}
//-----------------------------------------------------
SG_UI_Process_Set_Ready();
Get_Projection().Load(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);
return( true );
}
//---------------------------------------------------------
bool CSG_Table::_Load_Text(const CSG_String &File_Name, bool bHeadline, const SG_Char *Separator)
{
int i, iField, fLength;
CSG_String sLine, sField;
CSG_File Stream;
CSG_Table Table;
//-----------------------------------------------------
if( Stream.Open(File_Name, SG_FILE_R, false) == false )
{
return( false );
}
if( !Stream.Read_Line(sLine) )
{
return( false );
}
//-----------------------------------------------------
sLine += Separator;
while( (i = sLine.Find(Separator)) >= 0 )
{
sField = bHeadline ? sLine.Left(i) : CSG_String::Format(SG_T("FIELD_%02d"), Table.Get_Field_Count() + 1);
if( sField[0] == SG_T('\"') && sField[(int)(sField.Length() - 1)] == SG_T('\"') ) // remove quota
{
sField = sField.AfterFirst('\"').BeforeLast('\"');
}
Table.Add_Field(sField, SG_DATATYPE_String);
sLine.Remove(0, i + 1);
}
//-----------------------------------------------------
TSG_Data_Type *Type = new TSG_Data_Type[Table.Get_Field_Count()];
for(iField=0; iField<Table.Get_Field_Count(); iField++)
{
Type[iField] = SG_DATATYPE_Int;
}
if( !bHeadline )
{
Stream.Seek_Start();
}
fLength = Stream.Length();
while( Stream.Read_Line(sLine) && sLine.Length() > 0 && SG_UI_Process_Set_Progress(Stream.Tell(), fLength) )
{
CSG_Table_Record *pRecord = Table._Add_Record();
sLine += Separator;
for(iField=0; iField<Table.Get_Field_Count(); iField++)
{
if( (i = sLine.Find(Separator)) >= 0 )
{
sField = sLine.Left(i);
if( sField[0] == SG_T('\"') && sField[(int)(sField.Length() - 1)] == SG_T('\"') ) // remove quota
{
sField = sField.AfterFirst('\"').BeforeLast('\"');
}
if( Type[iField] != SG_DATATYPE_String )
{
double Value;
if( SG_SSCANF(sField, SG_T("%lf"), &Value) != 1 )
{
Type[iField] = SG_DATATYPE_String;
}
else if( Type[iField] != SG_DATATYPE_Double && Value - (int)Value != 0.0 )
{
Type[iField] = SG_DATATYPE_Double;
}
}
pRecord->Set_Value(iField, sField);
sLine.Remove(0, i + 1);
}
else
{
break;
}
}
}
//-----------------------------------------------------
if( Table.Get_Count() > 0 )
{
for(iField=0; iField<Table.Get_Field_Count(); iField++)
{
Add_Field(Table.Get_Field_Name(iField), Type[iField]);
}
for(int iRecord=0; iRecord<Table.Get_Count() && SG_UI_Process_Set_Progress(iRecord, Table.Get_Count()); iRecord++)
{
CSG_Table_Record *pRecord = _Add_Record();
for(iField=0; iField<Get_Field_Count(); iField++)
{
switch( Get_Field_Type(iField) )
{
default: pRecord->Set_Value(iField, Table[iRecord].asString(iField)); break;
case SG_DATATYPE_Int: pRecord->Set_Value(iField, Table[iRecord].asInt (iField)); break;
case SG_DATATYPE_Double: pRecord->Set_Value(iField, Table[iRecord].asDouble(iField)); break;
}
}
}
}
delete[](Type);
SG_UI_Process_Set_Ready();
return( Get_Field_Count() > 0 );
}
//---------------------------------------------------------
bool CXYZ_Import::On_Execute(void)
{
int nx, ny, nValues, fLength;
double x, y, z, xMin, yMin, xMax, yMax, Cellsize;
CSG_File Stream;
CSG_String FileName, sLine;
CSG_Grid *pGrid, *pCount;
FileName = Parameters("FILENAME")->asString();
Cellsize = Parameters("CELLSIZE")->asDouble();
switch( Parameters("SEPARATOR")->asInt() )
{
case 0: m_Separator = SG_T(' '); break;
case 1: m_Separator = SG_T('\t'); break;
case 2: m_Separator = SG_T(','); break;
case 3: m_Separator = SG_T(';'); break;
}
if( Cellsize > 0.0 && Stream.Open(FileName, SG_FILE_R, false) )
{
if( Parameters("CAPTION")->asBool() )
{
Stream.Read_Line(sLine);
}
fLength = Stream.Length();
nValues = 0;
xMin = xMax = 0;
yMin = yMax = 0;
while( Read_Values(Stream, x, y, z) && Set_Progress(Stream.Tell(), fLength) )
{
if( nValues == 0 )
{
xMin = xMax = x;
yMin = yMax = y;
}
else
{
if( xMin > x ) xMin = x; else if( xMax < x ) xMax = x;
if( yMin > y ) yMin = y; else if( yMax < y ) yMax = y;
}
nValues++;
}
//-------------------------------------------------
if( Process_Get_Okay() && xMin < xMax && yMin < yMax )
{
nx = 1 + (int)((xMax - xMin) / Cellsize);
ny = 1 + (int)((yMax - yMin) / Cellsize);
Parameters("GRID" )->Set_Value(pGrid = SG_Create_Grid(SG_DATATYPE_Float, nx, ny, Cellsize, xMin, yMin));
Parameters("COUNT")->Set_Value(pCount = SG_Create_Grid(SG_DATATYPE_Byte , nx, ny, Cellsize, xMin, yMin));
if( pGrid && pCount )
{
pGrid ->Set_Name(FileName = SG_File_Get_Name(FileName, false));
pCount ->Set_Name(CSG_String::Format(SG_T("%s [%s]"), FileName.c_str(), _TL("Count")));
Stream.Seek_Start();
if( Parameters("CAPTION")->asBool() )
{
Stream.Read_Line(sLine);
}
while( Read_Values(Stream, x, y, z) && Set_Progress(Stream.Tell(), fLength) )
{
if( pGrid->Get_System().Get_World_to_Grid(nx, ny, x, y) )
{
pGrid ->Add_Value(nx, ny, z);
pCount->Add_Value(nx, ny, 1.0);
}
}
for(ny=0; ny<pGrid->Get_NY() && Set_Progress(ny, pGrid->Get_NY()); ny++)
{
for(nx=0; nx<pGrid->Get_NX(); nx++)
{
nValues = pCount->asInt(nx, ny);
if( nValues == 0 )
{
pGrid->Set_NoData(nx, ny);
}
else if( nValues > 1 )
{
pGrid->Mul_Value(nx, ny, 1.0 / nValues);
}
}
}
return( true );
}
}
}
return( false );
}
//---------------------------------------------------------
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 CTable_Text_Import_Fixed_Cols::On_Execute(void)
{
bool bHeader;
int i, nChars, iField, nFields, *iFirst, *iLength;
CSG_String sLine;
CSG_File Stream;
CSG_Table *pTable;
//-----------------------------------------------------
pTable = Parameters("TABLE") ->asTable();
bHeader = Parameters("HEADLINE") ->asBool();
//-----------------------------------------------------
if( !Stream.Open(Parameters("FILENAME")->asString(), SG_FILE_R, true) )
{
Message_Add(_TL("file could not be opened"));
return( false );
}
if( !Stream.Read_Line(sLine) || (nChars = (int)sLine.Length()) <= 0 )
{
Message_Add(_TL("empty or corrupted file"));
return( false );
}
//-----------------------------------------------------
pTable->Destroy();
pTable->Set_Name(SG_File_Get_Name(Parameters("FILENAME")->asString(), false));
switch( Parameters("FIELDDEF")->asInt() )
{
//-----------------------------------------------------
case 0:
{
CSG_Parameters *pBreaks = Get_Parameters("BREAKS");
pBreaks->Del_Parameters();
for(i=0; i<nChars; i++)
{
pBreaks->Add_Value(NULL,
CSG_String::Format(SG_T("%03d"), i),
CSG_String::Format(SG_T("%03d %c"), i + 1, sLine[i]),
_TL(""), PARAMETER_TYPE_Bool, false
);
}
if( !Dlg_Parameters("BREAKS") )
{
return( false );
}
//-------------------------------------------------
for(i=0, nFields=1; i<pBreaks->Get_Count(); i++)
{
if( pBreaks->Get_Parameter(i)->asBool() )
{
nFields++;
}
}
//-------------------------------------------------
iFirst = new int[nFields];
iLength = new int[nFields];
iFirst[0] = 0;
for(i=0, iField=1; i<pBreaks->Get_Count() && iField<nFields; i++)
{
if( pBreaks->Get_Parameter(i)->asBool() )
{
iFirst[iField++] = i + 1;
}
}
//-------------------------------------------------
for(iField=0; iField<nFields; iField++)
{
iLength[iField] = (iField < nFields - 1 ? iFirst[iField + 1] : (int)sLine.Length()) - iFirst[iField];
pTable->Add_Field(bHeader ? sLine.Mid(iFirst[iField], iLength[iField]) : CSG_String::Format(SG_T("FIELD%03d"), iField + 1), SG_DATATYPE_String);
}
}
break;
//-----------------------------------------------------
case 1:
{
CSG_Parameters *pFields = Get_Parameters("FIELDS");
pFields->Del_Parameters();
nFields = Parameters("NFIELDS")->asInt();
for(iField=0; iField<nFields; iField++)
{
CSG_String s = CSG_String::Format(SG_T("%03d"), iField);
CSG_Parameter *pNode = pFields->Add_Node(NULL, SG_T("NODE") + s, _TL("Field") + s, _TL(""));
pFields->Add_Value (pNode, SG_T("LENGTH") + s, _TL("Length"), _TL(""), PARAMETER_TYPE_Int, 1, 1, true);
// pFields->Add_Value (pNode, SG_T("IMPORT") + s, _TL("Import"), _TL(""), PARAMETER_TYPE_Bool, true);
pFields->Add_Choice (pNode, SG_T("TYPE") + s, _TL("Type") , _TL(""), CSG_String::Format(SG_T("%s|%s|%s|%s|%s|"),
_TL("text"),
_TL("2 byte integer"),
_TL("4 byte integer"),
_TL("4 byte float"),
_TL("8 byte float"))
);
}
if( !Dlg_Parameters("FIELDS") )
{
return( false );
}
//-------------------------------------------------
iFirst = new int[nFields];
iLength = new int[nFields];
iFirst[0] = 0;
for(iField=0, i=0; iField<nFields && i<nChars; iField++)
{
CSG_String s = CSG_String::Format(SG_T("%03d"), iField);
iFirst [iField] = i;
iLength[iField] = pFields->Get_Parameter(SG_T("LENGTH") + s)->asInt();
i += iLength[iField];
CSG_String Name = bHeader ? sLine.Mid(iFirst[iField], iLength[iField]) : CSG_String::Format(SG_T("FIELD%03d"), iField + 1);
switch( pFields->Get_Parameter(SG_T("TYPE") + s)->asInt() )
{
default:
case 0:
pTable->Add_Field(Name, SG_DATATYPE_String);
break;
case 1:
pTable->Add_Field(Name, SG_DATATYPE_Short);
break;
case 2:
pTable->Add_Field(Name, SG_DATATYPE_Int);
break;
case 3:
pTable->Add_Field(Name, SG_DATATYPE_Float);
break;
case 4:
pTable->Add_Field(Name, SG_DATATYPE_Double);
break;
}
}
}
break;
//-----------------------------------------------------
case 2:
{
CSG_Table *pList = Parameters("LIST")->asTable();
nFields = pList->Get_Count();
//-------------------------------------------------
iFirst = new int[nFields];
iLength = new int[nFields];
iFirst[0] = 0;
for(iField=0, i=0; iField<nFields && i<nChars; iField++)
{
iFirst [iField] = i;
iLength[iField] = pList->Get_Record(iField)->asInt(1);
i += iLength[iField];
CSG_String Name = bHeader ? sLine.Mid(iFirst[iField], iLength[iField]) : CSG_String(pList->Get_Record(iField)->asString(0));
switch( pList->Get_Record(iField)->asInt(2) )
{
case 0:
pTable->Add_Field(Name, SG_DATATYPE_String);
break;
case 1:
pTable->Add_Field(Name, SG_DATATYPE_Short);
break;
case 2:
pTable->Add_Field(Name, SG_DATATYPE_Int);
break;
case 3:
pTable->Add_Field(Name, SG_DATATYPE_Float);
break;
default:
case 4:
pTable->Add_Field(Name, SG_DATATYPE_Double);
break;
}
}
}
break;
}
//-----------------------------------------------------
if( bHeader )
{
Stream.Read_Line(sLine);
}
//-----------------------------------------------------
int fLength = Stream.Length();
do
{
if( sLine.Length() == nChars )
{
CSG_Table_Record *pRecord = pTable->Add_Record();
for(iField=0; iField<nFields; iField++)
{
pRecord->Set_Value(iField, sLine.Mid(iFirst[iField], iLength[iField]));
}
}
}
while( Stream.Read_Line(sLine) && Set_Progress(Stream.Tell(), fLength) );
//-----------------------------------------------------
delete[](iFirst);
delete[](iLength);
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CTable_Text_Import_Numbers::On_Execute(void)
{
CSG_String sHead, sLine, Separator;
CSG_File Stream;
//-----------------------------------------------------
if( !Stream.Open(Parameters("FILENAME")->asString(), SG_FILE_R, false) )
{
Error_Set(_TL("file could not be opened"));
return( false );
}
if( Parameters("SKIP")->asInt() > 0 )
{
int i = Parameters("SKIP")->asInt();
while( i > 0 && Stream.Read_Line(sLine) ) {
i--;
}
}
if( !Stream.Read_Line(sHead) || sHead.Length() == 0 )
{
Error_Set(_TL("empty or corrupted file"));
return( false );
}
if( !Parameters("HEADLINE")->asBool() )
{
sLine = sHead;
}
else if( !Stream.Read_Line(sLine) || sLine.Length() == 0 )
{
Error_Set(_TL("empty or corrupted file"));
return( false );
}
//-----------------------------------------------------
switch( Parameters("SEPARATOR")->asInt() )
{
case 0:
Separator = "\t";
break;
case 1:
Separator = ";";
break;
case 2:
Separator = ",";
break;
case 3:
Separator = " ";
break;
default:
Separator = Parameters("SEP_OTHER")->asString();
break;
}
//-----------------------------------------------------
CSG_Table *pTable = Parameters("TABLE")->asTable();
pTable->Destroy();
pTable->Set_Name(SG_File_Get_Name(Parameters("FILENAME")->asString(), false));
sHead.Trim(true);
sHead.Replace(Separator, "\t");
while( sHead.Length() > 0 )
{
sHead.Trim();
if( Parameters("HEADLINE")->asBool() )
{
pTable->Add_Field(sHead.BeforeFirst('\t'), SG_DATATYPE_Double);
}
else
{
pTable->Add_Field(CSG_String::Format("FIELD%02d", 1 + pTable->Get_Field_Count()), SG_DATATYPE_Double);
}
sHead = sHead.AfterFirst('\t');
}
if( pTable->Get_Field_Count() <= 0 )
{
Error_Set(_TL("empty or corrupted file"));
return( false );
}
//-----------------------------------------------------
int fLength = Stream.Length();
bool bOkay = true;
do
{
sLine.Replace(Separator, "\t");
CSG_Table_Record *pRecord = pTable->Add_Record();
for(int i=0; bOkay && i<pTable->Get_Field_Count(); i++)
{
double Value;
sLine.Trim();
if( (bOkay = sLine.asDouble(Value)) == true )
{
pRecord->Set_Value(i, Value);
sLine = sLine.AfterFirst('\t');
}
else
{
pTable->Del_Record(pTable->Get_Count() - 1);
}
}
}
while( bOkay && Stream.Read_Line(sLine) && Set_Progress(Stream.Tell(), fLength) );
return( pTable->Get_Count() > 0 );
}