void DiMeshSerializerImpl::WriteSubMesh( DiSubMesh* pMesh )
{
WriteChunkHeader(DI_SUBMESH, CalcSubMeshSize(pMesh));
WriteString(pMesh->GetMaterialName());
unsigned int indexCount = pMesh->GetIndexNum();
WriteInts(&indexCount,1);
bool u32 = pMesh->GetIndexSize() == 32;
WriteBools(&u32,1);
uint16 primitive = (uint16)pMesh->GetPrimitiveType();
WriteShorts(&primitive,1);
WriteData(pMesh->GetIndexData(),
(pMesh->GetIndexSize() / 8) * pMesh->GetIndexNum(), 1);
WriteGeometry(pMesh);
if (!pMesh->mBoneWeights.empty())
{
WriteSubMeshBoneWeights(pMesh);
}
}
HRESULT CXMLExporter::WriteModel()
{
try
{
if (m_pProgressBar)
{
m_pProgressBar->SetPercentDone(0.0);
m_pProgressBar->SetProgressMessage(LoadLocalizedString(IDS_WRITING_TEXTURE_FILES));
}
WriteTextureFiles();
Write("<SkpToXML xmlversion=\"1.0\" skpversion=\"5.0\" units=\"inches\">\n");
if (m_pProgressBar)
{
m_pProgressBar->SetPercentDone(10.0);
m_pProgressBar->SetProgressMessage(LoadLocalizedString(IDS_WRITING_LAYERS));
}
WriteLayers();
if (m_pProgressBar)
{
m_pProgressBar->SetPercentDone(20.0);
m_pProgressBar->SetProgressMessage(LoadLocalizedString(IDS_WRITING_MATERIALS));
}
WriteMaterials();
if (m_pProgressBar)
{
m_pProgressBar->SetPercentDone(30.0);
m_pProgressBar->SetProgressMessage(LoadLocalizedString(IDS_WRITING_OPTIONS));
}
WriteOptions();
if (m_pProgressBar)
{
m_pProgressBar->SetPercentDone(40.0);
m_pProgressBar->SetProgressMessage(LoadLocalizedString(IDS_WRITING_GEOMETRY));
}
WriteGeometry();
Write("</SkpToXML>");
if (m_pProgressBar)
{
m_pProgressBar->SetPercentDone(100.0);
m_pProgressBar->SetProgressMessage(LoadLocalizedString(IDS_EXPORT_COMPLETE));
}
return S_OK;
}
catch(HRESULT hr)
{
return hr;
}
}
void FgfUtil::WriteGeometry(FdoIGeometry* geometry, FdoByteArray ** outputStream)
{
FdoInt32 dimensionality = 0;
FdoInt32 numPositions = 0;
FdoInt32 numOrdsPerPos = 0;
FdoInt32 numOrds = 0;
const double * ordinates = NULL;
FdoInt32 numRings = 0;
FdoInt32 numSubGeometries = 0;
FdoInt32 numCurveSegments = 0;
FdoPtr<FdoIRing> ring;
FdoPtr<FdoILinearRing> lRing;
FdoPtr<FdoIDirectPosition> pos;
FdoILineString * ls;
FdoIPoint * pt;
FdoIPolygon * poly;
FdoIMultiPoint * mpt;
FdoIMultiLineString * mls;
FdoIMultiPolygon * mpoly;
FdoICurveString * cs;
FdoIMultiCurveString * mcs;
FdoICurvePolygon * cpoly;
FdoIMultiCurvePolygon * mcpoly;
FdoIMultiGeometry * mgeom;
FdoInt32 i;
FdoGeometryType geometryType = geometry->GetDerivedType();
FGFUTIL_WRITE_INT32(outputStream, geometryType);
switch (geometryType)
{
case FdoGeometryType_LineString:
ls = static_cast<FdoILineString *>(geometry);
dimensionality = ls->GetDimensionality();
numPositions = ls->GetCount();
FGFUTIL_WRITE_INT32(outputStream, dimensionality);
FGFUTIL_WRITE_INT32(outputStream, numPositions);
numOrdsPerPos = GeometryUtility::DimensionalityToNumOrdinates(dimensionality);
numOrds = numPositions * numOrdsPerPos;
ordinates = ls->GetOrdinates();
FGFUTIL_WRITE_DOUBLES(outputStream, numOrds, ordinates);
break;
case FdoGeometryType_Point:
pt = static_cast<FdoIPoint *>(geometry);
dimensionality = pt->GetDimensionality();
numPositions = 1;
FGFUTIL_WRITE_INT32(outputStream, dimensionality);
numOrdsPerPos = GeometryUtility::DimensionalityToNumOrdinates(dimensionality);
numOrds = numPositions * numOrdsPerPos;
ordinates = pt->GetOrdinates();
FGFUTIL_WRITE_DOUBLES(outputStream, numOrds, ordinates);
break;
case FdoGeometryType_Polygon:
poly = static_cast<FdoIPolygon *>(geometry);
dimensionality = poly->GetDimensionality();
FGFUTIL_WRITE_INT32(outputStream, dimensionality);
numRings = poly->GetInteriorRingCount();
FGFUTIL_WRITE_INT32(outputStream, numRings+1); // Include exterior ring in count
lRing = poly->GetExteriorRing();
FgfUtil::WriteLinearRing(lRing, outputStream);
for (i=0; i<numRings; i++)
{
lRing = poly->GetInteriorRing(i);
FgfUtil::WriteLinearRing(lRing, outputStream);
}
break;
case FdoGeometryType_MultiPoint:
mpt = static_cast<FdoIMultiPoint *>(geometry);
numSubGeometries = mpt->GetCount();
FGFUTIL_WRITE_INT32(outputStream, numSubGeometries);
for (i=0; i<numSubGeometries; i++)
{
FdoPtr<FdoIPoint> pnt = mpt->GetItem(i);
WriteGeometry(pnt, outputStream);
}
break;
case FdoGeometryType_MultiLineString:
mls = static_cast<FdoIMultiLineString *>(geometry);
numSubGeometries = mls->GetCount();
FGFUTIL_WRITE_INT32(outputStream, numSubGeometries);
for (i=0; i<numSubGeometries; i++)
{
FdoPtr<FdoILineString> lineString = mls->GetItem(i);
WriteGeometry(lineString, outputStream);
}
break;
case FdoGeometryType_MultiPolygon:
mpoly = static_cast<FdoIMultiPolygon *>(geometry);
numSubGeometries = mpoly->GetCount();
FGFUTIL_WRITE_INT32(outputStream, numSubGeometries);
for (i=0; i<numSubGeometries; i++)
{
FdoPtr<FdoIPolygon> polygon = mpoly->GetItem(i);
WriteGeometry(polygon, outputStream);
}
break;
case FdoGeometryType_CurveString:
cs = static_cast<FdoICurveString *>(geometry);
dimensionality = cs->GetDimensionality();
FGFUTIL_WRITE_INT32(outputStream, dimensionality);
pos = cs->GetStartPosition();
WriteDirectPosition(outputStream, pos);
numCurveSegments = cs->GetCount();
FGFUTIL_WRITE_INT32(outputStream, numCurveSegments);
for (i=0; i<numCurveSegments; i++)
{
FdoPtr<FdoICurveSegmentAbstract> curveSeg = cs->GetItem(i);
WriteCurveSegment(curveSeg, outputStream);
}
break;
case FdoGeometryType_MultiCurveString:
mcs = static_cast<FdoIMultiCurveString *>(geometry);
numSubGeometries = mcs->GetCount();
FGFUTIL_WRITE_INT32(outputStream, numSubGeometries);
for (i=0; i<numSubGeometries; i++)
{
FdoPtr<FdoICurveString> curveString = mcs->GetItem(i);
WriteGeometry(curveString, outputStream);
}
break;
case FdoGeometryType_CurvePolygon:
cpoly = static_cast<FdoICurvePolygon *>(geometry);
dimensionality = cpoly->GetDimensionality();
FGFUTIL_WRITE_INT32(outputStream, dimensionality);
numRings = cpoly->GetInteriorRingCount();
FGFUTIL_WRITE_INT32(outputStream, numRings + 1); // Include exterior ring
ring = cpoly->GetExteriorRing();
FgfUtil::WriteRing(ring, outputStream);
// Interior rings
for (i=0; i<numRings; i++)
{
ring = cpoly->GetInteriorRing(i);
FgfUtil::WriteRing(ring, outputStream);
}
break;
case FdoGeometryType_MultiCurvePolygon:
mcpoly = static_cast<FdoIMultiCurvePolygon *>(geometry);
numSubGeometries = mcpoly->GetCount();
FGFUTIL_WRITE_INT32(outputStream, numSubGeometries);
for (i=0; i<numSubGeometries; i++)
{
FdoPtr<FdoICurvePolygon> curvePolygon = mcpoly->GetItem(i);
WriteGeometry(curvePolygon, outputStream);
}
break;
case FdoGeometryType_MultiGeometry:
mgeom = static_cast<FdoIMultiGeometry *>(geometry);
numSubGeometries = mgeom->GetCount();
FGFUTIL_WRITE_INT32(outputStream, numSubGeometries);
for (i=0; i<numSubGeometries; i++)
{
FdoPtr<FdoIGeometry> geom = mgeom->GetItem(i);
WriteGeometry(geom, outputStream);
}
break;
default:
throw FdoException::Create(FdoException::NLSGetMessage(FDO_NLSID(FDO_1_UNKNOWN_GEOMETRY_TYPE),
L"FgfUtil::WriteGeometry",
geometryType));
}
}
int S57Writer::WritePrimitive( OGRFeature *poFeature )
{
DDFRecord *poRec = MakeRecord();
DDFField *poField;
OGRGeometry *poGeom = poFeature->GetGeometryRef();
/* -------------------------------------------------------------------- */
/* Add the VRID field. */
/* -------------------------------------------------------------------- */
poField = poRec->AddField( poModule->FindFieldDefn( "VRID" ) );
poRec->SetIntSubfield ( "VRID", 0, "RCNM", 0,
poFeature->GetFieldAsInteger( "RCNM") );
poRec->SetIntSubfield ( "VRID", 0, "RCID", 0,
poFeature->GetFieldAsInteger( "RCID") );
poRec->SetIntSubfield ( "VRID", 0, "RVER", 0, 1 );
poRec->SetIntSubfield ( "VRID", 0, "RUIN", 0, 1 );
/* -------------------------------------------------------------------- */
/* Handle simple point. */
/* -------------------------------------------------------------------- */
if( poGeom != NULL && wkbFlatten(poGeom->getGeometryType()) == wkbPoint )
{
double dfX, dfY, dfZ;
OGRPoint *poPoint = (OGRPoint *) poGeom;
CPLAssert( poFeature->GetFieldAsInteger( "RCNM") == RCNM_VI
|| poFeature->GetFieldAsInteger( "RCNM") == RCNM_VC );
dfX = poPoint->getX();
dfY = poPoint->getY();
dfZ = poPoint->getZ();
if( dfZ == 0.0 )
WriteGeometry( poRec, 1, &dfX, &dfY, NULL );
else
WriteGeometry( poRec, 1, &dfX, &dfY, &dfZ );
}
/* -------------------------------------------------------------------- */
/* For multipoints we assuming SOUNDG, and write out as SG3D. */
/* -------------------------------------------------------------------- */
else if( poGeom != NULL
&& wkbFlatten(poGeom->getGeometryType()) == wkbMultiPoint )
{
OGRMultiPoint *poMP = (OGRMultiPoint *) poGeom;
int i, nVCount = poMP->getNumGeometries();
double *padfX, *padfY, *padfZ;
CPLAssert( poFeature->GetFieldAsInteger( "RCNM") == RCNM_VI
|| poFeature->GetFieldAsInteger( "RCNM") == RCNM_VC );
padfX = (double *) CPLMalloc(sizeof(double) * nVCount);
padfY = (double *) CPLMalloc(sizeof(double) * nVCount);
padfZ = (double *) CPLMalloc(sizeof(double) * nVCount);
for( i = 0; i < nVCount; i++ )
{
OGRPoint *poPoint = (OGRPoint *) poMP->getGeometryRef( i );
padfX[i] = poPoint->getX();
padfY[i] = poPoint->getY();
padfZ[i] = poPoint->getZ();
}
WriteGeometry( poRec, nVCount, padfX, padfY, padfZ );
CPLFree( padfX );
CPLFree( padfY );
CPLFree( padfZ );
}
/* -------------------------------------------------------------------- */
/* Handle LINESTRINGs (edge) geometry. */
/* -------------------------------------------------------------------- */
else if( poGeom != NULL
&& wkbFlatten(poGeom->getGeometryType()) == wkbLineString )
{
OGRLineString *poLS = (OGRLineString *) poGeom;
int i, nVCount = poLS->getNumPoints();
double *padfX, *padfY;
CPLAssert( poFeature->GetFieldAsInteger( "RCNM") == RCNM_VE );
padfX = (double *) CPLMalloc(sizeof(double) * nVCount);
padfY = (double *) CPLMalloc(sizeof(double) * nVCount);
for( i = 0; i < nVCount; i++ )
{
padfX[i] = poLS->getX(i);
padfY[i] = poLS->getY(i);
}
WriteGeometry( poRec, nVCount, padfX, padfY, NULL );
CPLFree( padfX );
CPLFree( padfY );
}
/* -------------------------------------------------------------------- */
/* edge node linkages. */
/* -------------------------------------------------------------------- */
if( poFeature->GetDefnRef()->GetFieldIndex( "NAME_RCNM_0" ) >= 0 )
{
DDFField *poField;
char szName[5];
int nRCID;
CPLAssert( poFeature->GetFieldAsInteger( "NAME_RCNM_0") == RCNM_VC );
poField = poRec->AddField( poModule->FindFieldDefn( "VRPT" ) );
nRCID = poFeature->GetFieldAsInteger( "NAME_RCID_0");
szName[0] = RCNM_VC;
szName[1] = nRCID & 0xff;
szName[2] = (nRCID & 0xff00) >> 8;
szName[3] = (nRCID & 0xff0000) >> 16;
szName[4] = (nRCID & 0xff000000) >> 24;
poRec->SetStringSubfield( "VRPT", 0, "NAME", 0, szName, 5 );
poRec->SetIntSubfield ( "VRPT", 0, "ORNT", 0,
poFeature->GetFieldAsInteger( "ORNT_0") );
poRec->SetIntSubfield ( "VRPT", 0, "USAG", 0,
poFeature->GetFieldAsInteger( "USAG_0") );
poRec->SetIntSubfield ( "VRPT", 0, "TOPI", 0,
poFeature->GetFieldAsInteger( "TOPI_0") );
poRec->SetIntSubfield ( "VRPT", 0, "MASK", 0,
poFeature->GetFieldAsInteger( "MASK_0") );
nRCID = poFeature->GetFieldAsInteger( "NAME_RCID_1");
szName[0] = RCNM_VC;
szName[1] = nRCID & 0xff;
szName[2] = (nRCID & 0xff00) >> 8;
szName[3] = (nRCID & 0xff0000) >> 16;
szName[4] = (nRCID & 0xff000000) >> 24;
poRec->SetStringSubfield( "VRPT", 0, "NAME", 1, szName, 5 );
poRec->SetIntSubfield ( "VRPT", 0, "ORNT", 1,
poFeature->GetFieldAsInteger( "ORNT_1") );
poRec->SetIntSubfield ( "VRPT", 0, "USAG", 1,
poFeature->GetFieldAsInteger( "USAG_1") );
poRec->SetIntSubfield ( "VRPT", 0, "TOPI", 1,
poFeature->GetFieldAsInteger( "TOPI_1") );
poRec->SetIntSubfield ( "VRPT", 0, "MASK", 1,
poFeature->GetFieldAsInteger( "MASK_1") );
}
OGRErr OGRGmtLayer::WriteGeometry( OGRGeometryH hGeom, int bHaveAngle )
{
/* -------------------------------------------------------------------- */
/* This is a geometry with sub-geometries. */
/* -------------------------------------------------------------------- */
if( OGR_G_GetGeometryCount( hGeom ) > 0 )
{
OGRErr eErr = OGRERR_NONE;
for( int iGeom = 0;
iGeom < OGR_G_GetGeometryCount(hGeom) && eErr == OGRERR_NONE;
iGeom++ )
{
// We need to emit polygon @P and @H items while we still
// know this is a polygon and which is the outer and inner
// ring.
if( wkbFlatten(OGR_G_GetGeometryType(hGeom)) == wkbPolygon )
{
if( !bHaveAngle )
{
VSIFPrintfL( fp, ">\n" );
bHaveAngle = TRUE;
}
if( iGeom == 0 )
VSIFPrintfL( fp, "# @P\n" );
else
VSIFPrintfL( fp, "# @H\n" );
}
eErr = WriteGeometry( OGR_G_GetGeometryRef( hGeom, iGeom ),
bHaveAngle );
bHaveAngle = FALSE;
}
return eErr;
}
/* -------------------------------------------------------------------- */
/* If this is not a point we need to have an angle bracket to */
/* mark the vertex list. */
/* -------------------------------------------------------------------- */
if( wkbFlatten(OGR_G_GetGeometryType(hGeom)) != wkbPoint
&& !bHaveAngle )
VSIFPrintfL( fp, ">\n" );
/* -------------------------------------------------------------------- */
/* Dump vertices. */
/* -------------------------------------------------------------------- */
const int nPointCount = OGR_G_GetPointCount(hGeom);
const int nDim = OGR_G_GetCoordinateDimension(hGeom);
// For testing only. Ticket #6453
const bool bUseTab = CPLTestBool( CPLGetConfigOption("GMT_USE_TAB", "FALSE") );
for( int iPoint = 0; iPoint < nPointCount; iPoint++ )
{
const double dfX = OGR_G_GetX( hGeom, iPoint );
const double dfY = OGR_G_GetY( hGeom, iPoint );
const double dfZ = OGR_G_GetZ( hGeom, iPoint );
sRegion.Merge( dfX, dfY );
char szLine[128];
OGRMakeWktCoordinate( szLine, dfX, dfY, dfZ, nDim );
if( bUseTab )
{
for( char* szPtr = szLine; *szPtr != '\0'; ++szPtr )
{
if( *szPtr == ' ' )
*szPtr = '\t';
}
}
if( VSIFPrintfL( fp, "%s\n", szLine ) < 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Gmt write failure: %s",
VSIStrerror( errno ) );
return OGRERR_FAILURE;
}
}
return OGRERR_NONE;
}
OGRErr OGRGmtLayer::ICreateFeature( OGRFeature *poFeature )
{
if( !bUpdate )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Cannot create features on read-only dataset." );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Do we need to write the header describing the fields? */
/* -------------------------------------------------------------------- */
if( !bHeaderComplete )
{
OGRErr eErr = CompleteHeader( poFeature->GetGeometryRef() );
if( eErr != OGRERR_NONE )
return eErr;
}
/* -------------------------------------------------------------------- */
/* Write out the feature */
/* -------------------------------------------------------------------- */
OGRGeometry *poGeom = poFeature->GetGeometryRef();
if( poGeom == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Features without geometry not supported by GMT writer." );
return OGRERR_FAILURE;
}
if( poFeatureDefn->GetGeomType() == wkbUnknown )
poFeatureDefn->SetGeomType(wkbFlatten(poGeom->getGeometryType()));
// Do we need a vertex collection marker grouping vertices.
if( poFeatureDefn->GetGeomType() != wkbPoint )
VSIFPrintfL( fp, ">\n" );
/* -------------------------------------------------------------------- */
/* Write feature properties() */
/* -------------------------------------------------------------------- */
if( poFeatureDefn->GetFieldCount() > 0 )
{
CPLString osFieldData;
for( int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
OGRFieldType eFType=poFeatureDefn->GetFieldDefn(iField)->GetType();
const char *pszRawValue = poFeature->GetFieldAsString(iField);
if( iField > 0 )
osFieldData += "|";
// We do not want prefix spaces for numeric values.
if( eFType == OFTInteger || eFType == OFTReal )
while( *pszRawValue == ' ' )
pszRawValue++;
if( strchr(pszRawValue,' ') || strchr(pszRawValue,'|')
|| strchr(pszRawValue, '\t') || strchr(pszRawValue, '\n') )
{
osFieldData += "\"";
char *pszEscapedVal
= CPLEscapeString( pszRawValue,
-1, CPLES_BackslashQuotable );
osFieldData += pszEscapedVal;
CPLFree( pszEscapedVal );
osFieldData += "\"";
}
else
osFieldData += pszRawValue;
}
VSIFPrintfL( fp, "# @D%s\n", osFieldData.c_str() );
}
/* -------------------------------------------------------------------- */
/* Write Geometry */
/* -------------------------------------------------------------------- */
return WriteGeometry( reinterpret_cast<OGRGeometryH>(poGeom), TRUE );
}
