自学教程：C++ wkbFlatten函数代码示例

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

OGRBoolean OGRCurvePolygon::Intersects( const OGRGeometry *poOtherGeom ) const{    if( !IsEmpty() && poOtherGeom != NULL &&        wkbFlatten(poOtherGeom->getGeometryType()) == wkbPoint )    {        return ContainsPoint((OGRPoint*)poOtherGeom);    }    else        return OGRGeometry::Intersects(poOtherGeom);}

OGRGeometry*  NASReader::ConvertGeometry(OGRGeometry* poGeom){    //poGeom = OGRGeometryFactory::forceToLineString( poGeom, false );    if( poGeom != NULL )    {        if( wkbFlatten(poGeom->getGeometryType()) == wkbMultiLineString )        {            poGeom = OGRGeometryFactory::forceTo(poGeom, wkbLineString);        }    }    return poGeom;}

mapnik::geometry::geometry<double> ogr_converter::convert_geometry(OGRGeometry* ogr_geom){    // NOTE: wkbFlatten macro in ogr flattens 2.5d types into base 2d type    switch (wkbFlatten(ogr_geom->getGeometryType()))    {    case wkbPoint:        return convert_point(static_cast<OGRPoint*>(ogr_geom));        break;    case wkbMultiPoint:        return convert_multipoint(static_cast<OGRMultiPoint*>(ogr_geom));        break;    case wkbLinearRing:        return convert_linestring(static_cast<OGRLinearRing*>(ogr_geom));        break;    case wkbLineString:        return convert_linestring(static_cast<OGRLineString*>(ogr_geom));        break;    case wkbMultiLineString:        return convert_multilinestring(static_cast<OGRMultiLineString*>(ogr_geom));        break;    case wkbPolygon:        return convert_polygon(static_cast<OGRPolygon*>(ogr_geom));        break;    case wkbMultiPolygon:        return convert_multipolygon(static_cast<OGRMultiPolygon*>(ogr_geom));        break;    case wkbGeometryCollection:        return convert_collection(static_cast<OGRGeometryCollection*>(ogr_geom));        break;    case wkbNone:    case wkbUnknown:    default:        {            MAPNIK_LOG_WARN(ogr) << "ogr_converter: unknown <ogr> geometry_type="                                 << wkbFlatten(ogr_geom->getGeometryType());        }        return mapnik::geometry::geometry<double>();        break;    }}

OGRErr OGRIngresTableLayer::PrepareNewStyleGeometry(    OGRGeometry *poGeom, CPLString &osRetGeomText ){	OGRErr eErr = OGRERR_NONE;    osRetGeomText = "";    if( poGeom == NULL )        return OGRERR_FAILURE;/* -------------------------------------------------------------------- *//*      Point                                                           *//* -------------------------------------------------------------------- */    if( wkbFlatten(poGeom->getGeometryType()) == wkbPoint )    {        osRetGeomText.Printf( "POINTFROMWKB( ~V )");    }/* -------------------------------------------------------------------- *//*      Linestring                                                      *//* -------------------------------------------------------------------- */    else if( wkbFlatten(poGeom->getGeometryType()) == wkbLineString )    {        osRetGeomText.Printf("LINEFROMWKB( ~V )");    }/* -------------------------------------------------------------------- *//*      Polygon                                                         *//* -------------------------------------------------------------------- */    else if( wkbFlatten(poGeom->getGeometryType()) == wkbPolygon )    {        osRetGeomText.Printf("POLYFROMWKB( ~V )");    }/* -------------------------------------------------------------------- *//*      Multipoint                                                      *//* -------------------------------------------------------------------- */    else if( wkbFlatten(poGeom->getGeometryType()) == wkbMultiPoint )    {        osRetGeomText.Printf("MPOINTFROMWKB( ~V )");    }/* -------------------------------------------------------------------- *//*      Multilinestring                                                 *//* -------------------------------------------------------------------- */    else if( wkbFlatten(poGeom->getGeometryType()) == wkbMultiLineString )    {    	osRetGeomText.Printf("MLINEFROMWKB( ~V )");    }/* -------------------------------------------------------------------- *//*      Multipolygon                                                    *//* -------------------------------------------------------------------- */    else if( wkbFlatten(poGeom->getGeometryType()) == wkbMultiPolygon )    {    	osRetGeomText.Printf("MPOLYFROMWKB( ~V )");    }    else    {        eErr = OGRERR_FAILURE;    }    return eErr;}

QgsOgrFeatureSource::QgsOgrFeatureSource( const QgsOgrProvider* p )    : mProvider( p ){  mFilePath = p->filePath();  mLayerName = p->layerName();  mLayerIndex = p->layerIndex();  mSubsetString = p->mSubsetString;  mEncoding = p->mEncoding; // no copying - this is a borrowed pointer from Qt  mFields = p->mAttributeFields;  mDriverName = p->ogrDriverName;  mOgrGeometryTypeFilter = wkbFlatten( p->mOgrGeometryTypeFilter );  QgsOgrConnPool::refS( mFilePath );}

void OGR_G_GetPoint( OGRGeometryH hGeom, int i,                      double *pdfX, double *pdfY, double *pdfZ ){    VALIDATE_POINTER0( hGeom, "OGR_G_GetPoint" );    switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )    {      case wkbPoint:      {          if( i == 0 )          {              *pdfX = ((OGRPoint *)hGeom)->getX();              *pdfY = ((OGRPoint *)hGeom)->getY();              if( pdfZ != NULL )                  *pdfZ = ((OGRPoint *)hGeom)->getZ();          }          else          {              CPLError(CE_Failure, CPLE_NotSupported, "Only i == 0 is supported");          }      }      break;      case wkbLineString:      case wkbCircularString:      {          OGRLineString* poLS = (OGRLineString *) hGeom;          if (i < 0 || i >= poLS->getNumPoints())          {              CPLError(CE_Failure, CPLE_NotSupported, "Index out of bounds");              *pdfX = *pdfY = 0;              if( pdfZ != NULL )                  *pdfZ = 0;          }          else          {            *pdfX = poLS->getX( i );            *pdfY = poLS->getY( i );            if( pdfZ != NULL )                *pdfZ =  poLS->getZ( i );          }      }      break;      default:        CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");        break;    }}

void OGRGeometryCollection::closeRings(){    for( auto&& poSubGeom: *this )    {        if( OGR_GT_IsSubClassOf(                     wkbFlatten(poSubGeom->getGeometryType()),                                wkbCurvePolygon ) )        {            OGRCurvePolygon *poPoly = poSubGeom->toCurvePolygon();            poPoly->closeRings();        }    }}

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 CPL_DLL OGR_G_SetPoints( OGRGeometryH hGeom, int nPointsIn,                              void* pabyX, int nXStride,                              void* pabyY, int nYStride,                              void* pabyZ, int nZStride ){    VALIDATE_POINTER0( hGeom, "OGR_G_SetPoints" );    switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )    {      case wkbPoint:      {        ((OGRPoint *) hGeom)->setX( pabyX ? *( (double *)pabyX ) : 0.0 );        ((OGRPoint *) hGeom)->setY( pabyY ? *( (double *)pabyY ) : 0.0 );        ((OGRPoint *) hGeom)->setZ( pabyZ ? *( (double *)pabyZ ) : 0.0 );        break;      }      case wkbLineString:      case wkbCircularString:      {        OGRLineString* poLine = (OGRLineString *) hGeom;        if( nXStride == 0 && nYStride == 0 && nZStride == 0 )        {          poLine->setPoints( nPointsIn, (double *)pabyX, (double *)pabyY, (double *)pabyZ );         }        else        {          double x, y, z;		            x = y = z = 0;          poLine->setNumPoints( nPointsIn );          for (int i = 0; i < nPointsIn; ++i)          {            if( pabyX ) x = *(double*)((char*)pabyX + i * nXStride);            if( pabyY ) y = *(double*)((char*)pabyY + i * nYStride);            if( pabyZ ) z = *(double*)((char*)pabyZ + i * nZStride);            poLine->setPoint( i, x, y, z );          }        }        break;      }      default:        CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");        break;    }}

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

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;    }    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, 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 )        {            CPLError(CE_Failure, CPLE_AppDefined, "Non contiguous curves");            return OGRERR_FAILURE;        }        ((OGRSimpleCurve*)poCurve)->setPoint(0, &end); /* patch so that it matches exactly */    }    return oCC.addCurveDirectly(this, poCurve, bNeedRealloc);}

OGRwkbGeometryType Geometry::getGeometryType_fixed(OGRGeometry* geom){	//For some reason OGRLinearRing::getGeometryType uses OGRLineString's method...	//meaning OGRLinearRing::getGeometryType returns wkbLineString	//http://trac.osgeo.org/gdal/ticket/1755	OGRwkbGeometryType type =  wkbFlatten(geom->getGeometryType());	if (type == wkbLineString) {		if (std::string(geom->getGeometryName()) == "LINEARRING") {			return wkbLinearRing;		}	}	return type;}

int OGR_G_GetPointCount( OGRGeometryH hGeom ){    VALIDATE_POINTER1( hGeom, "OGR_G_GetPointCount", 0 );    OGRwkbGeometryType eGType = wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType());    if( eGType == wkbPoint )        return 1;    else if( OGR_GT_IsCurve(eGType) )        return ((OGRCurve *) hGeom)->getNumPoints();    else    {        // autotest/pymod/ogrtest.py calls this method on any geometry. So keep silent        //CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");        return 0;    }}

/*!  /brief Recursively descend to feature and read the part    /param Map pointer to Map_info structure  /param hGeom OGR geometry  /param offset given offset  /param[out] Points container used to store line pointes within    /return feature type  /return -1 on error*/static int get_line_type(const struct Map_info *Map, long FID){    int eType;    OGRFeatureH hFeat;    OGRGeometryH hGeom;    G_debug(4, "get_line_type() fid = %ld", FID);    hFeat = OGR_L_GetFeature(Map->fInfo.ogr.layer, FID);    if (hFeat == NULL)	return -1;    hGeom = OGR_F_GetGeometryRef(hFeat);    if (hGeom == NULL)	return -1;        eType = wkbFlatten(OGR_G_GetGeometryType(hGeom));    OGR_F_Destroy(hFeat);    G_debug(4, "OGR Geometry of type: %d", eType);    switch (eType) {    case wkbPoint:    case wkbMultiPoint:	return GV_POINT;	break;	    case wkbLineString:    case wkbMultiLineString:	return GV_LINE;	break;    case wkbPolygon:    case wkbMultiPolygon:    case wkbGeometryCollection:	return GV_BOUNDARY;	break;    default:	G_warning(_("OGR feature type %d not supported"), eType);	break;    }    return -1;}

void OGR_G_SetPointCount( OGRGeometryH hGeom, int nNewPointCount ){    VALIDATE_POINTER0( hGeom, "OGR_G_SetPointCount" );    switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )    {      case wkbLineString:      {        OGRLineString *poLine = (OGRLineString *) hGeom;        poLine->setNumPoints( nNewPointCount );        break;      }      default:        CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");        break;    }}

OGRBoolean OGRPoint::Intersects( const OGRGeometry *poOtherGeom ) const{    if( !IsEmpty() && poOtherGeom != NULL &&        wkbFlatten(poOtherGeom->getGeometryType()) == wkbCurvePolygon )    {        const OGRCurvePolygon *poCurve =            dynamic_cast<const OGRCurvePolygon *>(poOtherGeom);        if( poCurve == NULL )        {            CPLError(CE_Fatal, CPLE_AppDefined,                     "dynamic_cast failed.  Expected OGRCurvePolygon.");            return FALSE;        }        return poCurve->Intersects(this);    }    return OGRGeometry::Intersects(poOtherGeom);}

OGRGeometry* OGRPolygon::getCurveGeometry(const char* const* papszOptions) const{    OGRCurvePolygon* poCC = new OGRCurvePolygon();    poCC->assignSpatialReference( getSpatialReference() );    bool bHasCurveGeometry = false;    for( int iRing = 0; iRing < oCC.nCurveCount; iRing++ )    {        OGRCurve* poSubGeom = (OGRCurve* )oCC.papoCurves[iRing]->getCurveGeometry(papszOptions);        if( wkbFlatten(poSubGeom->getGeometryType()) != wkbLineString )            bHasCurveGeometry = true;        poCC->addRingDirectly( poSubGeom );    }    if( !bHasCurveGeometry )    {        delete poCC;        return clone();    }    return poCC;}

double OGRGeometryCollection::get_Length() const{    double dfLength = 0.0;    for( int iGeom = 0; iGeom < nGeomCount; iGeom++ )    {        OGRGeometry* geom = papoGeoms[iGeom];        OGRwkbGeometryType eType = wkbFlatten(geom->getGeometryType());        if( OGR_GT_IsCurve(eType) )        {            dfLength += ((OGRCurve *) geom)->get_Length();        }        else if( OGR_GT_IsSubClassOf(eType, wkbMultiCurve) ||                eType == wkbGeometryCollection )        {            dfLength += ((OGRGeometryCollection *) geom)->get_Length();        }    }    return dfLength;}

double OGR_G_Area( OGRGeometryH hGeom ){    VALIDATE_POINTER1( hGeom, "OGR_G_Area", 0 );    double fArea = 0.0;    switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )    {      case wkbPolygon:        fArea = ((OGRPolygon *) hGeom)->get_Area();        break;      case wkbMultiPolygon:        fArea = ((OGRMultiPolygon *) hGeom)->get_Area();        break;      case wkbLinearRing:      case wkbLineString:        /* This test below is required to filter out wkbLineString geometries         * not being of type of wkbLinearRing.         */        if( EQUAL( ((OGRGeometry*) hGeom)->getGeometryName(), "LINEARRING" ) )        {            fArea = ((OGRLinearRing *) hGeom)->get_Area();        }        break;      case wkbGeometryCollection:        fArea = ((OGRGeometryCollection *) hGeom)->get_Area();        break;      default:        CPLError( CE_Warning, CPLE_AppDefined,                  "OGR_G_Area() called against non-surface geometry type." );        fArea = 0.0;    }    return fArea;}

void wxGISMapView::DrawGeometry(const wxGISGeometry &Geometry, WXGISRGBA stFillColour, WXGISRGBA stLineColour, double dfLineWidth){    wxCHECK_RET(Geometry.IsOk(), wxT("Input geometry is not valid"));	OGRwkbGeometryType type = wkbFlatten(Geometry.GetType());	switch(type)	{	case wkbPoint:	case wkbMultiPoint:	    m_pGISDisplay->SetColor(enumGISDrawStylePoint, stLineColour);	    m_pGISDisplay->SetColor(enumGISDrawStyleOutline, stLineColour);	    m_pGISDisplay->SetColor(enumGISDrawStyleFill, stFillColour);		m_pGISDisplay->SetLineCap(CAIRO_LINE_CAP_ROUND);		m_pGISDisplay->SetLineWidth(dfLineWidth);		m_pGISDisplay->SetPointRadius(2.0);		break;	case wkbLineString:	case wkbLinearRing:	case wkbMultiLineString:	    m_pGISDisplay->SetColor(enumGISDrawStylePoint, stFillColour);	    m_pGISDisplay->SetColor(enumGISDrawStyleOutline, stFillColour);	    m_pGISDisplay->SetColor(enumGISDrawStyleFill, stFillColour);		m_pGISDisplay->SetLineCap(CAIRO_LINE_CAP_BUTT);		m_pGISDisplay->SetLineWidth(2.0);		break;	case wkbMultiPolygon:	case wkbPolygon:	    m_pGISDisplay->SetColor(enumGISDrawStyleOutline, stLineColour);	    m_pGISDisplay->SetColor(enumGISDrawStyleFill, stFillColour);		m_pGISDisplay->SetLineCap(CAIRO_LINE_CAP_BUTT);		m_pGISDisplay->SetLineWidth(dfLineWidth);		break;	case wkbGeometryCollection:		break;	default:	case wkbUnknown:	case wkbNone:		break;	}	m_pGISDisplay->DrawGeometry( Geometry );}

	/**	 * 
C++ wl1251_debug函数代码示例
C++ wizardp函数代码示例