void CSG_Doc_SVG::Draw_Rectangle(const CSG_Rect &r,
int Fill_Color,
int Line_Color,
double Line_Width)
{
Draw_Rectangle(r.Get_XMin(), r.Get_YMin(), r.Get_XMax(), r.Get_YMax(), Fill_Color, Line_Color, Line_Width) ;
}
//---------------------------------------------------------
TSG_Intersection CSG_Rect::Intersects(const CSG_Rect &Rect) const
{
if( m_rect.xMax < Rect.Get_XMin() || Rect.Get_XMax() < m_rect.xMin
|| m_rect.yMax < Rect.Get_YMin() || Rect.Get_YMax() < m_rect.yMin )
{
return( INTERSECTION_None );
}
if( is_Equal(Rect) )
{
return( INTERSECTION_Identical );
}
if( Contains(Rect.Get_XMin(), Rect.Get_YMin())
&& Contains(Rect.Get_XMax(), Rect.Get_YMax()) )
{
return( INTERSECTION_Contains );
}
if( Rect.Contains(Get_XMin(), Get_YMin())
&& Rect.Contains(Get_XMax(), Get_YMax()) )
{
return( INTERSECTION_Contained );
}
return( INTERSECTION_Overlaps );
}
//---------------------------------------------------------
void CGrid_Cross_Profiles::Make_Report(const SG_Char *FileName, CSG_Grid *pDEM, CSG_Shapes *pLines, CSG_Shapes *pProfiles, double Distance)
{
if( FileName )
{
int iProfile, iPoint, nSamples, iBox;
CSG_Rect r;
CSG_Shape *pProfile, *pLine;
CSG_Shapes Profile;
CSG_Doc_PDF pdf;
pdf.Open(PDF_PAGE_SIZE_A4, PDF_PAGE_ORIENTATION_PORTRAIT, _TL("Cross Profiles"));
pdf.Layout_Add_Box(5, 5, 95, 20);
pdf.Layout_Add_Box(5, 25, 95, 45);
pdf.Layout_Add_Box(5, 50, 95, 70);
pdf.Layout_Add_Box(5, 75, 95, 90);
nSamples = pProfiles->Get_Field_Count() - OFFSET;
Distance = Distance / (nSamples - 1);
iBox = 0;
for(iProfile=0; iProfile<pProfiles->Get_Count() && Set_Progress(iProfile, pProfiles->Get_Count()); iProfile++)
{
pProfile = pProfiles->Get_Shape(iProfile);
Profile.Create(SHAPE_TYPE_Line);
pLine = Profile.Add_Shape();
for(iPoint=0; iPoint<nSamples; iPoint++)
{
if( !pProfile->is_NoData(OFFSET + iPoint) )
{
pLine->Add_Point(
(iPoint - nSamples / 2) * Distance,
pProfile->asDouble(OFFSET + iPoint)
);
}
}
if( pLine->Get_Point_Count(0) > 1 )
{
if( iBox >= NBOXES )
{
pdf.Add_Page();
iBox = 0;
}
// pdf.Draw_Graticule (pdf.Layout_Get_Box(iBox), Profile.Get_Extent(), 20);
// pdf.Draw_Shapes (pdf.Layout_Get_Box(iBox), &Profile);
r = pLine->Get_Extent(); r.Inflate(10);
pdf.Draw_Graticule (pdf.Layout_Get_Box(iBox), r, 15);
pdf.Draw_Shape (pdf.Layout_Get_Box(iBox), pLine, PDF_STYLE_POLYGON_FILLSTROKE, SG_COLOR_GREEN, SG_COLOR_BLACK, 1, &r);
iBox++;
}
}
pdf.Save(Parameters("DOCUMENT")->asString());
}
}
//---------------------------------------------------------
const CSG_Rect & CSG_Shape_Point::Get_Extent(void)
{
static CSG_Rect Extent;
Extent.Assign(m_Point.x, m_Point.y, m_Point.x, m_Point.y);
return( Extent );
}
//---------------------------------------------------------
void CWKSP_Shapes::Edit_Shape_Draw_Move(wxDC &dc, const CSG_Rect &rWorld, const wxPoint &Point, const TSG_Point &ptWorld)
{
double ClientToWorld = rWorld.Get_XRange() / (double)dc.GetSize().x;
dc.DrawLine(Point.x, Point.y,
(int)((ptWorld.x - rWorld.Get_XMin()) / ClientToWorld),
(int)((rWorld.Get_YMax() - ptWorld.y) / ClientToWorld)
);
}
//---------------------------------------------------------
bool CWKSP_Shapes::Edit_On_Mouse_Move(wxWindow *pMap, CSG_Rect rWorld, wxPoint pt, wxPoint ptLast, int Key)
{
switch( m_Edit_Mode )
{
case EDIT_SHAPE_MODE_Split:
case EDIT_SHAPE_MODE_Move:
{
CSG_Shape *pShape = m_Edit_Shapes.Get_Shape(1);
if( pShape && pShape->Get_Point_Count() > 0 && (pt.x != ptLast.x || pt.y != ptLast.y) )
{
wxClientDC dc(pMap); dc.SetLogicalFunction(wxINVERT);
Edit_Shape_Draw_Move(dc, rWorld, ptLast, pShape->Get_Point(0, 0, false));
Edit_Shape_Draw_Move(dc, rWorld, pt , pShape->Get_Point(0, 0, false));
}
return( true );
}
//-----------------------------------------------------
case EDIT_SHAPE_MODE_Normal: default:
if( m_Edit_pShape )
{
//---------------------------------------------
if( m_Edit_iPart >= 0 && (m_Edit_iPoint < 0 || Key & MODULE_INTERACTIVE_KEY_LEFT) && (pt.x != ptLast.x || pt.y != ptLast.y) )
{
wxClientDC dc(pMap); dc.SetLogicalFunction(wxINVERT);
Edit_Shape_Draw_Move(dc, rWorld, ptLast);
Edit_Shape_Draw_Move(dc, rWorld, pt);
return( true );
}
//---------------------------------------------
else
{
int iPart, iPoint;
double ClientToWorld = rWorld.Get_XRange() / (double)pMap->GetClientSize().x;
CSG_Point Point(rWorld.Get_XMin() + pt.x * ClientToWorld, rWorld.Get_YMax() - pt.y * ClientToWorld);
switch( Edit_Shape_HitTest(Point, EDIT_TICKMARK_SIZE * ClientToWorld, iPart, iPoint) )
{
default: pMap->SetCursor(IMG_Get_Cursor(ID_IMG_CRS_SELECT )); break;
case 1: pMap->SetCursor(IMG_Get_Cursor(ID_IMG_CRS_EDIT_POINT_MOVE)); break;
case 2: pMap->SetCursor(IMG_Get_Cursor(ID_IMG_CRS_EDIT_POINT_ADD )); break;
}
return( true );
}
}
}
return( false );
}
//---------------------------------------------------------
bool Cut_Shapes(CSG_Rect Extent, int Method, CSG_Shapes *pShapes, CSG_Shapes *pCut)
{
if( pCut && pShapes && pShapes->is_Valid() && Extent.Intersects(pShapes->Get_Extent()) )
{
pCut->Create(
pShapes->Get_Type(),
CSG_String::Format(SG_T("%s [%s]"), pShapes->Get_Name(), _TL("Cut")),
pShapes
);
for(int iShape=0; iShape<pShapes->Get_Count() && SG_UI_Process_Set_Progress(iShape, pShapes->Get_Count()); iShape++)
{
bool bAdd;
CSG_Shape *pShape = pShapes->Get_Shape(iShape);
if( Method == 2 ) // center
{
bAdd = pShapes->Get_Type() == SHAPE_TYPE_Polygon
? Extent.Contains(((CSG_Shape_Polygon *)pShape)->Get_Centroid())
: Extent.Contains(pShape->Get_Extent().Get_Center());
}
else // completely contained, intersects
{
switch( pShape->Intersects(Extent) )
{
case INTERSECTION_Identical:
case INTERSECTION_Contained:
bAdd = true;
break;
case INTERSECTION_Overlaps:
case INTERSECTION_Contains:
bAdd = Method == 1;
break;
default:
bAdd = false;
break;
}
}
if( bAdd )
{
pCut->Add_Shape(pShape);
}
}
return( pCut->Get_Count() > 0 );
}
return( false );
}
//---------------------------------------------------------
inline void CGeoref_Grid::Add_Target_Extent(CSG_Rect &Extent, double x, double y)
{
if( m_Engine.Get_Converted(x, y) )
{
if( Extent.Get_XRange() >= 0.0 && Extent.Get_YRange() >= 0.0 )
{
Extent.Union(CSG_Point(x, y));
}
else
{
Extent.Assign(x, y, x, y);
}
}
}
//---------------------------------------------------------
bool CVIEW_Map_Control::_Zoom(wxPoint A, wxPoint B)
{
CSG_Rect rWorld;
if( A.x == B.x && A.y == B.y )
{
return( _Zoom(_Get_World(A), true) );
}
rWorld.Assign(_Get_World(A), _Get_World(B));
m_pMap->Set_Extent(rWorld);
return( true );
}
//---------------------------------------------------------
bool CGeoref_Grid::Get_Target_Extent(CSG_Rect &Extent, bool bEdge)
{
if( Parameters("METHOD")->asInt() == GEOREF_Triangulation ) // triangulation
{
return( m_Engine.Get_Reference_Extent(Extent) );
}
//-----------------------------------------------------
CSG_Grid *pGrid = Parameters("GRID")->asGrid();
Extent.m_rect.xMin = Extent.m_rect.yMin = 1.0;
Extent.m_rect.xMax = Extent.m_rect.yMax = 0.0;
//-----------------------------------------------------
if( bEdge )
{
for(int y=0; y<pGrid->Get_NY(); y++)
{
Add_Target_Extent(Extent, pGrid->Get_XMin(), pGrid->Get_System().Get_yGrid_to_World(y));
Add_Target_Extent(Extent, pGrid->Get_XMax(), pGrid->Get_System().Get_yGrid_to_World(y));
}
for(int x=0; x<pGrid->Get_NX(); x++)
{
Add_Target_Extent(Extent, pGrid->Get_System().Get_xGrid_to_World(x), pGrid->Get_YMin());
Add_Target_Extent(Extent, pGrid->Get_System().Get_xGrid_to_World(x), pGrid->Get_YMax());
}
}
//-----------------------------------------------------
else
{
for(int y=0; y<pGrid->Get_NY() && Set_Progress(y, pGrid->Get_NY()); y++)
{
for(int x=0; x<pGrid->Get_NX(); x++)
{
if( !pGrid->is_NoData(x, y) )
{
TSG_Point p = pGrid->Get_System().Get_Grid_to_World(x, y);
Add_Target_Extent(Extent, p.x, p.y);
}
}
}
}
return( is_Progress() && Extent.Get_XRange() > 0.0 && Extent.Get_YRange() > 0.0 );
}
//---------------------------------------------------------
bool CSTL_Import::Get_Extent(CSG_File &Stream, CSG_Rect &Extent, int nFacettes)
{
float xMin = 1, xMax = 0, yMin, yMax;
for(int iFacette=0; iFacette<nFacettes && !Stream.is_EOF() && Set_Progress(iFacette, nFacettes); iFacette++)
{
TSTL_Point p[3];
if( Read_Facette(Stream, p) )
{
if( iFacette == 0 )
{
xMin = xMax = p[0].x;
yMin = yMax = p[0].y;
}
for(int i=0; i<3; i++)
{
if( xMin > p[i].x ) { xMin = p[i].x; } else if( xMax < p[i].x ) { xMax = p[i].x; }
if( yMin > p[i].y ) { yMin = p[i].y; } else if( yMax < p[i].y ) { yMax = p[i].y; }
}
}
}
Extent.Assign(xMin, yMin, xMax, yMax);
return( xMin < xMax && yMin < yMax && Stream.Seek(80 + sizeof(nFacettes)) );
}
//---------------------------------------------------------
bool CVIEW_Map_Control::_Move(wxPoint &A, const wxPoint &B)
{
if( A.x != B.x || A.y != B.y )
{
CSG_Rect rWorld;
rWorld.Assign(m_pMap->Get_Extent());
rWorld.Move(_Get_Client2World(A) - _Get_Client2World(B));
m_pMap->Set_Extent(rWorld);
A = B;
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CShapes_Cut_Interactive::Get_Extent(CSG_Rect &r)
{
CSG_Parameters *pParameters = Get_Parameters("CUT");
pParameters->Get_Parameter("AX")->Set_Value(r.Get_XMin());
pParameters->Get_Parameter("AY")->Set_Value(r.Get_YMin());
pParameters->Get_Parameter("BX")->Set_Value(r.Get_XMax());
pParameters->Get_Parameter("BY")->Set_Value(r.Get_YMax());
pParameters->Get_Parameter("DX")->Set_Value(r.Get_XRange());
pParameters->Get_Parameter("DY")->Set_Value(r.Get_YRange());
if( Dlg_Parameters("CUT") )
{
r.Assign(
pParameters->Get_Parameter("AX")->asDouble(),
pParameters->Get_Parameter("AY")->asDouble(),
pParameters->Get_Parameter("BX")->asDouble(),
pParameters->Get_Parameter("BY")->asDouble()
);
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGrid_Merge::Set_Target(CSG_Parameters *pParameters, CSG_Parameter_Grid_List *pGrids)
{
if( pParameters && pGrids && pGrids->Get_Count() > 0 )
{
double d = pGrids->asGrid(0)->Get_Cellsize();
CSG_Rect r = pGrids->asGrid(0)->Get_Extent();
for(int i=1; i<pGrids->Get_Count(); i++)
{
if( d > pGrids->asGrid(i)->Get_Cellsize() )
{
d = pGrids->asGrid(i)->Get_Cellsize();
}
r.Union(pGrids->asGrid(i)->Get_Extent());
}
int nx = 1 + (int)(r.Get_XRange() / d);
int ny = 1 + (int)(r.Get_YRange() / d);
m_Grid_Target.Set_User_Defined(pParameters, r.Get_XMin(), r.Get_YMin(), d, nx, ny);
}
return( false );
}
//---------------------------------------------------------
bool CWKSP_Map_Graticule::Get_Graticule(const CSG_Rect &Extent)
{
bool bResult = false;
m_Graticule .Create(SHAPE_TYPE_Line );
m_Coordinates.Create(SHAPE_TYPE_Point);
CSG_Tool *pTool = SG_Get_Tool_Library_Manager().Get_Tool("pj_proj4", 14);
if( pTool && Get_Map()->Get_Projection().is_Okay() )
{
SG_UI_Msg_Lock (true);
SG_UI_Progress_Lock(true);
pTool->Settings_Push();
if( pTool->Set_Parameter("XMIN" , Extent.Get_XMin())
&& pTool->Set_Parameter("XMAX" , Extent.Get_XMax())
&& pTool->Set_Parameter("YMIN" , Extent.Get_YMin())
&& pTool->Set_Parameter("YMAX" , Extent.Get_YMax())
&& pTool->Set_Parameter("INTERVAL" , m_Parameters("INTERVAL"))
&& pTool->Set_Parameter("FIXED" , m_Parameters("FIXED"))
&& pTool->Set_Parameter("FITTED" , m_Parameters("FITTED"))
&& pTool->Set_Parameter("RESOLUTION", m_Parameters("RESOLUTION"))
&& pTool->Set_Parameter("GRATICULE" , &m_Graticule)
&& pTool->Set_Parameter("COORDS" , &m_Coordinates)
&& pTool->Set_Parameter("CRS_PROJ4" , Get_Map()->Get_Projection().Get_Proj4())
&& pTool->On_Before_Execution() && pTool->Execute() )
{
bResult = true;
}
pTool->Settings_Pop();
SG_UI_Msg_Lock (false);
SG_UI_Progress_Lock(false);
}
return( bResult );
}
//---------------------------------------------------------
bool Cut_Set_Extent(CSG_Rect Extent, CSG_Shapes *pExtent, bool bClear)
{
if( pExtent )
{
if( bClear )
{
pExtent->Create(SHAPE_TYPE_Polygon, _TL("Extent [Cut]"));
pExtent->Add_Field("ID", SG_DATATYPE_Int);
}
if( pExtent->Get_Type() == SHAPE_TYPE_Polygon )
{
CSG_Shape *pShape = pExtent->Add_Shape();
pShape->Set_Value(SG_T("ID"), pExtent->Get_Count());
pShape->Add_Point(Extent.Get_XMin(), Extent.Get_YMin());
pShape->Add_Point(Extent.Get_XMin(), Extent.Get_YMax());
pShape->Add_Point(Extent.Get_XMax(), Extent.Get_YMax());
pShape->Add_Point(Extent.Get_XMax(), Extent.Get_YMin());
pShape->Add_Point(Extent.Get_XMin(), Extent.Get_YMin());
return( true );
}
}
return( false );
}
//---------------------------------------------------------
double CGCS_Graticule::Get_Interval(const CSG_Rect &Extent)
{
if( Parameters("INTERVAL")->asInt() == 0 )
{
return( Parameters("FIXED")->asDouble() );
}
double Interval = Extent.Get_XRange() > Extent.Get_YRange() ? Extent.Get_XRange() : Extent.Get_YRange();
if( Interval > 360 )
{
Interval = 360;
}
Interval = Interval / Parameters("FITTED")->asInt();
double d = pow(10.0, (int)(log10(Interval)) - (Interval < 1.0 ? 1.0 : 0.0));
Interval = (int)(Interval / d) * d;
return( Interval );
}
//---------------------------------------------------------
bool CSG_Rect::Intersect(const CSG_Rect &Rect)
{
switch( Intersects(Rect) )
{
case INTERSECTION_None: default:
return( false );
case INTERSECTION_Identical:
case INTERSECTION_Contained:
break;
case INTERSECTION_Contains:
m_rect = Rect.m_rect;
break;
case INTERSECTION_Overlaps:
if( m_rect.xMin < Rect.Get_XMin() )
{
m_rect.xMin = Rect.Get_XMin();
}
if( m_rect.yMin < Rect.Get_YMin() )
{
m_rect.yMin = Rect.Get_YMin();
}
if( m_rect.xMax > Rect.Get_XMax() )
{
m_rect.xMax = Rect.Get_XMax();
}
if( m_rect.yMax > Rect.Get_YMax() )
{
m_rect.yMax = Rect.Get_YMax();
}
break;
}
return( true );
}
//---------------------------------------------------------
void CSG_Rect::Union(const CSG_Rect &Rect)
{
if( m_rect.xMin > Rect.Get_XMin() )
{
m_rect.xMin = Rect.Get_XMin();
}
if( m_rect.yMin > Rect.Get_YMin() )
{
m_rect.yMin = Rect.Get_YMin();
}
if( m_rect.xMax < Rect.Get_XMax() )
{
m_rect.xMax = Rect.Get_XMax();
}
if( m_rect.yMax < Rect.Get_YMax() )
{
m_rect.yMax = Rect.Get_YMax();
}
}
bool CCreateGridSystem::On_Execute(void)
{
CSG_Grid *pDummy;
CSG_Shapes *pShapes;
CSG_Rect extent;
CSG_Parameter_Shapes_List *pShapesList;
CSG_Parameter_Grid_List *pGridList;
CSG_Grid_System System;
double xMin, xMax, yMin, yMax, cellsize, offset_x, offset_y, xRange, yRange, n, initVal;
int NX, NY, m_extent, m_adjust, i;
bool useoff;
xMin = Parameters("XMIN")->asDouble();
yMin = Parameters("YMIN")->asDouble();
xMax = Parameters("XMAX")->asDouble();
yMax = Parameters("YMAX")->asDouble();
NX = Parameters("NX")->asInt();
NY = Parameters("NY")->asInt();
cellsize = Parameters("CELLSIZE")->asDouble();
offset_x = Parameters("XOFFSET")->asDouble();
offset_y = Parameters("YOFFSET")->asDouble();
useoff = Parameters("USEOFF")->asBool();
m_extent = Parameters("M_EXTENT")->asInt();
m_adjust = Parameters("ADJUST")->asInt();
initVal = Parameters("INIT")->asDouble();
pShapesList = Parameters("SHAPESLIST")->asShapesList();
pGridList = Parameters("GRIDLIST")->asGridList();
if( useoff )
{
xMin += offset_x;
yMin += offset_y;
xMax += offset_x;
yMax += offset_y;
}
switch( m_extent )
{
case 0: // xMin, yMin, NX, NY
System.Assign(cellsize, xMin, yMin, NX, NY);
break;
case 1: // xMin, yMin, xMax, yMax
if( xMin > xMax || yMin > yMax )
{
Message_Add(CSG_String::Format(_TL("\nError: Please verify your xMin, yMin, xMax, yMax settings!\n")));
return false;
}
xRange = xMax - xMin;
yRange = yMax - yMin;
if( m_adjust == 0 ) // extent to cellsize
{
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) floor(xRange / cellsize + 0.5);
xMax = xMin + NX * cellsize;
}
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) floor(yRange / cellsize + 0.5);
yMax = yMin + NY * cellsize;
}
}
else if( m_adjust == 1) // cellsize to W-E extent
{
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) (xRange/cellsize);
cellsize = xRange/NX;
}
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) floor(yRange / cellsize + 0.5);
yMax = yMin + NY * cellsize;
}
}
else // cellsize to S-N extent
{
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) (yRange/cellsize);
cellsize = yRange/NY;
}
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) floor(xRange / cellsize + 0.5);
xMax = xMin + NX * cellsize;
}
}
System.Assign(cellsize, xMin, yMin, xMax, yMax);
break;
case 2: // Shape(s)
if( pShapesList == NULL || pShapesList->Get_Count() == 0)
{
Message_Add(CSG_String::Format(_TL("\nError: the method Extent by Shape(s) requires shape(s) as input!\n")));
return false;
}
for (i=0; i<pShapesList->Get_Count(); i++)
{
pShapes = pShapesList->asShapes(i);
extent = pShapes->Get_Extent();
if (i==0)
{
xMin = extent.Get_XMin();
yMin = extent.Get_YMin();
xMax = extent.Get_XMax();
yMax = extent.Get_YMax();
}
else
{
xMin = (extent.Get_XMin() < xMin) ? extent.Get_XMin() : xMin;
yMin = (extent.Get_YMin() < yMin) ? extent.Get_YMin() : yMin;
xMax = (extent.Get_XMax() > xMax) ? extent.Get_XMax() : xMax;
yMax = (extent.Get_YMax() > yMax) ? extent.Get_YMax() : yMax;
}
}
if( useoff )
{
xMin += offset_x;
xMax += offset_x;
yMin += offset_y;
yMax += offset_y;
}
xRange = xMax - xMin;
yRange = yMax - yMin;
if( m_adjust == 0 ) // extent to cellsize
{
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) floor(xRange / cellsize + 0.5);
xMax = xMin + NX * cellsize;
}
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) floor(yRange / cellsize + 0.5);
yMax = yMin + NY * cellsize;
}
}
else if( m_adjust == 1) // cellsize to W-E extent
{
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) (xRange/cellsize);
cellsize = xRange/NX;
}
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) floor(yRange / cellsize + 0.5);
yMax = yMin + NY * cellsize;
}
}
else // cellsize to S-N extent
{
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) (yRange/cellsize);
cellsize = yRange/NY;
}
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) floor(xRange / cellsize + 0.5);
xMax = xMin + NX * cellsize;
}
}
System.Assign(cellsize, xMin, yMin, xMax, yMax);
break;
case 3: // Grid(s)
if( pGridList == NULL || pGridList->Get_Count() == 0)
{
Message_Add(CSG_String::Format(_TL("\nError: the method Extent by Grid(s) requires grid(s) as input!\n")));
return false;
}
for (i=0; i<pGridList->Get_Count(); i++)
{
pDummy = pGridList->asGrid(i);
extent = pDummy->Get_Extent();
if (i==0)
{
xMin = extent.Get_XMin();
yMin = extent.Get_YMin();
xMax = extent.Get_XMax();
yMax = extent.Get_YMax();
}
else
{
xMin = (extent.Get_XMin() < xMin) ? extent.Get_XMin() : xMin;
yMin = (extent.Get_YMin() < yMin) ? extent.Get_YMin() : yMin;
xMax = (extent.Get_XMax() > xMax) ? extent.Get_XMax() : xMax;
yMax = (extent.Get_YMax() > yMax) ? extent.Get_YMax() : yMax;
}
}
if( useoff )
{
xMin += offset_x;
xMax += offset_x;
yMin += offset_y;
yMax += offset_y;
}
xRange = xMax - xMin;
yRange = yMax - yMin;
if( m_adjust == 0 ) // extent to cellsize
{
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) floor(xRange / cellsize + 0.5);
xMax = xMin + NX * cellsize;
}
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) floor(yRange / cellsize + 0.5);
yMax = yMin + NY * cellsize;
}
}
else if( m_adjust == 1) // cellsize to W-E extent
{
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) (xRange/cellsize);
cellsize = xRange/NX;
}
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) floor(yRange / cellsize + 0.5);
yMax = yMin + NY * cellsize;
}
}
else // cellsize to S-N extent
{
if( modf((yRange/cellsize), &n) != 0.0 )
{
NY = (int) (yRange/cellsize);
cellsize = yRange/NY;
}
if( modf((xRange/cellsize), &n) != 0.0 )
{
NX = (int) floor(xRange / cellsize + 0.5);
xMax = xMin + NX * cellsize;
}
}
System.Assign(cellsize, xMin, yMin, xMax, yMax);
break;
}
pDummy = SG_Create_Grid(System, SG_DATATYPE_Double);
pDummy->Assign(initVal);
pDummy->Set_Name(_TL("Dummy Grid"));
Parameters("GRID")->Set_Value(pDummy);
return (true);
}
bool CSG_Rect::is_Equal(const CSG_Rect &Rect, double epsilon) const
{
return( is_Equal(Rect.Get_XMin(), Rect.Get_YMin(), Rect.Get_XMax(), Rect.Get_YMax(), epsilon) );
}
//---------------------------------------------------------
bool CGCS_Graticule::Get_Coordinate(const CSG_Rect &Extent, CSG_Shapes *pCoordinates, CSG_Shape *pLine, int Axis)
{
if( !pCoordinates || !Extent.Intersects(pLine->Get_Extent()) || pLine->Get_Point_Count(0) < 2 )
{
return( false );
}
TSG_Point A[2], B[2], C;
switch( Axis )
{
case AXIS_LEFT : A[0].x = A[1].x = Extent.Get_XMin(); A[0].y = Extent.Get_YMin(); A[1].y = Extent.Get_YMax(); break;
case AXIS_RIGHT : A[0].x = A[1].x = Extent.Get_XMax(); A[0].y = Extent.Get_YMin(); A[1].y = Extent.Get_YMax(); break;
case AXIS_BOTTOM: A[0].y = A[1].y = Extent.Get_YMin(); A[0].x = Extent.Get_XMin(); A[1].x = Extent.Get_XMax(); break;
case AXIS_TOP : A[0].y = A[1].y = Extent.Get_YMax(); A[0].x = Extent.Get_XMin(); A[1].x = Extent.Get_XMax(); break;
default:
return( false );
}
//-----------------------------------------------------
B[1] = pLine->Get_Point(0);
for(int i=1; i<pLine->Get_Point_Count(); i++)
{
B[0] = B[1];
B[1] = pLine->Get_Point(i);
if( SG_Get_Crossing(C, A[0], A[1], B[0], B[1], true) )
{
CSG_Shape *pPoint = pCoordinates->Add_Shape();
pPoint->Add_Point(C);
pPoint->Set_Value(0, CSG_String(pLine->asString(0)) + (Axis == AXIS_LEFT || Axis == AXIS_BOTTOM ? "_MIN" : "_MAX"));
pPoint->Set_Value(1, pLine->asString(1));
return( true );
}
}
//-----------------------------------------------------
switch( Axis )
{
case AXIS_LEFT : C = pLine->Get_Point(0, 0, true ); break;
case AXIS_RIGHT : C = pLine->Get_Point(0, 0, false); break;
case AXIS_BOTTOM: C = pLine->Get_Point(0, 0, true ); break;
case AXIS_TOP : C = pLine->Get_Point(0, 0, false); break;
}
if( Extent.Contains(C) )
{
CSG_Shape *pPoint = pCoordinates->Add_Shape();
pPoint->Add_Point(C);
pPoint->Set_Value(0, CSG_String(pLine->asString(0)) + (Axis == AXIS_LEFT || Axis == AXIS_BOTTOM ? "_MIN" : "_MAX"));
pPoint->Set_Value(1, pLine->asString(1));
return( true );
}
//-----------------------------------------------------
return( false );
}
//---------------------------------------------------------
bool CShapes_Cut::Get_Extent(CSG_Rect &r)
{
m_pPolygons = NULL;
switch( Parameters("TARGET")->asInt() )
{
//-----------------------------------------------------
case 0: // user defined
Get_Parameters("CUT")->Get_Parameter("AX")->Set_Value(r.Get_XMin());
Get_Parameters("CUT")->Get_Parameter("AY")->Set_Value(r.Get_YMin());
Get_Parameters("CUT")->Get_Parameter("BX")->Set_Value(r.Get_XMax());
Get_Parameters("CUT")->Get_Parameter("BY")->Set_Value(r.Get_YMax());
Get_Parameters("CUT")->Get_Parameter("DX")->Set_Value(r.Get_XRange());
Get_Parameters("CUT")->Get_Parameter("DY")->Set_Value(r.Get_YRange());
if( Dlg_Parameters("CUT") )
{
r.Assign(
Get_Parameters("CUT")->Get_Parameter("AX")->asDouble(),
Get_Parameters("CUT")->Get_Parameter("AY")->asDouble(),
Get_Parameters("CUT")->Get_Parameter("BX")->asDouble(),
Get_Parameters("CUT")->Get_Parameter("BY")->asDouble()
);
return( true );
}
break;
//-----------------------------------------------------
case 1: // grid project
if( Dlg_Parameters("GRID") )
{
r.Assign(Get_Parameters("GRID")->Get_Parameter("GRID")->asGrid_System()->Get_Extent());
return( true );
}
break;
//-----------------------------------------------------
case 2: // shapes extent
if( Dlg_Parameters("SHAPES") )
{
r.Assign(Get_Parameters("SHAPES")->Get_Parameter("SHAPES")->asShapes()->Get_Extent());
return( true );
}
break;
//-----------------------------------------------------
case 3: // polygons
if( Dlg_Parameters("POLYGONS") )
{
r.Assign(Get_Parameters("POLYGONS")->Get_Parameter("POLYGONS")->asShapes()->Get_Extent());
m_pPolygons = Get_Parameters("POLYGONS")->Get_Parameter("POLYGONS")->asShapes();
return( true );
}
break;
}
return( false );
}
//---------------------------------------------------------
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 CGrid_Rectangle_Clip::On_Execute(void)
{
CSG_Grid *pGrid_in, *pGrid_out;
CSG_Shapes *pShapes;
int iMethod;
//-----------------------------------------------------
pGrid_in = Parameters("INPUT") ->asGrid();
pShapes = Parameters("SHAPES") ->asShapes();
iMethod = Parameters("BORDER") ->asInt();
//-----------------------------------------------------
CSG_Rect Extent;
if( pShapes->Get_Selection_Count() > 0 )
{
bool bFirst = true;
for(int iShape=0; iShape<pShapes->Get_Count() && Set_Progress(iShape, pShapes->Get_Count()); iShape++)
{
if( pShapes->Get_Shape(iShape)->is_Selected() )
{
if( bFirst )
{
Extent = pShapes->Get_Shape(iShape)->Get_Extent();
bFirst = false;
}
else
{
Extent.Union(pShapes->Get_Shape(iShape)->Get_Extent());
}
}
}
}
else
Extent = pShapes->Get_Extent();
//-----------------------------------------------------
if( iMethod == 0 )
{
Extent.Deflate(0.5 * pGrid_in->Get_Cellsize(), 0.5 * pGrid_in->Get_Cellsize(), false);
}
else if( iMethod == 2 )
{
double d, minX, minY;
d = Extent.Get_XMin() - pGrid_in->Get_XMin(true);
minX = pGrid_in->Get_XMin(true) + floor(d / pGrid_in->Get_Cellsize()) * pGrid_in->Get_Cellsize() + 0.5 * pGrid_in->Get_Cellsize();
d = Extent.Get_YMin() - pGrid_in->Get_YMin(true);
minY = pGrid_in->Get_YMin(true) + floor(d / pGrid_in->Get_Cellsize()) * pGrid_in->Get_Cellsize() + 0.5 * pGrid_in->Get_Cellsize();
Extent.Set_BottomLeft(minX, minY);
}
CSG_Grid_System GridSystem(pGrid_in->Get_Cellsize(), Extent);
pGrid_out = SG_Create_Grid(GridSystem, pGrid_in->Get_Type());
pGrid_out->Set_NoData_Value(pGrid_in->Get_NoData_Value());
pGrid_out->Set_Name(CSG_String::Format(SG_T("%s_clip"), pGrid_in->Get_Name()));
pGrid_out->Assign_NoData();
//-----------------------------------------------------
for(int y=0; y<pGrid_out->Get_NY() && Set_Progress(y, pGrid_out->Get_NY()); y++)
{
#pragma omp parallel for
for(int x=0; x<pGrid_out->Get_NX(); x++)
{
double xWorld = GridSystem.Get_xGrid_to_World(x);
double yWorld = GridSystem.Get_yGrid_to_World(y);
int xGrid, yGrid;
pGrid_in->Get_System().Get_World_to_Grid(xGrid, yGrid, xWorld, yWorld);
if (pGrid_in->is_InGrid(xGrid, yGrid))
pGrid_out->Set_Value(x, y, pGrid_in->asDouble(xGrid, yGrid));
}
}
//-----------------------------------------------------
Parameters("OUTPUT")->Set_Value(pGrid_out);
return( true );
}
//---------------------------------------------------------
bool CSG_PRQuadTree::Create(const CSG_Rect &Extent, bool bStatistics)
{
Destroy();
if( Extent.Get_XRange() > 0.0 && Extent.Get_YRange() > 0.0 )
{
if( bStatistics )
{
m_pRoot = new CSG_PRQuadTree_Node_Statistics(
Extent.Get_XCenter(),
Extent.Get_YCenter(),
(0.5 + 0.01) * (Extent.Get_XRange() > Extent.Get_YRange() ? Extent.Get_XRange() : Extent.Get_YRange())
);
}
else
{
m_pRoot = new CSG_PRQuadTree_Node(
Extent.Get_XCenter(),
Extent.Get_YCenter(),
(0.5 + 0.01) * (Extent.Get_XRange() > Extent.Get_YRange() ? Extent.Get_XRange() : Extent.Get_YRange())
);
}
return( true );
}
return( false );
}
//---------------------------------------------------------
bool CGCS_Graticule::Get_Graticule(const CSG_Rect &Extent)
{
double x, y, Interval;
CSG_Rect r;
if( !Get_Extent(Extent, r) || (Interval = Get_Interval(r)) <= 0.0 )
{
return( false );
}
//-----------------------------------------------------
r.m_rect.xMin = Interval * floor(r.Get_XMin() / Interval);
r.m_rect.xMax = Interval * ceil (r.Get_XMax() / Interval);
r.m_rect.yMin = Interval * floor(r.Get_YMin() / Interval);
r.m_rect.yMax = Interval * ceil (r.Get_YMax() / Interval);
r.Inflate(Interval, false);
if( r.Get_XMin() < -180.0 ) r.m_rect.xMin = -180.0;
if( r.Get_XMax() > 180.0 ) r.m_rect.xMax = 180.0;
if( r.Get_YMin() < -90.0 ) r.m_rect.yMin = -90.0;
if( r.Get_YMax() > 90.0 ) r.m_rect.yMax = 90.0;
//-----------------------------------------------------
double Resolution = Parameters("RESOLUTION")->asDouble(); if( Resolution <= 0.0 ) Resolution = Interval;
if( Interval > Resolution )
{
Resolution = Interval / ceil(Interval / Resolution);
}
//-----------------------------------------------------
CSG_Shapes *pGraticule = Parameters("GRATICULE")->asShapes();
pGraticule->Create(SHAPE_TYPE_Line);
pGraticule->Set_Name(_TL("Graticule"));
pGraticule->Add_Field("TYPE" , SG_DATATYPE_String);
pGraticule->Add_Field("LABEL" , SG_DATATYPE_String);
pGraticule->Add_Field("DEGREE", SG_DATATYPE_Double);
//-----------------------------------------------------
CSG_Shapes *pCoordinates = Parameters("COORDS")->asShapes();
if( pCoordinates )
{
pCoordinates->Create(SHAPE_TYPE_Point);
pCoordinates->Set_Name(_TL("Coordinates"));
pCoordinates->Add_Field("TYPE" , SG_DATATYPE_String);
pCoordinates->Add_Field("LABEL", SG_DATATYPE_String);
}
//-----------------------------------------------------
CSG_Shapes Clip(SHAPE_TYPE_Polygon);
CSG_Shape *pClip = Clip.Add_Shape();
pClip->Add_Point(Extent.Get_XMin(), Extent.Get_YMin());
pClip->Add_Point(Extent.Get_XMin(), Extent.Get_YMax());
pClip->Add_Point(Extent.Get_XMax(), Extent.Get_YMax());
pClip->Add_Point(Extent.Get_XMax(), Extent.Get_YMin());
pClip->Add_Point(Extent.Get_XMin(), Extent.Get_YMin());
//-----------------------------------------------------
for(y=r.Get_YMin(); y<=r.Get_YMax(); y+=Interval)
{
CSG_Shape *pLine = pGraticule->Add_Shape();
pLine->Set_Value(0, "LAT");
pLine->Set_Value(1, Get_Degree(y, DEG_PREC_DEG));
pLine->Set_Value(2, y);
for(x=r.Get_XMin(); x<=r.Get_XMax(); x+=Interval)
{
CSG_Point p(x, y); m_Projector.Get_Projection(p); pLine->Add_Point(p);
if( Resolution < Interval && x < r.Get_XMax() )
{
for(double i=x+Resolution; i<x+Interval; i+=Resolution)
{
CSG_Point p(i, y); m_Projector.Get_Projection(p); pLine->Add_Point(p);
}
}
}
Get_Coordinate(Extent, pCoordinates, pLine, AXIS_LEFT);
Get_Coordinate(Extent, pCoordinates, pLine, AXIS_RIGHT);
if( !SG_Polygon_Intersection(pLine, pClip) )
{
pGraticule->Del_Shape(pLine);
}
}
//-----------------------------------------------------
for(x=r.Get_XMin(); x<=r.Get_XMax(); x+=Interval)
{
CSG_Shape *pLine = pGraticule->Add_Shape();
pLine->Set_Value(0, "LON");
pLine->Set_Value(1, Get_Degree(x, DEG_PREC_DEG));
pLine->Set_Value(2, x);
for(y=r.Get_YMin(); y<=r.Get_YMax(); y+=Interval)
{
CSG_Point p(x, y); m_Projector.Get_Projection(p); pLine->Add_Point(p);
if( Resolution < Interval && y < r.Get_YMax() )
{
for(double i=y+Resolution; i<y+Interval; i+=Resolution)
{
CSG_Point p(x, i); m_Projector.Get_Projection(p); pLine->Add_Point(p);
}
}
}
Get_Coordinate(Extent, pCoordinates, pLine, AXIS_BOTTOM);
Get_Coordinate(Extent, pCoordinates, pLine, AXIS_TOP);
if( !SG_Polygon_Intersection(pLine, pClip) )
{
pGraticule->Del_Shape(pLine);
}
}
//-----------------------------------------------------
return( true );
}
//---------------------------------------------------------
bool CGCS_Graticule::Get_Extent(const CSG_Rect &Extent, CSG_Rect &r)
{
if( m_Projector.Set_Inverse() )
{
double x, y, d;
CSG_Point p(Extent.Get_XMin(), Extent.Get_YMin());
m_Projector.Get_Projection(p); r.Assign(p, p);
d = Extent.Get_XRange() / 10.0;
for(y=Extent.Get_YMin(), x=Extent.Get_XMin(); x<=Extent.Get_XMax(); x+=d)
{
p.Assign(x, y); m_Projector.Get_Projection(p); r.Union(p);
}
for(y=Extent.Get_YMax(), x=Extent.Get_XMin(); x<=Extent.Get_XMax(); x+=d)
{
p.Assign(x, y); m_Projector.Get_Projection(p); r.Union(p);
}
d = Extent.Get_YRange() / 10.0;
for(x=Extent.Get_XMin(), y=Extent.Get_YMin(); y<=Extent.Get_YMax(); y+=d)
{
p.Assign(x, y); m_Projector.Get_Projection(p); r.Union(p);
}
for(x=Extent.Get_XMax(), y=Extent.Get_YMin(); y<=Extent.Get_YMax(); y+=d)
{
p.Assign(x, y); m_Projector.Get_Projection(p); r.Union(p);
}
m_Projector.Set_Inverse(false);
if( r.Get_XMin() < -180 ) r.m_rect.xMin = -180; else if( r.Get_XMax() > 180 ) r.m_rect.xMax = 180;
if( r.Get_YMin() < -90 ) r.m_rect.yMin = -90; else if( r.Get_YMax() > 90 ) r.m_rect.yMax = 90;
return( r.Get_XRange() > 0.0 && r.Get_YRange() > 0.0 );
}
return( false );
}
bool CSG_Rect::is_Equal(const CSG_Rect &Rect) const
{
return( is_Equal(Rect.Get_XMin(), Rect.Get_YMin(), Rect.Get_XMax(), Rect.Get_YMax()) );
}
void CSG_Rect::Assign(const CSG_Rect &Rect)
{
Assign(Rect.Get_XMin(), Rect.Get_YMin(), Rect.Get_XMax(), Rect.Get_YMax());
}
