//---------------------------------------------------------
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 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) ;
}
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
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 );
}
//---------------------------------------------------------
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 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 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 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 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 );
}
void CSG_Rect::Assign(const CSG_Rect &Rect)
{
Assign(Rect.Get_XMin(), Rect.Get_YMin(), Rect.Get_XMax(), Rect.Get_YMax());
}
//---------------------------------------------------------
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 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 CSG_Rect::is_Equal(const CSG_Rect &Rect) const
{
return( is_Equal(Rect.Get_XMin(), Rect.Get_YMin(), Rect.Get_XMax(), 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 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 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) );
}
