OGRErr OGRPoint::importFromWkb( unsigned char * pabyData,
int nSize )
{
OGRwkbByteOrder eByteOrder;
if( nSize < 21 && nSize != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the byte order byte. */
/* -------------------------------------------------------------------- */
eByteOrder = DB2_V72_FIX_BYTE_ORDER((OGRwkbByteOrder) *pabyData);
if (!( eByteOrder == wkbXDR || eByteOrder == wkbNDR ))
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Get the geometry feature type. For now we assume that */
/* geometry type is between 0 and 255 so we only have to fetch */
/* one byte. */
/* -------------------------------------------------------------------- */
OGRBoolean bIs3D;
OGRwkbGeometryType eGeometryType;
OGRErr err = OGRReadWKBGeometryType( pabyData, &eGeometryType, &bIs3D );
if( err != OGRERR_NONE || eGeometryType != wkbPoint )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Get the vertex. */
/* -------------------------------------------------------------------- */
memcpy( &x, pabyData + 5, 8 );
memcpy( &y, pabyData + 5 + 8, 8 );
if( OGR_SWAP( eByteOrder ) )
{
CPL_SWAPDOUBLE( &x );
CPL_SWAPDOUBLE( &y );
}
if( bIs3D )
{
if ( nSize < 29 && nSize != -1 )
return OGRERR_NOT_ENOUGH_DATA;
memcpy( &z, pabyData + 5 + 16, 8 );
if( OGR_SWAP( eByteOrder ) )
{
CPL_SWAPDOUBLE( &z );
}
nCoordDimension = 3;
}
else
{
z = 0;
nCoordDimension = 2;
}
return OGRERR_NONE;
}
OGRErr OGRPoint::exportToWkb( OGRwkbByteOrder eByteOrder,
unsigned char * pabyData,
OGRwkbVariant eWkbVariant ) const
{
/* -------------------------------------------------------------------- */
/* Set the byte order. */
/* -------------------------------------------------------------------- */
pabyData[0] = DB2_V72_UNFIX_BYTE_ORDER((unsigned char) eByteOrder);
/* -------------------------------------------------------------------- */
/* Set the geometry feature type. */
/* -------------------------------------------------------------------- */
GUInt32 nGType = getGeometryType();
if ( eWkbVariant == wkbVariantIso )
nGType = getIsoGeometryType();
if( eByteOrder == wkbNDR )
nGType = CPL_LSBWORD32( nGType );
else
nGType = CPL_MSBWORD32( nGType );
memcpy( pabyData + 1, &nGType, 4 );
/* -------------------------------------------------------------------- */
/* Copy in the raw data. */
/* -------------------------------------------------------------------- */
if ( IsEmpty() && eWkbVariant == wkbVariantIso )
{
double dNan = std::numeric_limits<double>::quiet_NaN();
memcpy( pabyData+5, &dNan, 8 );
memcpy( pabyData+5+8, &dNan, 8 );
if( getCoordinateDimension() == 3 )
memcpy( pabyData+5+16, &dNan, 8 );
}
else
{
memcpy( pabyData+5, &x, 16 );
if( getCoordinateDimension() == 3 )
{
memcpy( pabyData + 5 + 16, &z, 8 );
}
}
/* -------------------------------------------------------------------- */
/* Swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
CPL_SWAPDOUBLE( pabyData + 5 );
CPL_SWAPDOUBLE( pabyData + 5 + 8 );
if( getCoordinateDimension() == 3 )
CPL_SWAPDOUBLE( pabyData + 5 + 16 );
}
return OGRERR_NONE;
}
OGRErr OGRPoint::importFromWkb( unsigned char * pabyData,
int nSize,
OGRwkbVariant eWkbVariant )
{
OGRwkbByteOrder eByteOrder;
OGRBoolean bIs3D = FALSE;
OGRErr eErr = importPreambuleFromWkb( pabyData, nSize, eByteOrder, bIs3D, eWkbVariant );
if( eErr >= 0 )
return eErr;
if ( nSize < ((bIs3D) ? 29 : 21) && nSize != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the vertex. */
/* -------------------------------------------------------------------- */
memcpy( &x, pabyData + 5, 8 );
memcpy( &y, pabyData + 5 + 8, 8 );
if( OGR_SWAP( eByteOrder ) )
{
CPL_SWAPDOUBLE( &x );
CPL_SWAPDOUBLE( &y );
}
if( bIs3D )
{
memcpy( &z, pabyData + 5 + 16, 8 );
if( OGR_SWAP( eByteOrder ) )
{
CPL_SWAPDOUBLE( &z );
}
nCoordDimension = 3;
}
else
{
z = 0;
nCoordDimension = 2;
}
/* Detect NaN coordinates --> EMPTY */
if( x != x && y != y )
nCoordDimension = -nCoordDimension;
return OGRERR_NONE;
}
OGRErr OGRPoint::exportToWkb( OGRwkbByteOrder eByteOrder,
unsigned char * pabyData ) const
{
/* -------------------------------------------------------------------- */
/* Set the byte order. */
/* -------------------------------------------------------------------- */
pabyData[0] = DB2_V72_UNFIX_BYTE_ORDER((unsigned char) eByteOrder);
/* -------------------------------------------------------------------- */
/* Set the geometry feature type. */
/* -------------------------------------------------------------------- */
GUInt32 nGType = getGeometryType();
if( eByteOrder == wkbNDR )
nGType = CPL_LSBWORD32( nGType );
else
nGType = CPL_MSBWORD32( nGType );
memcpy( pabyData + 1, &nGType, 4 );
/* -------------------------------------------------------------------- */
/* Copy in the raw data. */
/* -------------------------------------------------------------------- */
memcpy( pabyData+5, &nQual, 4 );
memcpy( pabyData+9, &x, 16 );
if( z != 0 )
{
memcpy( pabyData + 9 + 16, &z, 8 );
}
/* -------------------------------------------------------------------- */
/* Swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
CPL_SWAP32PTR( pabyData + 5 );
CPL_SWAPDOUBLE( pabyData + 9 );
CPL_SWAPDOUBLE( pabyData + 9 + 8 );
if( z != 0 )
CPL_SWAPDOUBLE( pabyData + 9 + 16 );
}
return OGRERR_NONE;
}
int TABRawBinBlock::WriteDouble(double dValue)
{
#ifdef CPL_MSB
CPL_SWAPDOUBLE(&dValue);
#endif
return WriteBytes(8, (GByte*)&dValue);
}
int TABRawBinBlock::WriteDouble(double dValue)
{
#ifdef CPL_MSB
CPL_SWAPDOUBLE(&dValue);
#endif
return WriteBytes(8, reinterpret_cast<GByte*>(&dValue));
}
void AVCRawBinWriteDouble(AVCRawBinFile *psFile, double dValue)
{
if (psFile->eByteOrder != geSystemByteOrder)
{
CPL_SWAPDOUBLE(&dValue);
}
AVCRawBinWriteBytes(psFile, 8, (GByte*)&dValue);
}
double TABRawBinBlock::ReadDouble()
{
double dValue;
ReadBytes(8, (GByte*)(&dValue));
#ifdef CPL_MSB
CPL_SWAPDOUBLE(&dValue);
#endif
return dValue;
}
double TABRawBinBlock::ReadDouble()
{
double dValue = 0.0;
ReadBytes(8, reinterpret_cast<GByte*>(&dValue));
#ifdef CPL_MSB
CPL_SWAPDOUBLE(&dValue);
#endif
return dValue;
}
double AVCRawBinReadDouble(AVCRawBinFile *psFile)
{
double dValue;
AVCRawBinReadBytes(psFile, 8, (GByte*)(&dValue));
if (psFile->eByteOrder != geSystemByteOrder)
{
CPL_SWAPDOUBLE(&dValue);
}
return dValue;
}
OGRErr OGRLinearRing::_exportToWkb( OGRwkbByteOrder eByteOrder, int b3D,
unsigned char * pabyData ) const
{
int i, nWords;
/* -------------------------------------------------------------------- */
/* Copy in the raw data. */
/* -------------------------------------------------------------------- */
memcpy( pabyData, &nPointCount, 4 );
/* -------------------------------------------------------------------- */
/* Copy in the raw data. */
/* -------------------------------------------------------------------- */
if( b3D )
{
nWords = 3 * nPointCount;
for( i = 0; i < nPointCount; i++ )
{
memcpy( pabyData+4+i*24, &(paoPoints[i].x), 8 );
memcpy( pabyData+4+i*24+8, &(paoPoints[i].y), 8 );
if( padfZ == NULL )
memset( pabyData+4+i*24+16, 0, 8 );
else
memcpy( pabyData+4+i*24+16, padfZ + i, 8 );
}
}
else
{
nWords = 2 * nPointCount;
memcpy( pabyData+4, paoPoints, 16 * nPointCount );
}
/* -------------------------------------------------------------------- */
/* Swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
int nCount;
nCount = CPL_SWAP32( nPointCount );
memcpy( pabyData, &nCount, 4 );
for( i = 0; i < nWords; i++ )
{
CPL_SWAPDOUBLE( pabyData + 4 + 8 * i );
}
}
return OGRERR_NONE;
}
OGRErr OGRPoint::importFromWkb( unsigned char * pabyData,
int nSize )
{
OGRwkbByteOrder eByteOrder;
if( nSize < 21 && nSize != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the byte order byte. */
/* -------------------------------------------------------------------- */
eByteOrder = DB2_V72_FIX_BYTE_ORDER((OGRwkbByteOrder) *pabyData);
if (!( eByteOrder == wkbXDR || eByteOrder == wkbNDR ))
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Get the geometry feature type. For now we assume that */
/* geometry type is between 0 and 255 so we only have to fetch */
/* one byte. */
/* -------------------------------------------------------------------- */
OGRwkbGeometryType eGeometryType;
int bIs3D;
if( eByteOrder == wkbNDR )
{
eGeometryType = (OGRwkbGeometryType) pabyData[1];
bIs3D = pabyData[4] & 0x80 || pabyData[2] & 0x80;
}
else
{
eGeometryType = (OGRwkbGeometryType) pabyData[4];
bIs3D = pabyData[1] & 0x80 || pabyData[3] & 0x80;
}
if( eGeometryType != wkbPoint )
return OGRERR_CORRUPT_DATA;
/* -------------------------------------------------------------------- */
/* Get the vertex. */
/* -------------------------------------------------------------------- */
memcpy( &x, pabyData + 5, 16 );
if( OGR_SWAP( eByteOrder ) )
{
CPL_SWAPDOUBLE( &x );
CPL_SWAPDOUBLE( &y );
}
if( bIs3D )
{
memcpy( &z, pabyData + 5 + 16, 8 );
if( OGR_SWAP( eByteOrder ) )
{
CPL_SWAPDOUBLE( &z );
}
nCoordDimension = 3;
}
else
{
z = 0;
nCoordDimension = 2;
}
return OGRERR_NONE;
}
OGRErr OGRLinearRing::_importFromWkb( OGRwkbByteOrder eByteOrder, int b3D,
unsigned char * pabyData,
int nBytesAvailable )
{
if( nBytesAvailable < 4 && nBytesAvailable != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the vertex count. */
/* -------------------------------------------------------------------- */
int nNewNumPoints;
memcpy( &nNewNumPoints, pabyData, 4 );
if( OGR_SWAP( eByteOrder ) )
nNewNumPoints = CPL_SWAP32(nNewNumPoints);
/* Check if the wkb stream buffer is big enough to store
* fetched number of points.
* 16 or 24 - size of point structure
*/
int nPointSize = (b3D ? 24 : 16);
if (nNewNumPoints < 0 || nNewNumPoints > INT_MAX / nPointSize)
return OGRERR_CORRUPT_DATA;
int nBufferMinSize = nPointSize * nNewNumPoints;
if( nBytesAvailable != -1 && nBufferMinSize > nBytesAvailable - 4 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Length of input WKB is too small" );
return OGRERR_NOT_ENOUGH_DATA;
}
/* (Re)Allocation of paoPoints buffer. */
setNumPoints( nNewNumPoints );
if( b3D )
Make3D();
else
Make2D();
/* -------------------------------------------------------------------- */
/* Get the vertices */
/* -------------------------------------------------------------------- */
int i = 0;
if( !b3D )
{
memcpy( paoPoints, pabyData + 4, 16 * nPointCount );
}
else
{
for( int i = 0; i < nPointCount; i++ )
{
memcpy( &(paoPoints[i].x), pabyData + 4 + 24 * i, 8 );
memcpy( &(paoPoints[i].y), pabyData + 4 + 24 * i + 8, 8 );
memcpy( padfZ + i, pabyData + 4 + 24 * i + 16, 8 );
}
}
/* -------------------------------------------------------------------- */
/* Byte swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
for( i = 0; i < nPointCount; i++ )
{
CPL_SWAPDOUBLE( &(paoPoints[i].x) );
CPL_SWAPDOUBLE( &(paoPoints[i].y) );
if( b3D )
{
CPL_SWAPDOUBLE( padfZ + i );
}
}
}
return OGRERR_NONE;
}
OGRErr OGRLineString::exportToWkb( OGRwkbByteOrder eByteOrder,
unsigned char * pabyData )
{
/* -------------------------------------------------------------------- */
/* Set the byte order. */
/* -------------------------------------------------------------------- */
pabyData[0] = (unsigned char) eByteOrder;
/* -------------------------------------------------------------------- */
/* Set the geometry feature type. */
/* -------------------------------------------------------------------- */
if( eByteOrder == wkbNDR )
{
pabyData[1] = wkbLineString;
if( getCoordinateDimension() == 3 )
pabyData[2] = 0x80;
else
pabyData[2] = 0;
pabyData[3] = 0;
pabyData[4] = 0;
}
else
{
pabyData[1] = 0;
pabyData[2] = 0;
if( getCoordinateDimension() == 3 )
pabyData[3] = 0x80;
else
pabyData[3] = 0;
pabyData[4] = wkbLineString;
}
/* -------------------------------------------------------------------- */
/* Copy in the raw data. */
/* -------------------------------------------------------------------- */
memcpy( pabyData+5, &nPointCount, 4 );
/* -------------------------------------------------------------------- */
/* Copy in the raw data. */
/* -------------------------------------------------------------------- */
int i;
if( getCoordinateDimension() == 3 )
{
for( i = 0; i < nPointCount; i++ )
{
memcpy( pabyData + 9 + 24*i, paoPoints+i, 16 );
memcpy( pabyData + 9 + 16 + 24*i, padfZ+i, 8 );
}
}
else
memcpy( pabyData+9, paoPoints, 16 * nPointCount );
/* -------------------------------------------------------------------- */
/* Swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
int nCount;
nCount = CPL_SWAP32( nPointCount );
memcpy( pabyData+5, &nCount, 4 );
for( i = getCoordinateDimension() * 3 - 1; i >= 0; i-- )
{
CPL_SWAPDOUBLE( pabyData + 9 + 8 * i );
}
}
return OGRERR_NONE;
}
OGRErr GPkgHeaderFromWKB(const GByte *pabyGpkg, GPkgHeader *poHeader)
{
CPLAssert( pabyGpkg != NULL );
CPLAssert( poHeader != NULL );
/* Magic (match required) */
if ( pabyGpkg[0] != 0x47 ||
pabyGpkg[1] != 0x50 ||
pabyGpkg[2] != 0 ) /* Version (only 0 supported at this time)*/
{
return OGRERR_FAILURE;
}
/* Flags */
GByte byFlags = pabyGpkg[3];
poHeader->bEmpty = (byFlags & (0x01 << 4)) >> 4;
poHeader->bExtended = (byFlags & (0x01 << 5)) >> 5;
poHeader->eByteOrder = (OGRwkbByteOrder)(byFlags & 0x01);
OGRBoolean bSwap = OGR_SWAP(poHeader->eByteOrder);
/* Envelope */
int iEnvelope = (byFlags & (0x07 << 1)) >> 1;
if ( iEnvelope == 1 )
poHeader->iDims = 2; /* 2D envelope */
else if ( iEnvelope == 2 )
poHeader->iDims = 3; /* 3D envelope */
else
poHeader->iDims = 0; /* No envelope */
/* SrsId */
int iSrsId;
memcpy(&iSrsId, pabyGpkg+4, 4);
if ( bSwap )
{
iSrsId = CPL_SWAP32(iSrsId);
}
poHeader->iSrsId = iSrsId;
/* Envelope */
double *padPtr = (double*)(pabyGpkg+8);
if ( poHeader->iDims >= 2 )
{
poHeader->MinX = padPtr[0];
poHeader->MaxX = padPtr[1];
poHeader->MinY = padPtr[2];
poHeader->MaxY = padPtr[3];
if ( bSwap )
{
CPL_SWAPDOUBLE(&(poHeader->MinX));
CPL_SWAPDOUBLE(&(poHeader->MaxX));
CPL_SWAPDOUBLE(&(poHeader->MinY));
CPL_SWAPDOUBLE(&(poHeader->MaxY));
}
}
if ( poHeader->iDims == 3 )
{
poHeader->MinZ = padPtr[4];
poHeader->MaxZ = padPtr[5];
if ( bSwap )
{
CPL_SWAPDOUBLE(&(poHeader->MinZ));
CPL_SWAPDOUBLE(&(poHeader->MaxZ));
}
}
/* Header size in byte stream */
poHeader->szHeader = 8 + 8*2*(poHeader->iDims);
return OGRERR_NONE;
}
OGRErr OGRLinearRing::_exportToWkb( OGRwkbByteOrder eByteOrder, int _flags,
unsigned char * pabyData ) const
{
/* -------------------------------------------------------------------- */
/* Copy in the raw data. */
/* -------------------------------------------------------------------- */
memcpy( pabyData, &nPointCount, 4 );
/* -------------------------------------------------------------------- */
/* Copy in the raw data. */
/* -------------------------------------------------------------------- */
int nWords = 0;
if( (_flags & OGR_G_3D) && (_flags & OGR_G_MEASURED) )
{
nWords = 4 * nPointCount;
for( int i = 0; i < nPointCount; i++ )
{
memcpy( pabyData+4+i*32, &(paoPoints[i].x), 8 );
memcpy( pabyData+4+i*32+8, &(paoPoints[i].y), 8 );
if( padfZ == nullptr )
memset( pabyData+4+i*32+16, 0, 8 );
else
memcpy( pabyData+4+i*32+16, padfZ + i, 8 );
if( padfM == nullptr )
memset( pabyData+4+i*32+24, 0, 8 );
else
memcpy( pabyData+4+i*32+24, padfM + i, 8 );
}
}
else if( _flags & OGR_G_MEASURED )
{
nWords = 3 * nPointCount;
for( int i = 0; i < nPointCount; i++ )
{
memcpy( pabyData+4+i*24, &(paoPoints[i].x), 8 );
memcpy( pabyData+4+i*24+8, &(paoPoints[i].y), 8 );
if( padfM == nullptr )
memset( pabyData+4+i*24+16, 0, 8 );
else
memcpy( pabyData+4+i*24+16, padfM + i, 8 );
}
}
else if( _flags & OGR_G_3D )
{
nWords = 3 * nPointCount;
for( int i = 0; i < nPointCount; i++ )
{
memcpy( pabyData+4+i*24, &(paoPoints[i].x), 8 );
memcpy( pabyData+4+i*24+8, &(paoPoints[i].y), 8 );
if( padfZ == nullptr )
memset( pabyData+4+i*24+16, 0, 8 );
else
memcpy( pabyData+4+i*24+16, padfZ + i, 8 );
}
}
else
{
nWords = 2 * nPointCount;
memcpy( pabyData+4, paoPoints, 16 * nPointCount );
}
/* -------------------------------------------------------------------- */
/* Swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
int nCount = CPL_SWAP32( nPointCount );
memcpy( pabyData, &nCount, 4 );
for( int i = 0; i < nWords; i++ )
{
CPL_SWAPDOUBLE( pabyData + 4 + 8 * i );
}
}
return OGRERR_NONE;
}
//! @cond Doxygen_Suppress
OGRErr OGRLinearRing::_importFromWkb( OGRwkbByteOrder eByteOrder, int _flags,
const unsigned char * pabyData,
int nBytesAvailable,
int& nBytesConsumedOut )
{
nBytesConsumedOut = -1;
if( nBytesAvailable < 4 && nBytesAvailable != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the vertex count. */
/* -------------------------------------------------------------------- */
int nNewNumPoints = 0;
memcpy( &nNewNumPoints, pabyData, 4 );
if( OGR_SWAP( eByteOrder ) )
nNewNumPoints = CPL_SWAP32(nNewNumPoints);
// Check if the wkb stream buffer is big enough to store
// fetched number of points.
// 16, 24, or 32 - size of point structure.
int nPointSize = 0;
if( (_flags & OGR_G_3D) && (_flags & OGR_G_MEASURED) )
nPointSize = 32;
else if( (_flags & OGR_G_3D) || (_flags & OGR_G_MEASURED) )
nPointSize = 24;
else
nPointSize = 16;
if( nNewNumPoints < 0 || nNewNumPoints > INT_MAX / nPointSize )
return OGRERR_CORRUPT_DATA;
int nBufferMinSize = nPointSize * nNewNumPoints;
if( nBytesAvailable != -1 && nBufferMinSize > nBytesAvailable - 4 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Length of input WKB is too small" );
return OGRERR_NOT_ENOUGH_DATA;
}
// (Re)Allocation of paoPoints buffer.
setNumPoints( nNewNumPoints, FALSE );
if( _flags & OGR_G_3D )
Make3D();
else
Make2D();
if( _flags & OGR_G_MEASURED )
AddM();
else
RemoveM();
nBytesConsumedOut = 4 + nPointCount * nPointSize;
/* -------------------------------------------------------------------- */
/* Get the vertices */
/* -------------------------------------------------------------------- */
if( (flags & OGR_G_3D) && (flags & OGR_G_MEASURED) )
{
for( int i = 0; i < nPointCount; i++ )
{
memcpy( &(paoPoints[i].x), pabyData + 4 + 32 * i, 8 );
memcpy( &(paoPoints[i].y), pabyData + 4 + 32 * i + 8, 8 );
memcpy( padfZ + i, pabyData + 4 + 32 * i + 16, 8 );
memcpy( padfM + i, pabyData + 4 + 32 * i + 24, 8 );
}
}
else if( flags & OGR_G_MEASURED )
{
for( int i = 0; i < nPointCount; i++ )
{
memcpy( &(paoPoints[i].x), pabyData + 4 + 24 * i, 8 );
memcpy( &(paoPoints[i].y), pabyData + 4 + 24 * i + 8, 8 );
memcpy( padfM + i, pabyData + 4 + 24 * i + 16, 8 );
}
}
else if( flags & OGR_G_3D )
{
for( int i = 0; i < nPointCount; i++ )
{
memcpy( &(paoPoints[i].x), pabyData + 4 + 24 * i, 8 );
memcpy( &(paoPoints[i].y), pabyData + 4 + 24 * i + 8, 8 );
memcpy( padfZ + i, pabyData + 4 + 24 * i + 16, 8 );
}
}
else
{
memcpy( paoPoints, pabyData + 4, 16 * nPointCount );
}
/* -------------------------------------------------------------------- */
/* Byte swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
for( int i = 0; i < nPointCount; i++ )
{
CPL_SWAPDOUBLE( &(paoPoints[i].x) );
CPL_SWAPDOUBLE( &(paoPoints[i].y) );
if( flags & OGR_G_3D )
{
CPL_SWAPDOUBLE( padfZ + i );
}
if( flags & OGR_G_MEASURED )
{
CPL_SWAPDOUBLE( padfM + i );
}
}
}
return OGRERR_NONE;
}
OGRErr OGRLinearRing::_importFromWkb( OGRwkbByteOrder eByteOrder, int b3D,
unsigned char * pabyData,
int nBytesAvailable )
{
if( nBytesAvailable < 4 && nBytesAvailable != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the vertex count. */
/* -------------------------------------------------------------------- */
int nNewNumPoints;
memcpy( &nNewNumPoints, pabyData, 4 );
if( OGR_SWAP( eByteOrder ) )
nNewNumPoints = CPL_SWAP32(nNewNumPoints);
setNumPoints( nNewNumPoints );
if( b3D )
Make3D();
else
Make2D();
/* -------------------------------------------------------------------- */
/* Get the vertices */
/* -------------------------------------------------------------------- */
int i;
if( !b3D )
memcpy( paoPoints, pabyData + 4, 16 * nPointCount );
else
{
for( int i = 0; i < nPointCount; i++ )
{
memcpy( &(paoPoints[i].x), pabyData + 4 + 24 * i, 8 );
memcpy( &(paoPoints[i].y), pabyData + 4 + 24 * i + 8, 8 );
memcpy( padfZ + i, pabyData + 4 + 24 * i + 16, 8 );
}
}
/* -------------------------------------------------------------------- */
/* Byte swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
for( i = 0; i < nPointCount; i++ )
{
CPL_SWAPDOUBLE( &(paoPoints[i].x) );
CPL_SWAPDOUBLE( &(paoPoints[i].y) );
if( b3D )
{
CPL_SWAPDOUBLE( padfZ + i );
}
}
}
return OGRERR_NONE;
}
OGRErr OGRLineString::importFromWkb( unsigned char * pabyData,
int nBytesAvailable )
{
OGRwkbByteOrder eByteOrder;
if( nBytesAvailable < 21 && nBytesAvailable != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the byte order byte. */
/* -------------------------------------------------------------------- */
eByteOrder = (OGRwkbByteOrder) *pabyData;
assert( eByteOrder == wkbXDR || eByteOrder == wkbNDR );
/* -------------------------------------------------------------------- */
/* Get the geometry feature type. For now we assume that */
/* geometry type is between 0 and 255 so we only have to fetch */
/* one byte. */
/* -------------------------------------------------------------------- */
OGRwkbGeometryType eGeometryType;
int bIs3D;
if( eByteOrder == wkbNDR )
{
eGeometryType = (OGRwkbGeometryType) pabyData[1];
bIs3D = (pabyData[2] & 0x80);
}
else
{
eGeometryType = (OGRwkbGeometryType) pabyData[4];
bIs3D = (pabyData[3] & 0x80);
}
assert( eGeometryType == wkbLineString );
/* -------------------------------------------------------------------- */
/* Get the vertex count. */
/* -------------------------------------------------------------------- */
int nNewNumPoints;
memcpy( &nNewNumPoints, pabyData + 5, 4 );
if( OGR_SWAP( eByteOrder ) )
nNewNumPoints = CPL_SWAP32(nNewNumPoints);
setNumPoints( nNewNumPoints );
if( bIs3D )
Make3D();
else
Make2D();
/* -------------------------------------------------------------------- */
/* Get the vertex. */
/* -------------------------------------------------------------------- */
int i;
if( bIs3D )
{
for( i = 0; i < nPointCount; i++ )
{
memcpy( paoPoints + i, pabyData + 9 + i*24, 16 );
memcpy( padfZ + i, pabyData + 9 + 16 + i*24, 8 );
}
}
else
{
memcpy( paoPoints, pabyData + 9, 16 * nPointCount );
}
/* -------------------------------------------------------------------- */
/* Byte swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
for( i = 0; i < nPointCount; i++ )
{
CPL_SWAPDOUBLE( &(paoPoints[i].x) );
CPL_SWAPDOUBLE( &(paoPoints[i].y) );
}
if( bIs3D )
{
for( i = 0; i < nPointCount; i++ )
{
CPL_SWAPDOUBLE( padfZ + i );
}
}
}
return OGRERR_NONE;
}
OGRErr OGRPoint::exportToWkb( OGRwkbByteOrder eByteOrder,
unsigned char * pabyData,
OGRwkbVariant eWkbVariant ) const
{
/* -------------------------------------------------------------------- */
/* Set the byte order. */
/* -------------------------------------------------------------------- */
pabyData[0] =
DB2_V72_UNFIX_BYTE_ORDER(static_cast<unsigned char>(eByteOrder));
pabyData += 1;
/* -------------------------------------------------------------------- */
/* Set the geometry feature type. */
/* -------------------------------------------------------------------- */
GUInt32 nGType = getGeometryType();
if( eWkbVariant == wkbVariantPostGIS1 )
{
nGType = wkbFlatten(nGType);
if( Is3D() )
// Explicitly set wkb25DBit.
nGType =
static_cast<OGRwkbGeometryType>(nGType | wkb25DBitInternalUse);
if( IsMeasured() )
nGType = static_cast<OGRwkbGeometryType>(nGType | 0x40000000);
}
else if( eWkbVariant == wkbVariantIso )
{
nGType = getIsoGeometryType();
}
if( eByteOrder == wkbNDR )
nGType = CPL_LSBWORD32( nGType );
else
nGType = CPL_MSBWORD32( nGType );
memcpy( pabyData, &nGType, 4 );
pabyData += 4;
/* -------------------------------------------------------------------- */
/* Copy in the raw data. Swap if needed. */
/* -------------------------------------------------------------------- */
if( IsEmpty() && eWkbVariant == wkbVariantIso )
{
const double dNan = std::numeric_limits<double>::quiet_NaN();
memcpy( pabyData, &dNan, 8 );
if( OGR_SWAP( eByteOrder ) )
CPL_SWAPDOUBLE( pabyData );
pabyData += 8;
memcpy( pabyData, &dNan, 8 );
if( OGR_SWAP( eByteOrder ) )
CPL_SWAPDOUBLE( pabyData );
pabyData += 8;
if( flags & OGR_G_3D ) {
memcpy( pabyData, &dNan, 8 );
if( OGR_SWAP( eByteOrder ) )
CPL_SWAPDOUBLE( pabyData );
pabyData += 8;
}
if( flags & OGR_G_MEASURED ) {
memcpy( pabyData, &dNan, 8 );
if( OGR_SWAP( eByteOrder ) )
CPL_SWAPDOUBLE( pabyData );
}
}
else
{
memcpy( pabyData, &x, 8 );
if( OGR_SWAP( eByteOrder ) )
CPL_SWAPDOUBLE( pabyData );
pabyData += 8;
memcpy( pabyData, &y, 8 );
if( OGR_SWAP( eByteOrder ) )
CPL_SWAPDOUBLE( pabyData );
pabyData += 8;
if( flags & OGR_G_3D ) {
memcpy( pabyData, &z, 8 );
if( OGR_SWAP( eByteOrder ) )
CPL_SWAPDOUBLE( pabyData );
pabyData += 8;
}
if( flags & OGR_G_MEASURED )
{
memcpy( pabyData, &m, 8 );
if( OGR_SWAP( eByteOrder ) )
CPL_SWAPDOUBLE( pabyData );
}
}
return OGRERR_NONE;
}
OGRErr OGRPoint::importFromWkb( unsigned char * pabyData,
int nSize,
OGRwkbVariant eWkbVariant )
{
OGRwkbByteOrder eByteOrder = wkbNDR;
flags = 0;
OGRErr eErr =
importPreambuleFromWkb( pabyData, nSize, eByteOrder, eWkbVariant );
pabyData += 5;
if( eErr != OGRERR_NONE )
return eErr;
if( nSize != -1 )
{
if( (nSize < 37) && ((flags & OGR_G_3D) && (flags & OGR_G_MEASURED)) )
return OGRERR_NOT_ENOUGH_DATA;
else if( (nSize < 29) && ((flags & OGR_G_3D) ||
(flags & OGR_G_MEASURED)) )
return OGRERR_NOT_ENOUGH_DATA;
else if( nSize < 21 )
return OGRERR_NOT_ENOUGH_DATA;
}
/* -------------------------------------------------------------------- */
/* Get the vertex. */
/* -------------------------------------------------------------------- */
memcpy( &x, pabyData, 8 );
pabyData += 8;
memcpy( &y, pabyData, 8 );
pabyData += 8;
if( OGR_SWAP( eByteOrder ) )
{
CPL_SWAPDOUBLE( &x );
CPL_SWAPDOUBLE( &y );
}
if( flags & OGR_G_3D )
{
memcpy( &z, pabyData, 8 );
pabyData += 8;
if( OGR_SWAP( eByteOrder ) )
CPL_SWAPDOUBLE( &z );
}
else
{
z = 0;
}
if( flags & OGR_G_MEASURED )
{
memcpy( &m, pabyData, 8 );
/*pabyData += 8; */
if( OGR_SWAP( eByteOrder ) )
{
CPL_SWAPDOUBLE( &m );
}
}
else
{
m = 0;
}
// Detect coordinates are not NaN --> NOT EMPTY.
if( !(CPLIsNan(x) && CPLIsNan(y)) )
flags |= OGR_G_NOT_EMPTY_POINT;
return OGRERR_NONE;
}