//---------------------------------------------------------
bool CSG_Table::_Save_Text(const CSG_String &File_Name, bool bHeadline, const SG_Char *Separator)
{
int iField, iRecord;
CSG_File Stream;
if( Get_Field_Count() > 0 )
{
if( Stream.Open(File_Name, SG_FILE_W, false) )
{
for(iField=0; iField<Get_Field_Count(); iField++)
{
Stream.Printf(SG_T("%s%s"), Get_Field_Name(iField), iField < Get_Field_Count() - 1 ? Separator : SG_T("\n"));
}
for(iRecord=0; iRecord<Get_Record_Count() && SG_UI_Process_Set_Progress(iRecord, Get_Record_Count()); iRecord++)
{
for(iField=0; iField<Get_Field_Count(); iField++)
{
Stream.Printf(SG_T("%s"), Get_Record(iRecord)->asString(iField));
Stream.Printf(SG_T("%s"), iField < Get_Field_Count() - 1 ? Separator : SG_T("\n"));
}
}
SG_UI_Process_Set_Ready();
return( true );
}
}
return( false );
}
//---------------------------------------------------------
bool CSurfer_BLN_Export::On_Execute(void)
{
//-----------------------------------------------------
CSG_File Stream;
if( !Stream.Open(Parameters("FILE")->asString(), SG_FILE_W) )
{
return( false );
}
CSG_Shapes *pShapes = Parameters("SHAPES")->asShapes();
if( !pShapes->is_Valid() || pShapes->Get_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
int iName = Parameters("BNAME" )->asBool() ? Parameters("NAME")->asInt() : -1;
int iDesc = Parameters("BDESC" )->asBool() ? Parameters("DESC")->asInt() : -1;
int iZVal = Parameters("BZVAL" )->asBool() ? Parameters("ZVAL")->asInt() : -1;
int Flag = 1;
//-----------------------------------------------------
for(int iShape=0; iShape<pShapes->Get_Count() && Set_Progress(iShape, pShapes->Get_Count()); iShape++)
{
CSG_Shape *pShape = pShapes->Get_Shape(iShape);
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
Stream.Printf(SG_T("%d,%d"), pShape->Get_Point_Count(iPart), Flag);
if( iName >= 0 ) { Stream.Printf(SG_T(",\"%s\""), pShape->asString(iName)); }
if( iDesc >= 0 ) { Stream.Printf(SG_T(",\"%s\""), pShape->asString(iDesc)); }
Stream.Printf(SG_T("\n"));
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
TSG_Point p = pShape->Get_Point(iPoint, iPart);
if( iZVal >= 0 )
{
Stream.Printf(SG_T("%f,%f,%f\n"), p.x, p.y, pShape->asDouble(iZVal));
}
else
{
Stream.Printf(SG_T("%f,%f\n" ), p.x, p.y);
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CSG_Table::_Save_Text(const CSG_String &File_Name, bool bHeadline, const SG_Char *Separator)
{
int iField, iRecord;
CSG_File Stream;
if( Get_Field_Count() > 0 )
{
if( Stream.Open(File_Name, SG_FILE_W, false) )
{
for(iField=0; iField<Get_Field_Count(); iField++)
{
Stream.Printf(SG_T("%s%s"), Get_Field_Name(iField), iField < Get_Field_Count() - 1 ? Separator : SG_T("\n"));
}
for(iRecord=0; iRecord<Get_Record_Count() && SG_UI_Process_Set_Progress(iRecord, Get_Record_Count()); iRecord++)
{
for(iField=0; iField<Get_Field_Count(); iField++)
{
if( !Get_Record(iRecord)->is_NoData(iField) )
{
switch( Get_Field_Type(iField) )
{
case SG_DATATYPE_String:
case SG_DATATYPE_Date:
Stream.Printf(SG_T("\"%s\""), Get_Record(iRecord)->asString(iField));
break;
default:
Stream.Printf(SG_T("%s") , Get_Record(iRecord)->asString(iField));
break;
}
}
Stream.Printf(SG_T("%s"), iField < Get_Field_Count() - 1 ? Separator : SG_T("\n"));
}
}
SG_UI_Process_Set_Ready();
return( true );
}
}
return( false );
}
//---------------------------------------------------------
bool CSG_Grid::_Save_ASCII(CSG_File &Stream, int xA, int yA, int xN, int yN, bool bFlip)
{
int x, y, ix, iy, dy;
if( Stream.is_Open() && is_Valid() )
{
Set_File_Type(GRID_FILE_FORMAT_ASCII);
if( bFlip )
{
y = yA + yN - 1;
dy = -1;
}
else
{
y = yA;
dy = 1;
}
//-------------------------------------------------
for(iy=0; iy<yN && SG_UI_Process_Set_Progress(iy, yN); iy++, y+=dy)
{
for(ix=0, x=xA; ix<xN; ix++, x++)
{
Stream.Printf(SG_T("%lf "), asDouble(x, y));
}
Stream.Printf(SG_T("\n"));
}
SG_UI_Process_Set_Ready();
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CXYZ_Export::On_Execute(void)
{
bool bExNoData;
int x, y, i;
TSG_Point p;
CSG_File Stream;
CSG_String FileName;
CSG_Parameter_Grid_List *pGrids;
pGrids = Parameters("GRIDS") ->asGridList();
FileName = Parameters("FILENAME")->asString();
bExNoData = Parameters("EX_NODATA")->asBool();
if( pGrids->Get_Count() > 0 && Stream.Open(FileName, SG_FILE_W, false) )
{
if( Parameters("CAPTION")->asBool() )
{
Stream.Printf(SG_T("\"X\"\t\"Y\""));
for(i=0; i<pGrids->Get_Count(); i++)
{
Stream.Printf(SG_T("\t\"%s\""), pGrids->asGrid(i)->Get_Name());
}
Stream.Printf(SG_T("\n"));
}
for(y=0, p.y=Get_YMin(); y<Get_NY() && Set_Progress(y); y++, p.y+=Get_Cellsize())
{
for(x=0, p.x=Get_XMin(); x<Get_NX(); x++, p.x+=Get_Cellsize())
{
if( !bExNoData || (bExNoData && !pGrids->asGrid(0)->is_NoData(x, y)) )
{
Stream.Printf(SG_T("%f\t%f"), p.x, p.y);
for(i=0; i<pGrids->Get_Count(); i++)
{
Stream.Printf(SG_T("\t%f"), pGrids->asGrid(i)->asDouble(x, y));
}
Stream.Printf(SG_T("\n"));
}
}
}
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CSTL_Export::On_Execute(void)
{
bool bBinary;
int zField;
float v[3];
CSG_String File;
CSG_File Stream;
CSG_TIN *pTIN;
pTIN = Parameters("TIN") ->asTIN();
File = Parameters("FILE") ->asString();
zField = Parameters("ZFIELD") ->asInt();
bBinary = Parameters("BINARY") ->asInt() == 1;
if( !Stream.Open(File, SG_FILE_W, bBinary) )
{
return( false );
}
//-----------------------------------------------------
if( bBinary )
{
char *sHeader = (char *)SG_Calloc(80, sizeof(char));
DWORD nFacets = pTIN->Get_Triangle_Count();
WORD nBytes = 0;
Stream.Write(sHeader , sizeof(char), 80);
Stream.Write(&nFacets, sizeof(DWORD));
SG_Free(sHeader);
//-------------------------------------------------
for(int iTriangle=0; iTriangle<pTIN->Get_Triangle_Count(); iTriangle++)
{
CSG_TIN_Triangle *pTriangle = pTIN->Get_Triangle(iTriangle);
Get_Normal(pTriangle, zField, v);
Stream.Write(v, sizeof(float), 3); // facet normal
for(int iNode=0; iNode<3; iNode++)
{
CSG_TIN_Node *pNode = pTriangle->Get_Node(iNode);
v[0] = (float)pNode->Get_X();
v[1] = (float)pNode->Get_Y();
v[2] = (float)pNode->asDouble(zField);
Stream.Write(v, sizeof(float), 3);
}
Stream.Write(&nBytes, sizeof(WORD));
}
}
//-----------------------------------------------------
else // ASCII
{
Stream.Printf(SG_T("solid %s\n"), SG_File_Get_Name(File, false).c_str());
for(int iTriangle=0; iTriangle<pTIN->Get_Triangle_Count(); iTriangle++)
{
CSG_TIN_Triangle *pTriangle = pTIN->Get_Triangle(iTriangle);
Get_Normal(pTriangle, zField, v);
Stream.Printf(SG_T(" facet normal %.4f %.4f %.4f\n"), v[0], v[1], v[2]);
Stream.Printf(SG_T(" outer loop\n"));
for(int iNode=0; iNode<3; iNode++)
{
CSG_TIN_Node *pNode = pTriangle->Get_Node(iNode);
v[0] = (float)pNode->Get_X();
v[1] = (float)pNode->Get_Y();
v[2] = (float)pNode->asDouble(zField);
Stream.Printf(SG_T(" vertex %.4f %.4f %.4f\n"), v[0], v[1], v[2]);
}
Stream.Printf(SG_T(" endloop\n"));
Stream.Printf(SG_T(" endfacet\n"));
}
Stream.Printf(SG_T("endsolid %s\n"), SG_File_Get_Name(File, false).c_str());
}
return( true );
}
//---------------------------------------------------------
bool CDirect_Georeferencing_WorldFile::On_Execute(void)
{
//-----------------------------------------------------
int nx = Parameters("NX")->asInt();
int ny = Parameters("NY")->asInt();
if( !m_Georeferencer.Set_Transformation(Parameters, nx, ny) )
{
return( false );
}
//-----------------------------------------------------
CSG_String File = Parameters("FILE")->asString();
if( File.is_Empty() )
{
return( false );
}
//-----------------------------------------------------
CSG_File Stream;
if( !Stream.Open(File, SG_FILE_W, false) )
{
return( false );
}
//-----------------------------------------------------
CSG_Matrix R(m_Georeferencer.Get_Transformation());
R *= 0.001 * Parameters("Z")->asDouble() / Parameters("CFL")->asDouble() * Parameters("PXSIZE")->asDouble();
TSG_Point p = m_Georeferencer.Image_to_World(0, ny);
Stream.Printf(SG_T("%.10f\n%.10f\n%.10f\n%.10f\n%.10f\n%.10f\n"),
R[0][0], // A: pixel size in the x-direction in map units/pixel
R[1][0], // D: rotation about y-axis
-R[0][1], // B: rotation about x-axis
-R[1][1], // E: pixel size in the y-direction in map units, almost always negative
p.x, // X: top left pixel center
p.y // Y: top left pixel center
);
//-----------------------------------------------------
CSG_Shapes *pExtents = Parameters("EXTENT")->asShapes();
if( pExtents )
{
pExtents->Create(SHAPE_TYPE_Polygon, SG_File_Get_Name(File, false));
pExtents->Add_Field(_TL("NAME"), SG_DATATYPE_String);
CSG_Shape *pExtent = pExtents->Add_Shape();
p = m_Georeferencer.Image_to_World( 0, 0); pExtent->Add_Point(p.x, p.y);
p = m_Georeferencer.Image_to_World( 0, ny); pExtent->Add_Point(p.x, p.y);
p = m_Georeferencer.Image_to_World(nx, ny); pExtent->Add_Point(p.x, p.y);
p = m_Georeferencer.Image_to_World(nx, 0); pExtent->Add_Point(p.x, p.y);
pExtent->Set_Value(0, SG_File_Get_Name(File, false));
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CWASP_MAP_Export::On_Execute(void)
{
//-----------------------------------------------------
CSG_File Stream;
if( !Stream.Open(Parameters("FILE")->asString(), SG_FILE_W, false) )
{
return( false );
}
CSG_Shapes *pLines = Parameters("SHAPES")->asShapes();
if( !pLines->is_Valid() || pLines->Get_Count() <= 0 )
{
return( false );
}
//-----------------------------------------------------
// 1) Text string identifying the terrain map: + ...
Stream.Printf("+ %s\n", pLines->Get_Name());
// 2) Fixed point #1 in user and metric [m] coordinates:
// X1(user) Y1(user) X1(metric) Y1(metric)
Stream.Printf("%f %f %f %f\n", 0.0, 0.0, 0.0, 0.0);
// 3) Fixed point #2 in user and metric [m] coordinates:
// X2(user) Y2(user) X2(metric) Y2(metric)
Stream.Printf("%f %f %f %f\n", 1.0, 1.0, 1.0, 1.0);
// 4) Scaling factor and offset for height scale (Z):
// Zmetric = {scaling factor}(Zuser + {offset})
Stream.Printf("%f %f\n", 1.0, 0.0);
int zField = Parameters("ELEVATION")->asInt();
//-----------------------------------------------------
for(int iLine=0; iLine<pLines->Get_Count() && Set_Progress(iLine, pLines->Get_Count()); iLine++)
{
CSG_Shape *pLine = pLines->Get_Shape(iLine);
for(int iPart=0; iPart<pLine->Get_Part_Count(); iPart++)
{
if( pLine->Get_Point_Count(iPart) > 1 )
{
// 5a) Height contour: elevation (Z) and number of points (n) in line:
// Z n
Stream.Printf("%f %d\n", pLine->asDouble(zField), pLine->Get_Point_Count(iPart));
// 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
// 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
// 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 iPoint=0; iPoint<pLine->Get_Point_Count(iPart); iPoint++)
{
TSG_Point p = pLine->Get_Point(iPoint, iPart);
Stream.Printf("%f\t%f\n", p.x, p.y);
}
}
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CSG_Grid::_Save_Native(const CSG_String &File_Name, int xA, int yA, int xN, int yN, bool bBinary)
{
bool bResult = false;
CSG_File Stream;
if( Stream.Open(File_Name, SG_FILE_W, false) )
{
//-------------------------------------------------
// Header...
Stream.Printf(SG_T("%s\t= %s\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_NAME ], Get_Name() );
Stream.Printf(SG_T("%s\t= %s\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_DESCRIPTION ], Get_Description() );
Stream.Printf(SG_T("%s\t= %s\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_UNITNAME ], Get_Unit() );
Stream.Printf(SG_T("%s\t= %d\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_DATAFILE_OFFSET], 0 );
Stream.Printf(SG_T("%s\t= %s\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_DATAFORMAT ], bBinary ? gSG_Data_Type_Identifier[Get_Type()] : SG_T("ASCII") );
Stream.Printf(SG_T("%s\t= %s\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_BYTEORDER_BIG ], GRID_FILE_KEY_FALSE );
Stream.Printf(SG_T("%s\t= %.10f\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_POSITION_XMIN ], Get_XMin() + Get_Cellsize() * xA );
Stream.Printf(SG_T("%s\t= %.10f\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_POSITION_YMIN ], Get_YMin() + Get_Cellsize() * yA );
Stream.Printf(SG_T("%s\t= %d\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_CELLCOUNT_X ], xN );
Stream.Printf(SG_T("%s\t= %d\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_CELLCOUNT_Y ], yN );
Stream.Printf(SG_T("%s\t= %.10f\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_CELLSIZE ], Get_Cellsize() );
Stream.Printf(SG_T("%s\t= %f\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_Z_FACTOR ], m_zFactor );
Stream.Printf(SG_T("%s\t= %f\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_NODATA_VALUE ], Get_NoData_Value() );
Stream.Printf(SG_T("%s\t= %s\n") , gSG_Grid_File_Key_Names[ GRID_FILE_KEY_TOPTOBOTTOM ], GRID_FILE_KEY_FALSE );
//-------------------------------------------------
// Data...
if( Stream.Open(SG_File_Make_Path(NULL, File_Name, SG_T("sdat")), SG_FILE_W, true) )
{
if( bBinary )
{
bResult = _Save_Binary (Stream, xA, yA, xN, yN, Get_Type(), false, false);
}
else
{
bResult = _Save_ASCII (Stream, xA, yA, xN, yN);
}
}
}
return( bResult );
}
//---------------------------------------------------------
bool CXYZ_Export::On_Execute(void)
{
bool bHeader;
int Field, off_Field, Separate;
CSG_File Stream;
CSG_Shapes *pPoints;
//-----------------------------------------------------
pPoints = Parameters("POINTS" )->asShapes();
bHeader = Parameters("HEADER" )->asBool();
Field = Parameters("FIELD" )->asInt();
Separate = pPoints->Get_Type() == SHAPE_TYPE_Point ? 0
: Parameters("SEPARATE")->asInt();
off_Field = pPoints->Get_ObjectType() == SG_DATAOBJECT_TYPE_PointCloud ? 2 : 0;
//-----------------------------------------------------
if( pPoints->Get_Field_Count() == 0 )
{
Error_Set(_TL("data set has no attributes"));
return( false );
}
//-----------------------------------------------------
if( !Stream.Open(Parameters("FILENAME")->asString(), SG_FILE_W, false) )
{
Error_Set(_TL("could not open file"));
return( false );
}
//-----------------------------------------------------
if( bHeader )
{
Stream.Printf("X\tY");
if( Field < 0 )
{
for(int iField=off_Field; iField<pPoints->Get_Field_Count(); iField++)
{
Stream.Printf("\t%s", pPoints->Get_Field_Name(iField));
}
}
else
{
Stream.Printf("\tZ");
}
Stream.Printf("\n");
}
//-------------------------------------------------
for(int iShape=0; iShape<pPoints->Get_Count() && Set_Progress(iShape, pPoints->Get_Count()); iShape++)
{
CSG_Shape *pShape = pPoints->Get_Shape(iShape);
for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
{
switch( Separate )
{
case 1: // *
Stream.Printf("*\n");
break;
case 2: // number of points
Stream.Printf("%d\n", pShape->Get_Point_Count(iPart));
break;
}
for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
{
TSG_Point Point = pShape->Get_Point(iPoint, iPart);
Stream.Printf("%f\t%f", Point.x, Point.y);
if( Field < 0 )
{
for(int iField=off_Field; iField<pPoints->Get_Field_Count(); iField++)
{
switch( pPoints->Get_Field_Type(iField) )
{
case SG_DATATYPE_String:
case SG_DATATYPE_Date:
Stream.Printf("\t\"%s\"", pShape->asString(iField));
break;
default:
Stream.Printf("\t%f" , pShape->asDouble(iField));
break;
}
}
}
else switch( pPoints->Get_Field_Type(Field) )
{
case SG_DATATYPE_String:
case SG_DATATYPE_Date:
Stream.Printf("\t\"%s\"", pShape->asString(Field));
break;
default:
Stream.Printf("\t%f" , pShape->asDouble(Field));
break;
}
Stream.Printf("\n");
}
}
}
//-------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CSG_Table::Serialize(CSG_File &Stream, bool bSave)
{
SG_Char Separator = SG_T('\t');
int iField, nFields, iRecord, nRecords, FieldType;
CSG_Table_Record *pRecord;
CSG_String s, sLine;
//-----------------------------------------------------
if( bSave )
{
Stream.Printf(SG_T("%d %d\n"), m_nFields, m_nRecords);
for(iField=0; iField<m_nFields; iField++)
{
Stream.Printf(SG_T("%d \"%s\"\n"), Get_Field_Type(iField), Get_Field_Name(iField));
}
for(iRecord=0; iRecord<m_nRecords; iRecord++)
{
for(iField=0; iField<m_nFields; iField++)
{
Stream.Printf(SG_T("%s%c"), Get_Record(iRecord)->asString(iField), iField < m_nFields - 1 ? Separator : '\n');
}
}
return( true );
}
//-----------------------------------------------------
else if( Stream.Read_Line(sLine) && SG_SSCANF(sLine, SG_T("%d %d"), &nFields, &nRecords) == 2 && nFields > 0 )
{
_Destroy();
for(iField=0; iField<nFields; iField++)
{
if( Stream.Read_Line(sLine) && SG_SSCANF(sLine, SG_T("%d"), &FieldType) == 1 )
{
Add_Field(sLine.AfterFirst(SG_T('\"')).BeforeFirst(SG_T('\"')), (TSG_Data_Type)FieldType);
}
}
for(iRecord=0; iRecord<nRecords; iRecord++)
{
if( Stream.Read_Line(sLine) )
{
pRecord = _Add_Record();
for(iField=0; iField<m_nFields; iField++)
{
pRecord->Set_Value(iField, sLine.BeforeFirst(Separator));
sLine = sLine.AfterFirst(Separator);
}
}
}
return( true );
}
//-----------------------------------------------------
return( false );
}
//---------------------------------------------------------
bool CGrid_Export::On_Execute(void)
{
//-----------------------------------------------------
int y, iy, Method;
double dTrans;
CSG_Grid *pGrid, *pShade, Grid, Shade;
//-----------------------------------------------------
pGrid = Parameters("GRID" )->asGrid();
pShade = Parameters("SHADE" )->asGrid();
Method = Parameters("COLOURING" )->asInt ();
dTrans = Parameters("SHADE_TRANS" )->asDouble() / 100.0;
if( !pGrid )
{
return( false );
}
//-----------------------------------------------------
if( Method == 5 ) // same as in graphical user interface
{
if( !SG_UI_DataObject_asImage(pGrid, &Grid) )
{
Error_Set("could not retrieve colour coding from graphical user interface.");
return( false );
}
}
else
{
double zMin, zScale;
CSG_Colors Colors;
CSG_Table LUT;
if( SG_UI_Get_Window_Main() )
{
Colors.Assign(Parameters("COL_PALETTE")->asColors());
}
else
{
Colors.Set_Palette(
Parameters("COL_PALETTE")->asInt (),
Parameters("COL_REVERT" )->asBool(),
Parameters("COL_COUNT" )->asInt ()
);
}
switch( Method )
{
case 0: // stretch to grid's standard deviation
zMin = pGrid->Get_Mean() - Parameters("STDDEV")->asDouble() * pGrid->Get_StdDev();
zScale = Colors.Get_Count() / (2 * Parameters("STDDEV")->asDouble() * pGrid->Get_StdDev());
break;
case 1: // stretch to grid's value range
zMin = pGrid->Get_ZMin();
zScale = Colors.Get_Count() / pGrid->Get_ZRange();
break;
case 2: // stretch to specified value range
zMin = Parameters("STRETCH")->asRange()->Get_LoVal();
if( zMin >= (zScale = Parameters("STRETCH")->asRange()->Get_HiVal()) )
{
Error_Set(_TL("invalid user specified value range."));
return( false );
}
zScale = Colors.Get_Count() / (zScale - zMin);
break;
case 3: // lookup table
if( !Parameters("LUT")->asTable() || Parameters("LUT")->asTable()->Get_Field_Count() < 5 )
{
Error_Set(_TL("invalid lookup table."));
return( false );
}
LUT.Create(*Parameters("LUT")->asTable());
break;
case 4: // rgb coded values
break;
}
//-------------------------------------------------
Grid.Create(*Get_System(), SG_DATATYPE_Int);
for(y=0, iy=Get_NY()-1; y<Get_NY() && Set_Progress(y); y++, iy--)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
double z = pGrid->asDouble(x, y);
if( Method == 3 ) // lookup table
{
int i, iColor = -1;
for(i=0; iColor<0 && i<LUT.Get_Count(); i++)
{
if( z == LUT[i][3] )
{
Grid.Set_Value(x, iy, LUT[iColor = i].asInt(0));
}
}
for(i=0; iColor<0 && i<LUT.Get_Count(); i++)
{
if( z >= LUT[i][3] && z <= LUT[i][4] )
{
Grid.Set_Value(x, iy, LUT[iColor = i].asInt(0));
}
}
if( iColor < 0 )
{
Grid.Set_NoData(x, iy);
}
}
else if( pGrid->is_NoData(x, y) )
{
Grid.Set_NoData(x, iy);
}
else if( Method == 4 ) // rgb coded values
{
Grid.Set_Value(x, iy, z);
}
else
{
int i = (int)(zScale * (z - zMin));
Grid.Set_Value(x, iy, Colors[i < 0 ? 0 : i >= Colors.Get_Count() ? Colors.Get_Count() - 1 : i]);
}
}
}
}
//-----------------------------------------------------
if( !pShade || pShade->Get_ZRange() <= 0.0 )
{
pShade = NULL;
}
else
{
double dMinBright, dMaxBright;
dMinBright = Parameters("SHADE_BRIGHT")->asRange()->Get_LoVal() / 100.0;
dMaxBright = Parameters("SHADE_BRIGHT")->asRange()->Get_HiVal() / 100.0;
if( dMinBright >= dMaxBright )
{
SG_UI_Msg_Add_Error(_TL("Minimum shade brightness must be lower than maximum shade brightness!"));
return( false );
}
int nColors = 100;
CSG_Colors Colors(nColors, SG_COLORS_BLACK_WHITE, true);
//-------------------------------------------------
Shade.Create(*Get_System(), SG_DATATYPE_Int);
for(y=0, iy=Get_NY()-1; y<Get_NY() && Set_Progress(y); y++, iy--)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( pShade->is_NoData(x, y) )
{
Shade.Set_NoData(x, iy);
}
else
{
Shade.Set_Value (x, iy, Colors[(int)(nColors * (dMaxBright - dMinBright) * (pShade->asDouble(x, y) - pShade->Get_ZMin()) / pShade->Get_ZRange() + dMinBright)]);
}
}
}
}
//-----------------------------------------------------
wxImage Image(Get_NX(), Get_NY());
if( Grid.Get_NoData_Count() > 0 )
{
Image.SetAlpha();
}
for(y=0; y<Get_NY() && Set_Progress(y); y++)
{
#pragma omp parallel for
for(int x=0; x<Get_NX(); x++)
{
if( Grid.is_NoData(x, y) || (pShade != NULL && Shade.is_NoData(x, y)) )
{
if( Image.HasAlpha() )
{
Image.SetAlpha(x, y, wxIMAGE_ALPHA_TRANSPARENT);
}
Image.SetRGB(x, y, 255, 255, 255);
}
else
{
if( Image.HasAlpha() )
{
Image.SetAlpha(x, y, wxIMAGE_ALPHA_OPAQUE);
}
int r, g, b, c = Grid.asInt(x, y);
r = SG_GET_R(c);
g = SG_GET_G(c);
b = SG_GET_B(c);
if( pShade )
{
c = Shade.asInt(x, y);
r = dTrans * r + SG_GET_R(c) * (1.0 - dTrans);
g = dTrans * g + SG_GET_G(c) * (1.0 - dTrans);
b = dTrans * b + SG_GET_B(c) * (1.0 - dTrans);
}
Image.SetRGB(x, y, r, g, b);
}
}
}
//-------------------------------------------------
CSG_String fName(Parameters("FILE")->asString());
if( !SG_File_Cmp_Extension(fName, SG_T("bmp"))
&& !SG_File_Cmp_Extension(fName, SG_T("jpg"))
&& !SG_File_Cmp_Extension(fName, SG_T("pcx"))
&& !SG_File_Cmp_Extension(fName, SG_T("png"))
&& !SG_File_Cmp_Extension(fName, SG_T("tif")) )
{
fName = SG_File_Make_Path(NULL, fName, SG_T("png"));
Parameters("FILE")->Set_Value(fName);
}
//-----------------------------------------------------
wxImageHandler *pImgHandler = NULL;
if( !SG_UI_Get_Window_Main() )
{
if( SG_File_Cmp_Extension(fName, SG_T("jpg")) )
pImgHandler = new wxJPEGHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("pcx")) )
pImgHandler = new wxPCXHandler;
else if( SG_File_Cmp_Extension(fName, SG_T("tif")) )
pImgHandler = new wxTIFFHandler;
#ifdef _SAGA_MSW
else if( SG_File_Cmp_Extension(fName, SG_T("bmp")) )
pImgHandler = new wxBMPHandler;
#endif
else // if( SG_File_Cmp_Extension(fName, SG_T("png")) )
pImgHandler = new wxPNGHandler;
wxImage::AddHandler(pImgHandler);
}
if( !Image.SaveFile(fName.c_str()) )
{
Error_Set(CSG_String::Format(SG_T("%s [%s]"), _TL("could not save image file"), fName.c_str()));
return( false );
}
pGrid->Get_Projection().Save(SG_File_Make_Path(NULL, fName, SG_T("prj")), SG_PROJ_FMT_WKT);
//-----------------------------------------------------
CSG_File Stream;
if( SG_File_Cmp_Extension(fName, SG_T("bmp")) ) Stream.Open(SG_File_Make_Path(NULL, fName, SG_T("bpw")), SG_FILE_W, false);
else if( SG_File_Cmp_Extension(fName, SG_T("jpg")) ) Stream.Open(SG_File_Make_Path(NULL, fName, SG_T("jgw")), SG_FILE_W, false);
else if( SG_File_Cmp_Extension(fName, SG_T("pcx")) ) Stream.Open(SG_File_Make_Path(NULL, fName, SG_T("pxw")), SG_FILE_W, false);
else if( SG_File_Cmp_Extension(fName, SG_T("png")) ) Stream.Open(SG_File_Make_Path(NULL, fName, SG_T("pgw")), SG_FILE_W, false);
else if( SG_File_Cmp_Extension(fName, SG_T("tif")) ) Stream.Open(SG_File_Make_Path(NULL, fName, SG_T("tfw")), SG_FILE_W, false);
if( Stream.is_Open() )
{
Stream.Printf(SG_T("%.10f\n%f\n%f\n%.10f\n%.10f\n%.10f\n"),
pGrid->Get_Cellsize(),
0.0, 0.0,
-pGrid->Get_Cellsize(),
pGrid->Get_XMin(),
pGrid->Get_YMax()
);
}
//-----------------------------------------------------
if( Parameters("FILE_KML")->asBool() )
{
CSG_MetaData KML; KML.Set_Name("kml"); KML.Add_Property("xmlns", "http://www.opengis.net/kml/2.2");
// CSG_MetaData *pFolder = KML.Add_Child("Folder");
// pFolder->Add_Child("name" , "Raster exported from SAGA");
// pFolder->Add_Child("description", "System for Automated Geoscientific Analyses - www.saga-gis.org");
// CSG_MetaData *pOverlay = pFolder->Add_Child("GroundOverlay");
CSG_MetaData *pOverlay = KML.Add_Child("GroundOverlay");
pOverlay->Add_Child("name" , pGrid->Get_Name());
pOverlay->Add_Child("description", pGrid->Get_Description());
pOverlay->Add_Child("Icon" )->Add_Child("href", SG_File_Get_Name(fName, true));
pOverlay->Add_Child("LatLonBox" );
pOverlay->Get_Child("LatLonBox" )->Add_Child("north", pGrid->Get_YMax());
pOverlay->Get_Child("LatLonBox" )->Add_Child("south", pGrid->Get_YMin());
pOverlay->Get_Child("LatLonBox" )->Add_Child("east" , pGrid->Get_XMax());
pOverlay->Get_Child("LatLonBox" )->Add_Child("west" , pGrid->Get_XMin());
KML.Save(fName, SG_T("kml"));
}
//-----------------------------------------------------
if( !SG_UI_Get_Window_Main() && pImgHandler != NULL)
{
wxImage::RemoveHandler(pImgHandler->GetName());
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CWRF_Index::Save(const CSG_String &File)
{
CSG_File Stream;
if( !Stream.Open(File, SG_FILE_W, false) )
{
return( false );
}
//-----------------------------------------------------
Stream.Printf(SG_T("%s=%s\n"), SG_T("TYPE") , m_TYPE == VAL_CATEGORICAL ? SG_T("CATEGORICAL") : SG_T("CONTINUOUS"));
if( m_CATEGORY_MIN < m_CATEGORY_MAX )
{
Stream.Printf(SG_T("%s=%d\n"), SG_T("CATEGORY_MIN") , m_CATEGORY_MIN);
Stream.Printf(SG_T("%s=%d\n"), SG_T("CATEGORY_MAX") , m_CATEGORY_MAX);
}
Stream.Printf(SG_T("%s=%s\n"), SG_T("PROJECTION") , m_PROJECTION.c_str());
if( m_PROJECTION.CmpNoCase(SG_T("regular_ll")) )
{
Stream.Printf(SG_T("%s=%f\n"), SG_T("STDLON") , m_STDLON);
Stream.Printf(SG_T("%s=%f\n"), SG_T("TRUELAT1") , m_TRUELAT1);
Stream.Printf(SG_T("%s=%f\n"), SG_T("TRUELAT2") , m_TRUELAT2);
}
Stream.Printf(SG_T("%s=%.8f\n"), SG_T("DX") , m_DX);
Stream.Printf(SG_T("%s=%.8f\n"), SG_T("DY") , m_DY);
Stream.Printf(SG_T("%s=%f\n"), SG_T("KNOWN_X") , m_KNOWN_X);
Stream.Printf(SG_T("%s=%f\n"), SG_T("KNOWN_Y") , m_KNOWN_Y);
Stream.Printf(SG_T("%s=%.5f\n"), SG_T("KNOWN_LAT") , m_KNOWN_LAT);
Stream.Printf(SG_T("%s=%.5f\n"), SG_T("KNOWN_LON") , m_KNOWN_LON);
if( m_SIGNED )
{
Stream.Printf(SG_T("%s=%s\n"), SG_T("SIGNED") , SG_T("YES"));
}
Stream.Printf(SG_T("%s=%d\n"), SG_T("WORDSIZE") , m_WORDSIZE);
Stream.Printf(SG_T("%s=%d\n"), SG_T("TILE_X") , m_TILE_X);
Stream.Printf(SG_T("%s=%d\n"), SG_T("TILE_Y") , m_TILE_Y);
if( m_TILE_Z == 1 )
{
Stream.Printf(SG_T("%s=%d\n"), SG_T("TILE_Z") , m_TILE_Z);
}
else
{
Stream.Printf(SG_T("%s=%d\n"), SG_T("TILE_Z_START") , m_TILE_Z_START);
Stream.Printf(SG_T("%s=%d\n"), SG_T("TILE_Z_END") , m_TILE_Z_END);
}
if( m_TILE_BDR > 0 )
{
Stream.Printf(SG_T("%s=%d\n"), SG_T("TILE_BDR") , m_TILE_BDR);
}
Stream.Printf(SG_T("%s=%f\n"), SG_T("MISSING_VALUE") , m_MISSING_VALUE);
if( m_SCALE_FACTOR != 1.0 )
{
Stream.Printf(SG_T("%s=%f\n"), SG_T("SCALE_FACTOR") , m_SCALE_FACTOR);
}
if( m_ROW_ORDER == VAL_TOP_BOTTOM )
{
Stream.Printf(SG_T("%s=%s\n"), SG_T("ROW_ORDER") , SG_T("TOP_BOTTOM"));
}
if( m_ENDIAN == VAL_ENDIAN_LITTLE )
{
Stream.Printf(SG_T("%s=%s\n"), SG_T("ENDIAN") , SG_T("LITTLE"));
}
if( m_TYPE == VAL_CATEGORICAL )
{
Stream.Printf(SG_T("%s=\"%s\"\n"), SG_T("UNITS") , SG_T("CATEGORY"));
}
else if( m_UNITS.Length() > 0 )
{
Stream.Printf(SG_T("%s=\"%s\"\n"), SG_T("UNITS") , m_UNITS.c_str());
}
if( m_DESCRIPTION.Length() > 0 )
{
Stream.Printf(SG_T("%s=\"%s\"\n"), SG_T("DESCRIPTION") , m_DESCRIPTION.c_str());
}
if( m_MMINLU.CmpNoCase(SG_T("USGS")) )
{
Stream.Printf(SG_T("%s=%s\n"), SG_T("MMINLU") , m_MMINLU.c_str());
}
if( m_ISWATER != 16 ) Stream.Printf(SG_T("%s=%d\n"), SG_T("ISWATER") , m_ISWATER);
if( m_ISLAKE != -1 ) Stream.Printf(SG_T("%s=%d\n"), SG_T("ISLAKE") , m_ISLAKE);
if( m_ISICE != 24 ) Stream.Printf(SG_T("%s=%d\n"), SG_T("_ISICE") , m_ISICE);
if( m_ISURBAN != 1 ) Stream.Printf(SG_T("%s=%d\n"), SG_T("m_ISURBAN") , m_ISURBAN);
if( m_ISOILWATER != 14 ) Stream.Printf(SG_T("%s=%d\n"), SG_T("m_ISOILWATER"), m_ISOILWATER);
return( true );
}
//---------------------------------------------------------
bool CTable_Text_Export::On_Execute(void)
{
CSG_String StrFormat, Separator;
CSG_File Stream;
CSG_Table *pTable;
//-----------------------------------------------------
pTable = Parameters("TABLE" )->asTable();
StrFormat = Parameters("STRQUOTA")->asBool() ? SG_T("\"%s\"") : SG_T("%s");
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;
}
//-----------------------------------------------------
if( !Stream.Open(Parameters("FILENAME")->asString(), SG_FILE_W, false) )
{
Message_Add(_TL("file could not be opened."));
}
//-----------------------------------------------------
else
{
if( Parameters("HEADLINE")->asBool() )
{
for(int iField=0; iField<pTable->Get_Field_Count(); iField++)
{
Stream.Printf(StrFormat.c_str(), pTable->Get_Field_Name(iField));
Stream.Printf(iField < pTable->Get_Field_Count() - 1 ? Separator.c_str() : SG_T("\n"));
}
}
//-------------------------------------------------
for(int iRecord=0; iRecord<pTable->Get_Record_Count() && Set_Progress(iRecord, pTable->Get_Record_Count()); iRecord++)
{
CSG_Table_Record *pRecord = pTable->Get_Record(iRecord);
for(int iField=0; iField<pTable->Get_Field_Count(); iField++)
{
switch( pTable->Get_Field_Type(iField) )
{
default:
case SG_DATATYPE_Char:
case SG_DATATYPE_String:
case SG_DATATYPE_Date:
Stream.Printf(StrFormat.c_str(), pRecord->asString(iField));
break;
case SG_DATATYPE_Short:
case SG_DATATYPE_Int:
case SG_DATATYPE_Color:
Stream.Printf(SG_T("%d") , pRecord->asInt(iField));
break;
case SG_DATATYPE_Long:
Stream.Printf(SG_T("%ld") , (long)pRecord->asDouble(iField));
break;
case SG_DATATYPE_ULong:
Stream.Printf(SG_T("%lu") , (unsigned long)pRecord->asDouble(iField));
break;
case SG_DATATYPE_Float:
case SG_DATATYPE_Double:
Stream.Printf(SG_T("%f") , pRecord->asDouble(iField));
break;
}
Stream.Printf(iField < pTable->Get_Field_Count() - 1 ? Separator.c_str() : SG_T("\n"));
}
}
//-------------------------------------------------
Stream.Close();
return( true );
}
return( false );
}