void wxGISRubberEnvelope::OnMouseUp(wxMouseEvent& event) { IDisplayTransformation* pDT = m_pCachedDisplay->GetDisplayTransformation(); wxPoint Points[2]; Points[0] = wxPoint(m_StartX, m_StartY); Points[1] = wxPoint(event.GetX(), event.GetY()); OGRRawPoint* pOGRPoints = pDT->TransformCoordDC2World(Points, 2); OGRLineString* pLine = new OGRLineString(); pLine->setPoints(2, pOGRPoints); m_pRetGeom = static_cast<OGRGeometry*>(pLine); delete [] pOGRPoints; OnUnlock(); }
OGRGeometry *OGRLineString::clone() { OGRLineString *poNewLineString; poNewLineString = new OGRLineString(); poNewLineString->assignSpatialReference( getSpatialReference() ); poNewLineString->setPoints( nPointCount, paoPoints, padfZ ); // notdef: not 3D return poNewLineString; }
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; } }
OGRFeature *OGRIdrisiLayer::GetNextRawFeature() { while(TRUE) { if (eGeomType == wkbPoint) { double dfId; double dfX, dfY; if (VSIFReadL(&dfId, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfX, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfY, sizeof(double), 1, fp) != 1) { return NULL; } CPL_LSBPTR64(&dfId); CPL_LSBPTR64(&dfX); CPL_LSBPTR64(&dfY); if (m_poFilterGeom != NULL && (dfX < m_sFilterEnvelope.MinX || dfX > m_sFilterEnvelope.MaxX || dfY < m_sFilterEnvelope.MinY || dfY > m_sFilterEnvelope.MaxY)) { nNextFID ++; continue; } OGRPoint* poGeom = new OGRPoint(dfX, dfY); if (poSRS) poGeom->assignSpatialReference(poSRS); OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetField(0, dfId); poFeature->SetFID(nNextFID ++); poFeature->SetGeometryDirectly(poGeom); ReadAVLLine(poFeature); return poFeature; } else if (eGeomType == wkbLineString) { double dfId; double dfMinXShape, dfMaxXShape, dfMinYShape, dfMaxYShape; unsigned int nNodes; if (VSIFReadL(&dfId, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMinXShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMaxXShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMinYShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMaxYShape, sizeof(double), 1, fp) != 1) { return NULL; } CPL_LSBPTR64(&dfId); CPL_LSBPTR64(&dfMinXShape); CPL_LSBPTR64(&dfMaxXShape); CPL_LSBPTR64(&dfMinYShape); CPL_LSBPTR64(&dfMaxYShape); if (VSIFReadL(&nNodes, sizeof(unsigned int), 1, fp) != 1) { return NULL; } CPL_LSBPTR32(&nNodes); if (nNodes > 100 * 1000 * 1000) return NULL; if (m_poFilterGeom != NULL && (dfMaxXShape < m_sFilterEnvelope.MinX || dfMinXShape > m_sFilterEnvelope.MaxX || dfMaxYShape < m_sFilterEnvelope.MinY || dfMinYShape > m_sFilterEnvelope.MaxY)) { nNextFID ++; VSIFSeekL(fp, sizeof(OGRRawPoint) * nNodes, SEEK_CUR); continue; } OGRRawPoint* poRawPoints = (OGRRawPoint*)VSIMalloc2(sizeof(OGRRawPoint), nNodes); if (poRawPoints == NULL) { return NULL; } if ((unsigned int)VSIFReadL(poRawPoints, sizeof(OGRRawPoint), nNodes, fp) != nNodes) { VSIFree(poRawPoints); return NULL; } #if defined(CPL_MSB) for(unsigned int iNode=0; iNode<nNodes; iNode++) { CPL_LSBPTR64(&poRawPoints[iNode].x); CPL_LSBPTR64(&poRawPoints[iNode].y); } #endif OGRLineString* poGeom = new OGRLineString(); poGeom->setPoints(nNodes, poRawPoints, NULL); VSIFree(poRawPoints); if (poSRS) poGeom->assignSpatialReference(poSRS); OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetField(0, dfId); poFeature->SetFID(nNextFID ++); poFeature->SetGeometryDirectly(poGeom); ReadAVLLine(poFeature); return poFeature; } else /* if (eGeomType == wkbPolygon) */ { double dfId; double dfMinXShape, dfMaxXShape, dfMinYShape, dfMaxYShape; unsigned int nParts; unsigned int nTotalNodes; if (VSIFReadL(&dfId, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMinXShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMaxXShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMinYShape, sizeof(double), 1, fp) != 1 || VSIFReadL(&dfMaxYShape, sizeof(double), 1, fp) != 1) { return NULL; } CPL_LSBPTR64(&dfId); CPL_LSBPTR64(&dfMinXShape); CPL_LSBPTR64(&dfMaxXShape); CPL_LSBPTR64(&dfMinYShape); CPL_LSBPTR64(&dfMaxYShape); if (VSIFReadL(&nParts, sizeof(unsigned int), 1, fp) != 1 || VSIFReadL(&nTotalNodes, sizeof(unsigned int), 1, fp) != 1) { return NULL; } CPL_LSBPTR32(&nParts); CPL_LSBPTR32(&nTotalNodes); if (nParts > 100000 || nTotalNodes > 100 * 1000 * 1000) return NULL; if (m_poFilterGeom != NULL && (dfMaxXShape < m_sFilterEnvelope.MinX || dfMinXShape > m_sFilterEnvelope.MaxX || dfMaxYShape < m_sFilterEnvelope.MinY || dfMinYShape > m_sFilterEnvelope.MaxY)) { VSIFSeekL(fp, sizeof(unsigned int) * nParts + sizeof(OGRRawPoint) * nTotalNodes, SEEK_CUR); nNextFID ++; continue; } OGRRawPoint* poRawPoints = (OGRRawPoint*)VSIMalloc2(sizeof(OGRRawPoint), nTotalNodes); if (poRawPoints == NULL) { return NULL; } unsigned int* panNodesCount = NULL; if( nParts > 1 ) { panNodesCount = (unsigned int *)CPLMalloc(sizeof(unsigned int) * nParts); if (VSIFReadL(panNodesCount, sizeof(unsigned int) * nParts, 1, fp) != 1) { VSIFree(poRawPoints); VSIFree(panNodesCount); return NULL; } #if defined(CPL_MSB) for(unsigned int iPart=0; iPart < nParts; iPart ++) { CPL_LSBPTR32(&panNodesCount[iPart]); } #endif } else { unsigned int nNodes; if (VSIFReadL(&nNodes, sizeof(unsigned int) * nParts, 1, fp) != 1) { VSIFree(poRawPoints); return NULL; } CPL_LSBPTR32(&nNodes); if( nNodes != nTotalNodes ) { VSIFree(poRawPoints); return NULL; } } unsigned int iPart; OGRPolygon* poGeom = new OGRPolygon(); for(iPart = 0; iPart < nParts; iPart ++) { unsigned int nNodes = (nParts > 1) ? panNodesCount[iPart] : nTotalNodes; if (nNodes > nTotalNodes || (unsigned int)VSIFReadL(poRawPoints, sizeof(OGRRawPoint), nNodes, fp) != nNodes) { VSIFree(poRawPoints); VSIFree(panNodesCount); delete poGeom; return NULL; } #if defined(CPL_MSB) for(unsigned int iNode=0; iNode<nNodes; iNode++) { CPL_LSBPTR64(&poRawPoints[iNode].x); CPL_LSBPTR64(&poRawPoints[iNode].y); } #endif OGRLinearRing* poLR = new OGRLinearRing(); poGeom->addRingDirectly(poLR); poLR->setPoints(nNodes, poRawPoints, NULL); } VSIFree(poRawPoints); VSIFree(panNodesCount); if (poSRS) poGeom->assignSpatialReference(poSRS); OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetField(0, dfId); poFeature->SetFID(nNextFID ++); poFeature->SetGeometryDirectly(poGeom); ReadAVLLine(poFeature); return poFeature; } } }
OGRFeature *OGRDODSSequenceLayer::GetFeature( GIntBig nFeatureId ) { /* -------------------------------------------------------------------- */ /* Ensure we have the dataset. */ /* -------------------------------------------------------------------- */ if( !ProvideDataDDS() ) return NULL; Sequence *seq = dynamic_cast<Sequence *>(poTargetVar); /* -------------------------------------------------------------------- */ /* Figure out what the super and subsequence number this */ /* feature will be, and validate it. If there is not super */ /* sequence the feature id is the subsequence number. */ /* -------------------------------------------------------------------- */ int iSubSeq = -1; if( nFeatureId < 0 || nFeatureId >= nRecordCount ) return NULL; if( poSuperSeq == NULL ) iSubSeq = nFeatureId; else { int nSeqOffset = 0, iSuperSeq; // for now we just scan through till find find out what // super sequence this in. In the long term we need a better (cached) // approach that doesn't involve this quadratic cost. for( iSuperSeq = 0; iSuperSeq < nSuperSeqCount; iSuperSeq++ ) { if( nSeqOffset + panSubSeqSize[iSuperSeq] > nFeatureId ) { iSubSeq = nFeatureId - nSeqOffset; break; } nSeqOffset += panSubSeqSize[iSuperSeq]; } CPLAssert( iSubSeq != -1 ); // Make sure we have the right target var ... the one // corresponding to our current super sequence. if( iSuperSeq != iLastSuperSeq ) { iLastSuperSeq = iSuperSeq; poTargetVar = poSuperSeq->var_value( iSuperSeq, pszSubSeqPath ); seq = dynamic_cast<Sequence *>(poTargetVar); } } /* -------------------------------------------------------------------- */ /* Create the feature being read. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature; poFeature = new OGRFeature( poFeatureDefn ); poFeature->SetFID( nFeatureId ); m_nFeaturesRead++; /* -------------------------------------------------------------------- */ /* Process all the regular data fields. */ /* -------------------------------------------------------------------- */ int iField; for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { if( papoFields[iField]->pszPathToSequence ) continue; BaseType *poFieldVar = GetFieldValue( papoFields[iField], iSubSeq, NULL ); if( poFieldVar == NULL ) continue; switch( poFieldVar->type() ) { case dods_byte_c: { signed char byVal; void *pValPtr = &byVal; poFieldVar->buf2val( &pValPtr ); poFeature->SetField( iField, byVal ); } break; case dods_int16_c: { GInt16 nIntVal; void *pValPtr = &nIntVal; poFieldVar->buf2val( &pValPtr ); poFeature->SetField( iField, nIntVal ); } break; case dods_uint16_c: { GUInt16 nIntVal; void *pValPtr = &nIntVal; poFieldVar->buf2val( &pValPtr ); poFeature->SetField( iField, nIntVal ); } break; case dods_int32_c: { GInt32 nIntVal; void *pValPtr = &nIntVal; poFieldVar->buf2val( &pValPtr ); poFeature->SetField( iField, nIntVal ); } break; case dods_uint32_c: { GUInt32 nIntVal; void *pValPtr = &nIntVal; poFieldVar->buf2val( &pValPtr ); poFeature->SetField( iField, (int) nIntVal ); } break; case dods_float32_c: poFeature->SetField( iField, dynamic_cast<Float32 *>(poFieldVar)->value()); break; case dods_float64_c: poFeature->SetField( iField, dynamic_cast<Float64 *>(poFieldVar)->value()); break; case dods_str_c: case dods_url_c: { string *poStrVal = NULL; poFieldVar->buf2val( (void **) &poStrVal ); poFeature->SetField( iField, poStrVal->c_str() ); delete poStrVal; } break; default: break; } } /* -------------------------------------------------------------------- */ /* Handle data nested in sequences. */ /* -------------------------------------------------------------------- */ for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { OGRDODSFieldDefn *poFD = papoFields[iField]; const char *pszPathFromSubSeq; if( poFD->pszPathToSequence == NULL ) continue; CPLAssert( strlen(poFD->pszPathToSequence) < strlen(poFD->pszFieldName)-1 ); if( strstr(poFD->pszFieldName,poFD->pszPathToSequence) != NULL ) pszPathFromSubSeq = strstr(poFD->pszFieldName,poFD->pszPathToSequence) + strlen(poFD->pszPathToSequence) + 1; else continue; /* -------------------------------------------------------------------- */ /* Get the sequence out of which this variable will be collected. */ /* -------------------------------------------------------------------- */ BaseType *poFieldVar = seq->var_value( iSubSeq, poFD->pszPathToSequence ); Sequence *poSubSeq; int nSubSeqCount; if( poFieldVar == NULL ) continue; poSubSeq = dynamic_cast<Sequence *>( poFieldVar ); if( poSubSeq == NULL ) continue; nSubSeqCount = poSubSeq->number_of_rows(); /* -------------------------------------------------------------------- */ /* Allocate array to put values into. */ /* -------------------------------------------------------------------- */ OGRFieldDefn *poOFD = poFeature->GetFieldDefnRef( iField ); int *panIntList = NULL; double *padfDblList = NULL; char **papszStrList = NULL; if( poOFD->GetType() == OFTIntegerList ) { panIntList = (int *) CPLCalloc(sizeof(int),nSubSeqCount); } else if( poOFD->GetType() == OFTRealList ) { padfDblList = (double *) CPLCalloc(sizeof(double),nSubSeqCount); } else if( poOFD->GetType() == OFTStringList ) { papszStrList = (char **) CPLCalloc(sizeof(char*),nSubSeqCount+1); } else continue; /* -------------------------------------------------------------------- */ /* Loop, fetching subsequence values. */ /* -------------------------------------------------------------------- */ int iSubIndex; for( iSubIndex = 0; iSubIndex < nSubSeqCount; iSubIndex++ ) { poFieldVar = poSubSeq->var_value( iSubIndex, pszPathFromSubSeq ); if( poFieldVar == NULL ) continue; switch( poFieldVar->type() ) { case dods_byte_c: { signed char byVal; void *pValPtr = &byVal; poFieldVar->buf2val( &pValPtr ); panIntList[iSubIndex] = byVal; } break; case dods_int16_c: { GInt16 nIntVal; void *pValPtr = &nIntVal; poFieldVar->buf2val( &pValPtr ); panIntList[iSubIndex] = nIntVal; } break; case dods_uint16_c: { GUInt16 nIntVal; void *pValPtr = &nIntVal; poFieldVar->buf2val( &pValPtr ); panIntList[iSubIndex] = nIntVal; } break; case dods_int32_c: { GInt32 nIntVal; void *pValPtr = &nIntVal; poFieldVar->buf2val( &pValPtr ); panIntList[iSubIndex] = nIntVal; } break; case dods_uint32_c: { GUInt32 nIntVal; void *pValPtr = &nIntVal; poFieldVar->buf2val( &pValPtr ); panIntList[iSubIndex] = nIntVal; } break; case dods_float32_c: padfDblList[iSubIndex] = dynamic_cast<Float32 *>(poFieldVar)->value(); break; case dods_float64_c: padfDblList[iSubIndex] = dynamic_cast<Float64 *>(poFieldVar)->value(); break; case dods_str_c: case dods_url_c: { string *poStrVal = NULL; poFieldVar->buf2val( (void **) &poStrVal ); papszStrList[iSubIndex] = CPLStrdup( poStrVal->c_str() ); delete poStrVal; } break; default: break; } } /* -------------------------------------------------------------------- */ /* Apply back to feature. */ /* -------------------------------------------------------------------- */ if( poOFD->GetType() == OFTIntegerList ) { poFeature->SetField( iField, nSubSeqCount, panIntList ); CPLFree(panIntList); } else if( poOFD->GetType() == OFTRealList ) { poFeature->SetField( iField, nSubSeqCount, padfDblList ); CPLFree(padfDblList); } else if( poOFD->GetType() == OFTStringList ) { poFeature->SetField( iField, papszStrList ); CSLDestroy( papszStrList ); } } /* ==================================================================== */ /* Fetch the geometry. */ /* ==================================================================== */ if( oXField.bValid && oYField.bValid ) { int iXField = poFeature->GetFieldIndex( oXField.pszFieldName ); int iYField = poFeature->GetFieldIndex( oYField.pszFieldName ); int iZField = -1; if( oZField.bValid ) iZField = poFeature->GetFieldIndex(oZField.pszFieldName); /* -------------------------------------------------------------------- */ /* If we can't find the values in attributes then use the more */ /* general mechanism to fetch the value. */ /* -------------------------------------------------------------------- */ if( iXField == -1 || iYField == -1 || (oZField.bValid && iZField == -1) ) { poFeature->SetGeometryDirectly( new OGRPoint( GetFieldValueAsDouble( &oXField, iSubSeq ), GetFieldValueAsDouble( &oYField, iSubSeq ), GetFieldValueAsDouble( &oZField, iSubSeq ) ) ); } /* -------------------------------------------------------------------- */ /* If the fields are list values, then build a linestring. */ /* -------------------------------------------------------------------- */ else if( poFeature->GetFieldDefnRef(iXField)->GetType() == OFTRealList && poFeature->GetFieldDefnRef(iYField)->GetType() == OFTRealList ) { const double *padfX, *padfY, *padfZ = NULL; int nPointCount, i; OGRLineString *poLS = new OGRLineString(); padfX = poFeature->GetFieldAsDoubleList( iXField, &nPointCount ); padfY = poFeature->GetFieldAsDoubleList( iYField, &nPointCount ); if( iZField != -1 ) padfZ = poFeature->GetFieldAsDoubleList(iZField,&nPointCount); poLS->setPoints( nPointCount, (double *) padfX, (double *) padfY, (double *) padfZ ); // Make a pass clearing out NaN or Inf values. for( i = 0; i < nPointCount; i++ ) { double dfX = poLS->getX(i); double dfY = poLS->getY(i); double dfZ = poLS->getZ(i); int bReset = FALSE; if( OGRDODSIsDoubleInvalid( &dfX ) ) { dfX = 0.0; bReset = TRUE; } if( OGRDODSIsDoubleInvalid( &dfY ) ) { dfY = 0.0; bReset = TRUE; } if( OGRDODSIsDoubleInvalid( &dfZ ) ) { dfZ = 0.0; bReset = TRUE; } if( bReset ) poLS->setPoint( i, dfX, dfY, dfZ ); } poFeature->SetGeometryDirectly( poLS ); } /* -------------------------------------------------------------------- */ /* Otherwise build a point. */ /* -------------------------------------------------------------------- */ else { poFeature->SetGeometryDirectly( new OGRPoint( poFeature->GetFieldAsDouble( iXField ), poFeature->GetFieldAsDouble( iYField ), poFeature->GetFieldAsDouble( iZField ) ) ); } } return poFeature; }
OGRErr OGRMultiLineString::importFromWkt( char ** ppszInput ) { char szToken[OGR_WKT_TOKEN_MAX]; const char *pszInput = *ppszInput; OGRErr eErr; /* -------------------------------------------------------------------- */ /* Clear existing rings. */ /* -------------------------------------------------------------------- */ empty(); /* -------------------------------------------------------------------- */ /* Read and verify the ``MULTILINESTRING'' keyword token. */ /* -------------------------------------------------------------------- */ pszInput = OGRWktReadToken( pszInput, szToken ); if( !EQUAL(szToken,getGeometryName()) ) return OGRERR_CORRUPT_DATA; /* -------------------------------------------------------------------- */ /* The next character should be a ( indicating the start of the */ /* list of linestrings. */ /* -------------------------------------------------------------------- */ pszInput = OGRWktReadToken( pszInput, szToken ); if( EQUAL(szToken,"EMPTY") ) { *ppszInput = (char *) pszInput; return OGRERR_NONE; } if( szToken[0] != '(' ) return OGRERR_CORRUPT_DATA; /* -------------------------------------------------------------------- */ /* If the next token is EMPTY, then verify that we have proper */ /* EMPTY format will a trailing closing bracket. */ /* -------------------------------------------------------------------- */ OGRWktReadToken( pszInput, szToken ); if( EQUAL(szToken,"EMPTY") ) { pszInput = OGRWktReadToken( pszInput, szToken ); pszInput = OGRWktReadToken( pszInput, szToken ); *ppszInput = (char *) pszInput; if( !EQUAL(szToken,")") ) return OGRERR_CORRUPT_DATA; else return OGRERR_NONE; } /* ==================================================================== */ /* Read each line in turn. Note that we try to reuse the same */ /* point list buffer from ring to ring to cut down on */ /* allocate/deallocate overhead. */ /* ==================================================================== */ OGRRawPoint *paoPoints = NULL; int nMaxPoints = 0; double *padfZ = NULL; do { int nPoints = 0; /* -------------------------------------------------------------------- */ /* Read points for one line from input. */ /* -------------------------------------------------------------------- */ pszInput = OGRWktReadPoints( pszInput, &paoPoints, &padfZ, &nMaxPoints, &nPoints ); if( pszInput == NULL ) { eErr = OGRERR_CORRUPT_DATA; break; } /* -------------------------------------------------------------------- */ /* Create the new line, and add to collection. */ /* -------------------------------------------------------------------- */ OGRLineString *poLine; poLine = new OGRLineString(); poLine->setPoints( nPoints, paoPoints, padfZ ); eErr = addGeometryDirectly( poLine ); /* -------------------------------------------------------------------- */ /* Read the delimeter following the ring. */ /* -------------------------------------------------------------------- */ pszInput = OGRWktReadToken( pszInput, szToken ); } while( szToken[0] == ',' && eErr == OGRERR_NONE ); /* -------------------------------------------------------------------- */ /* freak if we don't get a closing bracket. */ /* -------------------------------------------------------------------- */ CPLFree( paoPoints ); CPLFree( padfZ ); if( eErr != OGRERR_NONE ) return eErr; if( szToken[0] != ')' ) return OGRERR_CORRUPT_DATA; *ppszInput = (char *) pszInput; return OGRERR_NONE; }
//! Simplifies the OGR-geometry (Removing duplicated points) when is applied the specified map2pixel context bool QgsOgrMapToPixelSimplifier::simplifyOgrGeometry( OGRGeometry* geometry, bool isaLinearRing ) { OGRwkbGeometryType wkbGeometryType = wkbFlatten( geometry->getGeometryType() ); // Simplify the geometry rewriting temporally its WKB-stream for saving calloc's. if ( wkbGeometryType == wkbLineString ) { OGRLineString* lineString = ( OGRLineString* )geometry; int numPoints = lineString->getNumPoints(); if (( isaLinearRing && numPoints <= 5 ) || ( !isaLinearRing && numPoints <= 2 ) ) return false; OGREnvelope env; geometry->getEnvelope( &env ); QgsRectangle envelope( env.MinX, env.MinY, env.MaxX, env.MaxY ); // Can replace the geometry by its BBOX ? if (( mSimplifyFlags & QgsMapToPixelSimplifier::SimplifyEnvelope ) && canbeGeneralizedByMapBoundingBox( envelope ) ) { OGRRawPoint* points = NULL; int numPoints = 0; double x1 = envelope.xMinimum(); double y1 = envelope.yMinimum(); double x2 = envelope.xMaximum(); double y2 = envelope.yMaximum(); if ( isaLinearRing ) { numPoints = 5; points = mallocPoints( numPoints ); points[0].x = x1; points[0].y = y1; points[1].x = x2; points[1].y = y1; points[2].x = x2; points[2].y = y2; points[3].x = x1; points[3].y = y2; points[4].x = x1; points[4].y = y1; } else { numPoints = 2; points = mallocPoints( numPoints ); points[0].x = x1; points[0].y = y1; points[1].x = x2; points[1].y = y2; } lineString->setPoints( numPoints, points ); lineString->flattenTo2D(); return true; } else if ( mSimplifyFlags & QgsMapToPixelSimplifier::SimplifyGeometry ) { QGis::GeometryType geometryType = isaLinearRing ? QGis::Polygon : QGis::Line; int numSimplifiedPoints = 0; OGRRawPoint* points = mallocPoints( numPoints ); double* xptr = ( double* )points; double* yptr = xptr + 1; lineString->getPoints( points ); if ( simplifyOgrGeometry( geometryType, envelope, xptr, 16, yptr, 16, numPoints, numSimplifiedPoints ) ) { lineString->setPoints( numSimplifiedPoints, points ); lineString->flattenTo2D(); } return numSimplifiedPoints != numPoints; } } else if ( wkbGeometryType == wkbPolygon ) { OGRPolygon* polygon = ( OGRPolygon* )geometry; bool result = simplifyOgrGeometry( polygon->getExteriorRing(), true ); for ( int i = 0, numInteriorRings = polygon->getNumInteriorRings(); i < numInteriorRings; ++i ) { result |= simplifyOgrGeometry( polygon->getInteriorRing( i ), true ); } if ( result ) polygon->flattenTo2D(); return result; } else if ( wkbGeometryType == wkbMultiLineString || wkbGeometryType == wkbMultiPolygon ) { OGRGeometryCollection* collection = ( OGRGeometryCollection* )geometry; bool result = false; for ( int i = 0, numGeometries = collection->getNumGeometries(); i < numGeometries; ++i ) { result |= simplifyOgrGeometry( collection->getGeometryRef( i ), wkbGeometryType == wkbMultiPolygon ); } if ( result ) collection->flattenTo2D(); return result; } return false; }
OGRFeature * OGRSDTSLayer::GetNextUnfilteredFeature() { /* -------------------------------------------------------------------- */ /* If not done before we need to assemble the geometry for a */ /* polygon layer. */ /* -------------------------------------------------------------------- */ if( poTransfer->GetLayerType(iLayer) == SLTPoly ) { ((SDTSPolygonReader *) poReader)->AssembleRings(poTransfer,iLayer); } /* -------------------------------------------------------------------- */ /* Fetch the next sdts style feature object from the reader. */ /* -------------------------------------------------------------------- */ SDTSFeature *poSDTSFeature = poReader->GetNextFeature(); OGRFeature *poFeature; if( poSDTSFeature == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* Create the OGR feature. */ /* -------------------------------------------------------------------- */ poFeature = new OGRFeature( poFeatureDefn ); m_nFeaturesRead++; switch( poTransfer->GetLayerType(iLayer) ) { /* -------------------------------------------------------------------- */ /* Translate point feature specific information and geometry. */ /* -------------------------------------------------------------------- */ case SLTPoint: { SDTSRawPoint *poPoint = (SDTSRawPoint *) poSDTSFeature; poFeature->SetGeometryDirectly( new OGRPoint( poPoint->dfX, poPoint->dfY, poPoint->dfZ ) ); } break; /* -------------------------------------------------------------------- */ /* Translate line feature specific information and geometry. */ /* -------------------------------------------------------------------- */ case SLTLine: { SDTSRawLine *poLine = (SDTSRawLine *) poSDTSFeature; OGRLineString *poOGRLine = new OGRLineString(); poOGRLine->setPoints( poLine->nVertices, poLine->padfX, poLine->padfY, poLine->padfZ ); poFeature->SetGeometryDirectly( poOGRLine ); poFeature->SetField( "SNID", (int) poLine->oStartNode.nRecord ); poFeature->SetField( "ENID", (int) poLine->oEndNode.nRecord ); } break; /* -------------------------------------------------------------------- */ /* Translate polygon feature specific information and geometry. */ /* -------------------------------------------------------------------- */ case SLTPoly: { SDTSRawPolygon *poPoly = (SDTSRawPolygon *) poSDTSFeature; OGRPolygon *poOGRPoly = new OGRPolygon(); for( int iRing = 0; iRing < poPoly->nRings; iRing++ ) { OGRLinearRing *poRing = new OGRLinearRing(); int nVertices; if( iRing == poPoly->nRings - 1 ) nVertices = poPoly->nVertices - poPoly->panRingStart[iRing]; else nVertices = poPoly->panRingStart[iRing+1] - poPoly->panRingStart[iRing]; poRing->setPoints( nVertices, poPoly->padfX + poPoly->panRingStart[iRing], poPoly->padfY + poPoly->panRingStart[iRing], poPoly->padfZ + poPoly->panRingStart[iRing] ); poOGRPoly->addRingDirectly( poRing ); } poFeature->SetGeometryDirectly( poOGRPoly ); } break; default: break; } /* -------------------------------------------------------------------- */ /* Set attributes for any indicated attribute records. */ /* -------------------------------------------------------------------- */ int iAttrRecord; for( iAttrRecord = 0; iAttrRecord < poSDTSFeature->nAttributes; iAttrRecord++) { DDFField *poSR; poSR = poTransfer->GetAttr( poSDTSFeature->paoATID+iAttrRecord ); if( poSR != NULL ) AssignAttrRecordToFeature( poFeature, poTransfer, poSR ); } /* -------------------------------------------------------------------- */ /* If this record is an attribute record, attach the local */ /* attributes. */ /* -------------------------------------------------------------------- */ if( poTransfer->GetLayerType(iLayer) == SLTAttr ) { AssignAttrRecordToFeature( poFeature, poTransfer, ((SDTSAttrRecord *) poSDTSFeature)->poATTR); } /* -------------------------------------------------------------------- */ /* Translate the record id. */ /* -------------------------------------------------------------------- */ poFeature->SetFID( poSDTSFeature->oModId.nRecord ); poFeature->SetField( 0, (int) poSDTSFeature->oModId.nRecord ); if( poFeature->GetGeometryRef() != NULL ) poFeature->GetGeometryRef()->assignSpatialReference( poDS->GetSpatialRef() ); if( !poReader->IsIndexed() ) delete poSDTSFeature; return poFeature; }
OGRGeometry *OGRGRASSLayer::GetFeatureGeometry ( long nFeatureId, int *cat ) { CPLDebug ( "GRASS", "OGRGRASSLayer::GetFeatureGeometry nFeatureId = %d", nFeatureId ); int cidx = paFeatureIndex[(int)nFeatureId]; int type, id; Vect_cidx_get_cat_by_index ( poMap, iLayerIndex, cidx, cat, &type, &id ); //CPLDebug ( "GRASS", "cat = %d type = %d id = %d", *cat, type, id ); OGRGeometry *poOGR = NULL; int bIs3D = Vect_is_3d(poMap); switch ( type ) { case GV_POINT: { Vect_read_line ( poMap, poPoints, poCats, id); if (bIs3D) poOGR = new OGRPoint( poPoints->x[0], poPoints->y[0], poPoints->z[0] ); else poOGR = new OGRPoint( poPoints->x[0], poPoints->y[0] ); } break; case GV_LINE: case GV_BOUNDARY: { Vect_read_line ( poMap, poPoints, poCats, id); OGRLineString *poOGRLine = new OGRLineString(); if (bIs3D) poOGRLine->setPoints( poPoints->n_points, poPoints->x, poPoints->y, poPoints->z ); else poOGRLine->setPoints( poPoints->n_points, poPoints->x, poPoints->y ); poOGR = poOGRLine; } break; case GV_AREA: { Vect_get_area_points ( poMap, id, poPoints ); OGRPolygon *poOGRPoly; poOGRPoly = new OGRPolygon(); OGRLinearRing *poRing; poRing = new OGRLinearRing(); if (bIs3D) poRing->setPoints( poPoints->n_points, poPoints->x, poPoints->y, poPoints->z ); else poRing->setPoints( poPoints->n_points, poPoints->x, poPoints->y ); poOGRPoly->addRingDirectly( poRing ); // Islands int nisles = Vect_get_area_num_isles ( poMap, id ); for ( int i = 0; i < nisles; i++ ) { int isle = Vect_get_area_isle ( poMap, id, i ); Vect_get_isle_points ( poMap, isle, poPoints ); poRing = new OGRLinearRing(); if (bIs3D) poRing->setPoints( poPoints->n_points, poPoints->x, poPoints->y, poPoints->z ); else poRing->setPoints( poPoints->n_points, poPoints->x, poPoints->y ); poOGRPoly->addRingDirectly( poRing ); } poOGR = poOGRPoly; } break; default: // Should not happen { CPLError( CE_Failure, CPLE_AppDefined, "Unknown GRASS feature type."); return NULL; } } return poOGR; }
OGRErr OGRPGeoLayer::createFromShapeBin( GByte *pabyShape, OGRGeometry **ppoGeom, int nBytes ) { *ppoGeom = NULL; if( nBytes < 1 ) return OGRERR_FAILURE; int nSHPType = pabyShape[0]; // CPLDebug( "PGeo", // "Shape type read from PGeo data is nSHPType = %d", // nSHPType ); /* -------------------------------------------------------------------- */ /* type 50 appears to just be an alias for normal line */ /* strings. (#1484) */ /* Type 51 appears to just be an alias for normal polygon. (#3100) */ /* TODO: These types include additional attributes including */ /* non-linear segments and such. They should be handled. */ /* -------------------------------------------------------------------- */ switch( nSHPType ) { case 50: nSHPType = SHPT_ARC; break; case 51: nSHPType = SHPT_POLYGON; break; case 52: nSHPType = SHPT_POINT; break; case 53: nSHPType = SHPT_MULTIPOINT; break; case 54: nSHPType = SHPT_MULTIPATCH; } /* ==================================================================== */ /* Extract vertices for a Polygon or Arc. */ /* ==================================================================== */ if( nSHPType == SHPT_ARC || nSHPType == SHPT_ARCZ || nSHPType == SHPT_ARCM || nSHPType == SHPT_ARCZM || nSHPType == SHPT_POLYGON || nSHPType == SHPT_POLYGONZ || nSHPType == SHPT_POLYGONM || nSHPType == SHPT_POLYGONZM || nSHPType == SHPT_MULTIPATCH || nSHPType == SHPT_MULTIPATCHM) { GInt32 nPoints, nParts; int i, nOffset; GInt32 *panPartStart; if (nBytes < 44) { CPLError(CE_Failure, CPLE_AppDefined, "Corrupted Shape : nBytes=%d, nSHPType=%d", nBytes, nSHPType); return OGRERR_FAILURE; } /* -------------------------------------------------------------------- */ /* Extract part/point count, and build vertex and part arrays */ /* to proper size. */ /* -------------------------------------------------------------------- */ memcpy( &nPoints, pabyShape + 40, 4 ); memcpy( &nParts, pabyShape + 36, 4 ); CPL_LSBPTR32( &nPoints ); CPL_LSBPTR32( &nParts ); if (nPoints < 0 || nParts < 0 || nPoints > 50 * 1000 * 1000 || nParts > 10 * 1000 * 1000) { CPLError(CE_Failure, CPLE_AppDefined, "Corrupted Shape : nPoints=%d, nParts=%d.", nPoints, nParts); return OGRERR_FAILURE; } int bHasZ = ( nSHPType == SHPT_POLYGONZ || nSHPType == SHPT_POLYGONZM || nSHPType == SHPT_ARCZ || nSHPType == SHPT_ARCZM || nSHPType == SHPT_MULTIPATCH || nSHPType == SHPT_MULTIPATCHM ); int bIsMultiPatch = ( nSHPType == SHPT_MULTIPATCH || nSHPType == SHPT_MULTIPATCHM ); /* With the previous checks on nPoints and nParts, */ /* we should not overflow here and after */ /* since 50 M * (16 + 8 + 8) = 1 600 MB */ int nRequiredSize = 44 + 4 * nParts + 16 * nPoints; if ( bHasZ ) { nRequiredSize += 16 + 8 * nPoints; } if( bIsMultiPatch ) { nRequiredSize += 4 * nParts; } if (nRequiredSize > nBytes) { CPLError(CE_Failure, CPLE_AppDefined, "Corrupted Shape : nPoints=%d, nParts=%d, nBytes=%d, nSHPType=%d", nPoints, nParts, nBytes, nSHPType); return OGRERR_FAILURE; } panPartStart = (GInt32 *) VSICalloc(nParts,sizeof(GInt32)); if (panPartStart == NULL) { CPLError(CE_Failure, CPLE_OutOfMemory, "Not enough memory for shape (nPoints=%d, nParts=%d)", nPoints, nParts); return OGRERR_FAILURE; } /* -------------------------------------------------------------------- */ /* Copy out the part array from the record. */ /* -------------------------------------------------------------------- */ memcpy( panPartStart, pabyShape + 44, 4 * nParts ); for( i = 0; i < nParts; i++ ) { CPL_LSBPTR32( panPartStart + i ); /* We check that the offset is inside the vertex array */ if (panPartStart[i] < 0 || panPartStart[i] >= nPoints) { CPLError(CE_Failure, CPLE_AppDefined, "Corrupted Shape : panPartStart[%d] = %d, nPoints = %d", i, panPartStart[i], nPoints); CPLFree(panPartStart); return OGRERR_FAILURE; } if (i > 0 && panPartStart[i] <= panPartStart[i-1]) { CPLError(CE_Failure, CPLE_AppDefined, "Corrupted Shape : panPartStart[%d] = %d, panPartStart[%d] = %d", i, panPartStart[i], i - 1, panPartStart[i - 1]); CPLFree(panPartStart); return OGRERR_FAILURE; } } nOffset = 44 + 4*nParts; /* -------------------------------------------------------------------- */ /* If this is a multipatch, we will also have parts types. For */ /* now we ignore and skip past them. */ /* -------------------------------------------------------------------- */ if( bIsMultiPatch ) nOffset += 4*nParts; /* -------------------------------------------------------------------- */ /* Copy out the vertices from the record. */ /* -------------------------------------------------------------------- */ double *padfX = (double *) VSIMalloc(sizeof(double)*nPoints); double *padfY = (double *) VSIMalloc(sizeof(double)*nPoints); double *padfZ = (double *) VSICalloc(sizeof(double),nPoints); if (padfX == NULL || padfY == NULL || padfZ == NULL) { CPLFree( panPartStart ); CPLFree( padfX ); CPLFree( padfY ); CPLFree( padfZ ); CPLError(CE_Failure, CPLE_OutOfMemory, "Not enough memory for shape (nPoints=%d, nParts=%d)", nPoints, nParts); return OGRERR_FAILURE; } for( i = 0; i < nPoints; i++ ) { memcpy(padfX + i, pabyShape + nOffset + i * 16, 8 ); memcpy(padfY + i, pabyShape + nOffset + i * 16 + 8, 8 ); CPL_LSBPTR64( padfX + i ); CPL_LSBPTR64( padfY + i ); } nOffset += 16*nPoints; /* -------------------------------------------------------------------- */ /* If we have a Z coordinate, collect that now. */ /* -------------------------------------------------------------------- */ if( bHasZ ) { for( i = 0; i < nPoints; i++ ) { memcpy( padfZ + i, pabyShape + nOffset + 16 + i*8, 8 ); CPL_LSBPTR64( padfZ + i ); } nOffset += 16 + 8*nPoints; } /* -------------------------------------------------------------------- */ /* Build corresponding OGR objects. */ /* -------------------------------------------------------------------- */ if( nSHPType == SHPT_ARC || nSHPType == SHPT_ARCZ || nSHPType == SHPT_ARCM || nSHPType == SHPT_ARCZM ) { /* -------------------------------------------------------------------- */ /* Arc - As LineString */ /* -------------------------------------------------------------------- */ if( nParts == 1 ) { OGRLineString *poLine = new OGRLineString(); *ppoGeom = poLine; poLine->setPoints( nPoints, padfX, padfY, padfZ ); } /* -------------------------------------------------------------------- */ /* Arc - As MultiLineString */ /* -------------------------------------------------------------------- */ else { OGRMultiLineString *poMulti = new OGRMultiLineString; *ppoGeom = poMulti; for( i = 0; i < nParts; i++ ) { OGRLineString *poLine = new OGRLineString; int nVerticesInThisPart; if( i == nParts-1 ) nVerticesInThisPart = nPoints - panPartStart[i]; else nVerticesInThisPart = panPartStart[i+1] - panPartStart[i]; poLine->setPoints( nVerticesInThisPart, padfX + panPartStart[i], padfY + panPartStart[i], padfZ + panPartStart[i] ); poMulti->addGeometryDirectly( poLine ); } } } /* ARC */ /* -------------------------------------------------------------------- */ /* Polygon */ /* -------------------------------------------------------------------- */ else if( nSHPType == SHPT_POLYGON || nSHPType == SHPT_POLYGONZ || nSHPType == SHPT_POLYGONM || nSHPType == SHPT_POLYGONZM ) { OGRPolygon *poMulti = new OGRPolygon; *ppoGeom = poMulti; for( i = 0; i < nParts; i++ ) { OGRLinearRing *poRing = new OGRLinearRing; int nVerticesInThisPart; if( i == nParts-1 ) nVerticesInThisPart = nPoints - panPartStart[i]; else nVerticesInThisPart = panPartStart[i+1] - panPartStart[i]; poRing->setPoints( nVerticesInThisPart, padfX + panPartStart[i], padfY + panPartStart[i], padfZ + panPartStart[i] ); poMulti->addRingDirectly( poRing ); } } /* polygon */ /* -------------------------------------------------------------------- */ /* Multipatch */ /* -------------------------------------------------------------------- */ else if( bIsMultiPatch ) { /* return to this later */ } CPLFree( panPartStart ); CPLFree( padfX ); CPLFree( padfY ); CPLFree( padfZ ); if( !bHasZ ) (*ppoGeom)->setCoordinateDimension( 2 ); return OGRERR_NONE; } /* ==================================================================== */ /* Extract vertices for a MultiPoint. */ /* ==================================================================== */ else if( nSHPType == SHPT_MULTIPOINT || nSHPType == SHPT_MULTIPOINTM || nSHPType == SHPT_MULTIPOINTZ || nSHPType == SHPT_MULTIPOINTZM ) { #ifdef notdef int32 nPoints; int i, nOffset; memcpy( &nPoints, psSHP->pabyRec + 44, 4 ); if( bBigEndian ) SwapWord( 4, &nPoints ); psShape->nVertices = nPoints; psShape->padfX = (double *) calloc(nPoints,sizeof(double)); psShape->padfY = (double *) calloc(nPoints,sizeof(double)); psShape->padfZ = (double *) calloc(nPoints,sizeof(double)); psShape->padfM = (double *) calloc(nPoints,sizeof(double)); for( i = 0; i < nPoints; i++ ) { memcpy(psShape->padfX+i, psSHP->pabyRec + 48 + 16 * i, 8 ); memcpy(psShape->padfY+i, psSHP->pabyRec + 48 + 16 * i + 8, 8 ); if( bBigEndian ) SwapWord( 8, psShape->padfX + i ); if( bBigEndian ) SwapWord( 8, psShape->padfY + i ); } nOffset = 48 + 16*nPoints; /* -------------------------------------------------------------------- */ /* Get the X/Y bounds. */ /* -------------------------------------------------------------------- */ memcpy( &(psShape->dfXMin), psSHP->pabyRec + 8 + 4, 8 ); memcpy( &(psShape->dfYMin), psSHP->pabyRec + 8 + 12, 8 ); memcpy( &(psShape->dfXMax), psSHP->pabyRec + 8 + 20, 8 ); memcpy( &(psShape->dfYMax), psSHP->pabyRec + 8 + 28, 8 ); if( bBigEndian ) SwapWord( 8, &(psShape->dfXMin) ); if( bBigEndian ) SwapWord( 8, &(psShape->dfYMin) ); if( bBigEndian ) SwapWord( 8, &(psShape->dfXMax) ); if( bBigEndian ) SwapWord( 8, &(psShape->dfYMax) ); /* -------------------------------------------------------------------- */ /* If we have a Z coordinate, collect that now. */ /* -------------------------------------------------------------------- */ if( psShape->nSHPType == SHPT_MULTIPOINTZ || psShape->nSHPType == SHPT_MULTIPOINTZM ) { memcpy( &(psShape->dfZMin), psSHP->pabyRec + nOffset, 8 ); memcpy( &(psShape->dfZMax), psSHP->pabyRec + nOffset + 8, 8 ); if( bBigEndian ) SwapWord( 8, &(psShape->dfZMin) ); if( bBigEndian ) SwapWord( 8, &(psShape->dfZMax) ); for( i = 0; i < nPoints; i++ ) { memcpy( psShape->padfZ + i, psSHP->pabyRec + nOffset + 16 + i*8, 8 ); if( bBigEndian ) SwapWord( 8, psShape->padfZ + i ); } nOffset += 16 + 8*nPoints; } /* -------------------------------------------------------------------- */ /* If we have a M measure value, then read it now. We assume */ /* that the measure can be present for any shape if the size is */ /* big enough, but really it will only occur for the Z shapes */ /* (options), and the M shapes. */ /* -------------------------------------------------------------------- */ if( psSHP->panRecSize[hEntity]+8 >= nOffset + 16 + 8*nPoints ) { memcpy( &(psShape->dfMMin), psSHP->pabyRec + nOffset, 8 ); memcpy( &(psShape->dfMMax), psSHP->pabyRec + nOffset + 8, 8 ); if( bBigEndian ) SwapWord( 8, &(psShape->dfMMin) ); if( bBigEndian ) SwapWord( 8, &(psShape->dfMMax) ); for( i = 0; i < nPoints; i++ ) { memcpy( psShape->padfM + i, psSHP->pabyRec + nOffset + 16 + i*8, 8 ); if( bBigEndian ) SwapWord( 8, psShape->padfM + i ); } } #endif } /* ==================================================================== */ /* Extract vertices for a point. */ /* ==================================================================== */ else if( nSHPType == SHPT_POINT || nSHPType == SHPT_POINTM || nSHPType == SHPT_POINTZ || nSHPType == SHPT_POINTZM ) { int nOffset; double dfX, dfY, dfZ = 0; int bHasZ = (nSHPType == SHPT_POINTZ || nSHPType == SHPT_POINTZM); if (nBytes < 4 + 8 + 8 + ((nSHPType == SHPT_POINTZ) ? 8 : 0)) { CPLError(CE_Failure, CPLE_AppDefined, "Corrupted Shape : nBytes=%d, nSHPType=%d", nBytes, nSHPType); return OGRERR_FAILURE; } memcpy( &dfX, pabyShape + 4, 8 ); memcpy( &dfY, pabyShape + 4 + 8, 8 ); CPL_LSBPTR64( &dfX ); CPL_LSBPTR64( &dfY ); nOffset = 20 + 8; if( bHasZ ) { memcpy( &dfZ, pabyShape + 4 + 16, 8 ); CPL_LSBPTR64( &dfZ ); } *ppoGeom = new OGRPoint( dfX, dfY, dfZ ); if( !bHasZ ) (*ppoGeom)->setCoordinateDimension( 2 ); return OGRERR_NONE; } char* pszHex = CPLBinaryToHex( nBytes, pabyShape ); CPLDebug( "PGEO", "Unsupported geometry type:%d\nnBytes=%d, hex=%s", nSHPType, nBytes, pszHex ); CPLFree(pszHex); return OGRERR_FAILURE; }