//---------------------------------------------------------
CSG_Shapes * SG_Create_Shapes(const CSG_Shapes &Shapes)
{
switch( Shapes.Get_ObjectType() )
{
case DATAOBJECT_TYPE_Shapes:
return( new CSG_Shapes(Shapes) );
case DATAOBJECT_TYPE_PointCloud:
return( SG_Create_PointCloud(*((CSG_PointCloud *)&Shapes)) );
default:
return( NULL );
}
}
//---------------------------------------------------------
CSG_Shapes * SG_Create_Shapes(CSG_Shapes *pTemplate)
{
if( pTemplate )
{
switch( pTemplate->Get_ObjectType() )
{
case DATAOBJECT_TYPE_Shapes:
return( new CSG_Shapes(pTemplate->Get_Type(), pTemplate->Get_Name(), pTemplate, pTemplate->Get_Vertex_Type()) );
case DATAOBJECT_TYPE_PointCloud:
return( SG_Create_PointCloud((CSG_PointCloud *)pTemplate) );
default:
break;
}
}
return( new CSG_Shapes() );
}
//---------------------------------------------------------
bool CPC_Transform::On_Execute(void)
{
bool bCopy;
double angleX, angleY, angleZ;
TSG_Point_Z P, Q, Move, Scale, Anchor;
CSG_PointCloud *pIn, *pOut;
double a11, a12, a13, a21, a22, a23, a31, a32, a33;
//-----------------------------------------------------
pIn = Parameters("IN") ->asPointCloud();
pOut = Parameters("OUT") ->asPointCloud();
Scale.x = Parameters("SCALEX") ->asDouble();
Scale.y = Parameters("SCALEY") ->asDouble();
Scale.z = Parameters("SCALEZ") ->asDouble();
Move.x = Parameters("DX") ->asDouble();
Move.y = Parameters("DY") ->asDouble();
Move.z = Parameters("DZ") ->asDouble();
Anchor.x = Parameters("ANCHORX") ->asDouble();
Anchor.y = Parameters("ANCHORY") ->asDouble();
Anchor.z = Parameters("ANCHORZ") ->asDouble();
angleX = Parameters("ANGLEX") ->asDouble() * -M_DEG_TO_RAD;
angleY = Parameters("ANGLEY") ->asDouble() * -M_DEG_TO_RAD;
angleZ = Parameters("ANGLEZ") ->asDouble() * -M_DEG_TO_RAD;
if( pIn == pOut )
{
bCopy = true;
pOut = SG_Create_PointCloud();
}
else
bCopy = false;
pOut->Create(pIn);
pOut->Set_Name(CSG_String::Format(SG_T("%s [%s]"), pIn->Get_Name(), _TL("Transformed")));
//-----------------------------------------------------
for (int iPoint=0; iPoint<pIn->Get_Point_Count(); iPoint++)
{
P = pIn->Get_Point(iPoint);
//anchor shift
P.x -= Anchor.x;
P.y -= Anchor.y;
P.z -= Anchor.z;
// create rotation matrix
a11 = cos(angleY) * cos(angleZ);
a12 = -cos(angleX) * sin(angleZ) + sin(angleX) * sin(angleY) * cos(angleZ);
a13 = sin(angleX) * sin(angleZ) + cos(angleX) * sin(angleY) * cos(angleZ);
a21 = cos(angleY) * sin(angleZ);
a22 = cos(angleX) * cos(angleZ) + sin(angleX) * sin(angleY) * sin(angleZ);
a23 = -sin(angleX) * cos(angleZ) + cos(angleX) * sin(angleY) * sin(angleZ);
a31 = -sin(angleY);
a32 = sin(angleX) * cos(angleY);
a33 = cos(angleX) * cos(angleY);
//transform
Q.x = (P.x * a11 + P.y * a12 + P.z * a13) * Scale.x;
Q.y = (P.x * a21 + P.y * a22 + P.z * a23) * Scale.y;
Q.z = (P.x * a31 + P.y * a32 + P.z * a33) * Scale.z;
//undo anchor shift and apply move
Q.x += Anchor.x + Move.x;
Q.y += Anchor.y + Move.y;
Q.z += Anchor.z + Move.z;
pOut->Add_Point(Q.x, Q.y, Q.z);
for (int j=0; j<pIn->Get_Attribute_Count(); j++)
{
switch (pIn->Get_Attribute_Type(j))
{
default: pOut->Set_Attribute(iPoint, j, pIn->Get_Attribute(iPoint, j)); break;
case SG_DATATYPE_Date:
case SG_DATATYPE_String: CSG_String sAttr; pIn->Get_Attribute(iPoint, j, sAttr); pOut->Set_Attribute(iPoint, j, sAttr); break;
}
}
}
//-----------------------------------------------------
if( bCopy )
{
pIn->Assign(pOut);
delete(pOut);
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CSTL_Import::On_Execute(void)
{
int Method;
DWORD iFacette, nFacettes;
TSTL_Point p[3];
CSG_String sFile, sHeader;
CSG_File Stream;
//-----------------------------------------------------
sFile = Parameters("FILE") ->asString();
Method = Parameters("METHOD") ->asInt();
r_sin_x = sin(Parameters("ROT_X")->asDouble() * M_DEG_TO_RAD);
r_sin_y = sin(Parameters("ROT_Y")->asDouble() * M_DEG_TO_RAD);
r_sin_z = sin(Parameters("ROT_Z")->asDouble() * M_DEG_TO_RAD);
r_cos_x = cos(Parameters("ROT_X")->asDouble() * M_DEG_TO_RAD);
r_cos_y = cos(Parameters("ROT_Y")->asDouble() * M_DEG_TO_RAD);
r_cos_z = cos(Parameters("ROT_Z")->asDouble() * M_DEG_TO_RAD);
//-----------------------------------------------------
if( !Stream.Open(sFile) )
{
return( false );
}
if( !Stream.Read(sHeader, 80) )
{
return( false );
}
Message_Add(sHeader);
if( !Stream.Read(&nFacettes, sizeof(nFacettes)) )
{
return( false );
}
Message_Add(CSG_String::Format(SG_T("%s: %d"), _TL("Number of Facettes"), nFacettes));
//-----------------------------------------------------
switch( Method )
{
//-----------------------------------------------------
case 0: { // Point Cloud
CSG_Rect Extent;
if( Get_Extent(Stream, Extent, nFacettes) )
{
CSG_PRQuadTree Points(Extent);
CSG_PointCloud *pPoints = SG_Create_PointCloud();
Parameters("POINTS")->Set_Value(pPoints);
pPoints->Set_Name(SG_File_Get_Name(sFile, false));
pPoints->Add_Field((const char *)NULL, SG_DATATYPE_Undefined);
for(iFacette=0; iFacette<nFacettes && !Stream.is_EOF() && Set_Progress(iFacette, nFacettes); iFacette++)
{
if( Read_Facette(Stream, p) )
{
for(int i=0; i<3; i++)
{
if( Points.Add_Point(p[i].x, p[i].y, p[i].z) )
{
pPoints->Add_Point(p[i].x, p[i].y, p[i].z);
}
}
}
}
}
break; }
//-----------------------------------------------------
case 1: { // Point Cloud (centered)
CSG_PointCloud *pPoints = SG_Create_PointCloud();
Parameters("POINTS")->Set_Value(pPoints);
pPoints->Set_Name(SG_File_Get_Name(sFile, false));
pPoints->Add_Field((const char *)NULL, SG_DATATYPE_Undefined);
for(iFacette=0; iFacette<nFacettes && !Stream.is_EOF() && Set_Progress(iFacette, nFacettes); iFacette++)
{
if( Read_Facette(Stream, p) )
{
pPoints->Add_Point(
(p[0].x + p[1].x + p[2].x) / 3.0,
(p[0].y + p[1].y + p[2].y) / 3.0,
(p[0].z + p[1].z + p[2].z) / 3.0
);
}
}
break; }
//-----------------------------------------------------
case 2: { // Points
CSG_Shapes *pPoints = SG_Create_Shapes(SHAPE_TYPE_Point, SG_File_Get_Name(sFile, false));
pPoints->Add_Field(SG_T("Z"), SG_DATATYPE_Float);
Parameters("SHAPES")->Set_Value(pPoints);
for(iFacette=0; iFacette<nFacettes && !Stream.is_EOF() && Set_Progress(iFacette, nFacettes); iFacette++)
{
if( Read_Facette(Stream, p) )
{
CSG_Shape *pPoint = pPoints->Add_Shape();
pPoint->Add_Point(
(p[0].x + p[1].x + p[2].x) / 3.0,
(p[0].y + p[1].y + p[2].y) / 3.0
);
pPoint->Set_Value(0,
(p[0].z + p[1].z + p[2].z) / 3.0
);
}
}
break; }
//-----------------------------------------------------
case 3: { // Raster
CSG_Rect Extent;
if( Get_Extent(Stream, Extent, nFacettes) )
{
int nx, ny;
double d;
nx = Parameters("GRID_RES")->asInt();
d = Extent.Get_XRange() / nx;
ny = 1 + (int)(Extent.Get_YRange() / d);
m_pGrid = SG_Create_Grid(SG_DATATYPE_Float, nx, ny, d, Extent.Get_XMin(), Extent.Get_YMin());
m_pGrid->Set_Name(SG_File_Get_Name(sFile, false));
m_pGrid->Set_NoData_Value(-99999);
m_pGrid->Assign_NoData();
Parameters("GRID")->Set_Value(m_pGrid);
//---------------------------------------------
for(iFacette=0; iFacette<nFacettes && !Stream.is_EOF() && Set_Progress(iFacette, nFacettes); iFacette++)
{
if( Read_Facette(Stream, p) )
{
TSG_Point_Z Point[3];
for(int i=0; i<3; i++)
{
Point[i].x = (p[i].x - m_pGrid->Get_XMin()) / m_pGrid->Get_Cellsize();
Point[i].y = (p[i].y - m_pGrid->Get_YMin()) / m_pGrid->Get_Cellsize();
Point[i].z = p[i].z;
}
Set_Triangle(Point);
}
}
}
break; }
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CPointCloud_From_Text_File::On_Execute(void)
{
CSG_String fileName;
int iField, iType;
TSG_Data_Type Type;
CSG_String Name, Types, s;
CSG_PointCloud *pPoints;
CSG_Parameters P;
CSG_Parameter *pNode;
int xField, yField, zField, nAttribs, max_iField;
bool bSkipHeader;
char fieldSep;
std::vector<int> vCol;
std::ifstream tabStream;
std::string tabLine;
double lines;
long cntPt, cntInvalid;
double x, y, z, value;
//-----------------------------------------------------
fileName = Parameters("FILE") ->asString();
xField = Parameters("XFIELD") ->asInt() - 1;
yField = Parameters("YFIELD") ->asInt() - 1;
zField = Parameters("ZFIELD") ->asInt() - 1;
nAttribs = Parameters("ATTRIBS") ->asInt();
bSkipHeader = Parameters("SKIP_HEADER") ->asBool();
switch (Parameters("FIELDSEP")->asInt())
{
default:
case 0: fieldSep = '\t'; break;
case 1: fieldSep = ' '; break;
case 2: fieldSep = ','; break;
}
Types.Printf(SG_T("%s|%s|%s|%s|%s|"),
_TL("1 byte integer"),
_TL("2 byte integer"),
_TL("4 byte integer"),
_TL("4 byte floating point"),
_TL("8 byte floating point")
);
P.Set_Name(_TL("Attribute Field Properties"));
for(iField=1; iField<=nAttribs; iField++)
{
s.Printf(SG_T("NODE_%03d") , iField);
pNode = P.Add_Node(NULL, s, CSG_String::Format(SG_T("%d. %s"), iField, _TL("Field")), _TL(""));
s.Printf(SG_T("FIELD_%03d"), iField);
P.Add_String(pNode, s, _TL("Name"), _TL(""), s);
s.Printf(SG_T("COLUMN_%03d"), iField);
P.Add_Value(pNode, s, _TL("Attribute is Column ..."), _TL(""), PARAMETER_TYPE_Int, iField+3, 1, true);
s.Printf(SG_T("TYPE_%03d") , iField);
P.Add_Choice(pNode, s, _TL("Type"), _TL(""), Types, 3);
}
//-----------------------------------------------------
if( nAttribs > 0 )
{
if( Dlg_Parameters(&P, _TL("Field Properties")) )
{
pPoints = SG_Create_PointCloud();
pPoints->Set_Name(SG_File_Get_Name(fileName, false));
Parameters("POINTS")->Set_Value(pPoints);
for(iField=0; iField<nAttribs; iField++)
{
Name = P(CSG_String::Format(SG_T("FIELD_%03d" ), iField + 1).c_str())->asString();
iType = P(CSG_String::Format(SG_T("TYPE_%03d" ), iField + 1).c_str())->asInt();
vCol.push_back(P(CSG_String::Format(SG_T("COLUMN_%03d"), iField + 1).c_str())->asInt() - 1);
switch( iType )
{
default:
case 0: Type = SG_DATATYPE_Char; break;
case 1: Type = SG_DATATYPE_Short; break;
case 2: Type = SG_DATATYPE_Int; break;
case 3: Type = SG_DATATYPE_Float; break;
case 4: Type = SG_DATATYPE_Double; break;
}
pPoints->Add_Field(Name, Type);
}
}
else
return( false );
}
else
{
pPoints = SG_Create_PointCloud();
pPoints->Create();
pPoints->Set_Name(SG_File_Get_Name(fileName, false));
Parameters("POINTS")->Set_Value(pPoints);
}
max_iField = M_GET_MAX(xField, yField);
max_iField = M_GET_MAX(max_iField, zField);
for( unsigned int i=0; i<vCol.size(); i++ )
{
if( max_iField < vCol.at(i) )
max_iField = vCol.at(i);
}
// open input stream
//---------------------------------------------------------
tabStream.open(fileName.b_str(), std::ifstream::in);
if( !tabStream )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to open input file!")));
return (false);
}
tabStream.seekg(0, std::ios::end); // get length of file
lines = (double)tabStream.tellg();
tabStream.seekg(0, std::ios::beg);
std::getline(tabStream, tabLine); // as a workaround we assume the number of lines from the length of the first line
lines = lines / (double)tabStream.tellg();
if( !bSkipHeader )
{
tabStream.clear(); // let's forget we may have reached the EOF
tabStream.seekg(0, std::ios::beg); // and rewind to the beginning
}
// import
//---------------------------------------------------------
cntPt = cntInvalid = 0;
SG_UI_Process_Set_Text(CSG_String::Format(_TL("Importing data ...")));
while( std::getline(tabStream, tabLine) )
{
std::istringstream stream(tabLine);
std::vector<std::string> tabCols;
std::string tabEntry;
if( cntPt%10000 == 0 )
SG_UI_Process_Set_Progress((double)cntPt, lines);
cntPt++;
while( std::getline(stream, tabEntry, fieldSep) ) // read every column in this line and fill vector
{
if (tabEntry.length() == 0)
continue;
tabCols.push_back(tabEntry);
}
if ((int)tabCols.size() < max_iField - 1 )
{
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: Skipping misformatted line (%.0f)!"), cntPt), true);
cntInvalid++;
continue;
}
x = strtod(tabCols[xField].c_str(), NULL);
y = strtod(tabCols[yField].c_str(), NULL);
z = strtod(tabCols[zField].c_str(), NULL);
pPoints->Add_Point(x, y, z);
for( int i=0; i<nAttribs; i++ )
{
value = strtod(tabCols.at(vCol.at(i)).c_str(), NULL);
pPoints->Set_Attribute(i, value);
}
}
// finalize
//---------------------------------------------------------
tabStream.close();
CSG_Parameters sParms;
DataObject_Get_Parameters(pPoints, sParms);
if (sParms("COLORS_ATTRIB") && sParms("COLORS_TYPE") && sParms("METRIC_COLORS")
&& sParms("METRIC_ZRANGE") && sParms("COLORS_AGGREGATE"))
{
sParms("COLORS_AGGREGATE")->Set_Value(3); // highest z
sParms("COLORS_TYPE")->Set_Value(2); // graduated color
sParms("METRIC_COLORS")->asColors()->Set_Count(255); // number of colors
sParms("COLORS_ATTRIB")->Set_Value(2); // z attrib
sParms("METRIC_ZRANGE")->asRange()->Set_Range(pPoints->Get_Minimum(2),pPoints->Get_Maximum(2));
DataObject_Set_Parameters(pPoints, sParms);
DataObject_Update(pPoints);
}
if (cntInvalid > 0)
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: Skipped %d invalid points!"), cntInvalid), true);
SG_UI_Msg_Add(CSG_String::Format(_TL("%d points sucessfully imported."), (cntPt-cntInvalid)), true);
return( true );
}
//---------------------------------------------------------
bool CPointCloud_From_Text_File::On_Execute(void)
{
CSG_String fileName;
int iField, iType;
CSG_String Name, Types, s;
CSG_PointCloud *pPoints;
CSG_Parameters P;
CSG_Parameter *pNode;
int xField, yField, zField, nAttribs;
bool bSkipHeader;
char fieldSep;
std::vector<int> vCol;
std::ifstream tabStream;
std::string tabLine;
double lines;
long cntPt, cntInvalid;
double x, y, z;
//-----------------------------------------------------
fileName = Parameters("FILE") ->asString();
xField = Parameters("XFIELD") ->asInt() - 1;
yField = Parameters("YFIELD") ->asInt() - 1;
zField = Parameters("ZFIELD") ->asInt() - 1;
bSkipHeader = Parameters("SKIP_HEADER") ->asBool();
switch (Parameters("FIELDSEP")->asInt())
{
default:
case 0: fieldSep = '\t'; break;
case 1: fieldSep = ' '; break;
case 2: fieldSep = ','; break;
}
pPoints = SG_Create_PointCloud();
pPoints->Create();
pPoints->Set_Name(SG_File_Get_Name(fileName, false));
Parameters("POINTS")->Set_Value(pPoints);
DataObject_Add(pPoints);
//-----------------------------------------------------
if (SG_UI_Get_Window_Main())
{
nAttribs = Parameters("ATTRIBS") ->asInt();
Types.Printf(SG_T("%s|%s|%s|%s|%s|"),
_TL("1 byte integer"),
_TL("2 byte integer"),
_TL("4 byte integer"),
_TL("4 byte floating point"),
_TL("8 byte floating point")
);
P.Set_Name(_TL("Attribute Field Properties"));
for(iField=1; iField<=nAttribs; iField++)
{
s.Printf(SG_T("NODE_%03d") , iField);
pNode = P.Add_Node(NULL, s, CSG_String::Format(SG_T("%d. %s"), iField, _TL("Field")), _TL(""));
s.Printf(SG_T("FIELD_%03d"), iField);
P.Add_String(pNode, s, _TL("Name"), _TL(""), s);
s.Printf(SG_T("COLUMN_%03d"), iField);
P.Add_Value(pNode, s, _TL("Attribute is Column ..."), _TL(""), PARAMETER_TYPE_Int, iField+3, 1, true);
s.Printf(SG_T("TYPE_%03d") , iField);
P.Add_Choice(pNode, s, _TL("Type"), _TL(""), Types, 3);
}
//-----------------------------------------------------
if( nAttribs > 0 )
{
if( Dlg_Parameters(&P, _TL("Field Properties")) )
{
for(iField=0; iField<nAttribs; iField++)
{
Name = P(CSG_String::Format(SG_T("FIELD_%03d" ), iField + 1).c_str())->asString();
iType = P(CSG_String::Format(SG_T("TYPE_%03d" ), iField + 1).c_str())->asInt();
vCol.push_back(P(CSG_String::Format(SG_T("COLUMN_%03d"), iField + 1).c_str())->asInt() - 1);
pPoints->Add_Field(Name, Get_Data_Type(iType));
}
}
else
return( false );
}
}
else // CMD
{
CSG_String sFields, sNames, sTypes;
CSG_String token;
int iValue;
std::vector<int> vTypes;
sFields = Parameters("FIELDS")->asString();
sNames = Parameters("FIELDNAMES")->asString();
sTypes = Parameters("FIELDTYPES")->asString();
CSG_String_Tokenizer tkz_fields(sFields, ";", SG_TOKEN_STRTOK);
while( tkz_fields.Has_More_Tokens() )
{
token = tkz_fields.Get_Next_Token();
if( token.Length() == 0 )
break;
if( !token.asInt(iValue) )
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: can't convert to number"));
return( false );
}
iValue -= 1;
if( iValue < 1)
{
SG_UI_Msg_Add_Error(_TL("Error parsing attribute fields: field index out of range"));
return( false );
}
else
vCol.push_back(iValue);
}
CSG_String_Tokenizer tkz_datatypes(sTypes, ";", SG_TOKEN_STRTOK);
while( tkz_datatypes.Has_More_Tokens() )
{
token = tkz_datatypes.Get_Next_Token();
if( token.Length() == 0 )
break;
if( !token.asInt(iValue) )
{
SG_UI_Msg_Add_Error(_TL("Error parsing field type: can't convert to number"));
return( false );
}
vTypes.push_back(iValue);
}
CSG_String_Tokenizer tkz_datanames(sNames, ";", SG_TOKEN_STRTOK);
int iter = 0;
while( tkz_datanames.Has_More_Tokens() )
{
token = tkz_datanames.Get_Next_Token();
if( token.Length() == 0 )
break;
pPoints->Add_Field(token, Get_Data_Type(vTypes.at(iter)));
iter++;
}
if( vCol.size() != vTypes.size() || (int)vCol.size() != iter )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Number of arguments for attribute fields (%d), names (%d) and types (%d) do not match!"), vCol.size(), iter, vTypes.size()));
return( false );
}
}
// open input stream
//---------------------------------------------------------
tabStream.open(fileName.b_str(), std::ifstream::in);
if( !tabStream )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to open input file!")));
return (false);
}
tabStream.seekg(0, std::ios::end); // get length of file
lines = (double)tabStream.tellg();
tabStream.seekg(0, std::ios::beg);
std::getline(tabStream, tabLine); // as a workaround we assume the number of lines from the length of the first line
lines = lines / (double)tabStream.tellg();
if( !bSkipHeader )
{
tabStream.clear(); // let's forget we may have reached the EOF
tabStream.seekg(0, std::ios::beg); // and rewind to the beginning
}
// import
//---------------------------------------------------------
cntPt = cntInvalid = 0;
SG_UI_Process_Set_Text(CSG_String::Format(_TL("Importing data ...")));
while( std::getline(tabStream, tabLine) )
{
std::istringstream stream(tabLine);
std::vector<std::string> tabCols;
std::string tabEntry;
if( cntPt%10000 == 0 )
{
SG_UI_Process_Set_Progress((double)cntPt, lines);
}
cntPt++;
while( std::getline(stream, tabEntry, fieldSep) ) // read every column in this line and fill vector
{
if (tabEntry.length() == 0)
continue;
tabCols.push_back(tabEntry);
}
if ((int)tabCols.size() < (vCol.size() + 3) )
{
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: Skipping misformatted line: %d!"), cntPt), true);
cntInvalid++;
continue;
}
//parse line tokens
std::vector<double> fieldValues;
fieldValues.resize(vCol.size());
x = strtod(tabCols[xField].c_str(), NULL);
y = strtod(tabCols[yField].c_str(), NULL);
z = strtod(tabCols[zField].c_str(), NULL);
for( int i=0; i<(int)vCol.size(); i++ )
{
fieldValues[i] = strtod(tabCols.at(vCol.at(i)).c_str(), NULL);
}
pPoints->Add_Point(x, y, z);
for( int i=0; i<(int)vCol.size(); i++ )
{
pPoints->Set_Attribute(i, fieldValues[i]);
}
}
// finalize
//---------------------------------------------------------
tabStream.close();
CSG_Parameters sParms;
DataObject_Get_Parameters(pPoints, sParms);
if (sParms("METRIC_ATTRIB") && sParms("COLORS_TYPE") && sParms("METRIC_COLORS")
&& sParms("METRIC_ZRANGE") && sParms("DISPLAY_VALUE_AGGREGATE"))
{
sParms("DISPLAY_VALUE_AGGREGATE")->Set_Value(3); // highest z
sParms("COLORS_TYPE")->Set_Value(2); // graduated color
sParms("METRIC_COLORS")->asColors()->Set_Count(255); // number of colors
sParms("METRIC_ATTRIB")->Set_Value(2); // z attrib
sParms("METRIC_ZRANGE")->asRange()->Set_Range(pPoints->Get_Minimum(2),pPoints->Get_Maximum(2));
DataObject_Set_Parameters(pPoints, sParms);
DataObject_Update(pPoints);
}
if (cntInvalid > 0)
SG_UI_Msg_Add(CSG_String::Format(SG_T("%s: %d %s"), _TL("WARNING"), cntInvalid, _TL("invalid points have been skipped")), true);
SG_UI_Msg_Add(CSG_String::Format(SG_T("%d %s"), (cntPt-cntInvalid), _TL("points have been imported with success")), true);
return( true );
}
//---------------------------------------------------------
bool CLAS_Import::On_Execute(void)
{
CSG_Parameter_PointCloud_List *pPointsList;
bool bValidity;
CSG_Strings Files;
int RGBrange;
int cntInvalid = 0;
bValidity = Parameters("VALID")->asBool();
RGBrange = Parameters("RGB_RANGE")->asInt();
//-----------------------------------------------------
if( !Parameters("FILES")->asFilePath()->Get_FilePaths(Files) )
{
return( false );
}
//-----------------------------------------------------
pPointsList = Parameters("POINTS")->asPointCloudList();
pPointsList ->Del_Items();
for(int i=0; i<Files.Get_Count(); i++)
{
SG_UI_Msg_Add(CSG_String::Format(_TL("Parsing %s ... "), SG_File_Get_Name(Files[i], true).c_str()), true);
std::ifstream ifs;
ifs.open(Files[i].b_str(), std::ios::in | std::ios::binary);
if( !ifs )
{
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unable to open LAS file!")));
continue;
}
//-----------------------------------------------------
// Check if LAS version is supported
liblas::LASReader *pReader;
try {
pReader = new liblas::LASReader(ifs);
}
catch(std::exception &e) {
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("LAS header exception: %s"), e.what()));
ifs.close();
return( false );
}
catch(...) {
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unknown LAS header exception!")));
ifs.close();
return( false );
}
delete (pReader);
ifs.clear();
//-----------------------------------------------------
liblas::LASReader reader(ifs);
liblas::LASHeader const& header = reader.GetHeader();
//-----------------------------------------------------
int nFields, iField[VAR_Count];
CSG_PointCloud *pPoints = SG_Create_PointCloud();
pPoints->Set_Name(SG_File_Get_Name(Files[i], false));
nFields = 3;
ADD_FIELD("T", VAR_T, _TL("gps-time") , SG_DATATYPE_Double); // SG_DATATYPE_Long
ADD_FIELD("i", VAR_i, _TL("intensity") , SG_DATATYPE_Float); // SG_DATATYPE_Word
ADD_FIELD("a", VAR_a, _TL("scan angle") , SG_DATATYPE_Float); // SG_DATATYPE_Byte
ADD_FIELD("r", VAR_r, _TL("number of the return") , SG_DATATYPE_Int);
ADD_FIELD("c", VAR_c, _TL("classification") , SG_DATATYPE_Int); // SG_DATATYPE_Byte
ADD_FIELD("u", VAR_u, _TL("user data") , SG_DATATYPE_Double); // SG_DATATYPE_Byte
ADD_FIELD("n", VAR_n, _TL("number of returns of given pulse") , SG_DATATYPE_Int);
ADD_FIELD("R", VAR_R, _TL("red channel color") , SG_DATATYPE_Int); // SG_DATATYPE_Word
ADD_FIELD("G", VAR_G, _TL("green channel color") , SG_DATATYPE_Int);
ADD_FIELD("B", VAR_B, _TL("blue channel color") , SG_DATATYPE_Int);
ADD_FIELD("e", VAR_e, _TL("edge of flight line flag") , SG_DATATYPE_Char);
ADD_FIELD("d", VAR_d, _TL("direction of scan flag") , SG_DATATYPE_Char);
ADD_FIELD("p", VAR_p, _TL("point source ID") , SG_DATATYPE_Int); // SG_DATATYPE_Word
ADD_FIELD("C", VAR_C, _TL("rgb color") , SG_DATATYPE_Int);
//-----------------------------------------------------
int iPoint = 0;
try {
while( reader.ReadNextPoint() )
{
if (iPoint % 100000)
SG_UI_Process_Set_Progress(iPoint, header.GetPointRecordsCount());
liblas::LASPoint const& point = reader.GetPoint();
if( bValidity )
{
if( !point.IsValid() )
{
cntInvalid++;
continue;
}
}
pPoints->Add_Point(point.GetX(), point.GetY(), point.GetZ());
if( iField[VAR_T] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_T], point.GetTime());
if( iField[VAR_i] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_i], point.GetIntensity());
if( iField[VAR_a] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_a], point.GetScanAngleRank());
if( iField[VAR_r] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_r], point.GetReturnNumber());
if( iField[VAR_c] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_c], point.GetClassification());
if( iField[VAR_u] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_u], point.GetUserData());
if( iField[VAR_n] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_n], point.GetNumberOfReturns());
if( iField[VAR_R] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_R], point.GetColor().GetRed());
if( iField[VAR_G] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_G], point.GetColor().GetGreen());
if( iField[VAR_B] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_B], point.GetColor().GetBlue());
if( iField[VAR_e] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_e], point.GetFlightLineEdge());
if( iField[VAR_d] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_d], point.GetScanDirection());
if( iField[VAR_p] > 0 ) pPoints->Set_Value(iPoint, iField[VAR_p], point.GetPointSourceID());
if( iField[VAR_C] > 0 )
{
double r, g, b;
r = point.GetColor().GetRed();
g = point.GetColor().GetGreen();
b = point.GetColor().GetBlue();
if (RGBrange == 0) // 16 bit
{
r = r / 65535 * 255;
g = g / 65535 * 255;
b = b / 65535 * 255;
}
pPoints->Set_Value(iPoint, iField[VAR_C], SG_GET_RGB(r, g, b));
}
iPoint++;
}
}
catch(std::exception &e) {
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("LAS reader exception: %s"), e.what()));
ifs.close();
return( false );
}
catch(...) {
SG_UI_Msg_Add_Error(CSG_String::Format(_TL("Unknown LAS reader exception!")));
ifs.close();
return( false );
}
ifs.close();
pPointsList->Add_Item(pPoints);
DataObject_Add(pPoints);
//-----------------------------------------------------
CSG_Parameters sParms;
DataObject_Get_Parameters(pPoints, sParms);
if (sParms("METRIC_ATTRIB") && sParms("COLORS_TYPE") && sParms("METRIC_COLORS")
&& sParms("METRIC_ZRANGE") && sParms("DISPLAY_VALUE_AGGREGATE"))
{
sParms("DISPLAY_VALUE_AGGREGATE")->Set_Value(3); // highest z
sParms("COLORS_TYPE")->Set_Value(2); // graduated color
sParms("METRIC_COLORS")->asColors()->Set_Count(255); // number of colors
sParms("METRIC_ATTRIB")->Set_Value(2); // z attrib
sParms("METRIC_ZRANGE")->asRange()->Set_Range(pPoints->Get_Minimum(2),pPoints->Get_Maximum(2));
}
DataObject_Set_Parameters(pPoints, sParms);
SG_UI_Msg_Add(_TL("okay"), false);
}
//-----------------------------------------------------
if( bValidity && cntInvalid > 0 )
SG_UI_Msg_Add(CSG_String::Format(_TL("WARNING: %d invalid points skipped!"), cntInvalid), true);
return( true );
}
//---------------------------------------------------------
bool CPointCloud_From_Text_File::On_Execute(void)
{
//-----------------------------------------------------
CSG_File Stream;
if( !Stream.Open(Parameters("FILE")->asString(), SG_FILE_R, false) )
{
Error_Set(_TL("Unable to open input file!"));
return( false );
}
//-----------------------------------------------------
int xField = Parameters("XFIELD")->asInt() - 1;
int yField = Parameters("YFIELD")->asInt() - 1;
int zField = Parameters("ZFIELD")->asInt() - 1;
char Separator;
switch( Parameters("SEPARATOR")->asInt() )
{
default: Separator = '\t'; break;
case 1: Separator = ' '; break;
case 2: Separator = ','; break;
}
//-----------------------------------------------------
CSG_String sLine;
CSG_Strings Values;
if( !Stream.Read_Line(sLine) )
{
Error_Set(_TL("Empty file!"));
return( false );
}
if( Parameters("SKIP_HEADER")->asBool() ) // header contains field names
{
CSG_String_Tokenizer tokValues(sLine, Separator); // read each field name for later use
while( tokValues.Has_More_Tokens() )
{
Values += tokValues.Get_Next_Token();
}
}
else
{
Stream.Seek_Start();
}
//-----------------------------------------------------
CSG_PointCloud *pPoints = SG_Create_PointCloud();
pPoints->Set_Name(SG_File_Get_Name(Parameters("FILE")->asString(), false));
Parameters("POINTS")->Set_Value(pPoints);
CSG_Array_Int Fields;
//-----------------------------------------------------
if( SG_UI_Get_Window_Main() )
{
CSG_Parameters &Fields = *Parameters("FIELDSPECS")->asParameters();
int nFields = Fields.Get_Count() / 2;
CSG_String Names, Types;
for(int iField=0; iField<nFields; iField++)
{
Names += CSG_String::Format("%s;", Fields(CSG_String::Format("NAME%03d", iField))->asString());
Types += CSG_String::Format("%d;", Fields(CSG_String::Format("TYPE%03d", iField))->asInt ());
}
Parameters("FIELDNAMES")->Set_Value(Names);
Parameters("FIELDTYPES")->Set_Value(Types);
}
{
TSG_Data_Type Type = SG_DATATYPE_Float; // default
CSG_String_Tokenizer tokFields(Parameters("FIELDS" )->asString(), ";");
CSG_String_Tokenizer tokTypes (Parameters("FIELDTYPES")->asString(), ";");
CSG_String_Tokenizer tokNames (Parameters("FIELDNAMES")->asString(), ";");
while( tokFields.Has_More_Tokens() )
{
int iField;
if( !tokFields.Get_Next_Token().asInt(iField) || iField < 1 )
{
Error_Set(_TL("Error parsing attribute field index"));
return( false );
}
Fields += iField - 1;
CSG_String Name;
if( tokNames.Has_More_Tokens() )
{
Name = tokNames.Get_Next_Token(); Name.Trim(true); Name.Trim(false);
}
if( Name.is_Empty() )
{
if( iField - 1 < Values.Get_Count() )
{
Name = Values[iField - 1];
}
else
{
Name.Printf("FIELD%02d", iField);
}
}
if( tokTypes.Has_More_Tokens() )
{
Get_Data_Type(Type, tokTypes.Get_Next_Token());
}
pPoints->Add_Field(Name, Type);
}
}
//-----------------------------------------------------
Process_Set_Text(_TL("Importing data ..."));
int nLines = 0;
sLong Length = Stream.Length();
while( Stream.Read_Line(sLine) )
{
nLines++;
if( pPoints->Get_Count() % 10000 == 0 && !Set_Progress((double)Stream.Tell(), (double)Length) )
{
return( true ); // user break
}
//-------------------------------------------------
CSG_String_Tokenizer tokValues(sLine, Separator);
Values.Clear();
while( tokValues.Has_More_Tokens() ) // read every column in this line and fill vector
{
Values += tokValues.Get_Next_Token();
}
//-------------------------------------------------
double x, y, z;
if( xField >= Values.Get_Count() || !Values[xField].asDouble(x)
|| yField >= Values.Get_Count() || !Values[yField].asDouble(y)
|| zField >= Values.Get_Count() || !Values[zField].asDouble(z) )
{
Message_Fmt("\n%s: %s [%d]", _TL("Warning"), _TL("Skipping misformatted line"), nLines);
continue;
}
pPoints->Add_Point(x, y, z);
//-------------------------------------------------
for(int iAttribute=0; iAttribute<pPoints->Get_Attribute_Count(); iAttribute++)
{
if( Fields[iAttribute] >= Values.Get_Count() )
{
pPoints->Set_NoData(3 + iAttribute);
}
else switch( pPoints->Get_Attribute_Type(iAttribute) )
{
case SG_DATATYPE_String:
pPoints->Set_Attribute(iAttribute, Values[Fields[iAttribute]]);
break;
default:
{
double Value;
if( Values[Fields[iAttribute]].asDouble(Value) )
{
pPoints->Set_Attribute(iAttribute, Value);
}
else
{
pPoints->Set_NoData(3 + iAttribute);
}
}
break;
}
}
}
//-----------------------------------------------------
DataObject_Set_Parameter(pPoints, "DISPLAY_VALUE_AGGREGATE", 3); // highest z
DataObject_Set_Parameter(pPoints, "COLORS_TYPE" , 3); // graduated colors
DataObject_Set_Parameter(pPoints, "METRIC_ATTRIB" , 2); // z attrib
DataObject_Set_Parameter(pPoints, "METRIC_ZRANGE", pPoints->Get_Minimum(2), pPoints->Get_Maximum(2));
DataObject_Update(pPoints);
//-----------------------------------------------------
if( nLines > pPoints->Get_Count() )
{
Message_Add(" ", true);
Message_Fmt("%s: %d %s", _TL("Warning"), nLines - pPoints->Get_Count(), _TL("invalid points have been skipped"));
}
Message_Add(" ", true);
Message_Fmt("%d %s", pPoints->Get_Count(), _TL("points have been imported with success"));
return( true );
}
//---------------------------------------------------------
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 );
}
