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))
{
unsigned int iPart;
for(iPart = 0; iPart < nParts; iPart ++)
{
unsigned int nNodes;
if (VSIFReadL(&nNodes, sizeof(unsigned int), 1, fp) != 1)
return NULL;
CPL_LSBPTR32(&nNodes);
if (nNodes > nTotalNodes)
return NULL;
VSIFSeekL(fp, sizeof(OGRRawPoint) * nNodes, SEEK_CUR);
}
nNextFID ++;
continue;
}
OGRRawPoint* poRawPoints = (OGRRawPoint*)VSIMalloc2(sizeof(OGRRawPoint), nTotalNodes);
if (poRawPoints == NULL)
{
return NULL;
}
unsigned int iPart;
OGRPolygon* poGeom = new OGRPolygon();
for(iPart = 0; iPart < nParts; iPart ++)
{
unsigned int nNodes;
if (VSIFReadL(&nNodes, sizeof(unsigned int), 1, fp) != 1)
{
VSIFree(poRawPoints);
delete poGeom;
return NULL;
}
CPL_LSBPTR32(&nNodes);
if (nNodes > nTotalNodes ||
(unsigned int)VSIFReadL(poRawPoints, sizeof(OGRRawPoint), nNodes, fp) != nNodes)
{
VSIFree(poRawPoints);
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);
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 *OGRPCIDSKLayer::GetFeature( long nFID )
{
/* -------------------------------------------------------------------- */
/* Create the OGR feature. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature;
poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetFID( (int) nFID );
/* -------------------------------------------------------------------- */
/* Set attributes for any indicated attribute records. */
/* -------------------------------------------------------------------- */
try {
std::vector<PCIDSK::ShapeField> aoFields;
unsigned int i;
poVecSeg->GetFields( (int) nFID, aoFields );
for( i=0; i < aoFields.size(); i++ )
{
if( (int) i == iRingStartField )
continue;
switch( aoFields[i].GetType() )
{
case PCIDSK::FieldTypeNone:
// null field value.
break;
case PCIDSK::FieldTypeInteger:
poFeature->SetField( i, aoFields[i].GetValueInteger() );
break;
case PCIDSK::FieldTypeFloat:
poFeature->SetField( i, aoFields[i].GetValueFloat() );
break;
case PCIDSK::FieldTypeDouble:
poFeature->SetField( i, aoFields[i].GetValueDouble() );
break;
case PCIDSK::FieldTypeString:
poFeature->SetField( i, aoFields[i].GetValueString().c_str() );
break;
case PCIDSK::FieldTypeCountedInt:
std::vector<PCIDSK::int32> list = aoFields[i].GetValueCountedInt();
poFeature->SetField( i, list.size(), &(list[0]) );
break;
}
}
/* -------------------------------------------------------------------- */
/* Translate the geometry. */
/* -------------------------------------------------------------------- */
std::vector<PCIDSK::ShapeVertex> aoVertices;
poVecSeg->GetVertices( (int) nFID, aoVertices );
/* -------------------------------------------------------------------- */
/* Point */
/* -------------------------------------------------------------------- */
if( poFeatureDefn->GetGeomType() == wkbPoint25D
|| (wkbFlatten(poFeatureDefn->GetGeomType()) == wkbUnknown
&& aoVertices.size() == 1) )
{
if( aoVertices.size() == 1 )
{
OGRPoint* poPoint =
new OGRPoint( aoVertices[0].x,
aoVertices[0].y,
aoVertices[0].z );
if (poSRS)
poPoint->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poPoint);
}
else
{
// report issue?
}
}
/* -------------------------------------------------------------------- */
/* LineString */
/* -------------------------------------------------------------------- */
else if( poFeatureDefn->GetGeomType() == wkbLineString25D
|| (wkbFlatten(poFeatureDefn->GetGeomType()) == wkbUnknown
&& aoVertices.size() > 1) )
{
// We should likely be applying ringstart to break things into
// a multilinestring in some cases.
if( aoVertices.size() > 1 )
{
OGRLineString *poLS = new OGRLineString();
poLS->setNumPoints( aoVertices.size() );
for( i = 0; i < aoVertices.size(); i++ )
poLS->setPoint( i,
aoVertices[i].x,
aoVertices[i].y,
aoVertices[i].z );
if (poSRS)
poLS->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly( poLS );
}
else
{
// report issue?
}
}
/* -------------------------------------------------------------------- */
/* Polygon - Currently we have no way to recognise if we are */
/* dealing with a multipolygon when we have more than one */
/* ring. Also, PCIDSK allows the rings to be in arbitrary */
/* order, not necessarily outside first which we are not yet */
/* ready to address in the following code. */
/* -------------------------------------------------------------------- */
else if( poFeatureDefn->GetGeomType() == wkbPolygon25D )
{
std::vector<PCIDSK::int32> anRingStart;
OGRPolygon *poPoly = new OGRPolygon();
unsigned int iRing;
if( iRingStartField != -1 )
anRingStart = aoFields[iRingStartField].GetValueCountedInt();
for( iRing = 0; iRing < anRingStart.size()+1; iRing++ )
{
int iStartVertex, iEndVertex, iVertex;
OGRLinearRing *poRing = new OGRLinearRing();
if( iRing == 0 )
iStartVertex = 0;
else
iStartVertex = anRingStart[iRing-1];
if( iRing == anRingStart.size() )
iEndVertex = aoVertices.size() - 1;
else
iEndVertex = anRingStart[iRing] - 1;
poRing->setNumPoints( iEndVertex - iStartVertex + 1 );
for( iVertex = iStartVertex; iVertex <= iEndVertex; iVertex++ )
{
poRing->setPoint( iVertex - iStartVertex,
aoVertices[iVertex].x,
aoVertices[iVertex].y,
aoVertices[iVertex].z );
}
poPoly->addRingDirectly( poRing );
}
if (poSRS)
poPoly->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly( poPoly );
}
}
/* -------------------------------------------------------------------- */
/* Trap exceptions and report as CPL errors. */
/* -------------------------------------------------------------------- */
catch( PCIDSK::PCIDSKException ex )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s", ex.what() );
return NULL;
}
catch(...)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Non-PCIDSK exception trapped." );
return NULL;
}
m_nFeaturesRead++;
return poFeature;
}
OGRFeature *OGROpenAirLayer::GetNextRawFeature()
{
const char* pszLine;
CPLString osCLASS, osNAME, osFLOOR, osCEILING;
OGRLinearRing oLR;
double dfLastLat = 0, dfLastLon = 0;
int bFirst = TRUE;
int bClockWise = TRUE;
double dfCenterLat = 0, dfCenterLon = 0;
int bHasCenter = FALSE;
OpenAirStyle sStyle;
sStyle.penStyle = -1;
sStyle.penWidth = -1;
sStyle.penR = sStyle.penG = sStyle.penB = -1;
sStyle.fillR = sStyle.fillG = sStyle.fillB = -1;
if (bEOF)
return NULL;
while(TRUE)
{
if (bFirst && bHasLastLine)
{
pszLine = osLastLine.c_str();
bFirst = FALSE;
}
else
{
pszLine = CPLReadLine2L(fpOpenAir, 1024, NULL);
if (pszLine == NULL)
{
bEOF = TRUE;
if (oLR.getNumPoints() == 0)
return NULL;
if (osCLASS.size() != 0 &&
oStyleMap.find(osCLASS) != oStyleMap.end())
{
memcpy(&sStyle, oStyleMap[osCLASS], sizeof(sStyle));
}
break;
}
osLastLine = pszLine;
bHasLastLine = TRUE;
}
if (pszLine[0] == '*' || pszLine[0] == '\0')
continue;
if (EQUALN(pszLine, "AC ", 3) || EQUALN(pszLine, "AC,", 3))
{
if (osCLASS.size() != 0)
{
if (sStyle.penStyle != -1 || sStyle.fillR != -1)
{
if (oLR.getNumPoints() == 0)
{
OpenAirStyle* psStyle;
if (oStyleMap.find(osCLASS) == oStyleMap.end())
{
psStyle = (OpenAirStyle*)CPLMalloc(
sizeof(OpenAirStyle));
oStyleMap[osCLASS] = psStyle;
}
else
psStyle = oStyleMap[osCLASS];
memcpy(psStyle, &sStyle, sizeof(sStyle));
}
else
break;
}
else if (oStyleMap.find(osCLASS) != oStyleMap.end())
{
memcpy(&sStyle, oStyleMap[osCLASS], sizeof(sStyle));
break;
}
else
break;
}
sStyle.penStyle = -1;
sStyle.penWidth = -1;
sStyle.penR = sStyle.penG = sStyle.penB = -1;
sStyle.fillR = sStyle.fillG = sStyle.fillB = -1;
osCLASS = pszLine + 3;
bClockWise = TRUE;
bHasCenter = FALSE;
}
else if (EQUALN(pszLine, "AN ", 3))
{
if (osNAME.size() != 0)
break;
osNAME = pszLine + 3;
}
else if (EQUALN(pszLine, "AH ", 3))
osCEILING = pszLine + 3;
else if (EQUALN(pszLine, "AL ", 3))
osFLOOR = pszLine + 3;
else if (EQUALN(pszLine, "AT ", 3))
{
/* Ignored for that layer*/
}
else if (EQUALN(pszLine, "SP ", 3))
{
if (osCLASS.size() != 0)
{
char** papszTokens = CSLTokenizeString2(pszLine+3, ", ", 0);
if (CSLCount(papszTokens) == 5)
{
sStyle.penStyle = atoi(papszTokens[0]);
sStyle.penWidth = atoi(papszTokens[1]);
sStyle.penR = atoi(papszTokens[2]);
sStyle.penG = atoi(papszTokens[3]);
sStyle.penB = atoi(papszTokens[4]);
}
CSLDestroy(papszTokens);
}
}
else if (EQUALN(pszLine, "SB ", 3))
{
if (osCLASS.size() != 0)
{
char** papszTokens = CSLTokenizeString2(pszLine+3, ", ", 0);
if (CSLCount(papszTokens) == 3)
{
sStyle.fillR = atoi(papszTokens[0]);
sStyle.fillG = atoi(papszTokens[1]);
sStyle.fillB = atoi(papszTokens[2]);
}
CSLDestroy(papszTokens);
}
}
else if (EQUALN(pszLine, "DP ", 3))
{
pszLine += 3;
double dfLat, dfLon;
if (!OGROpenAirGetLatLon(pszLine, dfLat, dfLon))
continue;
oLR.addPoint(dfLon, dfLat);
dfLastLat = dfLat;
dfLastLon = dfLon;
}
else if (EQUALN(pszLine, "DA ", 3))
{
pszLine += 3;
char* pszStar = strchr((char*)pszLine, '*');
if (pszStar) *pszStar = 0;
char** papszTokens = CSLTokenizeString2(pszLine, ",", 0);
if (bHasCenter && CSLCount(papszTokens) == 3)
{
double dfRadius = atof(papszTokens[0]) * 1852;
double dfStartAngle = atof(papszTokens[1]);
double dfEndAngle = atof(papszTokens[2]);
if (bClockWise && dfEndAngle < dfStartAngle)
dfEndAngle += 360;
else if (!bClockWise && dfStartAngle < dfEndAngle)
dfEndAngle -= 360;
double dfStartDistance = dfRadius;
double dfEndDistance = dfRadius;
int nSign = (bClockWise) ? 1 : -1;
double dfAngle;
double dfLat, dfLon;
for(dfAngle = dfStartAngle;
(dfAngle - dfEndAngle) * nSign < 0;
dfAngle += nSign)
{
double pct = (dfAngle - dfStartAngle) /
(dfEndAngle - dfStartAngle);
double dfDist = dfStartDistance * (1-pct) +
dfEndDistance * pct;
OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon,
dfDist, dfAngle, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
}
OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon,
dfEndDistance, dfEndAngle, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
dfLastLat = oLR.getY(oLR.getNumPoints() - 1);
dfLastLon = oLR.getX(oLR.getNumPoints() - 1);
}
CSLDestroy(papszTokens);
}
else if (EQUALN(pszLine, "DB ", 3))
{
pszLine += 3;
char* pszStar = strchr((char*)pszLine, '*');
if (pszStar) *pszStar = 0;
char** papszTokens = CSLTokenizeString2(pszLine, ",", 0);
double dfFirstLat, dfFirstLon;
double dfSecondLat, dfSecondLon;
if (bHasCenter && CSLCount(papszTokens) == 2 &&
OGROpenAirGetLatLon(papszTokens[0], dfFirstLat, dfFirstLon) &&
OGROpenAirGetLatLon(papszTokens[1], dfSecondLat, dfSecondLon))
{
double dfStartDistance =OGRXPlane_Distance(dfCenterLat,
dfCenterLon, dfFirstLat, dfFirstLon);
double dfEndDistance = OGRXPlane_Distance(dfCenterLat,
dfCenterLon, dfSecondLat, dfSecondLon);
double dfStartAngle = OGRXPlane_Track(dfCenterLat,
dfCenterLon, dfFirstLat, dfFirstLon);
double dfEndAngle = OGRXPlane_Track(dfCenterLat,
dfCenterLon, dfSecondLat, dfSecondLon);
if (bClockWise && dfEndAngle < dfStartAngle)
dfEndAngle += 360;
else if (!bClockWise && dfStartAngle < dfEndAngle)
dfEndAngle -= 360;
int nSign = (bClockWise) ? 1 : -1;
double dfAngle;
for(dfAngle = dfStartAngle;
(dfAngle - dfEndAngle) * nSign < 0;
dfAngle += nSign)
{
double dfLat, dfLon;
double pct = (dfAngle - dfStartAngle) /
(dfEndAngle - dfStartAngle);
double dfDist = dfStartDistance * (1-pct) +
dfEndDistance * pct;
OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon,
dfDist, dfAngle, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
}
oLR.addPoint(dfSecondLon, dfSecondLat);
dfLastLat = oLR.getY(oLR.getNumPoints() - 1);
dfLastLon = oLR.getX(oLR.getNumPoints() - 1);
}
CSLDestroy(papszTokens);
}
else if ((EQUALN(pszLine, "DC ", 3) || EQUALN(pszLine, "DC=", 3)) &&
(bHasCenter || strstr(pszLine, "V X=") != NULL))
{
if (!bHasCenter)
{
const char* pszVX = strstr(pszLine, "V X=");
bHasCenter = OGROpenAirGetLatLon(pszVX, dfCenterLat, dfCenterLon);
}
if (bHasCenter)
{
pszLine += 3;
double dfRADIUS = atof(pszLine) * 1852;
double dfAngle;
double dfLat, dfLon;
for(dfAngle = 0; dfAngle < 360; dfAngle += 1)
{
OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon,
dfRADIUS, dfAngle, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
}
OGRXPlane_ExtendPosition(dfCenterLat, dfCenterLon,
dfRADIUS, 0, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
dfLastLat = oLR.getY(oLR.getNumPoints() - 1);
dfLastLon = oLR.getX(oLR.getNumPoints() - 1);
}
}
else if (EQUALN(pszLine, "V X=", 4))
{
bHasCenter =
OGROpenAirGetLatLon(pszLine + 4, dfCenterLat, dfCenterLon);
}
else if (EQUALN(pszLine, "V D=-", 5))
{
bClockWise = FALSE;
}
else if (EQUALN(pszLine, "V D=+", 5))
{
bClockWise = TRUE;
}
else
{
//CPLDebug("OpenAir", "Unexpected content : %s", pszLine);
}
}
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetField(0, osCLASS.c_str());
poFeature->SetField(1, osNAME.c_str());
poFeature->SetField(2, osFLOOR.c_str());
poFeature->SetField(3, osCEILING.c_str());
if (sStyle.penStyle != -1 || sStyle.fillR != -1)
{
CPLString osStyle;
if (sStyle.penStyle != -1)
{
osStyle += CPLString().Printf("PEN(c:#%02X%02X%02X,w:%dpt",
sStyle.penR, sStyle.penG, sStyle.penB,
sStyle.penWidth);
if (sStyle.penStyle == 1)
osStyle += ",p:\"5px 5px\"";
osStyle += ")";
}
if (sStyle.fillR != -1)
{
if (osStyle.size() != 0)
osStyle += ";";
osStyle += CPLString().Printf("BRUSH(fc:#%02X%02X%02X)",
sStyle.fillR, sStyle.fillG, sStyle.fillB);
}
else
{
if (osStyle.size() != 0)
osStyle += ";";
osStyle += "BRUSH(fc:#00000000,id:\"ogr-brush-1\")";
}
if (osStyle.size() != 0)
poFeature->SetStyleString(osStyle);
}
OGRPolygon* poPoly = new OGRPolygon();
oLR.closeRings();
poPoly->addRing(&oLR);
poPoly->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poPoly);
poFeature->SetFID(nNextFID++);
return poFeature;
}
OGRFeature *OGROGDILayer::GetNextRawFeature()
{
/* -------------------------------------------------------------------- */
/* Retrieve object from OGDI server and create new feature */
/* -------------------------------------------------------------------- */
ecs_Result *psResult = cln_GetNextObject(m_nClientID);
if (! ECSSUCCESS(psResult))
{
if( ECSERROR( psResult ) &&
(psResult->message == NULL ||
strstr(psResult->message, "End of selection") == NULL) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Access to next object of layer '%s' failed: %s\n",
m_pszOGDILayerName,
psResult->message ? psResult->message : "(no error string)" );
}
// We probably reached EOF... keep track of shape count.
m_nTotalShapeCount = m_iNextShapeId - m_nFilteredOutShapes;
return NULL;
}
OGRFeature *poFeature = new OGRFeature(m_poFeatureDefn);
poFeature->SetFID( m_iNextShapeId++ );
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Process geometry */
/* -------------------------------------------------------------------- */
if (m_eFamily == Point)
{
ecs_Point *psPoint = &(ECSGEOM(psResult).point);
OGRPoint *poOGRPoint = new OGRPoint(psPoint->c.x, psPoint->c.y);
poOGRPoint->assignSpatialReference(m_poSpatialRef);
poFeature->SetGeometryDirectly(poOGRPoint);
}
else if (m_eFamily == Line)
{
ecs_Line *psLine = &(ECSGEOM(psResult).line);
OGRLineString *poOGRLine = new OGRLineString();
poOGRLine->setNumPoints( psLine->c.c_len );
for( int i = 0; i < (int) psLine->c.c_len; i++ )
{
poOGRLine->setPoint(i, psLine->c.c_val[i].x, psLine->c.c_val[i].y);
}
poOGRLine->assignSpatialReference(m_poSpatialRef);
poFeature->SetGeometryDirectly(poOGRLine);
}
else if (m_eFamily == Area)
{
ecs_Area *psArea = &(ECSGEOM(psResult).area);
OGRPolygon *poOGRPolygon = new OGRPolygon();
for( int iRing = 0; iRing < (int) psArea->ring.ring_len; iRing++ )
{
ecs_FeatureRing *psRing = &(psArea->ring.ring_val[iRing]);
OGRLinearRing *poOGRRing = new OGRLinearRing();
poOGRRing->setNumPoints( psRing->c.c_len );
for( int i = 0; i < (int) psRing->c.c_len; i++ )
{
poOGRRing->setPoint(i, psRing->c.c_val[i].x,
psRing->c.c_val[i].y);
}
poOGRPolygon->addRingDirectly(poOGRRing);
}
// __TODO__
// When OGR supports polygon centroids then we should carry them here
poOGRPolygon->assignSpatialReference(m_poSpatialRef);
poFeature->SetGeometryDirectly(poOGRPolygon);
}
else if (m_eFamily == Text)
{
// __TODO__
// For now text is treated as a point and string is lost
//
ecs_Text *psText = &(ECSGEOM(psResult).text);
OGRPoint *poOGRPoint = new OGRPoint(psText->c.x, psText->c.y);
poOGRPoint->assignSpatialReference(m_poSpatialRef);
poFeature->SetGeometryDirectly(poOGRPoint);
}
else
{
CPLAssert(false);
}
/* -------------------------------------------------------------------- */
/* Set attributes */
/* -------------------------------------------------------------------- */
char *pszAttrList = ECSOBJECTATTR(psResult);
for( int iField = 0; iField < m_poFeatureDefn->GetFieldCount(); iField++ )
{
char *pszFieldStart = NULL;
int nNameLen = 0;
/* parse out the next attribute value */
if( !ecs_FindElement( pszAttrList, &pszFieldStart, &pszAttrList,
&nNameLen, NULL ) )
{
nNameLen = 0;
pszFieldStart = pszAttrList;
}
/* Skip any trailing white space (for string constants). */
if( nNameLen > 0 && pszFieldStart[nNameLen-1] == ' ' )
nNameLen--;
/* skip leading white space */
while( pszFieldStart[0] == ' ' && nNameLen > 0 )
{
pszFieldStart++;
nNameLen--;
}
/* zero terminate the single field value, but save the */
/* character we overwrote, so we can restore it when done. */
char chSavedChar = pszFieldStart[nNameLen];
pszFieldStart[nNameLen] = '\0';
/* OGR takes care of all field type conversions for us! */
poFeature->SetField(iField, pszFieldStart);
pszFieldStart[nNameLen] = chSavedChar;
}
/* -------------------------------------------------------------------- */
/* Apply the text associated with text features if appropriate. */
/* -------------------------------------------------------------------- */
if( m_eFamily == Text )
{
poFeature->SetField( "text", ECSGEOM(psResult).text.desc );
}
return poFeature;
}
OGRFeature *OGRSUALayer::GetNextRawFeature()
{
if( bEOF )
return nullptr;
CPLString osTYPE;
CPLString osCLASS;
CPLString osTITLE;
CPLString osTOPS;
CPLString osBASE;
OGRLinearRing oLR;
double dfLastLat = 0.0;
double dfLastLon = 0.0;
bool bFirst = true;
while( true )
{
const char* pszLine = nullptr;
if( bFirst && bHasLastLine )
{
pszLine = osLastLine.c_str();
bFirst = false;
}
else
{
pszLine = CPLReadLine2L(fpSUA, 1024, nullptr);
if (pszLine == nullptr)
{
bEOF = true;
if (oLR.getNumPoints() == 0)
return nullptr;
break;
}
osLastLine = pszLine;
bHasLastLine = true;
}
if (pszLine[0] == '#' || pszLine[0] == '\0')
continue;
if (STARTS_WITH_CI(pszLine, "TYPE="))
{
if (!osTYPE.empty())
break;
osTYPE = pszLine + 5;
}
else if (STARTS_WITH_CI(pszLine, "CLASS="))
{
if (!osCLASS.empty())
break;
osCLASS = pszLine + 6;
}
else if (STARTS_WITH_CI(pszLine, "TITLE="))
{
if (!osTITLE.empty())
break;
osTITLE = pszLine + 6;
}
else if (STARTS_WITH_CI(pszLine, "TOPS="))
osTOPS = pszLine + 5;
else if (STARTS_WITH_CI(pszLine, "BASE="))
osBASE = pszLine + 5;
else if (STARTS_WITH_CI(pszLine, "POINT="))
{
pszLine += 6;
if (strlen(pszLine) != 16)
continue;
double dfLat = 0.0;
double dfLon = 0.0;
if (!GetLatLon(pszLine, dfLat, dfLon))
continue;
oLR.addPoint(dfLon, dfLat);
dfLastLat = dfLat;
dfLastLon = dfLon;
}
else if (STARTS_WITH_CI(pszLine, "CLOCKWISE") || STARTS_WITH_CI(pszLine, "ANTI-CLOCKWISE"))
{
if (oLR.getNumPoints() == 0)
continue;
int bClockWise = STARTS_WITH_CI(pszLine, "CLOCKWISE");
/*const char* pszRADIUS = strstr(pszLine, "RADIUS=");
if (pszRADIUS == NULL)
continue;
double dfRADIUS = CPLAtof(pszRADIUS + 7) * 1852;*/
const char* pszCENTRE = strstr(pszLine, "CENTRE=");
if (pszCENTRE == nullptr)
continue;
pszCENTRE += 7;
if (strlen(pszCENTRE) < 17 || pszCENTRE[16] != ' ')
continue;
double dfCenterLat = 0.0;
double dfCenterLon = 0.0;
if (!GetLatLon(pszCENTRE, dfCenterLat, dfCenterLon))
continue;
const char* pszTO = strstr(pszLine, "TO=");
if (pszTO == nullptr)
continue;
pszTO += 3;
if (strlen(pszTO) != 16)
continue;
double dfToLat = 0.0;
double dfToLon = 0.0;
if (!GetLatLon(pszTO, dfToLat, dfToLon))
continue;
const double dfStartDistance =
OGR_GreatCircle_Distance(dfCenterLat, dfCenterLon, dfLastLat, dfLastLon);
const double dfEndDistance =
OGR_GreatCircle_Distance(dfCenterLat, dfCenterLon, dfToLat, dfToLon);
const double dfStartAngle =
OGR_GreatCircle_InitialHeading(dfCenterLat, dfCenterLon, dfLastLat, dfLastLon);
double dfEndAngle =
OGR_GreatCircle_InitialHeading(dfCenterLat, dfCenterLon, dfToLat, dfToLon);
if( bClockWise && dfEndAngle < dfStartAngle )
dfEndAngle += 360;
else if (!bClockWise && dfStartAngle < dfEndAngle)
dfEndAngle -= 360;
int nSign = (bClockWise) ? 1 : -1;
for( double dfAngle = dfStartAngle;
(dfAngle - dfEndAngle) * nSign < 0;
dfAngle += nSign )
{
const double pct = (dfAngle - dfStartAngle) / (dfEndAngle - dfStartAngle);
const double dfDist = dfStartDistance * (1-pct) + dfEndDistance * pct;
double dfLat = 0.0;
double dfLon = 0.0;
OGR_GreatCircle_ExtendPosition(dfCenterLat, dfCenterLon, dfDist, dfAngle, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
}
oLR.addPoint(dfToLon, dfToLat);
dfLastLat = oLR.getY(oLR.getNumPoints() - 1);
dfLastLon = oLR.getX(oLR.getNumPoints() - 1);
}
else if (STARTS_WITH_CI(pszLine, "CIRCLE"))
{
const char* pszRADIUS = strstr(pszLine, "RADIUS=");
if (pszRADIUS == nullptr)
continue;
double dfRADIUS = CPLAtof(pszRADIUS + 7) * 1852;
const char* pszCENTRE = strstr(pszLine, "CENTRE=");
if (pszCENTRE == nullptr)
continue;
pszCENTRE += 7;
if (strlen(pszCENTRE) != 16)
continue;
double dfCenterLat = 0.0;
double dfCenterLon = 0.0;
if (!GetLatLon(pszCENTRE, dfCenterLat, dfCenterLon))
continue;
double dfLat = 0.0;
double dfLon = 0.0;
for( double dfAngle = 0; dfAngle < 360; dfAngle += 1 )
{
OGR_GreatCircle_ExtendPosition(dfCenterLat, dfCenterLon, dfRADIUS, dfAngle, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
}
OGR_GreatCircle_ExtendPosition(dfCenterLat, dfCenterLon, dfRADIUS, 0, &dfLat, &dfLon);
oLR.addPoint(dfLon, dfLat);
dfLastLat = oLR.getY(oLR.getNumPoints() - 1);
dfLastLon = oLR.getX(oLR.getNumPoints() - 1);
}
else if (STARTS_WITH_CI(pszLine, "INCLUDE") || STARTS_WITH_CI(pszLine, "END"))
{
}
else
{
CPLDebug("SUA", "Unexpected content : %s", pszLine);
}
}
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetField(0, osTYPE.c_str());
poFeature->SetField(1, osCLASS.c_str());
poFeature->SetField(2, osTITLE.c_str());
poFeature->SetField(3, osTOPS.c_str());
poFeature->SetField(4, osBASE.c_str());
OGRPolygon* poPoly = new OGRPolygon();
poPoly->assignSpatialReference(poSRS);
oLR.closeRings();
poPoly->addRing(&oLR);
poFeature->SetGeometryDirectly(poPoly);
poFeature->SetFID(nNextFID++);
return poFeature;
}
OGRFeature *OGRHTFPolygonLayer::GetNextRawFeature()
{
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
const char* pszLine;
OGRLinearRing oLR;
int bHastFirstCoord = FALSE;
double dfFirstEasting = 0, dfFirstNorthing = 0;
double dfIslandEasting = 0, dfIslandNorthing = 0;
int bInIsland = FALSE;
OGRPolygon* poPoly = new OGRPolygon();
while( (pszLine = CPLReadLine2L(fpHTF, 1024, NULL)) != NULL)
{
if (pszLine[0] == ';')
{
/* comment */ ;
}
else if (pszLine[0] == 0)
{
/* end of polygon is marked by a blank line */
break;
}
else if (strncmp(pszLine, "POLYGON DESCRIPTION: ",
strlen("POLYGON DESCRIPTION: ")) == 0)
{
poFeature->SetField(0, pszLine + strlen("POLYGON DESCRIPTION: "));
}
else if (strncmp(pszLine, "POLYGON IDENTIFIER: ",
strlen("POLYGON IDENTIFIER: ")) == 0)
{
poFeature->SetField(1, pszLine + strlen("POLYGON IDENTIFIER: "));
}
else if (strncmp(pszLine, "SEAFLOOR COVERAGE: ",
strlen("SEAFLOOR COVERAGE:")) == 0)
{
const char* pszVal = pszLine + strlen("SEAFLOOR COVERAGE: ");
if (*pszVal != '*')
poFeature->SetField(2, pszVal);
}
else if (strncmp(pszLine, "POSITION ACCURACY: ",
strlen("POSITION ACCURACY:")) == 0)
{
const char* pszVal = pszLine + strlen("POSITION ACCURACY: ");
if (*pszVal != '*')
poFeature->SetField(3, pszVal);
}
else if (strncmp(pszLine, "DEPTH ACCURACY: ",
strlen("DEPTH ACCURACY:")) == 0)
{
const char* pszVal = pszLine + strlen("DEPTH ACCURACY: ");
if (*pszVal != '*')
poFeature->SetField(4, pszVal);
}
else if (strcmp(pszLine, "END OF POLYGON DATA") == 0)
{
bEOF = TRUE;
break;
}
else
{
char** papszTokens = CSLTokenizeString(pszLine);
if (CSLCount(papszTokens) == 4)
{
double dfEasting = atof(papszTokens[2]);
double dfNorthing = atof(papszTokens[3]);
if (!bHastFirstCoord)
{
bHastFirstCoord = TRUE;
dfFirstEasting = dfEasting;
dfFirstNorthing = dfNorthing;
oLR.addPoint(dfEasting, dfNorthing);
}
else if (dfFirstEasting == dfEasting &&
dfFirstNorthing == dfNorthing)
{
if (!bInIsland)
{
oLR.addPoint(dfEasting, dfNorthing);
poPoly->addRing(&oLR);
oLR.empty();
bInIsland = TRUE;
}
}
else if (bInIsland && oLR.getNumPoints() == 0)
{
dfIslandEasting = dfEasting;
dfIslandNorthing = dfNorthing;
oLR.addPoint(dfEasting, dfNorthing);
}
else if (bInIsland && dfIslandEasting == dfEasting &&
dfIslandNorthing == dfNorthing)
{
oLR.addPoint(dfEasting, dfNorthing);
poPoly->addRing(&oLR);
oLR.empty();
}
else
{
oLR.addPoint(dfEasting, dfNorthing);
}
}
CSLDestroy(papszTokens);
}
}
if (pszLine == NULL)
bEOF = TRUE;
if (oLR.getNumPoints() >= 3)
{
oLR.closeRings();
poPoly->addRing(&oLR);
}
poPoly->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poPoly);
poFeature->SetFID(nNextFID++);
return poFeature;
}
void OGRSVGLayer::startElementCbk(const char *pszName, const char **ppszAttr)
{
int i;
if (bStopParsing) return;
nWithoutEventCounter = 0;
if (svgGeomType == SVG_POINTS &&
strcmp(pszName, "circle") == 0 &&
strcmp(OGRSVGGetClass(ppszAttr), "point") == 0)
{
int bHasFoundX = FALSE, bHasFoundY = FALSE;
double dfX = 0, dfY = 0;
for (i = 0; ppszAttr[i]; i += 2)
{
if (strcmp(ppszAttr[i], "cx") == 0)
{
bHasFoundX = TRUE;
dfX = CPLAtof(ppszAttr[i + 1]);
}
else if (strcmp(ppszAttr[i], "cy") == 0)
{
bHasFoundY = TRUE;
/* Cloudmade --> negate y */
dfY = - CPLAtof(ppszAttr[i + 1]);
}
}
if (bHasFoundX && bHasFoundY)
{
interestingDepthLevel = depthLevel;
inInterestingElement = TRUE;
if (poFeature)
delete poFeature;
poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetFID( nNextFID++ );
OGRPoint* poPoint = new OGRPoint( dfX, dfY );
poPoint->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly( poPoint );
}
}
else if (svgGeomType == SVG_LINES &&
strcmp(pszName, "path") == 0 &&
strcmp(OGRSVGGetClass(ppszAttr), "line") == 0)
{
const char* pszD = NULL;
for (i = 0; ppszAttr[i]; i += 2)
{
if (strcmp(ppszAttr[i], "d") == 0)
{
pszD = ppszAttr[i + 1];
break;
}
}
if (pszD)
{
interestingDepthLevel = depthLevel;
inInterestingElement = TRUE;
if (poFeature)
delete poFeature;
poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetFID( nNextFID++ );
OGRLineString* poLS = new OGRLineString();
OGRSVGParseD(poLS, pszD);
poLS->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly( poLS );
}
}
else if (svgGeomType == SVG_POLYGONS &&
strcmp(pszName, "path") == 0 &&
strcmp(OGRSVGGetClass(ppszAttr), "polygon") == 0)
{
const char* pszD = NULL;
for (i = 0; ppszAttr[i]; i += 2)
{
if (strcmp(ppszAttr[i], "d") == 0)
{
pszD = ppszAttr[i + 1];
break;
}
}
if (pszD)
{
interestingDepthLevel = depthLevel;
inInterestingElement = TRUE;
if (poFeature)
delete poFeature;
poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetFID( nNextFID++ );
OGRPolygon* poPolygon = new OGRPolygon();
OGRLinearRing* poLS = new OGRLinearRing();
OGRSVGParseD(poLS, pszD);
poPolygon->addRingDirectly(poLS);
poPolygon->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly( poPolygon );
}
}
else if (inInterestingElement &&
depthLevel == interestingDepthLevel + 1 &&
STARTS_WITH(pszName, "cm:"))
{
iCurrentField = poFeatureDefn->GetFieldIndex(pszName + 3);
}
depthLevel++;
}