//--------------------------------------------------------- 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 ); }
//--------------------------------------------------------- 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 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 ); }
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 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 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 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 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 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) ); }