OGRErr OGRCompoundCurve::addCurveDirectlyInternal( OGRCurve* poCurve,
double dfToleranceEps,
int bNeedRealloc )
{
if( poCurve->getNumPoints() == 1 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid curve: not enough points");
return OGRERR_FAILURE;
}
const OGRwkbGeometryType eCurveType =
wkbFlatten(poCurve->getGeometryType());
if( EQUAL(poCurve->getGeometryName(), "LINEARRING") )
{
CPLError(CE_Failure, CPLE_AppDefined, "Linearring not allowed.");
return OGRERR_FAILURE;
}
else if( eCurveType == wkbCompoundCurve )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot add a compound curve inside a compound curve");
return OGRERR_FAILURE;
}
if( oCC.nCurveCount > 0 )
{
if( oCC.papoCurves[oCC.nCurveCount-1]->IsEmpty() ||
poCurve->IsEmpty() )
{
CPLError(CE_Failure, CPLE_AppDefined, "Non contiguous curves");
return OGRERR_FAILURE;
}
OGRPoint end;
OGRPoint start;
oCC.papoCurves[oCC.nCurveCount-1]->EndPoint(&end);
poCurve->StartPoint(&start);
if( fabs(end.getX() - start.getX()) > dfToleranceEps ||
fabs(end.getY() - start.getY()) > dfToleranceEps ||
fabs(end.getZ() - start.getZ()) > dfToleranceEps )
{
poCurve->EndPoint(&start);
if( fabs(end.getX() - start.getX()) > dfToleranceEps ||
fabs(end.getY() - start.getY()) > dfToleranceEps ||
fabs(end.getZ() - start.getZ()) > dfToleranceEps )
{
CPLError(CE_Failure, CPLE_AppDefined, "Non contiguous curves");
return OGRERR_FAILURE;
}
CPLDebug("GML", "reversing curve");
((OGRSimpleCurve*)poCurve)->reversePoints();
}
// Patch so that it matches exactly.
((OGRSimpleCurve*)poCurve)->setPoint(0, &end);
}
return oCC.addCurveDirectly(this, poCurve, bNeedRealloc);
}
void wxGISSimpleCircleSymbol::Draw(const wxGISGeometry &Geometry, int nLevel)
{
if (!Geometry.IsOk() || !m_pDisplay)
return;
OGRwkbGeometryType eGeomType = wkbFlatten(Geometry.GetType());
if (eGeomType != wkbMultiPoint)
return;
OGREnvelope Env;
OGRGeometry *pGeom = Geometry;
OGRMultiPoint* pMPT = (OGRMultiPoint*)pGeom;
OGRPoint* pCenterPt = (OGRPoint*)pMPT->getGeometryRef(0);
OGRPoint* pOriginPt = (OGRPoint*)pMPT->getGeometryRef(1);
double dfRadius = sqrt((pCenterPt->getX() - pOriginPt->getX())*(pCenterPt->getX() - pOriginPt->getX()) + (pCenterPt->getY() - pOriginPt->getY())*(pCenterPt->getY() - pOriginPt->getY()));
Env.MaxX = pCenterPt->getX() + dfRadius;
Env.MinX = pCenterPt->getX() - dfRadius;
Env.MaxY = pCenterPt->getY() + dfRadius;
Env.MinY = pCenterPt->getY() - dfRadius;
if (!m_pDisplay->CanDraw(Env))
return;
wxCriticalSectionLocker lock(m_pDisplay->GetLock());
if (!m_pDisplay->CheckDrawAsPoint(Env, m_pLineSymbol->GetWidth()))
{
if (!m_pDisplay->DrawCircle(pCenterPt->getX(), pCenterPt->getY(), 0, 0, dfRadius))
{
return;
}
if (m_Color.Alpha() > 0)
{
switch (m_eFillRule)
{
case enumGISFillRuleWinding:
m_pDisplay->SetFillRule(CAIRO_FILL_RULE_WINDING);
break;
case enumGISFillRuleOdd:
m_pDisplay->SetFillRule(CAIRO_FILL_RULE_EVEN_ODD);
break;
}
m_pDisplay->SetColor(m_Color);
m_pDisplay->FillPreserve();
}
}
m_pLineSymbol->SetStyleToDisplay();
m_pDisplay->Stroke();
}
OGRErr OGRMultiPoint::exportToWkt( char ** ppszDstText ) const
{
int nMaxString = getNumGeometries() * 20 + 128;
int nRetLen = 0;
if( getNumGeometries() == 0 )
{
*ppszDstText = CPLStrdup("MULTIPOINT(EMPTY)");
return OGRERR_NONE;
}
*ppszDstText = (char *) VSIMalloc( nMaxString );
if( *ppszDstText == NULL )
return OGRERR_NOT_ENOUGH_MEMORY;
sprintf( *ppszDstText, "%s (", getGeometryName() );
for( int i = 0; i < getNumGeometries(); i++ )
{
OGRPoint *poPoint = (OGRPoint *) getGeometryRef( i );
if( i > 0 )
strcat( *ppszDstText + nRetLen, "," );
nRetLen += strlen(*ppszDstText + nRetLen);
if( nMaxString < nRetLen + 100 )
{
nMaxString = nMaxString * 2;
*ppszDstText = (char *) CPLRealloc(*ppszDstText,nMaxString);
}
if( poPoint->getCoordinateDimension() == 3 )
OGRMakeWktCoordinate( *ppszDstText + nRetLen,
poPoint->getX(),
poPoint->getY(),
poPoint->getZ() );
else
OGRMakeWktCoordinate( *ppszDstText + nRetLen,
poPoint->getX(),
poPoint->getY(),
0.0 );
}
strcat( *ppszDstText+nRetLen, ")" );
return OGRERR_NONE;
}
double OGRCompoundCurve::get_Area() const
{
if( IsEmpty() || !get_IsClosed() )
return 0;
// Optimization for convex rings.
if( IsConvex() )
{
// Compute area of shape without the circular segments.
OGRPointIterator* poIter = getPointIterator();
OGRLineString oLS;
oLS.setNumPoints( getNumPoints() );
OGRPoint p;
for( int i = 0; poIter->getNextPoint(&p); i++ )
{
oLS.setPoint( i, p.getX(), p.getY() );
}
double dfArea = oLS.get_Area();
delete poIter;
// Add the area of the spherical segments.
dfArea += get_AreaOfCurveSegments();
return dfArea;
}
OGRLineString* poLS = CurveToLine();
double dfArea = poLS->get_Area();
delete poLS;
return dfArea;
}
OGRErr TigerPoint::CreateFeature( OGRFeature *poFeature,
int pointIndex)
{
char szRecord[OGR_TIGER_RECBUF_LEN];
OGRPoint *poPoint = poFeature->GetGeometryRef()->toPoint();
if( !SetWriteModule( m_pszFileCode, psRTInfo->nRecordLength+2, poFeature ) )
return OGRERR_FAILURE;
memset( szRecord, ' ', psRTInfo->nRecordLength );
WriteFields( psRTInfo, poFeature, szRecord );
if( poPoint != nullptr
&& (poPoint->getGeometryType() == wkbPoint
|| poPoint->getGeometryType() == wkbPoint25D) ) {
WritePoint( szRecord, pointIndex, poPoint->getX(), poPoint->getY() );
} else {
if (bRequireGeom) {
return OGRERR_FAILURE;
}
}
WriteRecord( szRecord, psRTInfo->nRecordLength, m_pszFileCode );
return OGRERR_NONE;
}
OGRBoolean OGRPoint::Equals( OGRGeometry * poOther ) const
{
if( poOther== this )
return TRUE;
if( poOther->getGeometryType() != getGeometryType() )
return FALSE;
OGRPoint *poOPoint = dynamic_cast<OGRPoint *>(poOther);
if( poOPoint == NULL )
{
CPLError(CE_Fatal, CPLE_AppDefined,
"dynamic_cast failed. Expected OGRPoint.");
return FALSE;
}
if( flags != poOPoint->flags )
return FALSE;
if( IsEmpty() )
return TRUE;
// Should eventually test the SRS.
if( poOPoint->getX() != getX()
|| poOPoint->getY() != getY()
|| poOPoint->getZ() != getZ() )
return FALSE;
return TRUE;
}
osg::Geometry* multiPointToDrawable(OGRMultiPoint* mpoint) const
{
osg::Geometry* geom = new osg::Geometry;
osg::Geometry* pointGeom = new osg::Geometry();
osg::Vec3Array* vertices = new osg::Vec3Array();
vertices->reserve(mpoint->getNumGeometries());
for (int i = 0; i < mpoint->getNumGeometries(); i++ )
{
OGRGeometry* ogrGeom = mpoint->getGeometryRef(i);
OGRwkbGeometryType ogrGeomType = ogrGeom->getGeometryType();
if (wkbPoint != ogrGeomType && wkbPoint25D != ogrGeomType)
continue; // skip
OGRPoint* points = static_cast<OGRPoint*>(ogrGeom);
vertices->push_back(osg::Vec3(points->getX(), points->getY(), points->getZ()));
}
pointGeom->setVertexArray(vertices);
pointGeom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POINTS, 0, vertices->size()));
if (pointGeom->getVertexArray())
{
OSG_INFO << "osgOgrFeature::multiPointToDrawable " << geom->getVertexArray()->getNumElements() << " vertexes"<< std::endl;
}
return pointGeom;
}
void wxGISSimpleMarkerSymbol::Draw(const wxGISGeometry &Geometry, int nLevel)
{
if(!Geometry.IsOk() ||!m_pDisplay)
return;
OGRwkbGeometryType eGeomType = wkbFlatten(Geometry.GetType());
if(eGeomType != wkbPoint && eGeomType != wkbMultiPoint)
return;
OGREnvelope Env = Geometry.GetEnvelope();
if(!m_pDisplay->CanDraw(Env))
return;
OGRGeometry *pGeom = Geometry;
if(eGeomType == wkbMultiPoint)
{
OGRGeometryCollection* pOGRGeometryCollection = (OGRGeometryCollection*)pGeom;
for(int i = 0; i < pOGRGeometryCollection->getNumGeometries(); ++i)
Draw(wxGISGeometry(pOGRGeometryCollection->getGeometryRef(i), false));
return;
}
wxCriticalSectionLocker lock(m_pDisplay->GetLock());
OGRPoint* pPoint = (OGRPoint*)pGeom;
if(m_dfOutlineSize)
{
if(!m_pDisplay->DrawPointFast(pPoint->getX(), pPoint->getY()))
{
return;
}
m_pDisplay->SetColor(m_OutlineColor);
m_pDisplay->SetLineWidth( m_dfSize + m_dfOutlineSize + m_dfOutlineSize);
m_pDisplay->Stroke();
}
if(!m_pDisplay->DrawPointFast(pPoint->getX(), pPoint->getY()))
{
return;
}
m_pDisplay->SetColor(m_Color);
m_pDisplay->SetLineWidth( m_dfSize );
m_pDisplay->SetLineCap(CAIRO_LINE_CAP_ROUND);
m_pDisplay->Stroke();
}
static unsigned long HashAirwayIntersectionFeatureFunc(const void* _feature)
{
OGRFeature* feature = (OGRFeature*)_feature;
OGRPoint* point = (OGRPoint*) feature->GetGeometryRef();
unsigned long hash = CPLHashSetHashStr((unsigned char*)feature->GetFieldAsString(0));
const double x = point->getX();
const double y = point->getY();
return hash ^ OGRXPlaneAirwayHashDouble(x) ^ OGRXPlaneAirwayHashDouble(y);
}
OGRErr GTMWaypointLayer::CreateFeature (OGRFeature *poFeature)
{
FILE* fp = poDS->getOutputFP();
if (fp == NULL)
return CE_Failure;
OGRGeometry *poGeom = poFeature->GetGeometryRef();
if ( poGeom == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Features without geometry not supported by GTM writer in waypoints layer." );
return OGRERR_FAILURE;
}
if (NULL != poCT)
{
poGeom = poGeom->clone();
poGeom->transform( poCT );
}
switch( poGeom->getGeometryType() )
{
case wkbPoint:
case wkbPoint25D:
{
OGRPoint* point = (OGRPoint*)poGeom;
double lat = point->getY();
double lon = point->getX();
CheckAndFixCoordinatesValidity(lat, lon);
poDS->checkBounds((float)lat, (float)lon);
writeDouble(fp, lat);
writeDouble(fp, lon);
float altitude = 0.0;
if (poGeom->getGeometryType() == wkbPoint25D)
altitude = (float) point->getZ();
WriteFeatureAttributes(poFeature, altitude);
break;
}
default:
{
CPLError( CE_Failure, CPLE_NotSupported,
"Geometry type of `%s' not supported for 'waypoint' element.\n",
OGRGeometryTypeToName(poGeom->getGeometryType()) );
return OGRERR_FAILURE;
}
}
if (NULL != poCT)
delete poGeom;
return OGRERR_NONE;
}
osg::Geometry* polygonToDrawable(OGRPolygon* polygon) const
{
osg::Geometry* geom = new osg::Geometry();
osg::Vec3Array* vertices = new osg::Vec3Array();
geom->setVertexArray(vertices);
{
OGRLinearRing *ring = polygon->getExteriorRing();
OGRPoint point;
for(int i = 0; i < ring->getNumPoints(); i++)
{
ring->getPoint(i, &point);
vertices->push_back(osg::Vec3(point.getX(), point.getY(), point.getZ()));
}
geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINE_LOOP, 0, vertices->size()));
}
if (polygon->getNumInteriorRings())
{
for (int i = 0; i < polygon->getNumInteriorRings(); i++)
{
OGRLinearRing *ring = polygon->getInteriorRing(i);
OGRPoint point;
for (int j = 0; j < ring->getNumPoints(); j++)
{
ring->getPoint(j, &point);
vertices->push_back(osg::Vec3(point.getX(), point.getY(), point.getZ()));
}
geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINE_LOOP, vertices->size()-ring->getNumPoints() , ring->getNumPoints()));
}
}
osgUtil::Tessellator tsl;
tsl.setTessellationType(osgUtil::Tessellator::TESS_TYPE_GEOMETRY);
tsl.setBoundaryOnly(false);
tsl.retessellatePolygons(*geom);
osg::Vec3Array* array = triangulizeGeometry(geom);
geom->setVertexArray(array);
geom->removePrimitiveSet(0,geom->getNumPrimitiveSets());
geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::TRIANGLES, 0, array->size()));
return geom;
}
void GeometryPainter::_convertRingToQPolygon(const OGRLinearRing* ring, QPolygonF& qp,
const QMatrix& m)
{
OGRPoint p;
qp.resize(ring->getNumPoints());
for (int i = 0; i < ring->getNumPoints(); i++)
{
ring->getPoint(i, &p);
qp[i] = QPointF(m.map(QPointF(p.getX(), p.getY())) - QPointF(0.5, 0.5));
}
}
void Shape::readRing(OGRLinearRing* ring, ShapePart& shapePart) {
shapePart.points.resize(ring->getNumPoints());
for (int j = 0; j < ring->getNumPoints(); ++j) {
OGRPoint point;
ring->getPoint(j, &point);
shapePart.points[j].x = point.getX();
shapePart.points[j].y = point.getY();
updateBounds(&point);
}
}
void Shape::readLineString(OGRLineString* lineString, ShapeObject& shapeObject) {
shapeObject.parts.resize(1);
shapeObject.parts[0].points.resize(lineString->getNumPoints());
for (int i = 0; i < lineString->getNumPoints(); ++i) {
OGRPoint point;
lineString->getPoint(i, &point);
shapeObject.parts[0].points[i].x = point.getX();
shapeObject.parts[0].points[i].y = point.getY();
updateBounds(&point);
}
}
inline Usul::Math::Vec3d convertAndTransform ( const OGRPoint& point, OGRCoordinateTransformation* transform, double verticalOffset )
{
// Declare the point.
Usul::Math::Vec3d p ( point.getX(), point.getY(), point.getZ() + verticalOffset );
// Transform the point.
if ( 0x0 != transform )
{
transform->Transform ( 1, &p[0], &p[1], &p[2] );
}
return p;
}
void OGRLinearRing::reverseWindingOrder()
{
int pos = 0;
OGRPoint tempPoint;
for( int i = 0; i < nPointCount / 2; i++ )
{
getPoint( i, &tempPoint );
pos = nPointCount - i - 1;
if( getCoordinateDimension() == 2 )
{
setPoint( i, getX(pos), getY(pos) );
setPoint( pos, tempPoint.getX(), tempPoint.getY() );
}
else
{
setPoint( i, getX(pos), getY(pos), getZ(pos) );
setPoint( pos, tempPoint.getX(), tempPoint.getY(), tempPoint.getZ() );
}
}
}
OGREnvelope wxGISShape::GetBounds() const
{
OGREnvelope oReturnBounds;
switch (m_eType)
{
case enumGISShapeTypeRectangle:
case enumGISShapeTypePolygon:
case enumGISShapeTypeLine:
case enumGISShapeTypeEllipse:
case enumGISShapeTypeMarker:
oReturnBounds = m_oGeom.GetEnvelope();
break;
case enumGISShapeTypeCircle:
{
OGRGeometry *pGeom = m_oGeom;
OGRMultiPoint* pMPT = (OGRMultiPoint*)pGeom;
OGRPoint* pCenterPt = (OGRPoint*)pMPT->getGeometryRef(0);
OGRPoint* pOriginPt = (OGRPoint*)pMPT->getGeometryRef(1);
double dfRadius = sqrt((pCenterPt->getX() - pOriginPt->getX())*(pCenterPt->getX() - pOriginPt->getX()) + (pCenterPt->getY() - pOriginPt->getY())*(pCenterPt->getY() - pOriginPt->getY()));
oReturnBounds.MaxX = pCenterPt->getX() + dfRadius;
oReturnBounds.MinX = pCenterPt->getX() - dfRadius;
oReturnBounds.MaxY = pCenterPt->getY() + dfRadius;
oReturnBounds.MinY = pCenterPt->getY() - dfRadius;
break;
}
#ifdef wxGIS_USE_SPLINE
case enumGISShapeTypeCurve://TODO:
case enumGISShapeTypeFreeHand:
break;
#endif //wxGIS_USE_SPLINE
case enumGISShapeTypeFreeHand:
oReturnBounds = m_oGeom.GetEnvelope();
break;
};
return oReturnBounds;
}
void GeometryPainter::drawLineString(QPainter& pt, const OGRLineString* lineString,
const QMatrix& m)
{
QPolygonF a(lineString->getNumPoints());
OGRPoint point;
for (int j = 0; j < lineString->getNumPoints(); j++)
{
lineString->getPoint(j, &point);
a[j] = QPointF(m.map(QPointF(point.getX(), point.getY())) - QPointF(0.5, 0.5));
}
pt.drawPolyline(a);
}
void OGRLinearRing::reverseWindingOrder()
{
int pos = 0;
OGRPoint tempPoint;
for( int i = 0; i < nPointCount / 2; i++ )
{
getPoint( i, &tempPoint );
pos = nPointCount - i - 1;
setPoint( i, getX(pos), getY(pos), getZ(pos) );
setPoint( pos, tempPoint.getX(), tempPoint.getY(), tempPoint.getZ() );
}
}
OGRErr OGRDXFWriterLayer::WriteINSERT( OGRFeature *poFeature )
{
WriteValue( 0, "INSERT" );
WriteCore( poFeature );
WriteValue( 100, "AcDbEntity" );
WriteValue( 100, "AcDbBlockReference" );
WriteValue( 2, poFeature->GetFieldAsString("BlockName") );
/* -------------------------------------------------------------------- */
/* Write location. */
/* -------------------------------------------------------------------- */
OGRPoint *poPoint = (OGRPoint *) poFeature->GetGeometryRef();
WriteValue( 10, poPoint->getX() );
if( !WriteValue( 20, poPoint->getY() ) )
return OGRERR_FAILURE;
if( poPoint->getGeometryType() == wkbPoint25D )
{
if( !WriteValue( 30, poPoint->getZ() ) )
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Write scaling. */
/* -------------------------------------------------------------------- */
int nScaleCount;
const double *padfScale =
poFeature->GetFieldAsDoubleList( "BlockScale", &nScaleCount );
if( nScaleCount == 3 )
{
WriteValue( 41, padfScale[0] );
WriteValue( 42, padfScale[1] );
WriteValue( 43, padfScale[2] );
}
/* -------------------------------------------------------------------- */
/* Write rotation. */
/* -------------------------------------------------------------------- */
double dfAngle = poFeature->GetFieldAsDouble( "BlockAngle" );
if( dfAngle != 0.0 )
{
WriteValue( 50, dfAngle ); // degrees
}
return OGRERR_NONE;
}
osg::Geometry* linearRingToDrawable(OGRLinearRing* ring) const
{
osg::Geometry* contourGeom = new osg::Geometry();
osg::Vec3Array* vertices = new osg::Vec3Array();
OGRPoint point;
for(int j = 0; j < ring->getNumPoints(); j++)
{
ring->getPoint(j, &point);
vertices->push_back(osg::Vec3(point.getX(), point.getY(),point.getZ()));
}
contourGeom->setVertexArray(vertices);
contourGeom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINE_LOOP, 0, vertices->size()));
return contourGeom;
}
int OGRPolygon::PointOnSurface( OGRPoint *poPoint ) const
{
if( poPoint == NULL )
return OGRERR_FAILURE;
#ifndef HAVE_GEOS
return OGRERR_FAILURE;
#else
GEOSGeom hThisGeosGeom = NULL;
GEOSGeom hOtherGeosGeom = NULL;
hThisGeosGeom = exportToGEOS();
if( hThisGeosGeom != NULL )
{
hOtherGeosGeom = GEOSPointOnSurface( hThisGeosGeom );
GEOSGeom_destroy( hThisGeosGeom );
if( hOtherGeosGeom == NULL )
return OGRERR_FAILURE;
OGRGeometry *poInsidePointGeom = (OGRGeometry *)
OGRGeometryFactory::createFromGEOS( hOtherGeosGeom );
GEOSGeom_destroy( hOtherGeosGeom );
if (poInsidePointGeom == NULL)
return OGRERR_FAILURE;
if (wkbFlatten(poInsidePointGeom->getGeometryType()) != wkbPoint)
{
delete poInsidePointGeom;
return OGRERR_FAILURE;
}
OGRPoint *poInsidePoint = (OGRPoint *) poInsidePointGeom;
poPoint->setX( poInsidePoint->getX() );
poPoint->setY( poInsidePoint->getY() );
delete poInsidePointGeom;
return OGRERR_NONE;
}
else
{
return OGRERR_FAILURE;
}
#endif /* HAVE_GEOS */
}
void wxSimpleMarkerSymbol::Draw(OGRGeometry* pGeometry, IDisplay* pwxGISDisplay)
{
IDisplayTransformation* pDisplayTransformation = pwxGISDisplay->GetDisplayTransformation();
OGRwkbGeometryType type = wkbFlatten(pGeometry->getGeometryType());
switch(type)
{
case wkbPoint:
{
OGRPoint *pPoint = (OGRPoint*)pGeometry;
OGRRawPoint Point;
Point.x = pPoint->getX();
Point.y = pPoint->getY();
wxPoint* pPoints = pDisplayTransformation->TransformCoordWorld2DC(&Point, 1);
pwxGISDisplay->SetBrush(m_Brush);
pwxGISDisplay->SetPen(m_Pen);
pwxGISDisplay->DrawCircle(pPoints[0].x, pPoints[0].y, m_Size);
delete[](pPoints);
}
break;
case wkbPolygon:
case wkbMultiPolygon:
case wkbLineString:
case wkbLinearRing:
case wkbMultiPoint:
case wkbMultiLineString:
case wkbGeometryCollection:
{
OGREnvelope sEnvelope;
pGeometry->getEnvelope(&sEnvelope);
//
//
OGRRawPoint Point;
Point.x = sEnvelope.MinX;
Point.y = sEnvelope.MinY;
wxPoint* pPoints = pDisplayTransformation->TransformCoordWorld2DC(&Point, 1);
pwxGISDisplay->SetBrush(m_Brush);
pwxGISDisplay->SetPen(m_Pen);
pwxGISDisplay->DrawPoint(pPoints[0].x, pPoints[0].y);
delete[](pPoints);
}
break;
case wkbUnknown:
case wkbNone:
default:
break;
}
}
void MSN_Helper::LoadSamples(Config &config, Matrix &mat)
{
if(config.bShapefile)
{
OGRRegisterAll();
string pLayerName = StringGetFileName(config.sSamples);
OGRDataSource* poDS = OGRSFDriverRegistrar::Open(config.sSamples.c_str(),FALSE);
OGRLayer* poLayer = poDS->GetLayerByName(pLayerName.c_str());
config.nSamples = poLayer->GetFeatureCount();
mat.Resize(config.nSamples, 4);
OGRPoint *poPoint;
OGRFeature * pFeature =poLayer->GetNextFeature();
for(unsigned long i=1; i<=config.nSamples; i++)
{
//样本取值字段名为value，double型
poPoint = (OGRPoint *)pFeature->GetGeometryRef();
mat[i][1] = poPoint->getX();
mat[i][2] = poPoint->getY();
mat[i][3] = pFeature->GetFieldAsInteger("stratum");
mat[i][4] = pFeature->GetFieldAsDouble("value");
pFeature = poLayer->GetNextFeature();
}
OGRDataSource::DestroyDataSource( poDS );
}
else
{
double x, y, v, stratum;
string sline;
ifstream infile(config.sSamples.c_str());
infile >> config.nSamples;
mat.Resize(config.nSamples, 4);
for(unsigned long i=1; i<=config.nSamples; i++)
{
infile >> x >> y >> stratum >> v;
mat[i][1] = x;
mat[i][2] = y;
mat[i][3] = stratum;
mat[i][4] = v;
}
infile.close();
}
}
osg::ref_ptr<osg::Group> MapExtruder::osg_assemble()
{
osg::ref_ptr<osg::Group> osg = new osg::Group;
osg::ref_ptr<osg::Node> surface = osgDB::readNodeFile(_map2dFile);
ExtrudeVisitor extrude(_height);
surface->accept(extrude);
osg->addChild(surface);
int n = _sides ->getNumGeometries();
osg::ref_ptr<osg::Geode> geode = new osg::Geode;
for(int i=0;i<n;i++)
{
osg::ref_ptr<osg::Geometry> geom = new osg::Geometry;
osg::ref_ptr<osg::Vec3Array> verts = new osg::Vec3Array;
std::vector<OGRPoint> points;
OGRLinearRing *ring = ((OGRPolygon*)_sides->getGeometryRef(i))->getExteriorRing();
int m = ring->getNumPoints();
for(int j=0;j<m;j++)
{
OGRPoint pt;
ring->getPoint(j,&pt);
verts->push_back(osg::Vec3(pt.getX(),pt.getY(),pt.getZ()));
}
geom->setVertexArray(verts);
osg::Vec4Array* colors = new osg::Vec4Array;
colors->push_back(YELLOW);
geom->setColorArray(colors);
geom->setColorBinding(osg::Geometry::BIND_OVERALL);
geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POLYGON,0,m));
geode->addDrawable(geom);
}
osg->addChild(geode);
return osg;
}
// xSize and ySize should be in meters
Template::Template( int xSize, int ySize, const OGRPoint ¢er )
: mnXSize( xSize * PIX_PER_METER ),
mnYSize( ySize * PIX_PER_METER )
{
mpbBuf = new bool[ mnXSize * mnYSize ];
for( int i=0; i<(mnXSize*mnYSize); ++i )
{
mpbBuf[i] = false;
}
// The center point minus half the size of the raster should work
// as an offset for transforming projection coordinates onto the
// raster. I don't think my template images will ever be very big.
// Currently I'm thinking 60 meters tops.
mdXTrans = center.getX() - mnXSize/2;
mdYTrans = center.getY() - mnYSize/2;
} // End Constructor
OGRErr OGRDXFWriterLayer::WritePOINT( OGRFeature *poFeature )
{
WriteValue( 0, "POINT" );
WriteCore( poFeature );
WriteValue( 100, "AcDbEntity" );
WriteValue( 100, "AcDbPoint" );
// Write style pen color
OGRStyleTool *poTool = nullptr;
OGRStyleMgr oSM;
if( poFeature->GetStyleString() != nullptr )
{
oSM.InitFromFeature( poFeature );
if( oSM.GetPartCount() > 0 )
poTool = oSM.GetPart(0);
}
if( poTool && poTool->GetType() == OGRSTCPen )
{
OGRStylePen *poPen = (OGRStylePen *) poTool;
GBool bDefault;
if( poPen->Color(bDefault) != nullptr && !bDefault )
WriteValue( 62, ColorStringToDXFColor( poPen->Color(bDefault) ) );
}
delete poTool;
OGRPoint *poPoint = poFeature->GetGeometryRef()->toPoint();
WriteValue( 10, poPoint->getX() );
if( !WriteValue( 20, poPoint->getY() ) )
return OGRERR_FAILURE;
if( poPoint->getGeometryType() == wkbPoint25D )
{
if( !WriteValue( 30, poPoint->getZ() ) )
return OGRERR_FAILURE;
}
return OGRERR_NONE;
}
OGRBoolean OGRPoint::Equals( OGRGeometry * poOther ) const
{
OGRPoint *poOPoint = (OGRPoint *) poOther;
if( poOPoint== this )
return TRUE;
if( poOther->getGeometryType() != getGeometryType() )
return FALSE;
// we should eventually test the SRS.
if( poOPoint->getX() != getX()
|| poOPoint->getY() != getY()
|| poOPoint->getZ() != getZ() )
return FALSE;
else
return TRUE;
}
static int AddPoint( OGRGeometry *poGeometry,
double dfX, double dfY, double dfZ, int nDimension )
{
if( poGeometry->getGeometryType() == wkbPoint
|| poGeometry->getGeometryType() == wkbPoint25D )
{
OGRPoint *poPoint = (OGRPoint *) poGeometry;
if( poPoint->getX() != 0.0 || poPoint->getY() != 0.0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"More than one coordinate for <Point> element.");
return FALSE;
}
poPoint->setX( dfX );
poPoint->setY( dfY );
if( nDimension == 3 )
poPoint->setZ( dfZ );
return TRUE;
}
else if( poGeometry->getGeometryType() == wkbLineString
|| poGeometry->getGeometryType() == wkbLineString25D )
{
if( nDimension == 3 )
((OGRLineString *) poGeometry)->addPoint( dfX, dfY, dfZ );
else
((OGRLineString *) poGeometry)->addPoint( dfX, dfY );
return TRUE;
}
else
{
CPLAssert( FALSE );
return FALSE;
}
}
int OGRPolygon::PointOnSurface( OGRPoint *poPoint ) const
{
if( poPoint == NULL )
return OGRERR_FAILURE;
OGRGeometryH hInsidePoint = OGR_G_PointOnSurface( (OGRGeometryH) this );
if( hInsidePoint == NULL )
return OGRERR_FAILURE;
OGRPoint *poInsidePoint = (OGRPoint *) hInsidePoint;
if( poInsidePoint->IsEmpty() )
poPoint->empty();
else
{
poPoint->setX( poInsidePoint->getX() );
poPoint->setY( poInsidePoint->getY() );
}
return OGRERR_NONE;
}
