OGRLayer *OGRCARTODBDataSource::ICreateLayer( const char *pszName,
OGRSpatialReference *poSpatialRef,
OGRwkbGeometryType eGType,
char ** papszOptions )
{
if (!bReadWrite)
{
CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszName,papoLayers[iLayer]->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( iLayer );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszName );
return NULL;
}
}
}
CPLString osName(pszName);
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
{
char* pszTmp = OGRPGCommonLaunderName(pszName);
osName = pszTmp;
CPLFree(pszTmp);
}
OGRCARTODBTableLayer* poLayer = new OGRCARTODBTableLayer(this, osName);
int bGeomNullable = CSLFetchBoolean(papszOptions, "GEOMETRY_NULLABLE", TRUE);
int bCartoDBify = CSLFetchBoolean(papszOptions, "CARTODBFY",
CSLFetchBoolean(papszOptions, "CARTODBIFY", TRUE));
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetDeferedCreation(eGType, poSpatialRef, bGeomNullable, bCartoDBify);
papoLayers = (OGRCARTODBTableLayer**) CPLRealloc(
papoLayers, (nLayers + 1) * sizeof(OGRCARTODBTableLayer*));
papoLayers[nLayers ++] = poLayer;
return poLayer;
}
QString QgsRasterFileWriter::driverForExtension( const QString &extension )
{
QString ext = extension.trimmed();
if ( ext.isEmpty() )
return QString();
if ( ext.startsWith( '.' ) )
ext.remove( 0, 1 );
GDALAllRegister();
int const drvCount = GDALGetDriverCount();
for ( int i = 0; i < drvCount; ++i )
{
GDALDriverH drv = GDALGetDriver( i );
if ( drv )
{
char **driverMetadata = GDALGetMetadata( drv, nullptr );
if ( CSLFetchBoolean( driverMetadata, GDAL_DCAP_RASTER, false ) )
{
QString drvName = GDALGetDriverShortName( drv );
QStringList driverExtensions = QString( GDALGetMetadataItem( drv, GDAL_DMD_EXTENSIONS, nullptr ) ).split( ' ' );
Q_FOREACH ( const QString &driver, driverExtensions )
{
if ( driver.compare( ext, Qt::CaseInsensitive ) == 0 )
return drvName;
}
}
}
}
void write_map(fs::path file_path, GDALDataType data_type, boost::shared_ptr<Map_Matrix<DataFormat> > data, std::string WKTprojection, GeoTransform transform, std::string driverName) throw(std::runtime_error)
{
GDALAllRegister(); //This registers all availble raster file formats for use with this utility. How neat is that. We can input any GDAL supported rater file format.
const char *pszFormat = driverName.c_str();
GDALDriver * poDriver = GetGDALDriverManager()->GetDriverByName(pszFormat);
if (poDriver == NULL)
{
throw std::runtime_error("No driver for file tyle found");
}
char ** papszMetadata = poDriver->GetMetadata();
if (!(CSLFetchBoolean(papszMetadata, GDAL_DCAP_CREATE, FALSE)))
{
throw std::runtime_error("Driver does not support raster creation");
}
char **papszOptions = NULL;
papszOptions = CSLSetNameValue(papszOptions, "COMPRESS", "LZW");
GDALDataset *poDstDS = poDriver->Create(file_path.string().c_str(), (int)data->NCols(), (int)data->NRows(), 1, data_type, papszOptions);
double adfGeoTransform[6] = {1, 1, 1, 1, 1, 1};
adfGeoTransform[0] = transform.x_origin;
adfGeoTransform[1] = transform.pixel_width;
adfGeoTransform[2] = transform.x_line_space;
adfGeoTransform[3] = transform.y_origin;
adfGeoTransform[4] = transform.pixel_height;
adfGeoTransform[5] = transform.y_line_space;
const char * psz_WKT = WKTprojection.c_str();
poDstDS->SetGeoTransform(adfGeoTransform);
poDstDS->SetProjection(psz_WKT);
DataFormat * pafScanline = new DataFormat[data->NCols() * data->NRows()];
int pafIterator = 0;
for (int i = 0; i < data->NRows(); i++)
{
for (int j = 0; j < data->NCols(); j++)
{
pafScanline[pafIterator] = data->Get(i, j);
pafIterator++;
}
}
GDALRasterBand * poBand = poDstDS->GetRasterBand(1);
poBand->SetNoDataValue(data->NoDataValue());
poBand->RasterIO(GF_Write, 0, 0, (int) data->NCols(), (int) data->NRows(), pafScanline, (int) data->NCols(), (int) data->NRows(), data_type, 0, 0);
GDALClose( (GDALDatasetH) poDstDS);
}
void QgsRasterCalcDialog::insertAvailableOutputFormats()
{
GDALAllRegister();
int nDrivers = GDALGetDriverCount();
for ( int i = 0; i < nDrivers; ++i )
{
GDALDriverH driver = GDALGetDriver( i );
if ( driver != NULL )
{
char** driverMetadata = GDALGetMetadata( driver, NULL );
if ( CSLFetchBoolean( driverMetadata, GDAL_DCAP_CREATE, false ) )
{
mOutputFormatComboBox->addItem( GDALGetDriverLongName( driver ), QVariant( GDALGetDriverShortName( driver ) ) );
//store the driver shortnames and the corresponding extensions
//(just in case the user does not give an extension for the output file name)
int index = 0;
while (( driverMetadata ) && driverMetadata[index] != 0 )
{
QStringList metadataTokens = QString( driverMetadata[index] ).split( "=", QString::SkipEmptyParts );
if ( metadataTokens.size() < 1 )
{
break;
}
if ( metadataTokens[0] == "DMD_EXTENSION" )
{
if ( metadataTokens.size() < 2 )
{
++index;
continue;
}
mDriverExtensionMap.insert( QString( GDALGetDriverShortName( driver ) ), metadataTokens[1] );
break;
}
++index;
}
}
}
}
//and set last used driver in combo box
QSettings s;
QString lastUsedDriver = s.value( "/RasterCalculator/lastOutputFormat", "GeoTIFF" ).toString();
int lastDriverIndex = mOutputFormatComboBox->findText( lastUsedDriver );
if ( lastDriverIndex != -1 )
{
mOutputFormatComboBox->setCurrentIndex( lastDriverIndex );
}
}
void QgsRasterCalcDialog::insertAvailableOutputFormats()
{
GDALAllRegister();
int nDrivers = GDALGetDriverCount();
for ( int i = 0; i < nDrivers; ++i )
{
GDALDriverH driver = GDALGetDriver( i );
if ( driver )
{
char** driverMetadata = GDALGetMetadata( driver, nullptr );
if ( CSLFetchBoolean( driverMetadata, GDAL_DCAP_CREATE, false ) )
{
QString driverShortName = GDALGetDriverShortName( driver );
QString driverLongName = GDALGetDriverLongName( driver );
if ( driverShortName == "MEM" )
{
// in memory rasters are not (yet) supported because the GDAL dataset handle
// would need to be passed directly to QgsRasterLayer (it is not possible to
// close it in raster calculator and reopen the dataset again in raster layer)
continue;
}
mOutputFormatComboBox->addItem( driverLongName, driverShortName );
//store the driver shortnames and the corresponding extensions
//(just in case the user does not give an extension for the output file name)
QString driverExtension = GDALGetMetadataItem( driver, GDAL_DMD_EXTENSION, nullptr );
mDriverExtensionMap.insert( driverShortName, driverExtension );
}
}
}
//and set last used driver in combo box
QSettings s;
QString lastUsedDriver = s.value( "/RasterCalculator/lastOutputFormat", "GeoTIFF" ).toString();
int lastDriverIndex = mOutputFormatComboBox->findText( lastUsedDriver );
if ( lastDriverIndex != -1 )
{
mOutputFormatComboBox->setCurrentIndex( lastDriverIndex );
}
}
GDALDriverH QgsRasterCalculator::openOutputDriver()
{
char **driverMetadata;
//open driver
GDALDriverH outputDriver = GDALGetDriverByName( mOutputFormat.toLocal8Bit().data() );
if ( outputDriver == NULL )
{
return outputDriver; //return NULL, driver does not exist
}
driverMetadata = GDALGetMetadata( outputDriver, NULL );
if ( !CSLFetchBoolean( driverMetadata, GDAL_DCAP_CREATE, false ) )
{
return NULL; //driver exist, but it does not support the create operation
}
return outputDriver;
}
GDALDriverH QgsRelief::openOutputDriver()
{
char **driverMetadata = nullptr;
//open driver
GDALDriverH outputDriver = GDALGetDriverByName( mOutputFormat.toLocal8Bit().data() );
if ( !outputDriver )
{
return outputDriver; //return nullptr, driver does not exist
}
driverMetadata = GDALGetMetadata( outputDriver, nullptr );
if ( !CSLFetchBoolean( driverMetadata, GDAL_DCAP_CREATE, false ) )
{
return nullptr; //driver exist, but it does not support the create operation
}
return outputDriver;
}
int main(int argc, char *argv[]){
GDALDataset *poDataset;
GDALAllRegister();
if(argc != 3){
std::cout << "usage:\n" << argv[0] << " src_file dest_file\n";
exit(0);
}
const std::string name = argv[1];
const std::string destName = argv[2];
poDataset = (GDALDataset *) GDALOpen(name.c_str(), GA_ReadOnly );
if( poDataset == NULL ){
std::cout << "Failed to open " << name << "\n";
}else{
const char *pszFormat = "GTiff";
GDALDriver *poDriver;
char **papszMetadata;
poDriver = GetGDALDriverManager()->GetDriverByName(pszFormat);
if( poDriver == NULL ){
std::cout << "Cant open driver\n";
exit(1);
}
papszMetadata = GDALGetMetadata( poDriver, NULL );
if( !CSLFetchBoolean( papszMetadata, GDAL_DCAP_CREATE, FALSE ) ){
std::cout << "Create Method not suported!\n";
}
if( !CSLFetchBoolean( papszMetadata, GDAL_DCAP_CREATECOPY, FALSE ) ){
std::cout << "CreateCopy() method not suported.\n";
}
char **papszOptions = NULL;
GDALDataset *dest = poDriver->Create(destName.c_str() , poDataset->GetRasterXSize(),
poDataset->GetRasterYSize(), 3, GDT_Byte, papszOptions );
std::cout << "Reading file " << name << "\n";
std::cout <<
"x= " << poDataset->GetRasterXSize() <<
", h=" << poDataset->GetRasterYSize() <<
", bands= " << poDataset->GetRasterCount() << "\n";
GDALRasterBand *data;
data = poDataset->GetRasterBand(1);
GDALDataType type = data->GetRasterDataType();
printDataType(type);
int size = data->GetXSize()*data->GetYSize();
std::cout << "size=" << size << " , w*h = " << poDataset->GetRasterXSize()*poDataset->GetRasterYSize() << "\n";
float *buffer;
buffer = (float *) CPLMalloc(sizeof(float)*size);
data->RasterIO(GF_Read, 0, 0, data->GetXSize(), data->GetYSize(), buffer, data->GetXSize(), data->GetYSize(), GDT_Float32, 0, 0 );
GDALRasterBand *destBand1 = dest->GetRasterBand(1);
GDALRasterBand *destBand2 = dest->GetRasterBand(2);
GDALRasterBand *destBand3 = dest->GetRasterBand(3);
// GDALRasterBand *destBand4 = dest->GetRasterBand(4);
// Metadata,
double geot[6];
poDataset->GetGeoTransform(geot);
dest->SetGeoTransform(geot);// adfGeoTransform );
dest->SetProjection( poDataset->GetProjectionRef() );
GByte destWrite1[size]; // = (GUInt32 *) CPLMalloc(sizeof(GUInt32)*size);
GByte destWrite2[size];
GByte destWrite3[size];
// GByte destWrite4[size];
unsigned int i;
float max=0, min=0;
for(i=0; i<size; i++){
if(max < buffer[i]){
max = buffer[i];
}
if(min > buffer[i]){
min = buffer[i];
}
}
float range = max - min;
std::cout << "range=" << range << ", max=" << max << ", min=" << min << "\n";
std::map<float, unsigned int> counter;
for(i=0; i<size; i++){
counter[buffer[i]]++;
unsigned int v = buffer[i] * 100;
destWrite1[i] = (v & (0xff << 0)) >> 0;
destWrite2[i] = (v & (0xff << 8)) >> 8;
destWrite3[i] = (v & (0xff << 16)) >> 16;
// destWrite4[i] = 0x00; // (v & (0xff << 24)) >> 24;
}
destBand1->RasterIO( GF_Write, 0, 0, data->GetXSize(), data->GetYSize(),
destWrite1, data->GetXSize(), data->GetYSize(), GDT_Byte, 0, 0 );
destBand2->RasterIO( GF_Write, 0, 0, data->GetXSize(), data->GetYSize(),
destWrite2, data->GetXSize(), data->GetYSize(), GDT_Byte, 0, 0 );
destBand3->RasterIO( GF_Write, 0, 0, data->GetXSize(), data->GetYSize(),
destWrite3, data->GetXSize(), data->GetYSize(), GDT_Byte, 0, 0 );
// destBand4->RasterIO( GF_Write, 0, 0, data->GetXSize(), data->GetYSize(),
// destWrite4, data->GetXSize(), data->GetYSize(), GDT_Byte, 0, 0 );
/*std::map<float, unsigned int>::iterator it;
std::cout << "Counter: \n";
for(it=counter.begin(); it!=counter.end(); it++){
std::cout << (it->first*1000) << " = " << it->second << "\n";
}*/
/* Once we're done, close properly the dataset */
if( dest != NULL ){
GDALClose(dest );
GDALClose(poDataset );
}
/*
unsigned int *buffer;
buffer = (unsigned int *) CPLMalloc(sizeof(unsigned int)*size);
data->RasterIO(GF_Read, 0, 0, size, 1, buffer, size, 1, GDT_UInt32, 0, 0 );
unsigned int i;
std::map<unsigned int, unsigned int> counter;
for(i=0; i<size; i++){
counter[buffer[i]]++;
}
std::map<unsigned int, unsigned int>::iterator it;
std::cout << "Counter: \n";
for(it=counter.begin(); it!=counter.end(); it++){
std::cout << it->first << " = " << it->second << "\n";
}*/
}
exit(0);
}
CPLErr
GDALWarpCutlineMasker( void *pMaskFuncArg,
CPL_UNUSED int nBandCount,
CPL_UNUSED GDALDataType eType,
int nXOff, int nYOff, int nXSize, int nYSize,
GByte ** /*ppImageData */,
int bMaskIsFloat, void *pValidityMask )
{
GDALWarpOptions *psWO = (GDALWarpOptions *) pMaskFuncArg;
float *pafMask = (float *) pValidityMask;
CPLErr eErr;
GDALDriverH hMemDriver;
if( nXSize < 1 || nYSize < 1 )
return CE_None;
/* -------------------------------------------------------------------- */
/* Do some minimal checking. */
/* -------------------------------------------------------------------- */
if( !bMaskIsFloat )
{
CPLAssert( FALSE );
return CE_Failure;
}
if( psWO == NULL || psWO->hCutline == NULL )
{
CPLAssert( FALSE );
return CE_Failure;
}
hMemDriver = GDALGetDriverByName("MEM");
if (hMemDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "GDALWarpCutlineMasker needs MEM driver");
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Check the polygon. */
/* -------------------------------------------------------------------- */
OGRGeometryH hPolygon = (OGRGeometryH) psWO->hCutline;
OGREnvelope sEnvelope;
if( wkbFlatten(OGR_G_GetGeometryType(hPolygon)) != wkbPolygon
&& wkbFlatten(OGR_G_GetGeometryType(hPolygon)) != wkbMultiPolygon )
{
CPLAssert( FALSE );
return CE_Failure;
}
OGR_G_GetEnvelope( hPolygon, &sEnvelope );
if( sEnvelope.MaxX + psWO->dfCutlineBlendDist < nXOff
|| sEnvelope.MinX - psWO->dfCutlineBlendDist > nXOff + nXSize
|| sEnvelope.MaxY + psWO->dfCutlineBlendDist < nYOff
|| sEnvelope.MinY - psWO->dfCutlineBlendDist > nYOff + nYSize )
{
// We are far from the blend line - everything is masked to zero.
// It would be nice to realize no work is required for this whole
// chunk!
memset( pafMask, 0, sizeof(float) * nXSize * nYSize );
return CE_None;
}
/* -------------------------------------------------------------------- */
/* Create a byte buffer into which we can burn the */
/* mask polygon and wrap it up as a memory dataset. */
/* -------------------------------------------------------------------- */
GByte *pabyPolyMask = (GByte *) CPLCalloc( nXSize, nYSize );
GDALDatasetH hMemDS;
double adfGeoTransform[6] = { 0.0, 1.0, 0.0, 0.0, 0.0, 1.0 };
char szDataPointer[100];
char *apszOptions[] = { szDataPointer, NULL };
memset( szDataPointer, 0, sizeof(szDataPointer) );
sprintf( szDataPointer, "DATAPOINTER=" );
CPLPrintPointer( szDataPointer+strlen(szDataPointer),
pabyPolyMask,
sizeof(szDataPointer) - strlen(szDataPointer) );
hMemDS = GDALCreate( hMemDriver, "warp_temp",
nXSize, nYSize, 0, GDT_Byte, NULL );
GDALAddBand( hMemDS, GDT_Byte, apszOptions );
GDALSetGeoTransform( hMemDS, adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Burn the polygon into the mask with 1.0 values. */
/* -------------------------------------------------------------------- */
int nTargetBand = 1;
double dfBurnValue = 255.0;
int anXYOff[2];
char **papszRasterizeOptions = NULL;
if( CSLFetchBoolean( psWO->papszWarpOptions, "CUTLINE_ALL_TOUCHED", FALSE ))
papszRasterizeOptions =
CSLSetNameValue( papszRasterizeOptions, "ALL_TOUCHED", "TRUE" );
anXYOff[0] = nXOff;
anXYOff[1] = nYOff;
eErr =
GDALRasterizeGeometries( hMemDS, 1, &nTargetBand,
1, &hPolygon,
CutlineTransformer, anXYOff,
&dfBurnValue, papszRasterizeOptions,
NULL, NULL );
CSLDestroy( papszRasterizeOptions );
// Close and ensure data flushed to underlying array.
GDALClose( hMemDS );
/* -------------------------------------------------------------------- */
/* In the case with no blend distance, we just apply this as a */
/* mask, zeroing out everything outside the polygon. */
/* -------------------------------------------------------------------- */
if( psWO->dfCutlineBlendDist == 0.0 )
{
int i;
for( i = nXSize * nYSize - 1; i >= 0; i-- )
{
if( pabyPolyMask[i] == 0 )
((float *) pValidityMask)[i] = 0.0;
}
}
else
{
eErr = BlendMaskGenerator( nXOff, nYOff, nXSize, nYSize,
pabyPolyMask, (float *) pValidityMask,
hPolygon, psWO->dfCutlineBlendDist );
}
/* -------------------------------------------------------------------- */
/* Clean up. */
/* -------------------------------------------------------------------- */
CPLFree( pabyPolyMask );
return eErr;
}
GDALDataset *NTv2Dataset::Create( const char * pszFilename,
int nXSize, int nYSize,
int nBands,
GDALDataType eType,
char ** papszOptions )
{
if( eType != GDT_Float32 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to create NTv2 file with unsupported data type '%s'.",
GDALGetDataTypeName( eType ) );
return NULL;
}
if( nBands != 4 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to create NTv2 file with unsupported "
"band number '%d'.",
nBands);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Are we extending an existing file? */
/* -------------------------------------------------------------------- */
int bAppend = CSLFetchBoolean(papszOptions,"APPEND_SUBDATASET",FALSE);
/* -------------------------------------------------------------------- */
/* Try to open or create file. */
/* -------------------------------------------------------------------- */
VSILFILE *fp = NULL;
if( bAppend )
fp = VSIFOpenL( pszFilename, "rb+" );
else
fp = VSIFOpenL( pszFilename, "wb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to open/create file `%s' failed.\n",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a file level header if we are creating new. */
/* -------------------------------------------------------------------- */
char achHeader[11*16] = { '\0' };
const char *pszValue = NULL;
GUInt32 nNumFile = 1;
bool bMustSwap = false;
bool bIsLE = false;
if( !bAppend )
{
memset( achHeader, 0, sizeof(achHeader) );
bIsLE = EQUAL(CSLFetchNameValueDef(papszOptions,"ENDIANNESS", "LE"), "LE");
#ifdef CPL_LSB
bMustSwap = !bIsLE;
#else
bMustSwap = bIsLE;
#endif
memcpy( achHeader + 0*16, "NUM_OREC", 8 );
int nNumOrec = 11;
SwapPtr32IfNecessary( bMustSwap, &nNumOrec );
memcpy( achHeader + 0*16 + 8, &nNumOrec, 4 );
memcpy( achHeader + 1*16, "NUM_SREC", 8 );
int nNumSrec = 11;
SwapPtr32IfNecessary( bMustSwap, &nNumSrec );
memcpy( achHeader + 1*16 + 8, &nNumSrec, 4 );
memcpy( achHeader + 2*16, "NUM_FILE", 8 );
SwapPtr32IfNecessary( bMustSwap, &nNumFile );
memcpy( achHeader + 2*16 + 8, &nNumFile, 4 );
SwapPtr32IfNecessary( bMustSwap, &nNumFile );
memcpy( achHeader + 3*16, "GS_TYPE ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "GS_TYPE", "SECONDS");
memcpy( achHeader + 3*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 4*16, "VERSION ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "VERSION", "" );
memcpy( achHeader + 4*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 5*16, "SYSTEM_F ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "SYSTEM_F", "" );
memcpy( achHeader + 5*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 6*16, "SYSTEM_T ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "SYSTEM_T", "" );
memcpy( achHeader + 6*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 7*16, "MAJOR_F ", 8);
memcpy( achHeader + 8*16, "MINOR_F ", 8 );
memcpy( achHeader + 9*16, "MAJOR_T ", 8 );
memcpy( achHeader + 10*16, "MINOR_T ", 8 );
CPL_IGNORE_RET_VAL(VSIFWriteL( achHeader, 1, sizeof(achHeader), fp ));
}
/* -------------------------------------------------------------------- */
/* Otherwise update the header with an increased subfile count, */
/* and advanced to the last record of the file. */
/* -------------------------------------------------------------------- */
else
{
CPL_IGNORE_RET_VAL(VSIFSeekL( fp, 0, SEEK_SET ));
CPL_IGNORE_RET_VAL(VSIFReadL( achHeader, 1, 16, fp ));
bIsLE =
achHeader[8] == 11 &&
achHeader[9] == 0 &&
achHeader[10] == 0 &&
achHeader[11] == 0;
const bool bIsBE =
achHeader[8] == 0 &&
achHeader[9] == 0 &&
achHeader[10] == 0 &&
achHeader[11] == 11;
if( !bIsLE && !bIsBE )
{
VSIFCloseL(fp);
return NULL;
}
#ifdef CPL_LSB
bMustSwap = bIsBE;
#else
bMustSwap = bIsLE;
#endif
CPL_IGNORE_RET_VAL(VSIFSeekL( fp, 2*16 + 8, SEEK_SET ));
CPL_IGNORE_RET_VAL(VSIFReadL( &nNumFile, 1, 4, fp ));
SwapPtr32IfNecessary( bMustSwap, &nNumFile );
nNumFile++;
SwapPtr32IfNecessary( bMustSwap, &nNumFile );
CPL_IGNORE_RET_VAL(VSIFSeekL( fp, 2*16 + 8, SEEK_SET ));
CPL_IGNORE_RET_VAL(VSIFWriteL( &nNumFile, 1, 4, fp ));
SwapPtr32IfNecessary( bMustSwap, &nNumFile );
CPL_IGNORE_RET_VAL(VSIFSeekL( fp, 0, SEEK_END ));
const vsi_l_offset nEnd = VSIFTellL( fp );
CPL_IGNORE_RET_VAL(VSIFSeekL( fp, nEnd-16, SEEK_SET ));
}
/* -------------------------------------------------------------------- */
/* Write the grid header. */
/* -------------------------------------------------------------------- */
memset( achHeader, 0, sizeof(achHeader) );
memcpy( achHeader + 0*16, "SUB_NAME ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "SUB_NAME", "" );
memcpy( achHeader + 0*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 1*16, "PARENT ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "PARENT", "NONE" );
memcpy( achHeader + 1*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 2*16, "CREATED ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "CREATED", "" );
memcpy( achHeader + 2*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 3*16, "UPDATED ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "UPDATED", "" );
memcpy( achHeader + 3*16+8, pszValue, MIN(16,strlen(pszValue)) );
double dfValue;
memcpy( achHeader + 4*16, "S_LAT ", 8 );
dfValue = 0;
SwapPtr64IfNecessary( bMustSwap, &dfValue );
memcpy( achHeader + 4*16 + 8, &dfValue, 8 );
memcpy( achHeader + 5*16, "N_LAT ", 8 );
dfValue = nYSize-1;
SwapPtr64IfNecessary( bMustSwap, &dfValue );
memcpy( achHeader + 5*16 + 8, &dfValue, 8 );
memcpy( achHeader + 6*16, "E_LONG ", 8 );
dfValue = -1*(nXSize-1);
SwapPtr64IfNecessary( bMustSwap, &dfValue );
memcpy( achHeader + 6*16 + 8, &dfValue, 8 );
memcpy( achHeader + 7*16, "W_LONG ", 8 );
dfValue = 0;
SwapPtr64IfNecessary( bMustSwap, &dfValue );
memcpy( achHeader + 7*16 + 8, &dfValue, 8 );
memcpy( achHeader + 8*16, "LAT_INC ", 8 );
dfValue = 1;
SwapPtr64IfNecessary( bMustSwap, &dfValue );
memcpy( achHeader + 8*16 + 8, &dfValue, 8 );
memcpy( achHeader + 9*16, "LONG_INC", 8 );
memcpy( achHeader + 9*16 + 8, &dfValue, 8 );
memcpy( achHeader + 10*16, "GS_COUNT", 8 );
GUInt32 nGSCount = nXSize * nYSize;
SwapPtr32IfNecessary( bMustSwap, &nGSCount );
memcpy( achHeader + 10*16+8, &nGSCount, 4 );
CPL_IGNORE_RET_VAL(VSIFWriteL( achHeader, 1, sizeof(achHeader), fp ));
/* -------------------------------------------------------------------- */
/* Write zeroed grid data. */
/* -------------------------------------------------------------------- */
memset( achHeader, 0, 16 );
// Use -1 (0x000080bf) as the default error value.
memset( achHeader + ((bIsLE) ? 10 : 9), 0x80, 1 );
memset( achHeader + ((bIsLE) ? 11 : 8), 0xbf, 1 );
memset( achHeader + ((bIsLE) ? 14 : 13), 0x80, 1 );
memset( achHeader + ((bIsLE) ? 15 : 12), 0xbf, 1 );
for( int i = 0; i < nXSize * nYSize; i++ )
CPL_IGNORE_RET_VAL(VSIFWriteL( achHeader, 1, 16, fp ));
/* -------------------------------------------------------------------- */
/* Write the end record. */
/* -------------------------------------------------------------------- */
memset( achHeader, 0, 16 );
memcpy( achHeader, "END ", 8 );
CPL_IGNORE_RET_VAL(VSIFWriteL( achHeader, 1, 16, fp ));
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
if( nNumFile == 1 )
return reinterpret_cast<GDALDataset *>(
GDALOpen( pszFilename, GA_Update ) );
CPLString osSubDSName;
osSubDSName.Printf( "NTv2:%d:%s", nNumFile-1, pszFilename );
return reinterpret_cast<GDALDataset *>(
GDALOpen( osSubDSName, GA_Update ) );
}
OGRLayer * OGRMSSQLSpatialDataSource::CreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
char *pszTableName = NULL;
char *pszSchemaName = NULL;
const char *pszGeomType = NULL;
const char *pszGeomColumn = NULL;
int nCoordDimension = 3;
/* determine the dimension */
if( eType == wkbFlatten(eType) )
nCoordDimension = 2;
if( CSLFetchNameValue( papszOptions, "DIM") != NULL )
nCoordDimension = atoi(CSLFetchNameValue( papszOptions, "DIM"));
/* MSSQL Schema handling:
Extract schema name from input layer name or passed with -lco SCHEMA.
Set layer name to "schema.table" or to "table" if schema is not
specified
*/
const char* pszDotPos = strstr(pszLayerName,".");
if ( pszDotPos != NULL )
{
int length = pszDotPos - pszLayerName;
pszSchemaName = (char*)CPLMalloc(length+1);
strncpy(pszSchemaName, pszLayerName, length);
pszSchemaName[length] = '\0';
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
pszTableName = LaunderName( pszDotPos + 1 ); //skip "."
else
pszTableName = CPLStrdup( pszDotPos + 1 ); //skip "."
}
else
{
pszSchemaName = NULL;
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
pszTableName = LaunderName( pszLayerName ); //skip "."
else
pszTableName = CPLStrdup( pszLayerName ); //skip "."
}
if( CSLFetchNameValue( papszOptions, "SCHEMA" ) != NULL )
{
CPLFree(pszSchemaName);
pszSchemaName = CPLStrdup(CSLFetchNameValue( papszOptions, "SCHEMA" ));
}
if (pszSchemaName == NULL)
pszSchemaName = CPLStrdup("dbo");
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetTableName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
if (!pszSchemaName)
pszSchemaName = CPLStrdup(papoLayers[iLayer]->GetSchemaName());
DeleteLayer( iLayer );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszLayerName );
CPLFree( pszSchemaName );
CPLFree( pszTableName );
return NULL;
}
}
}
/* -------------------------------------------------------------------- */
/* Handle the GEOM_TYPE option. */
/* -------------------------------------------------------------------- */
pszGeomType = CSLFetchNameValue( papszOptions, "GEOM_TYPE" );
if( !pszGeomType )
pszGeomType = "geometry";
if( !EQUAL(pszGeomType, "geometry")
&& !EQUAL(pszGeomType, "geography"))
{
CPLError( CE_Failure, CPLE_AppDefined,
"FORMAT=%s not recognised or supported.",
pszGeomType );
CPLFree( pszSchemaName );
CPLFree( pszTableName );
return NULL;
}
/* determine the geometry column name */
pszGeomColumn = CSLFetchNameValue( papszOptions, "GEOM_NAME");
if (!pszGeomColumn)
pszGeomColumn = "ogr_geometry";
/* -------------------------------------------------------------------- */
/* Initialize the metadata tables */
/* -------------------------------------------------------------------- */
if (InitializeMetadataTables() != OGRERR_NONE)
{
CPLFree( pszSchemaName );
CPLFree( pszTableName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding to the srs table if needed. */
/* -------------------------------------------------------------------- */
int nSRSId = 0;
if( CSLFetchNameValue( papszOptions, "SRID") != NULL )
nSRSId = atoi(CSLFetchNameValue( papszOptions, "SRID"));
if( nSRSId == 0 && poSRS != NULL )
nSRSId = FetchSRSId( poSRS );
/* -------------------------------------------------------------------- */
/* Create a new table and create a new entry in the geometry, */
/* geometry_columns metadata table. */
/* -------------------------------------------------------------------- */
if( eType != wkbNone )
{
const char *pszGeometryType = OGRToOGCGeomType(eType);
CPLODBCStatement oStmt( &oSession );
oStmt.Appendf( "DELETE FROM geometry_columns WHERE f_table_schema = '%s' "
"AND f_table_name = '%s'\n", pszSchemaName, pszTableName );
oStmt.Appendf("INSERT INTO [geometry_columns] ([f_table_catalog], [f_table_schema] ,[f_table_name], "
"[f_geometry_column],[coord_dimension],[srid],[geometry_type]) VALUES ('%s', '%s', '%s', '%s', %d, %d, '%s')\n",
pszCatalog, pszSchemaName, pszTableName, pszGeomColumn, nCoordDimension, nSRSId, pszGeometryType );
oStmt.Appendf("CREATE TABLE [%s].[%s] ([ogr_fid] [int] IDENTITY(1,1) NOT NULL, "
"[%s] [%s] NULL, CONSTRAINT [PK_%s] PRIMARY KEY CLUSTERED ([ogr_fid] ASC))",
pszSchemaName, pszTableName, pszGeomColumn, pszGeomType, pszTableName);
oSession.BeginTransaction();
if( !oStmt.ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error creating layer: %s", GetSession()->GetLastError() );
return NULL;
}
oSession.CommitTransaction();
}
CPLFree( pszSchemaName );
CPLFree( pszTableName );
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRMSSQLSpatialTableLayer *poLayer;
poLayer = new OGRMSSQLSpatialTableLayer( this );
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
if (poLayer->Initialize("dbo", pszLayerName, pszGeomColumn, nCoordDimension, nSRSId, eType) == OGRERR_FAILURE)
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRMSSQLSpatialTableLayer **)
CPLRealloc( papoLayers, sizeof(OGRMSSQLSpatialTableLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
return poLayer;
}
OGRLayer *
OGRMySQLDataSource::CreateLayer( const char * pszLayerNameIn,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
MYSQL_RES *hResult=NULL;
CPLString osCommand;
const char *pszGeometryType;
const char *pszGeomColumnName;
const char *pszExpectedFIDName;
char *pszLayerName;
int nDimension = 3; // MySQL only supports 2d currently
/* -------------------------------------------------------------------- */
/* Make sure there isn't an active transaction already. */
/* -------------------------------------------------------------------- */
InterruptLongResult();
if( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) )
pszLayerName = LaunderName( pszLayerNameIn );
else
pszLayerName = CPLStrdup( pszLayerNameIn );
if( wkbFlatten(eType) == eType )
nDimension = 2;
CPLDebug("MYSQL","Creating layer %s.", pszLayerName);
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( iLayer );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszLayerName );
CPLFree( pszLayerName );
return NULL;
}
}
}
pszGeomColumnName = CSLFetchNameValue( papszOptions, "GEOMETRY_NAME" );
if (!pszGeomColumnName)
pszGeomColumnName="SHAPE";
pszExpectedFIDName = CSLFetchNameValue( papszOptions, "MYSQL_FID" );
if (!pszExpectedFIDName)
pszExpectedFIDName="OGR_FID";
CPLDebug("MYSQL","Geometry Column Name %s.", pszGeomColumnName);
CPLDebug("MYSQL","FID Column Name %s.", pszExpectedFIDName);
if( wkbFlatten(eType) == wkbNone )
{
osCommand.Printf(
"CREATE TABLE `%s` ( "
" %s INT UNIQUE NOT NULL AUTO_INCREMENT )",
pszLayerName, pszExpectedFIDName );
}
else
{
osCommand.Printf(
"CREATE TABLE `%s` ( "
" %s INT UNIQUE NOT NULL AUTO_INCREMENT, "
" %s GEOMETRY NOT NULL )",
pszLayerName, pszExpectedFIDName, pszGeomColumnName );
}
if( CSLFetchNameValue( papszOptions, "ENGINE" ) != NULL )
{
osCommand += " ENGINE = ";
osCommand += CSLFetchNameValue( papszOptions, "ENGINE" );
}
if( !mysql_query(GetConn(), osCommand ) )
{
if( mysql_field_count( GetConn() ) == 0 )
CPLDebug("MYSQL","Created table %s.", pszLayerName);
else
{
ReportError( osCommand );
return NULL;
}
}
else
{
ReportError( osCommand );
return NULL;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
// Calling this does no harm
InitializeMetadataTables();
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding tot the srs table if needed. */
/* -------------------------------------------------------------------- */
int nSRSId = -1;
if( poSRS != NULL )
nSRSId = FetchSRSId( poSRS );
/* -------------------------------------------------------------------- */
/* Sometimes there is an old crufty entry in the geometry_columns */
/* table if things were not properly cleaned up before. We make */
/* an effort to clean out such cruft. */
/* */
/* -------------------------------------------------------------------- */
osCommand.Printf(
"DELETE FROM geometry_columns WHERE f_table_name = '%s'",
pszLayerName );
if( mysql_query(GetConn(), osCommand ) )
{
ReportError( osCommand );
return NULL;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
/* -------------------------------------------------------------------- */
/* Attempt to add this table to the geometry_columns table, if */
/* it is a spatial layer. */
/* -------------------------------------------------------------------- */
if( eType != wkbNone )
{
int nCoordDimension;
if( eType == wkbFlatten(eType) )
nCoordDimension = 2;
else
nCoordDimension = 3;
pszGeometryType = OGRToOGCGeomType(eType);
if( nSRSId == -1 )
osCommand.Printf(
"INSERT INTO geometry_columns "
" (F_TABLE_NAME, "
" F_GEOMETRY_COLUMN, "
" COORD_DIMENSION, "
" TYPE) values "
" ('%s', '%s', %d, '%s')",
pszLayerName,
pszGeomColumnName,
nCoordDimension,
pszGeometryType );
else
osCommand.Printf(
"INSERT INTO geometry_columns "
" (F_TABLE_NAME, "
" F_GEOMETRY_COLUMN, "
" COORD_DIMENSION, "
" SRID, "
" TYPE) values "
" ('%s', '%s', %d, %d, '%s')",
pszLayerName,
pszGeomColumnName,
nCoordDimension,
nSRSId,
pszGeometryType );
if( mysql_query(GetConn(), osCommand ) )
{
ReportError( osCommand );
return NULL;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
}
/* -------------------------------------------------------------------- */
/* Create the spatial index. */
/* */
/* We're doing this before we add geometry and record to the table */
/* so this may not be exactly the best way to do it. */
/* -------------------------------------------------------------------- */
const char *pszSI = CSLFetchNameValue( papszOptions, "SPATIAL_INDEX" );
if( eType != wkbNone && (pszSI == NULL || CSLTestBoolean(pszSI)) )
{
osCommand.Printf(
"ALTER TABLE `%s` ADD SPATIAL INDEX(`%s`) ",
pszLayerName,
pszGeomColumnName);
if( mysql_query(GetConn(), osCommand ) )
{
ReportError( osCommand );
return NULL;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRMySQLTableLayer *poLayer;
OGRErr eErr;
poLayer = new OGRMySQLTableLayer( this, pszLayerName, TRUE, nSRSId );
eErr = poLayer->Initialize(pszLayerName);
if (eErr == OGRERR_FAILURE)
return NULL;
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRMySQLLayer **)
CPLRealloc( papoLayers, sizeof(OGRMySQLLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
CPLFree( pszLayerName );
return poLayer;
}
OGRLayer *
OGRShapeDataSource::ICreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
SHPHandle hSHP;
DBFHandle hDBF;
int nShapeType;
/* To ensure that existing layers are created */
GetLayerCount();
/* -------------------------------------------------------------------- */
/* Check that the layer doesn't already exist. */
/* -------------------------------------------------------------------- */
if (GetLayerByName(pszLayerName) != NULL)
{
CPLError( CE_Failure, CPLE_AppDefined, "Layer '%s' already exists",
pszLayerName);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Verify we are in update mode. */
/* -------------------------------------------------------------------- */
if( !bDSUpdate )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Data source %s opened read-only.\n"
"New layer %s cannot be created.\n",
pszName, pszLayerName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Figure out what type of layer we need. */
/* -------------------------------------------------------------------- */
if( eType == wkbUnknown || eType == wkbLineString )
nShapeType = SHPT_ARC;
else if( eType == wkbPoint )
nShapeType = SHPT_POINT;
else if( eType == wkbPolygon )
nShapeType = SHPT_POLYGON;
else if( eType == wkbMultiPoint )
nShapeType = SHPT_MULTIPOINT;
else if( eType == wkbPoint25D )
nShapeType = SHPT_POINTZ;
else if( eType == wkbLineString25D )
nShapeType = SHPT_ARCZ;
else if( eType == wkbMultiLineString )
nShapeType = SHPT_ARC;
else if( eType == wkbMultiLineString25D )
nShapeType = SHPT_ARCZ;
else if( eType == wkbPolygon25D )
nShapeType = SHPT_POLYGONZ;
else if( eType == wkbMultiPolygon )
nShapeType = SHPT_POLYGON;
else if( eType == wkbMultiPolygon25D )
nShapeType = SHPT_POLYGONZ;
else if( eType == wkbMultiPoint25D )
nShapeType = SHPT_MULTIPOINTZ;
else if( eType == wkbNone )
nShapeType = SHPT_NULL;
else
nShapeType = -1;
/* -------------------------------------------------------------------- */
/* Has the application overridden this with a special creation */
/* option? */
/* -------------------------------------------------------------------- */
const char *pszOverride = CSLFetchNameValue( papszOptions, "SHPT" );
if( pszOverride == NULL )
/* ignore */;
else if( EQUAL(pszOverride,"POINT") )
{
nShapeType = SHPT_POINT;
eType = wkbPoint;
}
else if( EQUAL(pszOverride,"ARC") )
{
nShapeType = SHPT_ARC;
eType = wkbLineString;
}
else if( EQUAL(pszOverride,"POLYGON") )
{
nShapeType = SHPT_POLYGON;
eType = wkbPolygon;
}
else if( EQUAL(pszOverride,"MULTIPOINT") )
{
nShapeType = SHPT_MULTIPOINT;
eType = wkbMultiPoint;
}
else if( EQUAL(pszOverride,"POINTZ") )
{
nShapeType = SHPT_POINTZ;
eType = wkbPoint25D;
}
else if( EQUAL(pszOverride,"ARCZ") )
{
nShapeType = SHPT_ARCZ;
eType = wkbLineString25D;
}
else if( EQUAL(pszOverride,"POLYGONZ") )
{
nShapeType = SHPT_POLYGONZ;
eType = wkbPolygon25D;
}
else if( EQUAL(pszOverride,"MULTIPOINTZ") )
{
nShapeType = SHPT_MULTIPOINTZ;
eType = wkbMultiPoint25D;
}
else if( EQUAL(pszOverride,"NONE") || EQUAL(pszOverride,"NULL") )
{
nShapeType = SHPT_NULL;
eType = wkbNone;
}
else
{
CPLError( CE_Failure, CPLE_NotSupported,
"Unknown SHPT value of `%s' passed to Shapefile layer\n"
"creation. Creation aborted.\n",
pszOverride );
return NULL;
}
if( nShapeType == -1 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Geometry type of `%s' not supported in shapefiles.\n"
"Type can be overridden with a layer creation option\n"
"of SHPT=POINT/ARC/POLYGON/MULTIPOINT/POINTZ/ARCZ/POLYGONZ/MULTIPOINTZ.\n",
OGRGeometryTypeToName(eType) );
return NULL;
}
/* -------------------------------------------------------------------- */
/* What filename do we use, excluding the extension? */
/* -------------------------------------------------------------------- */
char *pszFilenameWithoutExt;
if( bSingleFileDataSource && nLayers == 0 )
{
char *pszPath = CPLStrdup(CPLGetPath(pszName));
char *pszFBasename = CPLStrdup(CPLGetBasename(pszName));
pszFilenameWithoutExt = CPLStrdup(CPLFormFilename(pszPath, pszFBasename, NULL));
CPLFree( pszFBasename );
CPLFree( pszPath );
}
else if( bSingleFileDataSource )
{
/* This is a very weird use case : the user creates/open a datasource */
/* made of a single shapefile 'foo.shp' and wants to add a new layer */
/* to it, 'bar'. So we create a new shapefile 'bar.shp' in the same */
/* directory as 'foo.shp' */
/* So technically, we will not be any longer a single file */
/* datasource ... Ahem ahem */
char *pszPath = CPLStrdup(CPLGetPath(pszName));
pszFilenameWithoutExt = CPLStrdup(CPLFormFilename(pszPath,pszLayerName,NULL));
CPLFree( pszPath );
}
else
pszFilenameWithoutExt = CPLStrdup(CPLFormFilename(pszName,pszLayerName,NULL));
/* -------------------------------------------------------------------- */
/* Create the shapefile. */
/* -------------------------------------------------------------------- */
char *pszFilename;
int b2GBLimit = CSLTestBoolean(CSLFetchNameValueDef( papszOptions, "2GB_LIMIT", "FALSE" ));
if( nShapeType != SHPT_NULL )
{
pszFilename = CPLStrdup(CPLFormFilename( NULL, pszFilenameWithoutExt, "shp" ));
hSHP = SHPCreateLL( pszFilename, nShapeType, (SAHooks*) VSI_SHP_GetHook(b2GBLimit) );
if( hSHP == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open Shapefile `%s'.\n",
pszFilename );
CPLFree( pszFilename );
CPLFree( pszFilenameWithoutExt );
return NULL;
}
SHPSetFastModeReadObject( hSHP, TRUE );
CPLFree( pszFilename );
}
else
hSHP = NULL;
/* -------------------------------------------------------------------- */
/* Has a specific LDID been specified by the caller? */
/* -------------------------------------------------------------------- */
const char *pszLDID = CSLFetchNameValue( papszOptions, "ENCODING" );
/* -------------------------------------------------------------------- */
/* Create a DBF file. */
/* -------------------------------------------------------------------- */
pszFilename = CPLStrdup(CPLFormFilename( NULL, pszFilenameWithoutExt, "dbf" ));
if( pszLDID != NULL )
hDBF = DBFCreateLL( pszFilename, pszLDID, (SAHooks*) VSI_SHP_GetHook(b2GBLimit) );
else
hDBF = DBFCreateLL( pszFilename, "LDID/87",(SAHooks*) VSI_SHP_GetHook(b2GBLimit) );
if( hDBF == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open Shape DBF file `%s'.\n",
pszFilename );
CPLFree( pszFilename );
CPLFree( pszFilenameWithoutExt );
SHPClose(hSHP);
return NULL;
}
CPLFree( pszFilename );
/* -------------------------------------------------------------------- */
/* Create the .prj file, if required. */
/* -------------------------------------------------------------------- */
if( poSRS != NULL )
{
char *pszWKT = NULL;
CPLString osPrjFile = CPLFormFilename( NULL, pszFilenameWithoutExt, "prj");
VSILFILE *fp;
/* the shape layer needs it's own copy */
poSRS = poSRS->Clone();
poSRS->morphToESRI();
if( poSRS->exportToWkt( &pszWKT ) == OGRERR_NONE
&& (fp = VSIFOpenL( osPrjFile, "wt" )) != NULL )
{
VSIFWriteL( pszWKT, strlen(pszWKT), 1, fp );
VSIFCloseL( fp );
}
CPLFree( pszWKT );
poSRS->morphFromESRI();
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRShapeLayer *poLayer;
/* OGRShapeLayer constructor expects a filename with an extension (that could be */
/* random actually), otherwise this is going to cause problems with layer */
/* names that have a dot (not speaking about the one before the shp) */
pszFilename = CPLStrdup(CPLFormFilename( NULL, pszFilenameWithoutExt, "shp" ));
poLayer = new OGRShapeLayer( this, pszFilename, hSHP, hDBF, poSRS, TRUE, TRUE,
eType );
CPLFree( pszFilenameWithoutExt );
CPLFree( pszFilename );
poLayer->SetResizeAtClose( CSLFetchBoolean( papszOptions, "RESIZE", FALSE ) );
poLayer->CreateSpatialIndexAtClose( CSLFetchBoolean( papszOptions, "SPATIAL_INDEX", FALSE ) );
poLayer->SetModificationDate(
CSLFetchNameValue( papszOptions, "DBF_DATE_LAST_UPDATE" ) );
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
AddLayer(poLayer);
return poLayer;
}
GDALDataset *
GIFDataset::CreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
int bInterlace = FALSE;
/* -------------------------------------------------------------------- */
/* Check for interlaced option. */
/* -------------------------------------------------------------------- */
bInterlace = CSLFetchBoolean(papszOptions, "INTERLACING", FALSE);
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
if( nBands != 1 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GIF driver only supports one band images.\n" );
return NULL;
}
if (nXSize > 65535 || nYSize > 65535)
{
CPLError( CE_Failure, CPLE_NotSupported,
"GIF driver only supports datasets up to 65535x65535 size.\n" );
return NULL;
}
if( poSrcDS->GetRasterBand(1)->GetRasterDataType() != GDT_Byte
&& bStrict )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GIF driver doesn't support data type %s. "
"Only eight bit bands supported.\n",
GDALGetDataTypeName(
poSrcDS->GetRasterBand(1)->GetRasterDataType()) );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Open the output file. */
/* -------------------------------------------------------------------- */
GifFileType *hGifFile;
VSILFILE *fp;
fp = VSIFOpenL( pszFilename, "wb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create %s:\n%s",
pszFilename, VSIStrerror( errno ) );
return NULL;
}
#if defined(GIFLIB_MAJOR) && GIFLIB_MAJOR >= 5
int nError;
hGifFile = EGifOpen( fp, VSIGIFWriteFunc, &nError );
#else
hGifFile = EGifOpen( fp, VSIGIFWriteFunc );
#endif
if( hGifFile == NULL )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_OpenFailed,
"EGifOpenFilename(%s) failed. Does file already exist?",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Prepare colortable. */
/* -------------------------------------------------------------------- */
GDALRasterBand *poBand = poSrcDS->GetRasterBand(1);
ColorMapObject *psGifCT;
int iColor;
if( poBand->GetColorTable() == NULL )
{
psGifCT = GifMakeMapObject( 256, NULL );
for( iColor = 0; iColor < 256; iColor++ )
{
psGifCT->Colors[iColor].Red = (GifByteType) iColor;
psGifCT->Colors[iColor].Green = (GifByteType) iColor;
psGifCT->Colors[iColor].Blue = (GifByteType) iColor;
}
}
else
{
GDALColorTable *poCT = poBand->GetColorTable();
int nFullCount = 1;
while( nFullCount < poCT->GetColorEntryCount() )
nFullCount = nFullCount * 2;
psGifCT = GifMakeMapObject( nFullCount, NULL );
for( iColor = 0; iColor < poCT->GetColorEntryCount(); iColor++ )
{
GDALColorEntry sEntry;
poCT->GetColorEntryAsRGB( iColor, &sEntry );
psGifCT->Colors[iColor].Red = (GifByteType) sEntry.c1;
psGifCT->Colors[iColor].Green = (GifByteType) sEntry.c2;
psGifCT->Colors[iColor].Blue = (GifByteType) sEntry.c3;
}
for( ; iColor < nFullCount; iColor++ )
{
psGifCT->Colors[iColor].Red = 0;
psGifCT->Colors[iColor].Green = 0;
psGifCT->Colors[iColor].Blue = 0;
}
}
/* -------------------------------------------------------------------- */
/* Setup parameters. */
/* -------------------------------------------------------------------- */
if (EGifPutScreenDesc(hGifFile, nXSize, nYSize,
psGifCT->ColorCount, 255, psGifCT) == GIF_ERROR)
{
GifFreeMapObject(psGifCT);
GDALPrintGifError(hGifFile, "Error writing gif file.");
GIFAbstractDataset::myEGifCloseFile(hGifFile);
VSIFCloseL( fp );
return NULL;
}
GifFreeMapObject(psGifCT);
psGifCT = NULL;
/* Support for transparency */
int bNoDataValue;
double noDataValue = poBand->GetNoDataValue(&bNoDataValue);
if (bNoDataValue && noDataValue >= 0 && noDataValue <= 255)
{
unsigned char extensionData[4];
extensionData[0] = 1; /* Transparent Color Flag */
extensionData[1] = 0;
extensionData[2] = 0;
extensionData[3] = (unsigned char)noDataValue;
EGifPutExtension(hGifFile, 0xf9, 4, extensionData);
}
if (EGifPutImageDesc(hGifFile, 0, 0, nXSize, nYSize, bInterlace, NULL) == GIF_ERROR )
{
GDALPrintGifError(hGifFile, "Error writing gif file.");
GIFAbstractDataset::myEGifCloseFile(hGifFile);
VSIFCloseL( fp );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Loop over image, copying image data. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
GDALPamDataset *poDS;
GByte *pabyScanline;
pabyScanline = (GByte *) CPLMalloc( nXSize );
if( !pfnProgress( 0.0, NULL, pProgressData ) )
eErr = CE_Failure;
if( !bInterlace )
{
for( int iLine = 0; iLine < nYSize; iLine++ )
{
eErr = poBand->RasterIO( GF_Read, 0, iLine, nXSize, 1,
pabyScanline, nXSize, 1, GDT_Byte,
nBands, nBands * nXSize );
if( eErr != CE_None || EGifPutLine( hGifFile, pabyScanline, nXSize ) == GIF_ERROR )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error writing gif file." );
goto error;
}
if( !pfnProgress( (iLine + 1) * 1.0 / nYSize, NULL, pProgressData ) )
{
goto error;
}
}
}
else
{
int i, j;
int nLinesRead = 0;
int nLinesToRead = 0;
for ( i = 0; i < 4; i++)
{
for (j = InterlacedOffset[i]; j < nYSize; j += InterlacedJumps[i])
{
nLinesToRead ++;
}
}
/* Need to perform 4 passes on the images: */
for ( i = 0; i < 4; i++)
{
for (j = InterlacedOffset[i]; j < nYSize; j += InterlacedJumps[i])
{
eErr= poBand->RasterIO( GF_Read, 0, j, nXSize, 1,
pabyScanline, nXSize, 1, GDT_Byte,
1, nXSize );
if (eErr != CE_None || EGifPutLine(hGifFile, pabyScanline, nXSize) == GIF_ERROR)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error writing gif file." );
goto error;
}
nLinesRead ++;
if( !pfnProgress( nLinesRead * 1.0 / nYSize, NULL, pProgressData ) )
{
goto error;
}
}
}
}
CPLFree( pabyScanline );
pabyScanline = NULL;
/* -------------------------------------------------------------------- */
/* cleanup */
/* -------------------------------------------------------------------- */
if (GIFAbstractDataset::myEGifCloseFile(hGifFile) == GIF_ERROR)
{
CPLError( CE_Failure, CPLE_AppDefined,
"EGifCloseFile() failed.\n" );
hGifFile = NULL;
goto error;
}
hGifFile = NULL;
VSIFCloseL( fp );
fp = NULL;
/* -------------------------------------------------------------------- */
/* Do we need a world file? */
/* -------------------------------------------------------------------- */
if( CSLFetchBoolean( papszOptions, "WORLDFILE", FALSE ) )
{
double adfGeoTransform[6];
if( poSrcDS->GetGeoTransform( adfGeoTransform ) == CE_None )
GDALWriteWorldFile( pszFilename, "wld", adfGeoTransform );
}
/* -------------------------------------------------------------------- */
/* Re-open dataset, and copy any auxilary pam information. */
/* -------------------------------------------------------------------- */
/* If outputing to stdout, we can't reopen it, so we'll return */
/* a fake dataset to make the caller happy */
CPLPushErrorHandler(CPLQuietErrorHandler);
poDS = (GDALPamDataset*) GDALOpen(pszFilename, GA_ReadOnly);
CPLPopErrorHandler();
if (poDS)
{
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
return poDS;
}
else
{
CPLErrorReset();
GIFDataset* poGIF_DS = new GIFDataset();
poGIF_DS->nRasterXSize = nXSize;
poGIF_DS->nRasterYSize = nYSize;
for(int i=0;i<nBands;i++)
poGIF_DS->SetBand( i+1, new GIFRasterBand( poGIF_DS, i+1, NULL, 0 ) );
return poGIF_DS;
}
error:
if (hGifFile)
GIFAbstractDataset::myEGifCloseFile(hGifFile);
if (fp)
VSIFCloseL( fp );
if (pabyScanline)
CPLFree( pabyScanline );
return NULL;
}
OGRErr OGRCSVEditableLayerSynchronizer::EditableSyncToDisk(OGRLayer* poEditableLayer,
OGRLayer** ppoDecoratedLayer)
{
CPLAssert( m_poCSVLayer == *ppoDecoratedLayer );
CPLString osLayerName(m_poCSVLayer->GetName());
CPLString osFilename(m_poCSVLayer->GetFilename());
const bool bCreateCSVT = m_poCSVLayer->GetCreateCSVT() != FALSE;
CPLString osCSVTFilename(CPLResetExtension(osFilename, "csvt"));
VSIStatBufL sStatBuf;
const bool bHasCSVT = VSIStatL(osCSVTFilename, &sStatBuf) == 0;
CPLString osTmpFilename(osFilename);
CPLString osTmpCSVTFilename(osFilename);
if( VSIStatL(osFilename, &sStatBuf) == 0 )
{
osTmpFilename += "_ogr_tmp.csv";
osTmpCSVTFilename += "_ogr_tmp.csvt";
}
const char chDelimiter = m_poCSVLayer->GetDelimiter();
OGRCSVLayer* poCSVTmpLayer = new OGRCSVLayer( osLayerName, NULL,
osTmpFilename,
TRUE, TRUE, chDelimiter );
poCSVTmpLayer->BuildFeatureDefn(NULL, NULL, m_papszOpenOptions);
poCSVTmpLayer->SetCRLF( m_poCSVLayer->GetCRLF() );
poCSVTmpLayer->SetCreateCSVT( bCreateCSVT || bHasCSVT );
poCSVTmpLayer->SetWriteBOM( m_poCSVLayer->GetWriteBOM() );
if( m_poCSVLayer->GetGeometryFormat() == OGR_CSV_GEOM_AS_WKT )
poCSVTmpLayer->SetWriteGeometry( wkbNone, OGR_CSV_GEOM_AS_WKT, NULL );
OGRErr eErr = OGRERR_NONE;
OGRFeatureDefn* poEditableFDefn = poEditableLayer->GetLayerDefn();
for( int i=0; eErr == OGRERR_NONE &&
i < poEditableFDefn->GetFieldCount(); i++ )
{
OGRFieldDefn oFieldDefn(poEditableFDefn->GetFieldDefn(i));
int iGeomFieldIdx;
if( (EQUAL(oFieldDefn.GetNameRef(), "WKT") &&
(iGeomFieldIdx = poEditableFDefn->GetGeomFieldIndex("")) >= 0) ||
(iGeomFieldIdx = poEditableFDefn->GetGeomFieldIndex(oFieldDefn.GetNameRef())) >= 0 )
{
OGRGeomFieldDefn oGeomFieldDefn(
poEditableFDefn->GetGeomFieldDefn(iGeomFieldIdx) );
eErr = poCSVTmpLayer->CreateGeomField( &oGeomFieldDefn );
}
else
{
eErr = poCSVTmpLayer->CreateField( &oFieldDefn );
}
}
const bool bHasXY = ( m_poCSVLayer->GetXField().size() != 0 &&
m_poCSVLayer->GetYField().size() != 0 );
const bool bHasZ = ( m_poCSVLayer->GetZField().size() != 0 );
if( bHasXY && !CSLFetchBoolean(m_papszOpenOptions, "KEEP_GEOM_COLUMNS", TRUE) )
{
if( poCSVTmpLayer->GetLayerDefn()->GetFieldIndex(m_poCSVLayer->GetXField()) < 0 )
{
OGRFieldDefn oFieldDefn(m_poCSVLayer->GetXField(), OFTReal);
if( eErr == OGRERR_NONE )
eErr = poCSVTmpLayer->CreateField( &oFieldDefn );
}
if( poCSVTmpLayer->GetLayerDefn()->GetFieldIndex(m_poCSVLayer->GetYField()) < 0 )
{
OGRFieldDefn oFieldDefn(m_poCSVLayer->GetYField(), OFTReal);
if( eErr == OGRERR_NONE )
eErr = poCSVTmpLayer->CreateField( &oFieldDefn );
}
if( bHasZ && poCSVTmpLayer->GetLayerDefn()->GetFieldIndex(m_poCSVLayer->GetZField()) < 0 )
{
OGRFieldDefn oFieldDefn(m_poCSVLayer->GetZField(), OFTReal);
if( eErr == OGRERR_NONE )
eErr = poCSVTmpLayer->CreateField( &oFieldDefn );
}
}
int nFirstGeomColIdx = 0;
if( m_poCSVLayer->HasHiddenWKTColumn() )
{
poCSVTmpLayer->SetWriteGeometry(
poEditableFDefn->GetGeomFieldDefn(0)->GetType(),
OGR_CSV_GEOM_AS_WKT,
poEditableFDefn->GetGeomFieldDefn(0)->GetNameRef());
nFirstGeomColIdx = 1;
}
if( !(poEditableFDefn->GetGeomFieldCount() == 1 && bHasXY) )
{
for( int i=nFirstGeomColIdx; eErr == OGRERR_NONE &&
i < poEditableFDefn->GetGeomFieldCount(); i++ )
{
OGRGeomFieldDefn oGeomFieldDefn( poEditableFDefn->GetGeomFieldDefn(i) );
if( poCSVTmpLayer->GetLayerDefn()->GetGeomFieldIndex(oGeomFieldDefn.GetNameRef()) >= 0 )
continue;
eErr = poCSVTmpLayer->CreateGeomField( &oGeomFieldDefn );
}
}
OGRFeature* poFeature;
poEditableLayer->ResetReading();
while( eErr == OGRERR_NONE &&
(poFeature = poEditableLayer->GetNextFeature()) != NULL )
{
OGRFeature* poNewFeature = new OGRFeature( poCSVTmpLayer->GetLayerDefn() );
poNewFeature->SetFrom(poFeature);
if( bHasXY )
{
OGRGeometry* poGeom = poFeature->GetGeometryRef();
if( poGeom != NULL && wkbFlatten(poGeom->getGeometryType()) == wkbPoint )
{
poNewFeature->SetField( m_poCSVLayer->GetXField(),
static_cast<OGRPoint*>(poGeom)->getX());
poNewFeature->SetField( m_poCSVLayer->GetYField(),
static_cast<OGRPoint*>(poGeom)->getY());
if( bHasZ )
{
poNewFeature->SetField( m_poCSVLayer->GetZField(),
static_cast<OGRPoint*>(poGeom)->getZ());
}
}
}
eErr = poCSVTmpLayer->CreateFeature(poNewFeature);
delete poFeature;
delete poNewFeature;
}
delete poCSVTmpLayer;
if( eErr != OGRERR_NONE )
{
CPLError(CE_Failure, CPLE_AppDefined, "Error while creating %s",
osTmpFilename.c_str());
VSIUnlink( osTmpFilename );
VSIUnlink( CPLResetExtension(osTmpFilename, "csvt") );
return eErr;
}
delete m_poCSVLayer;
if( osFilename != osTmpFilename )
{
CPLString osTmpOriFilename(osFilename + ".ogr_bak");
CPLString osTmpOriCSVTFilename(osCSVTFilename + ".ogr_bak");
if( VSIRename( osFilename, osTmpOriFilename ) != 0 ||
(bHasCSVT && VSIRename( osCSVTFilename, osTmpOriCSVTFilename ) != 0 ) ||
VSIRename( osTmpFilename, osFilename) != 0 ||
(bHasCSVT && VSIRename( osTmpCSVTFilename, osCSVTFilename ) != 0) )
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot rename files");
*ppoDecoratedLayer = m_poCSVLayer = NULL;
return OGRERR_FAILURE;
}
VSIUnlink( osTmpOriFilename );
if( bHasCSVT )
VSIUnlink( osTmpOriCSVTFilename );
}
VSILFILE* fp = VSIFOpenL( osFilename, "rb+" );
if( fp == NULL )
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot reopen updated %s",
osFilename.c_str());
*ppoDecoratedLayer = m_poCSVLayer = NULL;
return OGRERR_FAILURE;
}
m_poCSVLayer = new OGRCSVLayer( osLayerName, fp,
osFilename,
FALSE, /* new */
TRUE, /* update */
chDelimiter );
m_poCSVLayer->BuildFeatureDefn(NULL, NULL, m_papszOpenOptions);
*ppoDecoratedLayer = m_poCSVLayer;
return OGRERR_NONE;
}
int InCoreInterp::outputFile(const std::string& outputName, int outputFormat, unsigned int outputType, double *adfGeoTransform, const char* wkt)
{
int i,j,k;
FILE **arcFiles;
char arcFileName[1024];
FILE **gridFiles;
char gridFileName[1024];
const char *ext[6] = {".min", ".max", ".mean", ".idw", ".den", ".std"};
unsigned int type[6] = {OUTPUT_TYPE_MIN, OUTPUT_TYPE_MAX, OUTPUT_TYPE_MEAN, OUTPUT_TYPE_IDW, OUTPUT_TYPE_DEN, OUTPUT_TYPE_STD};
int numTypes = 6;
// open ArcGIS files
if(outputFormat == OUTPUT_FORMAT_ARC_ASCII || outputFormat == OUTPUT_FORMAT_ALL)
{
if((arcFiles = (FILE **)malloc(sizeof(FILE *) * numTypes)) == NULL)
{
cerr << "Arc File open error: " << endl;
return -1;
}
for(i = 0; i < numTypes; i++)
{
if(outputType & type[i])
{
strncpy(arcFileName, outputName.c_str(), sizeof(arcFileName));
strncat(arcFileName, ext[i], strlen(ext[i]));
strncat(arcFileName, ".asc", strlen(".asc"));
if((arcFiles[i] = fopen(arcFileName, "w+")) == NULL)
{
cerr << "File open error: " << arcFileName << endl;
return -1;
}
} else {
arcFiles[i] = NULL;
}
}
} else {
arcFiles = NULL;
}
// open Grid ASCII files
if(outputFormat == OUTPUT_FORMAT_GRID_ASCII || outputFormat == OUTPUT_FORMAT_ALL)
{
if((gridFiles = (FILE **)malloc(sizeof(FILE *) * numTypes)) == NULL)
{
cerr << "File array allocation error" << endl;
return -1;
}
for(i = 0; i < numTypes; i++)
{
if(outputType & type[i])
{
strncpy(gridFileName, outputName.c_str(), sizeof(arcFileName));
strncat(gridFileName, ext[i], strlen(ext[i]));
strncat(gridFileName, ".grid", strlen(".grid"));
if((gridFiles[i] = fopen(gridFileName, "w+")) == NULL)
{
cerr << "File open error: " << gridFileName << endl;
return -1;
}
} else {
gridFiles[i] = NULL;
}
}
} else {
gridFiles = NULL;
}
// print ArcGIS headers
if(arcFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(arcFiles[i] != NULL)
{
fprintf(arcFiles[i], "ncols %d\n", GRID_SIZE_X);
fprintf(arcFiles[i], "nrows %d\n", GRID_SIZE_Y);
fprintf(arcFiles[i], "xllcorner %f\n", min_x - 0.5*GRID_DIST_X);
fprintf(arcFiles[i], "yllcorner %f\n", min_y - 0.5*GRID_DIST_Y);
fprintf(arcFiles[i], "cellsize %f\n", GRID_DIST_X);
fprintf(arcFiles[i], "NODATA_value -9999\n");
}
}
}
// print Grid headers
if(gridFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(gridFiles[i] != NULL)
{
fprintf(gridFiles[i], "north: %f\n", min_y - 0.5*GRID_DIST_Y + GRID_DIST_Y*GRID_SIZE_Y);
fprintf(gridFiles[i], "south: %f\n", min_y - 0.5*GRID_DIST_Y);
fprintf(gridFiles[i], "east: %f\n", min_x - 0.5*GRID_DIST_X + GRID_DIST_X*GRID_SIZE_X);
fprintf(gridFiles[i], "west: %f\n", min_x - 0.5*GRID_DIST_X);
fprintf(gridFiles[i], "rows: %d\n", GRID_SIZE_Y);
fprintf(gridFiles[i], "cols: %d\n", GRID_SIZE_X);
}
}
}
// print data
for(i = GRID_SIZE_Y - 1; i >= 0; i--)
{
for(j = 0; j < GRID_SIZE_X; j++)
{
if(arcFiles != NULL)
{
// Zmin
if(arcFiles[0] != NULL)
{
if(interp[j][i].empty == 0 &&
interp[j][i].filled == 0)
fprintf(arcFiles[0], "-9999 ");
else
fprintf(arcFiles[0], "%f ", interp[j][i].Zmin);
}
// Zmax
if(arcFiles[1] != NULL)
{
if(interp[j][i].empty == 0 &&
interp[j][i].filled == 0)
fprintf(arcFiles[1], "-9999 ");
else
fprintf(arcFiles[1], "%f ", interp[j][i].Zmax);
}
// Zmean
if(arcFiles[2] != NULL)
{
if(interp[j][i].empty == 0 &&
interp[j][i].filled == 0)
fprintf(arcFiles[2], "-9999 ");
else
fprintf(arcFiles[2], "%f ", interp[j][i].Zmean);
}
// Zidw
if(arcFiles[3] != NULL)
{
if(interp[j][i].empty == 0 &&
interp[j][i].filled == 0)
fprintf(arcFiles[3], "-9999 ");
else
fprintf(arcFiles[3], "%f ", interp[j][i].Zidw);
}
// count
if(arcFiles[4] != NULL)
{
if(interp[j][i].empty == 0 &&
interp[j][i].filled == 0)
fprintf(arcFiles[4], "-9999 ");
else
fprintf(arcFiles[4], "%d ", interp[j][i].count);
}
// count
if(arcFiles[5] != NULL)
{
if(interp[j][i].empty == 0 &&
interp[j][i].filled == 0)
fprintf(arcFiles[5], "-9999 ");
else
fprintf(arcFiles[5], "%f ", interp[j][i].Zstd);
}
}
if(gridFiles != NULL)
{
// Zmin
if(gridFiles[0] != NULL)
{
if(interp[j][i].empty == 0 &&
interp[j][i].filled == 0)
fprintf(gridFiles[0], "-9999 ");
else
fprintf(gridFiles[0], "%f ", interp[j][i].Zmin);
}
// Zmax
if(gridFiles[1] != NULL)
{
if(interp[j][i].empty == 0 &&
interp[j][i].filled == 0)
fprintf(gridFiles[1], "-9999 ");
else
fprintf(gridFiles[1], "%f ", interp[j][i].Zmax);
}
// Zmean
if(gridFiles[2] != NULL)
{
if(interp[j][i].empty == 0 &&
interp[j][i].filled == 0)
fprintf(gridFiles[2], "-9999 ");
else
fprintf(gridFiles[2], "%f ", interp[j][i].Zmean);
}
// Zidw
if(gridFiles[3] != NULL)
{
if(interp[j][i].empty == 0 &&
interp[j][i].filled == 0)
fprintf(gridFiles[3], "-9999 ");
else
fprintf(gridFiles[3], "%f ", interp[j][i].Zidw);
}
// count
if(gridFiles[4] != NULL)
{
if(interp[j][i].empty == 0 &&
interp[j][i].filled == 0)
fprintf(gridFiles[4], "-9999 ");
else
fprintf(gridFiles[4], "%d ", interp[j][i].count);
}
// count
if(gridFiles[5] != NULL)
{
if(interp[j][i].empty == 0 &&
interp[j][i].filled == 0)
fprintf(gridFiles[5], "-9999 ");
else
fprintf(gridFiles[5], "%f ", interp[j][i].Zstd);
}
}
}
if(arcFiles != NULL)
for(k = 0; k < numTypes; k++)
{
if(arcFiles[k] != NULL)
fprintf(arcFiles[k], "\n");
}
if(gridFiles != NULL)
for(k = 0; k < numTypes; k++)
{
if(gridFiles[k] != NULL)
fprintf(gridFiles[k], "\n");
}
}
#ifdef HAVE_GDAL
GDALDataset **gdalFiles;
char gdalFileName[1024];
// open GDAL GeoTIFF files
if(outputFormat == OUTPUT_FORMAT_GDAL_GTIFF || outputFormat == OUTPUT_FORMAT_ALL)
{
GDALAllRegister();
if((gdalFiles = (GDALDataset **)malloc(sizeof(GDALDataset *) * numTypes)) == NULL)
{
cerr << "File array allocation error" << endl;
return -1;
}
for(i = 0; i < numTypes; i++)
{
if(outputType & type[i])
{
strncpy(gdalFileName, outputName.c_str(), sizeof(gdalFileName));
strncat(gdalFileName, ext[i], strlen(ext[i]));
strncat(gdalFileName, ".tif", strlen(".tif"));
char **papszMetadata;
const char *pszFormat = "GTIFF";
GDALDriver* tpDriver = GetGDALDriverManager()->GetDriverByName(pszFormat);
if (tpDriver)
{
papszMetadata = tpDriver->GetMetadata();
if (CSLFetchBoolean(papszMetadata, GDAL_DCAP_CREATE, FALSE))
{
char **papszOptions = NULL;
gdalFiles[i] = tpDriver->Create(gdalFileName, GRID_SIZE_X, GRID_SIZE_Y, 1, GDT_Float32, papszOptions);
if (gdalFiles[i] == NULL)
{
cerr << "File open error: " << gdalFileName << endl;
return -1;
} else {
if (adfGeoTransform)
{
gdalFiles[i]->SetGeoTransform(adfGeoTransform);
}
else
{
double defaultTransform [6] = { min_x - 0.5*GRID_DIST_X, // top left x
(double)GRID_DIST_X, // w-e pixel resolution
0.0, // no rotation/shear
min_y - 0.5*GRID_DIST_Y + GRID_DIST_Y*GRID_SIZE_Y, // top left y
0.0, // no rotation/shear
-(double)GRID_DIST_Y }; // n-x pixel resolution (negative value)
gdalFiles[i]->SetGeoTransform(defaultTransform);
}
if (wkt)
gdalFiles[i]->SetProjection(wkt);
}
}
}
} else {
gdalFiles[i] = NULL;
}
}
} else {
gdalFiles = NULL;
}
if (gdalFiles != NULL)
{
for (i = 0; i < numTypes; i++)
{
if (gdalFiles[i] != NULL)
{
float *poRasterData = new float[GRID_SIZE_X*GRID_SIZE_Y];
for (int j = 0; j < GRID_SIZE_X*GRID_SIZE_Y; j++)
{
poRasterData[j] = 0;
}
for(j = GRID_SIZE_Y - 1; j >= 0; j--)
{
for(k = 0; k < GRID_SIZE_X; k++)
{
int index = (GRID_SIZE_Y - 1 - j) * GRID_SIZE_X + k;
if(interp[k][j].empty == 0 &&
interp[k][j].filled == 0)
{
poRasterData[index] = -9999.f;
} else {
switch (i)
{
case 0:
poRasterData[index] = interp[k][j].Zmin;
break;
case 1:
poRasterData[index] = interp[k][j].Zmax;
break;
case 2:
poRasterData[index] = interp[k][j].Zmean;
break;
case 3:
poRasterData[index] = interp[k][j].Zidw;
break;
case 4:
poRasterData[index] = interp[k][j].count;
break;
case 5:
poRasterData[index] = interp[k][j].Zstd;
break;
}
}
}
}
GDALRasterBand *tBand = gdalFiles[i]->GetRasterBand(1);
tBand->SetNoDataValue(-9999.f);
if (GRID_SIZE_X > 0 && GRID_SIZE_Y > 0)
tBand->RasterIO(GF_Write, 0, 0, GRID_SIZE_X, GRID_SIZE_Y, poRasterData, GRID_SIZE_X, GRID_SIZE_Y, GDT_Float32, 0, 0);
GDALClose((GDALDatasetH) gdalFiles[i]);
delete [] poRasterData;
}
}
}
#endif // HAVE_GDAL
// close files
if(gridFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(gridFiles[i] != NULL)
fclose(gridFiles[i]);
}
}
if(arcFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(arcFiles[i] != NULL)
fclose(arcFiles[i]);
}
}
return 0;
}
OGRLayer *
OGROCIDataSource::ICreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
char szCommand[1024];
char *pszSafeLayerName = CPLStrdup(pszLayerName);
poSession->CleanName( pszSafeLayerName );
CPLDebug( "OCI", "In Create Layer ..." );
bNoLogging = CSLFetchBoolean( papszOptions, "NO_LOGGING", false );
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
if( CSLFetchBoolean( papszOptions, "TRUNCATE", false ) )
{
CPLDebug( "OCI", "Calling TruncateLayer for %s", pszLayerName );
TruncateLayer( pszSafeLayerName );
}
else
{
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszSafeLayerName,
papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( pszSafeLayerName );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszSafeLayerName );
CPLFree( pszSafeLayerName );
return NULL;
}
}
}
}
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding tot the srs table if needed. */
/* -------------------------------------------------------------------- */
char szSRSId[100];
if( CSLFetchNameValue( papszOptions, "SRID" ) != NULL )
strcpy( szSRSId, CSLFetchNameValue( papszOptions, "SRID" ) );
else if( poSRS != NULL )
snprintf( szSRSId, sizeof(szSRSId), "%d", FetchSRSId( poSRS ) );
else
strcpy( szSRSId, "NULL" );
/* -------------------------------------------------------------------- */
/* Determine name of geometry column to use. */
/* -------------------------------------------------------------------- */
const char *pszGeometryName =
CSLFetchNameValue( papszOptions, "GEOMETRY_NAME" );
if( pszGeometryName == NULL )
pszGeometryName = "ORA_GEOMETRY";
const bool bGeomNullable =
CPLFetchBool(const_cast<const char**>(papszOptions), "GEOMETRY_NULLABLE", true);
/* -------------------------------------------------------------------- */
/* Create a basic table with the FID. Also include the */
/* geometry if this is not a PostGIS enabled table. */
/* -------------------------------------------------------------------- */
const char *pszExpectedFIDName =
CPLGetConfigOption( "OCI_FID", "OGR_FID" );
OGROCIStatement oStatement( poSession );
/* -------------------------------------------------------------------- */
/* If geometry type is wkbNone, do not create a geometry column. */
/* -------------------------------------------------------------------- */
if ( CSLFetchNameValue( papszOptions, "TRUNCATE" ) == NULL )
{
if (eType == wkbNone)
{
snprintf( szCommand, sizeof(szCommand),
"CREATE TABLE \"%s\" ( "
"%s INTEGER PRIMARY KEY)",
pszSafeLayerName, pszExpectedFIDName);
}
else
{
snprintf( szCommand, sizeof(szCommand),
"CREATE TABLE \"%s\" ( "
"%s INTEGER PRIMARY KEY, "
"%s %s%s )",
pszSafeLayerName, pszExpectedFIDName,
pszGeometryName, SDO_GEOMETRY,
(!bGeomNullable) ? " NOT NULL":"");
}
if (bNoLogging)
{
char szCommand2[1024];
strncpy( szCommand2, szCommand, sizeof(szCommand) );
snprintf( szCommand, sizeof(szCommand), "%s NOLOGGING "
"VARRAY %s.SDO_ELEM_INFO STORE AS SECUREFILE LOB (NOCACHE NOLOGGING) "
"VARRAY %s.SDO_ORDINATES STORE AS SECUREFILE LOB (NOCACHE NOLOGGING) ",
szCommand2, pszGeometryName, pszGeometryName);
}
if( oStatement.Execute( szCommand ) != CE_None )
{
CPLFree( pszSafeLayerName );
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
const char *pszLoaderFile = CSLFetchNameValue(papszOptions,"LOADER_FILE");
OGROCIWritableLayer *poLayer;
if( pszLoaderFile == NULL )
poLayer = new OGROCITableLayer( this, pszSafeLayerName, eType,
EQUAL(szSRSId,"NULL") ? -1 : atoi(szSRSId),
TRUE, TRUE );
else
poLayer =
new OGROCILoaderLayer( this, pszSafeLayerName,
pszGeometryName,
EQUAL(szSRSId,"NULL") ? -1 : atoi(szSRSId),
pszLoaderFile );
/* -------------------------------------------------------------------- */
/* Set various options on the layer. */
/* -------------------------------------------------------------------- */
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions, "LAUNDER", false) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions, "PRECISION", true));
if( CSLFetchNameValue(papszOptions,"DIM") != NULL )
poLayer->SetDimension( atoi(CSLFetchNameValue(papszOptions,"DIM")) );
poLayer->SetOptions( papszOptions );
if( eType != wkbNone && !bGeomNullable )
poLayer->GetLayerDefn()->GetGeomFieldDefn(0)->SetNullable(FALSE);
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGROCILayer **)
CPLRealloc( papoLayers, sizeof(OGROCILayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
CPLFree( pszSafeLayerName );
return poLayer;
}
OGRLayer *
OGRPGDumpDataSource::ICreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
CPLString osCommand;
const char *pszGeomType = NULL;
char *pszTableName = NULL;
char *pszSchemaName = NULL;
int nDimension = 3;
int bHavePostGIS = TRUE;
const char* pszFIDColumnNameIn = CSLFetchNameValue(papszOptions, "FID");
CPLString osFIDColumnName, osFIDColumnNameEscaped;
if (pszFIDColumnNameIn == NULL)
osFIDColumnName = "ogc_fid";
else
{
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
{
char* pszLaunderedFid = OGRPGCommonLaunderName(pszFIDColumnNameIn, "PGDump");
osFIDColumnName = pszLaunderedFid;
CPLFree(pszLaunderedFid);
}
else
{
osFIDColumnName = pszFIDColumnNameIn;
}
}
osFIDColumnNameEscaped = OGRPGDumpEscapeColumnName(osFIDColumnName);
if (strncmp(pszLayerName, "pg", 2) == 0)
{
CPLError(CE_Warning, CPLE_AppDefined,
"The layer name should not begin by 'pg' as it is a reserved prefix");
}
//bHavePostGIS = CSLFetchBoolean(papszOptions,"POSTGIS", TRUE);
int bCreateTable = CSLFetchBoolean(papszOptions,"CREATE_TABLE", TRUE);
int bCreateSchema = CSLFetchBoolean(papszOptions,"CREATE_SCHEMA", TRUE);
const char* pszDropTable = CSLFetchNameValueDef(papszOptions,"DROP_TABLE", "IF_EXISTS");
if( wkbFlatten(eType) == eType )
nDimension = 2;
if( CSLFetchNameValue( papszOptions, "DIM") != NULL )
nDimension = atoi(CSLFetchNameValue( papszOptions, "DIM"));
/* Should we turn layers with None geometry type as Unknown/GEOMETRY */
/* so they are still recorded in geometry_columns table ? (#4012) */
int bNoneAsUnknown = CSLTestBoolean(CSLFetchNameValueDef(
papszOptions, "NONE_AS_UNKNOWN", "NO"));
if (bNoneAsUnknown && eType == wkbNone)
eType = wkbUnknown;
else if (eType == wkbNone)
bHavePostGIS = FALSE;
int bExtractSchemaFromLayerName = CSLTestBoolean(CSLFetchNameValueDef(
papszOptions, "EXTRACT_SCHEMA_FROM_LAYER_NAME", "YES"));
/* Postgres Schema handling:
Extract schema name from input layer name or passed with -lco SCHEMA.
Set layer name to "schema.table" or to "table" if schema == current_schema()
Usage without schema name is backwards compatible
*/
const char* pszDotPos = strstr(pszLayerName,".");
if ( pszDotPos != NULL && bExtractSchemaFromLayerName )
{
int length = pszDotPos - pszLayerName;
pszSchemaName = (char*)CPLMalloc(length+1);
strncpy(pszSchemaName, pszLayerName, length);
pszSchemaName[length] = '\0';
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
pszTableName = OGRPGCommonLaunderName( pszDotPos + 1, "PGDump" ); //skip "."
else
pszTableName = CPLStrdup( pszDotPos + 1 ); //skip "."
}
else
{
pszSchemaName = NULL;
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
pszTableName = OGRPGCommonLaunderName( pszLayerName, "PGDump" ); //skip "."
else
pszTableName = CPLStrdup( pszLayerName ); //skip "."
}
LogCommit();
/* -------------------------------------------------------------------- */
/* Set the default schema for the layers. */
/* -------------------------------------------------------------------- */
if( CSLFetchNameValue( papszOptions, "SCHEMA" ) != NULL )
{
CPLFree(pszSchemaName);
pszSchemaName = CPLStrdup(CSLFetchNameValue( papszOptions, "SCHEMA" ));
if (bCreateSchema)
{
osCommand.Printf("CREATE SCHEMA \"%s\"", pszSchemaName);
Log(osCommand);
}
}
if ( pszSchemaName == NULL)
{
pszSchemaName = CPLStrdup("public");
}
/* -------------------------------------------------------------------- */
/* Do we already have this layer? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n",
pszLayerName );
CPLFree( pszTableName );
CPLFree( pszSchemaName );
return NULL;
}
}
if (bCreateTable && (EQUAL(pszDropTable, "YES") ||
EQUAL(pszDropTable, "ON") ||
EQUAL(pszDropTable, "TRUE") ||
EQUAL(pszDropTable, "IF_EXISTS")))
{
if (EQUAL(pszDropTable, "IF_EXISTS"))
osCommand.Printf("DROP TABLE IF EXISTS \"%s\".\"%s\" CASCADE", pszSchemaName, pszTableName );
else
osCommand.Printf("DROP TABLE \"%s\".\"%s\" CASCADE", pszSchemaName, pszTableName );
Log(osCommand);
}
/* -------------------------------------------------------------------- */
/* Handle the GEOM_TYPE option. */
/* -------------------------------------------------------------------- */
pszGeomType = CSLFetchNameValue( papszOptions, "GEOM_TYPE" );
if( pszGeomType == NULL )
{
pszGeomType = "geometry";
}
if( !EQUAL(pszGeomType,"geometry") && !EQUAL(pszGeomType, "geography"))
{
CPLError( CE_Failure, CPLE_AppDefined,
"GEOM_TYPE in PostGIS enabled databases must be 'geometry' or 'geography'.\n"
"Creation of layer %s with GEOM_TYPE %s has failed.",
pszLayerName, pszGeomType );
CPLFree( pszTableName );
CPLFree( pszSchemaName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding tot the srs table if needed. */
/* -------------------------------------------------------------------- */
int nUnknownSRSId = -1;
const char* pszPostgisVersion = CSLFetchNameValue( papszOptions, "POSTGIS_VERSION" );
int bPostGIS2 = FALSE;
if( pszPostgisVersion != NULL && atoi(pszPostgisVersion) >= 2 )
{
bPostGIS2 = TRUE;
nUnknownSRSId = 0;
}
int nSRSId = nUnknownSRSId;
int nForcedSRSId = -2;
if( CSLFetchNameValue( papszOptions, "SRID") != NULL )
{
nSRSId = atoi(CSLFetchNameValue( papszOptions, "SRID"));
nForcedSRSId = nSRSId;
}
else
{
if (poSRS)
{
const char* pszAuthorityName = poSRS->GetAuthorityName(NULL);
if( pszAuthorityName != NULL && EQUAL( pszAuthorityName, "EPSG" ) )
{
/* Assume the EPSG Id is the SRS ID. Might be a wrong guess ! */
nSRSId = atoi( poSRS->GetAuthorityCode(NULL) );
}
else
{
const char* pszGeogCSName = poSRS->GetAttrValue("GEOGCS");
if (pszGeogCSName != NULL && EQUAL(pszGeogCSName, "GCS_WGS_1984"))
nSRSId = 4326;
}
}
}
CPLString osEscapedTableNameSingleQuote = OGRPGDumpEscapeString(pszTableName);
const char* pszEscapedTableNameSingleQuote = osEscapedTableNameSingleQuote.c_str();
const char *pszGeometryType = OGRToOGCGeomType(eType);
const char *pszGFldName = NULL;
if( bHavePostGIS && !EQUAL(pszGeomType, "geography"))
{
if( CSLFetchNameValue( papszOptions, "GEOMETRY_NAME") != NULL )
pszGFldName = CSLFetchNameValue( papszOptions, "GEOMETRY_NAME");
else
pszGFldName = "wkb_geometry";
if( pszPostgisVersion == NULL || atoi(pszPostgisVersion) < 2 )
{
/* Sometimes there is an old cruft entry in the geometry_columns
* table if things were not properly cleaned up before. We make
* an effort to clean out such cruft.
* Note: PostGIS 2.0 defines geometry_columns as a view (no clean up is needed)
*/
osCommand.Printf(
"DELETE FROM geometry_columns WHERE f_table_name = %s AND f_table_schema = '%s'",
pszEscapedTableNameSingleQuote, pszSchemaName );
if (bCreateTable)
Log(osCommand);
}
}
LogStartTransaction();
/* -------------------------------------------------------------------- */
/* Create a basic table with the FID. Also include the */
/* geometry if this is not a PostGIS enabled table. */
/* -------------------------------------------------------------------- */
int bFID64 = CSLFetchBoolean(papszOptions, "FID64", FALSE);
const char* pszSerialType = bFID64 ? "BIGSERIAL": "SERIAL";
CPLString osCreateTable;
int bTemporary = CSLFetchBoolean( papszOptions, "TEMPORARY", FALSE );
if (bTemporary)
{
CPLFree(pszSchemaName);
pszSchemaName = CPLStrdup("pg_temp_1");
osCreateTable.Printf("CREATE TEMPORARY TABLE \"%s\"", pszTableName);
}
else
osCreateTable.Printf("CREATE TABLE%s \"%s\".\"%s\"",
CSLFetchBoolean( papszOptions, "UNLOGGED", FALSE ) ? " UNLOGGED": "",
pszSchemaName, pszTableName);
if( !bHavePostGIS )
{
if (eType == wkbNone)
osCommand.Printf(
"%s ( "
" %s %s, "
" CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), osFIDColumnNameEscaped.c_str(), pszSerialType, pszTableName, osFIDColumnNameEscaped.c_str() );
else
osCommand.Printf(
"%s ( "
" %s %s, "
" WKB_GEOMETRY %s, "
" CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), osFIDColumnNameEscaped.c_str(), pszSerialType, pszGeomType, pszTableName, osFIDColumnNameEscaped.c_str() );
}
else if ( EQUAL(pszGeomType, "geography") )
{
if( CSLFetchNameValue( papszOptions, "GEOMETRY_NAME") != NULL )
pszGFldName = CSLFetchNameValue( papszOptions, "GEOMETRY_NAME");
else
pszGFldName = "the_geog";
if (nSRSId)
osCommand.Printf(
"%s ( %s %s, \"%s\" geography(%s%s,%d), CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), osFIDColumnNameEscaped.c_str(), pszSerialType, pszGFldName, pszGeometryType, nDimension == 2 ? "" : "Z", nSRSId, pszTableName, osFIDColumnNameEscaped.c_str() );
else
osCommand.Printf(
"%s ( %s %s, \"%s\" geography(%s%s), CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), osFIDColumnNameEscaped.c_str(), pszSerialType, pszGFldName, pszGeometryType, nDimension == 2 ? "" : "Z", pszTableName, osFIDColumnNameEscaped.c_str() );
}
else
{
osCommand.Printf(
"%s ( %s %s, CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), osFIDColumnNameEscaped.c_str(), pszSerialType, pszTableName, osFIDColumnNameEscaped.c_str() );
}
if (bCreateTable)
Log(osCommand);
/* -------------------------------------------------------------------- */
/* Eventually we should be adding this table to a table of */
/* "geometric layers", capturing the WKT projection, and */
/* perhaps some other housekeeping. */
/* -------------------------------------------------------------------- */
if( bCreateTable && bHavePostGIS && !EQUAL(pszGeomType, "geography"))
{
osCommand.Printf(
"SELECT AddGeometryColumn('%s',%s,'%s',%d,'%s',%d)",
pszSchemaName, pszEscapedTableNameSingleQuote, pszGFldName,
nSRSId, pszGeometryType, nDimension );
Log(osCommand);
}
const char *pszSI = CSLFetchNameValue( papszOptions, "SPATIAL_INDEX" );
int bCreateSpatialIndex = ( pszSI == NULL || CSLTestBoolean(pszSI) );
if( bCreateTable && bHavePostGIS && bCreateSpatialIndex )
{
/* -------------------------------------------------------------------- */
/* Create the spatial index. */
/* */
/* We're doing this before we add geometry and record to the table */
/* so this may not be exactly the best way to do it. */
/* -------------------------------------------------------------------- */
osCommand.Printf("CREATE INDEX \"%s_%s_geom_idx\" "
"ON \"%s\".\"%s\" "
"USING GIST (\"%s\")",
pszTableName, pszGFldName, pszSchemaName, pszTableName, pszGFldName);
Log(osCommand);
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRPGDumpLayer *poLayer;
int bWriteAsHex = !CSLFetchBoolean(papszOptions,"WRITE_EWKT_GEOM",FALSE);
poLayer = new OGRPGDumpLayer( this, pszSchemaName, pszTableName,
osFIDColumnName, bWriteAsHex, bCreateTable );
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
const char* pszOverrideColumnTypes = CSLFetchNameValue( papszOptions, "COLUMN_TYPES" );
poLayer->SetOverrideColumnTypes(pszOverrideColumnTypes);
poLayer->SetUnknownSRSId(nUnknownSRSId);
poLayer->SetForcedSRSId(nForcedSRSId);
poLayer->SetCreateSpatialIndexFlag(bCreateSpatialIndex);
poLayer->SetPostGIS2(bPostGIS2);
if( bHavePostGIS )
{
OGRGeomFieldDefn oTmp( pszGFldName, eType );
OGRPGDumpGeomFieldDefn *poGeomField =
new OGRPGDumpGeomFieldDefn(&oTmp);
poGeomField->nSRSId = nSRSId;
poGeomField->nCoordDimension = nDimension;
poLayer->GetLayerDefn()->AddGeomFieldDefn(poGeomField, FALSE);
}
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRPGDumpLayer **)
CPLRealloc( papoLayers, sizeof(OGRPGDumpLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
CPLFree( pszTableName );
CPLFree( pszSchemaName );
return poLayer;
}
OGRLayer *GNMGenericNetwork::GetPath(GNMGFID nStartFID, GNMGFID nEndFID,
GNMGraphAlgorithmType eAlgorithm, char **papszOptions)
{
if(!m_bIsGraphLoaded && LoadGraph() != CE_None)
{
return NULL;
}
GDALDriver* poMEMDrv =
OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName("Memory");
if (poMEMDrv == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load 'Memory' driver");
return NULL;
}
GDALDataset* poMEMDS =
poMEMDrv->Create("dummy_name", 0, 0, 0, GDT_Unknown, NULL);
OGRSpatialReference oDstSpaRef(GetProjectionRef());
OGRLayer* poMEMLayer = poMEMDS->CreateLayer(GetAlgorithmName(eAlgorithm,
true), &oDstSpaRef, wkbGeometryCollection, NULL);
OGRGNMWrappedResultLayer* poResLayer =
new OGRGNMWrappedResultLayer(poMEMDS, poMEMLayer);
bool bReturnEdges = CSLFetchBoolean(papszOptions, GNM_MD_FETCHEDGES, TRUE);
bool bReturnVertices = CSLFetchBoolean(papszOptions, GNM_MD_FETCHVERTEX, TRUE);
switch (eAlgorithm)
{
case GATDijkstraShortestPath:
{
GNMPATH path = m_oGraph.DijkstraShortestPath(nStartFID, nEndFID);
// fill features in result layer
FillResultLayer(poResLayer, path, 1, bReturnVertices, bReturnEdges);
}
break;
case GATKShortestPath:
{
int nK = atoi(CSLFetchNameValueDef(papszOptions, GNM_MD_NUM_PATHS,
"1"));
CPLDebug("GNM", "Search %d path(s)", nK);
std::vector<GNMPATH> paths = m_oGraph.KShortestPaths(nStartFID,
nEndFID, nK);
// fill features in result layer
for(size_t i = 0; i < paths.size(); ++i)
{
FillResultLayer(poResLayer, paths[i], i + 1, bReturnVertices,
bReturnEdges);
}
}
break;
case GATConnectedComponents:
{
GNMVECTOR anEmitters;
if(NULL != papszOptions)
{
char** papszEmitter = CSLFetchNameValueMultiple(papszOptions, GNM_MD_EMITTER);
for(int i = 0; papszEmitter[i] != NULL; ++i)
{
GNMGFID nEmitter = atol(papszEmitter[i]);
anEmitters.push_back(nEmitter);
}
}
if(nStartFID != -1)
{
anEmitters.push_back(nStartFID);
}
if(nStartFID != -1)
{
anEmitters.push_back(nEndFID);
}
GNMPATH path = m_oGraph.ConnectedComponents(anEmitters);
// fill features in result layer
FillResultLayer(poResLayer, path, 1, bReturnVertices, bReturnEdges);
}
break;
}
return poResLayer;
}
bool GDALUtilities::createRasterFile(QString& theFilename,
QString& theFormat,
GDALDataType theType,
int theBands,
int theRows,
int theCols,
void ** theData,
double * theGeoTransform,
const QgsCoordinateReferenceSystem * theCrs,
double theNodataValue)
{
if ( theBands <= 0 )
return false;
if ( theRows <= 0 )
return false;
if ( theCols <= 0 )
return false;
if ( !theData )
return false;
/* bool formatSupported = false;
QMapIterator<QString, QString> i(mSupportedFormats);
while (i.hasNext())
{
i.next();
if( theFormat == i.key())
{
formatSupported = true;
break;
}
}
if ( !formatSupported )
return false;
*/
//GDALAllRegister();
GDALDriver * driver;
//set format
char * format = new char[theFormat.size() + 1];
strcpy( format, theFormat.toLocal8Bit().data() );
driver = GetGDALDriverManager()->GetDriverByName(format);
if( driver == NULL )
return false;
char ** metadata = driver->GetMetadata();
if( !CSLFetchBoolean( metadata, GDAL_DCAP_CREATE, FALSE ) )
return false;
GDALDataset * dstDS;
//set options
char ** options = NULL;
options = CSLSetNameValue( options, "COMPRESS", "LZW" );
//if it is a GeoTIFF format set correct compression options
if ( !strcmp( format, "GTiff" ) )
{
if( theType == GDT_Byte )
{
options = CSLSetNameValue( options, "PREDICTOR", "1" );
}
else
{
if ( theType == GDT_UInt16 || theType == GDT_Int16
|| theType == GDT_UInt32 || theType == GDT_Int32 )
{
options = CSLSetNameValue( options, "PREDICTOR", "2" );
}
else
{
options = CSLSetNameValue( options, "PREDICTOR", "3" );
}
}
}
//set filename
char * dstFilename = new char[theFilename.size() + 1];
strcpy( dstFilename, theFilename.toLocal8Bit().data() );
dstDS = driver->Create( dstFilename, theCols, theRows, theBands, theType,
options );
delete dstFilename;
delete [] options;
//set geotransform
dstDS->SetGeoTransform( theGeoTransform );
//set CRS
char * crsWkt = new char[theCrs->toWkt().size() + 1];
strcpy( crsWkt, theCrs->toWkt().toLocal8Bit().data());
dstDS->SetProjection( crsWkt );
delete crsWkt;
GDALRasterBand * band;
for( int i=1; i <= theBands; i++ )
{
band = dstDS->GetRasterBand( i );
band->SetNoDataValue( theNodataValue );
band->RasterIO( GF_Write, 0, 0, theCols, theRows, theData[ i-1 ],
theCols, theRows, theType, 0, 0);
}
GDALClose( (GDALDatasetH) dstDS );
return true;
}
CPLErr VRTDataset::AddBand( GDALDataType eType, char **papszOptions )
{
int i;
const char *pszSubClass = CSLFetchNameValue(papszOptions, "subclass");
bNeedsFlush = 1;
/* ==================================================================== */
/* Handle a new raw band. */
/* ==================================================================== */
if( pszSubClass != NULL && EQUAL(pszSubClass,"VRTRawRasterBand") )
{
int nWordDataSize = GDALGetDataTypeSize( eType ) / 8;
vsi_l_offset nImageOffset = 0;
int nPixelOffset = nWordDataSize;
int nLineOffset = nWordDataSize * GetRasterXSize();
const char *pszFilename;
const char *pszByteOrder = NULL;
int bRelativeToVRT = FALSE;
/* -------------------------------------------------------------------- */
/* Collect required information. */
/* -------------------------------------------------------------------- */
if( CSLFetchNameValue(papszOptions, "ImageOffset") != NULL )
nImageOffset = atoi(CSLFetchNameValue(papszOptions, "ImageOffset"));
if( CSLFetchNameValue(papszOptions, "PixelOffset") != NULL )
nPixelOffset = atoi(CSLFetchNameValue(papszOptions,"PixelOffset"));
if( CSLFetchNameValue(papszOptions, "LineOffset") != NULL )
nLineOffset = atoi(CSLFetchNameValue(papszOptions, "LineOffset"));
if( CSLFetchNameValue(papszOptions, "ByteOrder") != NULL )
pszByteOrder = CSLFetchNameValue(papszOptions, "ByteOrder");
if( CSLFetchNameValue(papszOptions, "SourceFilename") != NULL )
pszFilename = CSLFetchNameValue(papszOptions, "SourceFilename");
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"AddBand() requires a SourceFilename option for VRTRawRasterBands." );
return CE_Failure;
}
bRelativeToVRT =
CSLFetchBoolean( papszOptions, "RelativeToVRT", FALSE );
/* -------------------------------------------------------------------- */
/* Create and initialize the band. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
VRTRawRasterBand *poBand =
new VRTRawRasterBand( this, GetRasterCount() + 1, eType );
eErr =
poBand->SetRawLink( pszFilename, NULL, FALSE,
nImageOffset, nPixelOffset, nLineOffset,
pszByteOrder );
if( eErr != CE_None )
{
delete poBand;
return eErr;
}
SetBand( GetRasterCount() + 1, poBand );
return CE_None;
}
/* ==================================================================== */
/* Handle a new "sourced" band. */
/* ==================================================================== */
else
{
VRTSourcedRasterBand *poBand;
/* ---- Check for our sourced band 'derived' subclass ---- */
if(pszSubClass != NULL && EQUAL(pszSubClass,"VRTDerivedRasterBand")) {
/* We'll need a pointer to the subclass in case we need */
/* to set the new band's pixel function below. */
VRTDerivedRasterBand* poDerivedBand;
poDerivedBand = new VRTDerivedRasterBand
(this, GetRasterCount() + 1, eType,
GetRasterXSize(), GetRasterYSize());
/* Set the pixel function options it provided. */
const char* pszFuncName =
CSLFetchNameValue(papszOptions, "PixelFunctionType");
if (pszFuncName != NULL)
poDerivedBand->SetPixelFunctionName(pszFuncName);
const char* pszTransferTypeName =
CSLFetchNameValue(papszOptions, "SourceTransferType");
if (pszTransferTypeName != NULL) {
GDALDataType eTransferType =
GDALGetDataTypeByName(pszTransferTypeName);
if (eTransferType == GDT_Unknown) {
CPLError( CE_Failure, CPLE_AppDefined,
"invalid SourceTransferType: \"%s\".",
pszTransferTypeName);
delete poDerivedBand;
return CE_Failure;
}
poDerivedBand->SetSourceTransferType(eTransferType);
}
/* We're done with the derived band specific stuff, so */
/* we can assigned the base class pointer now. */
poBand = poDerivedBand;
}
else {
/* ---- Standard sourced band ---- */
poBand = new VRTSourcedRasterBand
(this, GetRasterCount() + 1, eType,
GetRasterXSize(), GetRasterYSize());
}
SetBand( GetRasterCount() + 1, poBand );
for( i=0; papszOptions != NULL && papszOptions[i] != NULL; i++ )
{
if( EQUALN(papszOptions[i],"AddFuncSource=", 14) )
{
VRTImageReadFunc pfnReadFunc = NULL;
void *pCBData = NULL;
double dfNoDataValue = VRT_NODATA_UNSET;
char **papszTokens = CSLTokenizeStringComplex( papszOptions[i]+14,
",", TRUE, FALSE );
if( CSLCount(papszTokens) < 1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"AddFuncSource() ... required argument missing." );
}
sscanf( papszTokens[0], "%p", &pfnReadFunc );
if( CSLCount(papszTokens) > 1 )
sscanf( papszTokens[1], "%p", &pCBData );
if( CSLCount(papszTokens) > 2 )
dfNoDataValue = atof( papszTokens[2] );
poBand->AddFuncSource( pfnReadFunc, pCBData, dfNoDataValue );
}
}
return CE_None;
}
}
int OGRBNADataSource::Create( const char *pszFilename,
char **papszOptions )
{
if( fpOutput != NULL)
{
CPLAssert( FALSE );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Do not override exiting file. */
/* -------------------------------------------------------------------- */
VSIStatBufL sStatBuf;
if( VSIStatL( pszFilename, &sStatBuf ) == 0 )
return FALSE;
/* -------------------------------------------------------------------- */
/* Create the output file. */
/* -------------------------------------------------------------------- */
pszName = CPLStrdup( pszFilename );
if( EQUAL(pszFilename,"stdout") )
fpOutput = VSIFOpenL( "/vsistdout/", "wb" );
else
fpOutput = VSIFOpenL( pszFilename, "wb" );
if( fpOutput == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create BNA file %s.",
pszFilename );
return FALSE;
}
/* EOL token */
const char *pszCRLFFormat = CSLFetchNameValue( papszOptions, "LINEFORMAT");
if( pszCRLFFormat == NULL )
{
#ifdef WIN32
bUseCRLF = TRUE;
#else
bUseCRLF = FALSE;
#endif
}
else if( EQUAL(pszCRLFFormat,"CRLF") )
bUseCRLF = TRUE;
else if( EQUAL(pszCRLFFormat,"LF") )
bUseCRLF = FALSE;
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"LINEFORMAT=%s not understood, use one of CRLF or LF.",
pszCRLFFormat );
#ifdef WIN32
bUseCRLF = TRUE;
#else
bUseCRLF = FALSE;
#endif
}
/* Multi line or single line format ? */
bMultiLine = CSLFetchBoolean( papszOptions, "MULTILINE", TRUE);
/* Number of identifiers per record */
const char* pszNbOutID = CSLFetchNameValue ( papszOptions, "NB_IDS");
if (pszNbOutID == NULL)
{
nbOutID = NB_MIN_BNA_IDS;
}
else if (EQUAL(pszNbOutID, "NB_SOURCE_FIELDS"))
{
nbOutID = -1;
}
else
{
nbOutID = atoi(pszNbOutID);
if (nbOutID <= 0)
{
CPLError( CE_Warning, CPLE_AppDefined,
"NB_ID=%s not understood. Must be >=%d and <=%d or equal to NB_SOURCE_FIELDS",
pszNbOutID, NB_MIN_BNA_IDS, NB_MAX_BNA_IDS );
nbOutID = NB_MIN_BNA_IDS;
}
if (nbOutID > NB_MAX_BNA_IDS)
{
CPLError( CE_Warning, CPLE_AppDefined,
"NB_ID=%s not understood. Must be >=%d and <=%d or equal to NB_SOURCE_FIELDS",
pszNbOutID, NB_MIN_BNA_IDS, NB_MAX_BNA_IDS );
nbOutID = NB_MAX_BNA_IDS;
}
}
/* Ellipses export as ellipses or polygons ? */
bEllipsesAsEllipses = CSLFetchBoolean( papszOptions, "ELLIPSES_AS_ELLIPSES", TRUE);
/* Number of coordinate pairs per line */
const char* pszNbPairPerLine = CSLFetchNameValue( papszOptions, "NB_PAIRS_PER_LINE");
if (pszNbPairPerLine)
{
nbPairPerLine = atoi(pszNbPairPerLine);
if (nbPairPerLine <= 0)
nbPairPerLine = (bMultiLine == FALSE) ? 1000000000 : 1;
if (bMultiLine == FALSE)
{
CPLError( CE_Warning, CPLE_AppDefined, "NB_PAIR_PER_LINE option is ignored when MULTILINE=NO");
}
}
else
{
nbPairPerLine = (bMultiLine == FALSE) ? 1000000000 : 1;
}
/* Coordinate precision */
const char* pszCoordinatePrecision = CSLFetchNameValue( papszOptions, "COORDINATE_PRECISION");
if (pszCoordinatePrecision)
{
coordinatePrecision = atoi(pszCoordinatePrecision);
if (coordinatePrecision <= 0)
coordinatePrecision = 0;
else if (coordinatePrecision >= 20)
coordinatePrecision = 20;
}
else
{
coordinatePrecision = 10;
}
pszCoordinateSeparator = (char*)CSLFetchNameValue( papszOptions, "COORDINATE_SEPARATOR");
if (pszCoordinateSeparator == NULL)
pszCoordinateSeparator = CPLStrdup(",");
else
pszCoordinateSeparator = CPLStrdup(pszCoordinateSeparator);
return TRUE;
}
OGRLayer *OGRDGNDataSource::CreateLayer( const char *pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eGeomType,
char **papszExtraOptions )
{
const char *pszSeed, *pszMasterUnit = "m", *pszSubUnit = "cm";
const char *pszValue;
int nUORPerSU=1, nSUPerMU=100;
int nCreationFlags = 0, b3DRequested;
double dfOriginX = -21474836.0, /* default origin centered on zero */
dfOriginY = -21474836.0, /* with two decimals of precision */
dfOriginZ = -21474836.0;
/* -------------------------------------------------------------------- */
/* Ensure only one layer gets created. */
/* -------------------------------------------------------------------- */
if( nLayers > 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"DGN driver only supports one layer will all the elements in it." );
return NULL;
}
/* -------------------------------------------------------------------- */
/* If the coordinate system is geographic, we should use a */
/* localized default origin and resolution. */
/* -------------------------------------------------------------------- */
if( poSRS != NULL && poSRS->IsGeographic() )
{
dfOriginX = -200.0;
dfOriginY = -200.0;
pszMasterUnit = "d";
pszSubUnit = "s";
nSUPerMU = 3600;
nUORPerSU = 1000;
}
/* -------------------------------------------------------------------- */
/* Parse out various creation options. */
/* -------------------------------------------------------------------- */
CSLInsertStrings( papszOptions, 0, papszExtraOptions );
b3DRequested = CSLFetchBoolean( papszOptions, "3D",
(((int) eGeomType) & wkb25DBit) );
pszSeed = CSLFetchNameValue( papszOptions, "SEED" );
if( pszSeed )
nCreationFlags |= DGNCF_USE_SEED_ORIGIN | DGNCF_USE_SEED_UNITS;
else if( b3DRequested )
pszSeed = CPLFindFile( "gdal", "seed_3d.dgn" );
else
pszSeed = CPLFindFile( "gdal", "seed_2d.dgn" );
if( pszSeed == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"No seed file provided, and unable to find seed_2d.dgn." );
return NULL;
}
if( CSLFetchBoolean( papszOptions, "COPY_WHOLE_SEED_FILE", TRUE ) )
nCreationFlags |= DGNCF_COPY_WHOLE_SEED_FILE;
if( CSLFetchBoolean( papszOptions, "COPY_SEED_FILE_COLOR_TABLE", TRUE ) )
nCreationFlags |= DGNCF_COPY_SEED_FILE_COLOR_TABLE;
pszValue = CSLFetchNameValue( papszOptions, "MASTER_UNIT_NAME" );
if( pszValue != NULL )
{
nCreationFlags &= ~DGNCF_USE_SEED_UNITS;
pszMasterUnit = pszValue;
}
pszValue = CSLFetchNameValue( papszOptions, "SUB_UNIT_NAME" );
if( pszValue != NULL )
{
nCreationFlags &= ~DGNCF_USE_SEED_UNITS;
pszSubUnit = pszValue;
}
pszValue = CSLFetchNameValue( papszOptions, "SUB_UNITS_PER_MASTER_UNIT" );
if( pszValue != NULL )
{
nCreationFlags &= ~DGNCF_USE_SEED_UNITS;
nSUPerMU = atoi(pszValue);
}
pszValue = CSLFetchNameValue( papszOptions, "UOR_PER_SUB_UNIT" );
if( pszValue != NULL )
{
nCreationFlags &= ~DGNCF_USE_SEED_UNITS;
nUORPerSU = atoi(pszValue);
}
pszValue = CSLFetchNameValue( papszOptions, "ORIGIN" );
if( pszValue != NULL )
{
char **papszTuple = CSLTokenizeStringComplex( pszValue, " ,",
FALSE, FALSE );
nCreationFlags &= ~DGNCF_USE_SEED_ORIGIN;
if( CSLCount(papszTuple) == 3 )
{
dfOriginX = atof(papszTuple[0]);
dfOriginY = atof(papszTuple[1]);
dfOriginZ = atof(papszTuple[2]);
}
else if( CSLCount(papszTuple) == 2 )
{
dfOriginX = atof(papszTuple[0]);
dfOriginY = atof(papszTuple[1]);
dfOriginZ = 0.0;
}
else
{
CSLDestroy(papszTuple);
CPLError( CE_Failure, CPLE_AppDefined,
"ORIGIN is not a valid 2d or 3d tuple.\n"
"Separate tuple values with comma." );
return FALSE;
}
CSLDestroy(papszTuple);
}
/* -------------------------------------------------------------------- */
/* Try creating the base file. */
/* -------------------------------------------------------------------- */
hDGN = DGNCreate( pszName, pszSeed, nCreationFlags,
dfOriginX, dfOriginY, dfOriginZ,
nSUPerMU, nUORPerSU, pszMasterUnit, pszSubUnit );
if( hDGN == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRDGNLayer *poLayer;
poLayer = new OGRDGNLayer( pszLayerName, hDGN, TRUE );
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRDGNLayer **)
CPLRealloc( papoLayers, sizeof(OGRDGNLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
return poLayer;
}
OGRLayer *
OGROCIDataSource::CreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
char szCommand[1024];
char *pszSafeLayerName = CPLStrdup(pszLayerName);
poSession->CleanName( pszSafeLayerName );
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszSafeLayerName,
papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( pszSafeLayerName );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszSafeLayerName );
CPLFree( pszSafeLayerName );
return NULL;
}
}
}
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding tot the srs table if needed. */
/* -------------------------------------------------------------------- */
char szSRSId[100];
if( CSLFetchNameValue( papszOptions, "SRID" ) != NULL )
strcpy( szSRSId, CSLFetchNameValue( papszOptions, "SRID" ) );
else if( poSRS != NULL )
sprintf( szSRSId, "%d", FetchSRSId( poSRS ) );
else
strcpy( szSRSId, "NULL" );
/* -------------------------------------------------------------------- */
/* Determine name of geometry column to use. */
/* -------------------------------------------------------------------- */
const char *pszGeometryName =
CSLFetchNameValue( papszOptions, "GEOMETRY_NAME" );
if( pszGeometryName == NULL )
pszGeometryName = "ORA_GEOMETRY";
/* -------------------------------------------------------------------- */
/* Create a basic table with the FID. Also include the */
/* geometry if this is not a PostGIS enabled table. */
/* -------------------------------------------------------------------- */
const char *pszExpectedFIDName =
CPLGetConfigOption( "OCI_FID", "OGR_FID" );
OGROCIStatement oStatement( poSession );
/* -------------------------------------------------------------------- */
/* If geometry type is wkbNone, do not create a geoemtry column */
/* -------------------------------------------------------------------- */
if (eType == wkbNone)
{
sprintf( szCommand,
"CREATE TABLE \"%s\" ( "
"%s INTEGER)",
pszSafeLayerName, pszExpectedFIDName);
}
else
{
sprintf( szCommand,
"CREATE TABLE \"%s\" ( "
"%s INTEGER, "
"%s %s )",
pszSafeLayerName, pszExpectedFIDName, pszGeometryName, SDO_GEOMETRY );
}
if( oStatement.Execute( szCommand ) != CE_None )
{
CPLFree( pszSafeLayerName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
const char *pszLoaderFile = CSLFetchNameValue(papszOptions,"LOADER_FILE");
OGROCIWritableLayer *poLayer;
if( pszLoaderFile == NULL )
poLayer = new OGROCITableLayer( this, pszSafeLayerName,
EQUAL(szSRSId,"NULL") ? -1 : atoi(szSRSId),
TRUE, TRUE );
else
poLayer =
new OGROCILoaderLayer( this, pszSafeLayerName,
pszGeometryName,
EQUAL(szSRSId,"NULL") ? -1 : atoi(szSRSId),
pszLoaderFile );
/* -------------------------------------------------------------------- */
/* Set various options on the layer. */
/* -------------------------------------------------------------------- */
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",FALSE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
if( CSLFetchNameValue(papszOptions,"DIM") != NULL )
poLayer->SetDimension( atoi(CSLFetchNameValue(papszOptions,"DIM")) );
poLayer->SetOptions( papszOptions );
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGROCILayer **)
CPLRealloc( papoLayers, sizeof(OGROCILayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
CPLFree( pszSafeLayerName );
return poLayer;
}
CPLErr GDALRasterizeGeometries( GDALDatasetH hDS,
int nBandCount, int *panBandList,
int nGeomCount, OGRGeometryH *pahGeometries,
GDALTransformerFunc pfnTransformer,
void *pTransformArg,
double *padfGeomBurnValue,
char **papszOptions,
GDALProgressFunc pfnProgress,
void *pProgressArg )
{
GDALDataType eType;
int nYChunkSize, nScanlineBytes;
unsigned char *pabyChunkBuf;
int iY;
GDALDataset *poDS = (GDALDataset *) hDS;
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
/* -------------------------------------------------------------------- */
/* Do some rudimentary arg checking. */
/* -------------------------------------------------------------------- */
if( nBandCount == 0 || nGeomCount == 0 )
return CE_None;
// prototype band.
GDALRasterBand *poBand = poDS->GetRasterBand( panBandList[0] );
if (poBand == NULL)
return CE_Failure;
int bAllTouched = CSLFetchBoolean( papszOptions, "ALL_TOUCHED", FALSE );
const char *pszOpt = CSLFetchNameValue( papszOptions, "BURN_VALUE_FROM" );
GDALBurnValueSrc eBurnValueSource = GBV_UserBurnValue;
if( pszOpt )
{
if( EQUAL(pszOpt,"Z"))
eBurnValueSource = GBV_Z;
/*else if( EQUAL(pszOpt,"M"))
eBurnValueSource = GBV_M;*/
}
/* -------------------------------------------------------------------- */
/* If we have no transformer, assume the geometries are in file */
/* georeferenced coordinates, and create a transformer to */
/* convert that to pixel/line coordinates. */
/* */
/* We really just need to apply an affine transform, but for */
/* simplicity we use the more general GenImgProjTransformer. */
/* -------------------------------------------------------------------- */
int bNeedToFreeTransformer = FALSE;
if( pfnTransformer == NULL )
{
bNeedToFreeTransformer = TRUE;
pTransformArg =
GDALCreateGenImgProjTransformer( NULL, NULL, hDS, NULL,
FALSE, 0.0, 0);
pfnTransformer = GDALGenImgProjTransform;
}
/* -------------------------------------------------------------------- */
/* Establish a chunksize to operate on. The larger the chunk */
/* size the less times we need to make a pass through all the */
/* shapes. */
/* -------------------------------------------------------------------- */
if( poBand->GetRasterDataType() == GDT_Byte )
eType = GDT_Byte;
else
eType = GDT_Float32;
nScanlineBytes = nBandCount * poDS->GetRasterXSize()
* (GDALGetDataTypeSize(eType)/8);
nYChunkSize = 10000000 / nScanlineBytes;
if( nYChunkSize > poDS->GetRasterYSize() )
nYChunkSize = poDS->GetRasterYSize();
pabyChunkBuf = (unsigned char *) VSIMalloc(nYChunkSize * nScanlineBytes);
if( pabyChunkBuf == NULL )
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"Unable to allocate rasterization buffer." );
return CE_Failure;
}
/* ==================================================================== */
/* Loop over image in designated chunks. */
/* ==================================================================== */
CPLErr eErr = CE_None;
pfnProgress( 0.0, NULL, pProgressArg );
for( iY = 0;
iY < poDS->GetRasterYSize() && eErr == CE_None;
iY += nYChunkSize )
{
int nThisYChunkSize;
int iShape;
nThisYChunkSize = nYChunkSize;
if( nThisYChunkSize + iY > poDS->GetRasterYSize() )
nThisYChunkSize = poDS->GetRasterYSize() - iY;
eErr =
poDS->RasterIO(GF_Read,
0, iY, poDS->GetRasterXSize(), nThisYChunkSize,
pabyChunkBuf,poDS->GetRasterXSize(),nThisYChunkSize,
eType, nBandCount, panBandList,
0, 0, 0 );
if( eErr != CE_None )
break;
for( iShape = 0; iShape < nGeomCount; iShape++ )
{
gv_rasterize_one_shape( pabyChunkBuf, iY,
poDS->GetRasterXSize(), nThisYChunkSize,
nBandCount, eType, bAllTouched,
(OGRGeometry *) pahGeometries[iShape],
padfGeomBurnValue + iShape*nBandCount,
eBurnValueSource,
pfnTransformer, pTransformArg );
}
eErr =
poDS->RasterIO( GF_Write, 0, iY,
poDS->GetRasterXSize(), nThisYChunkSize,
pabyChunkBuf,
poDS->GetRasterXSize(), nThisYChunkSize,
eType, nBandCount, panBandList, 0, 0, 0 );
if( !pfnProgress((iY+nThisYChunkSize)/((double)poDS->GetRasterYSize()),
"", pProgressArg ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
eErr = CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* cleanup */
/* -------------------------------------------------------------------- */
VSIFree( pabyChunkBuf );
if( bNeedToFreeTransformer )
GDALDestroyTransformer( pTransformArg );
return eErr;
}
CPLErr GDALRasterizeLayers( GDALDatasetH hDS,
int nBandCount, int *panBandList,
int nLayerCount, OGRLayerH *pahLayers,
GDALTransformerFunc pfnTransformer,
void *pTransformArg,
double *padfLayerBurnValues,
char **papszOptions,
GDALProgressFunc pfnProgress,
void *pProgressArg )
{
GDALDataType eType;
unsigned char *pabyChunkBuf;
GDALDataset *poDS = (GDALDataset *) hDS;
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
/* -------------------------------------------------------------------- */
/* Do some rudimentary arg checking. */
/* -------------------------------------------------------------------- */
if( nBandCount == 0 || nLayerCount == 0 )
return CE_None;
// prototype band.
GDALRasterBand *poBand = poDS->GetRasterBand( panBandList[0] );
if (poBand == NULL)
return CE_Failure;
int bAllTouched = CSLFetchBoolean( papszOptions, "ALL_TOUCHED", FALSE );
const char *pszOpt = CSLFetchNameValue( papszOptions, "BURN_VALUE_FROM" );
GDALBurnValueSrc eBurnValueSource = GBV_UserBurnValue;
if( pszOpt )
{
if( EQUAL(pszOpt,"Z"))
eBurnValueSource = GBV_Z;
/*else if( EQUAL(pszOpt,"M"))
eBurnValueSource = GBV_M;*/
}
/* -------------------------------------------------------------------- */
/* Establish a chunksize to operate on. The larger the chunk */
/* size the less times we need to make a pass through all the */
/* shapes. */
/* -------------------------------------------------------------------- */
int nYChunkSize, nScanlineBytes;
const char *pszYChunkSize =
CSLFetchNameValue( papszOptions, "CHUNKYSIZE" );
if( poBand->GetRasterDataType() == GDT_Byte )
eType = GDT_Byte;
else
eType = GDT_Float32;
nScanlineBytes = nBandCount * poDS->GetRasterXSize()
* (GDALGetDataTypeSize(eType)/8);
if ( pszYChunkSize && (nYChunkSize = atoi(pszYChunkSize)) )
;
else
nYChunkSize = GDALGetCacheMax() / nScanlineBytes;
if( nYChunkSize < 1 )
nYChunkSize = 1;
if( nYChunkSize > poDS->GetRasterYSize() )
nYChunkSize = poDS->GetRasterYSize();
pabyChunkBuf = (unsigned char *) VSIMalloc(nYChunkSize * nScanlineBytes);
if( pabyChunkBuf == NULL )
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"Unable to allocate rasterization buffer." );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Read the image once for all layers if user requested to render */
/* the whole raster in single chunk. */
/* -------------------------------------------------------------------- */
if ( nYChunkSize == poDS->GetRasterYSize() )
{
if ( poDS->RasterIO( GF_Read, 0, 0, poDS->GetRasterXSize(),
nYChunkSize, pabyChunkBuf,
poDS->GetRasterXSize(), nYChunkSize,
eType, nBandCount, panBandList, 0, 0, 0 )
!= CE_None )
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"Unable to read buffer." );
CPLFree( pabyChunkBuf );
return CE_Failure;
}
}
/* ==================================================================== */
/* Read the specified layers transfoming and rasterizing */
/* geometries. */
/* ==================================================================== */
CPLErr eErr = CE_None;
int iLayer;
const char *pszBurnAttribute =
CSLFetchNameValue( papszOptions, "ATTRIBUTE" );
pfnProgress( 0.0, NULL, pProgressArg );
for( iLayer = 0; iLayer < nLayerCount; iLayer++ )
{
int iBurnField = -1;
double *padfBurnValues = NULL;
OGRLayer *poLayer = (OGRLayer *) pahLayers[iLayer];
if ( !poLayer )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Layer element number %d is NULL, skipping.\n", iLayer );
continue;
}
/* -------------------------------------------------------------------- */
/* If the layer does not contain any features just skip it. */
/* Do not force the feature count, so if driver doesn't know */
/* exact number of features, go down the normal way. */
/* -------------------------------------------------------------------- */
if ( poLayer->GetFeatureCount(FALSE) == 0 )
continue;
if ( pszBurnAttribute )
{
iBurnField =
poLayer->GetLayerDefn()->GetFieldIndex( pszBurnAttribute );
if ( iBurnField == -1 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Failed to find field %s on layer %s, skipping.\n",
pszBurnAttribute,
poLayer->GetLayerDefn()->GetName() );
continue;
}
}
else
padfBurnValues = padfLayerBurnValues + iLayer * nBandCount;
/* -------------------------------------------------------------------- */
/* If we have no transformer, create the one from input file */
/* projection. Note that each layer can be georefernced */
/* separately. */
/* -------------------------------------------------------------------- */
int bNeedToFreeTransformer = FALSE;
if( pfnTransformer == NULL )
{
char *pszProjection = NULL;
bNeedToFreeTransformer = TRUE;
OGRSpatialReference *poSRS = poLayer->GetSpatialRef();
if ( !poSRS )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Failed to fetch spatial reference on layer %s "
"to build transformer, assuming matching coordinate systems.\n",
poLayer->GetLayerDefn()->GetName() );
}
else
poSRS->exportToWkt( &pszProjection );
pTransformArg =
GDALCreateGenImgProjTransformer( NULL, pszProjection,
hDS, NULL, FALSE, 0.0, 0 );
pfnTransformer = GDALGenImgProjTransform;
CPLFree( pszProjection );
}
OGRFeature *poFeat;
poLayer->ResetReading();
/* -------------------------------------------------------------------- */
/* Loop over image in designated chunks. */
/* -------------------------------------------------------------------- */
int iY;
for( iY = 0;
iY < poDS->GetRasterYSize() && eErr == CE_None;
iY += nYChunkSize )
{
int nThisYChunkSize;
nThisYChunkSize = nYChunkSize;
if( nThisYChunkSize + iY > poDS->GetRasterYSize() )
nThisYChunkSize = poDS->GetRasterYSize() - iY;
// Only re-read image if not a single chunk is being rendered
if ( nYChunkSize < poDS->GetRasterYSize() )
{
eErr =
poDS->RasterIO( GF_Read, 0, iY,
poDS->GetRasterXSize(), nThisYChunkSize,
pabyChunkBuf,
poDS->GetRasterXSize(), nThisYChunkSize,
eType, nBandCount, panBandList, 0, 0, 0 );
if( eErr != CE_None )
break;
}
double *padfAttrValues = (double *) VSIMalloc(sizeof(double) * nBandCount);
while( (poFeat = poLayer->GetNextFeature()) != NULL )
{
OGRGeometry *poGeom = poFeat->GetGeometryRef();
if ( pszBurnAttribute )
{
int iBand;
double dfAttrValue;
dfAttrValue = poFeat->GetFieldAsDouble( iBurnField );
for (iBand = 0 ; iBand < nBandCount ; iBand++)
padfAttrValues[iBand] = dfAttrValue;
padfBurnValues = padfAttrValues;
}
gv_rasterize_one_shape( pabyChunkBuf, iY,
poDS->GetRasterXSize(),
nThisYChunkSize,
nBandCount, eType, bAllTouched, poGeom,
padfBurnValues, eBurnValueSource,
pfnTransformer, pTransformArg );
delete poFeat;
}
VSIFree( padfAttrValues );
// Only write image if not a single chunk is being rendered
if ( nYChunkSize < poDS->GetRasterYSize() )
{
eErr =
poDS->RasterIO( GF_Write, 0, iY,
poDS->GetRasterXSize(), nThisYChunkSize,
pabyChunkBuf,
poDS->GetRasterXSize(), nThisYChunkSize,
eType, nBandCount, panBandList, 0, 0, 0 );
}
poLayer->ResetReading();
if( !pfnProgress((iY+nThisYChunkSize)/((double)poDS->GetRasterYSize()),
"", pProgressArg) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
eErr = CE_Failure;
}
}
if ( bNeedToFreeTransformer )
{
GDALDestroyTransformer( pTransformArg );
pTransformArg = NULL;
pfnTransformer = NULL;
}
}
/* -------------------------------------------------------------------- */
/* Write out the image once for all layers if user requested */
/* to render the whole raster in single chunk. */
/* -------------------------------------------------------------------- */
if ( nYChunkSize == poDS->GetRasterYSize() )
{
poDS->RasterIO( GF_Write, 0, 0,
poDS->GetRasterXSize(), nYChunkSize,
pabyChunkBuf,
poDS->GetRasterXSize(), nYChunkSize,
eType, nBandCount, panBandList, 0, 0, 0 );
}
/* -------------------------------------------------------------------- */
/* cleanup */
/* -------------------------------------------------------------------- */
VSIFree( pabyChunkBuf );
return eErr;
}
GDALDataset *
WEBPDataset::CreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
/* -------------------------------------------------------------------- */
/* WEBP library initialization */
/* -------------------------------------------------------------------- */
WebPPicture sPicture;
if (!WebPPictureInit(&sPicture))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureInit() failed");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
if( nXSize > 16383 || nYSize > 16383 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"WEBP maximum image dimensions are 16383 x 16383.");
return NULL;
}
if( nBands != 3
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
&& nBands != 4
#endif
)
{
CPLError( CE_Failure, CPLE_NotSupported,
"WEBP driver doesn't support %d bands. Must be 3 (RGB) "
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
"or 4 (RGBA) "
#endif
"bands.",
nBands );
return NULL;
}
GDALDataType eDT = poSrcDS->GetRasterBand(1)->GetRasterDataType();
if( eDT != GDT_Byte )
{
CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
"WEBP driver doesn't support data type %s. "
"Only eight bit byte bands supported.",
GDALGetDataTypeName(
poSrcDS->GetRasterBand(1)->GetRasterDataType()) );
if (bStrict)
return NULL;
}
/* -------------------------------------------------------------------- */
/* What options has the user selected? */
/* -------------------------------------------------------------------- */
float fQuality = 75.0f;
const char* pszQUALITY = CSLFetchNameValue(papszOptions, "QUALITY");
if( pszQUALITY != NULL )
{
fQuality = (float) CPLAtof(pszQUALITY);
if( fQuality < 0.0f || fQuality > 100.0f )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"%s=%s is not a legal value.", "QUALITY", pszQUALITY);
return NULL;
}
}
WebPPreset nPreset = WEBP_PRESET_DEFAULT;
const char* pszPRESET = CSLFetchNameValueDef(papszOptions, "PRESET", "DEFAULT");
if (EQUAL(pszPRESET, "DEFAULT"))
nPreset = WEBP_PRESET_DEFAULT;
else if (EQUAL(pszPRESET, "PICTURE"))
nPreset = WEBP_PRESET_PICTURE;
else if (EQUAL(pszPRESET, "PHOTO"))
nPreset = WEBP_PRESET_PHOTO;
else if (EQUAL(pszPRESET, "PICTURE"))
nPreset = WEBP_PRESET_PICTURE;
else if (EQUAL(pszPRESET, "DRAWING"))
nPreset = WEBP_PRESET_DRAWING;
else if (EQUAL(pszPRESET, "ICON"))
nPreset = WEBP_PRESET_ICON;
else if (EQUAL(pszPRESET, "TEXT"))
nPreset = WEBP_PRESET_TEXT;
else
{
CPLError( CE_Failure, CPLE_IllegalArg,
"%s=%s is not a legal value.", "PRESET", pszPRESET );
return NULL;
}
WebPConfig sConfig;
if (!WebPConfigInitInternal(&sConfig, nPreset, fQuality, WEBP_ENCODER_ABI_VERSION))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPConfigInit() failed");
return NULL;
}
#define FETCH_AND_SET_OPTION_INT(name, fieldname, minval, maxval) \
{ \
const char* pszVal = CSLFetchNameValue(papszOptions, name); \
if (pszVal != NULL) \
{ \
sConfig.fieldname = atoi(pszVal); \
if (sConfig.fieldname < minval || sConfig.fieldname > maxval) \
{ \
CPLError( CE_Failure, CPLE_IllegalArg, \
"%s=%s is not a legal value.", name, pszVal ); \
return NULL; \
} \
} \
}
FETCH_AND_SET_OPTION_INT("TARGETSIZE", target_size, 0, INT_MAX);
const char* pszPSNR = CSLFetchNameValue(papszOptions, "PSNR");
if (pszPSNR)
{
sConfig.target_PSNR = CPLAtof(pszPSNR);
if (sConfig.target_PSNR < 0)
{
CPLError( CE_Failure, CPLE_IllegalArg,
"PSNR=%s is not a legal value.", pszPSNR );
return NULL;
}
}
FETCH_AND_SET_OPTION_INT("METHOD", method, 0, 6);
FETCH_AND_SET_OPTION_INT("SEGMENTS", segments, 1, 4);
FETCH_AND_SET_OPTION_INT("SNS_STRENGTH", sns_strength, 0, 100);
FETCH_AND_SET_OPTION_INT("FILTER_STRENGTH", filter_strength, 0, 100);
FETCH_AND_SET_OPTION_INT("FILTER_SHARPNESS", filter_sharpness, 0, 7);
FETCH_AND_SET_OPTION_INT("FILTER_TYPE", filter_type, 0, 1);
FETCH_AND_SET_OPTION_INT("AUTOFILTER", autofilter, 0, 1);
FETCH_AND_SET_OPTION_INT("PASS", pass, 1, 10);
FETCH_AND_SET_OPTION_INT("PREPROCESSING", preprocessing, 0, 1);
FETCH_AND_SET_OPTION_INT("PARTITIONS", partitions, 0, 3);
#if WEBP_ENCODER_ABI_VERSION >= 0x0002
FETCH_AND_SET_OPTION_INT("PARTITION_LIMIT", partition_limit, 0, 100);
#endif
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
sConfig.lossless = CSLFetchBoolean(papszOptions, "LOSSLESS", FALSE);
if (sConfig.lossless)
sPicture.use_argb = 1;
#endif
if (!WebPValidateConfig(&sConfig))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPValidateConfig() failed");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Allocate memory */
/* -------------------------------------------------------------------- */
GByte *pabyBuffer;
pabyBuffer = (GByte *) VSIMalloc( nBands * nXSize * nYSize );
if (pabyBuffer == NULL)
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the dataset. */
/* -------------------------------------------------------------------- */
VSILFILE *fpImage;
fpImage = VSIFOpenL( pszFilename, "wb" );
if( fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create WEBP file %s.\n",
pszFilename );
VSIFree(pabyBuffer);
return NULL;
}
WebPUserData sUserData;
sUserData.fp = fpImage;
sUserData.pfnProgress = pfnProgress ? pfnProgress : GDALDummyProgress;
sUserData.pProgressData = pProgressData;
/* -------------------------------------------------------------------- */
/* WEBP library settings */
/* -------------------------------------------------------------------- */
sPicture.width = nXSize;
sPicture.height = nYSize;
sPicture.writer = WEBPDatasetWriter;
sPicture.custom_ptr = &sUserData;
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
sPicture.progress_hook = WEBPDatasetProgressHook;
#endif
if (!WebPPictureAlloc(&sPicture))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureAlloc() failed");
VSIFree(pabyBuffer);
VSIFCloseL( fpImage );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Acquire source imagery. */
/* -------------------------------------------------------------------- */
CPLErr eErr = CE_None;
eErr = poSrcDS->RasterIO( GF_Read, 0, 0, nXSize, nYSize,
pabyBuffer, nXSize, nYSize, GDT_Byte,
nBands, NULL,
nBands, nBands * nXSize, 1, NULL );
/* -------------------------------------------------------------------- */
/* Import and write to file */
/* -------------------------------------------------------------------- */
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
if (eErr == CE_None && nBands == 4)
{
if (!WebPPictureImportRGBA(&sPicture, pabyBuffer, nBands * nXSize))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureImportRGBA() failed");
eErr = CE_Failure;
}
}
else
#endif
if (eErr == CE_None &&
!WebPPictureImportRGB(&sPicture, pabyBuffer, nBands * nXSize))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureImportRGB() failed");
eErr = CE_Failure;
}
if (eErr == CE_None && !WebPEncode(&sConfig, &sPicture))
{
const char* pszErrorMsg = NULL;
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
switch(sPicture.error_code)
{
case VP8_ENC_ERROR_OUT_OF_MEMORY: pszErrorMsg = "Out of memory"; break;
case VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY: pszErrorMsg = "Out of memory while flushing bits"; break;
case VP8_ENC_ERROR_NULL_PARAMETER: pszErrorMsg = "A pointer parameter is NULL"; break;
case VP8_ENC_ERROR_INVALID_CONFIGURATION: pszErrorMsg = "Configuration is invalid"; break;
case VP8_ENC_ERROR_BAD_DIMENSION: pszErrorMsg = "Picture has invalid width/height"; break;
case VP8_ENC_ERROR_PARTITION0_OVERFLOW: pszErrorMsg = "Partition is bigger than 512k. Try using less SEGMENTS, or increase PARTITION_LIMIT value"; break;
case VP8_ENC_ERROR_PARTITION_OVERFLOW: pszErrorMsg = "Partition is bigger than 16M"; break;
case VP8_ENC_ERROR_BAD_WRITE: pszErrorMsg = "Error while flusing bytes"; break;
case VP8_ENC_ERROR_FILE_TOO_BIG: pszErrorMsg = "File is bigger than 4G"; break;
case VP8_ENC_ERROR_USER_ABORT: pszErrorMsg = "User interrupted"; break;
default: break;
}
#endif
if (pszErrorMsg)
CPLError(CE_Failure, CPLE_AppDefined, "WebPEncode() failed : %s", pszErrorMsg);
else
CPLError(CE_Failure, CPLE_AppDefined, "WebPEncode() failed");
eErr = CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Cleanup and close. */
/* -------------------------------------------------------------------- */
CPLFree( pabyBuffer );
WebPPictureFree(&sPicture);
VSIFCloseL( fpImage );
if( eErr != CE_None )
{
VSIUnlink( pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Re-open dataset, and copy any auxiliary pam information. */
/* -------------------------------------------------------------------- */
GDALOpenInfo oOpenInfo(pszFilename, GA_ReadOnly);
/* If outputing to stdout, we can't reopen it, so we'll return */
/* a fake dataset to make the caller happy */
CPLPushErrorHandler(CPLQuietErrorHandler);
WEBPDataset *poDS = (WEBPDataset*) WEBPDataset::Open( &oOpenInfo );
CPLPopErrorHandler();
if( poDS )
{
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
return poDS;
}
return NULL;
}
GDALDataset *SAGADataset::Create( const char * pszFilename,
int nXSize, int nYSize, int nBands,
GDALDataType eType,
char **papszParmList )
{
if( nXSize <= 0 || nYSize <= 0 )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"Unable to create grid, both X and Y size must be "
"non-negative.\n" );
return NULL;
}
if( nBands != 1 )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"SAGA Binary Grid only supports 1 band" );
return NULL;
}
if( eType != GDT_Byte && eType != GDT_UInt16 && eType != GDT_Int16
&& eType != GDT_UInt32 && eType != GDT_Int32 && eType != GDT_Float32
&& eType != GDT_Float64 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"SAGA Binary Grid only supports Byte, UInt16, Int16, "
"UInt32, Int32, Float32 and Float64 datatypes. Unable to "
"create with type %s.\n", GDALGetDataTypeName( eType ) );
return NULL;
}
VSILFILE *fp = VSIFOpenL( pszFilename, "w+b" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file '%s' failed.\n",
pszFilename );
return NULL;
}
char abyNoData[8];
double dfNoDataVal = 0.0;
const char* pszNoDataValue = CSLFetchNameValue(papszParmList, "NODATA_VALUE");
if (pszNoDataValue)
{
dfNoDataVal = CPLAtofM(pszNoDataValue);
}
else
{
switch (eType) /* GDT_Byte, GDT_UInt16, GDT_Int16, GDT_UInt32 */
{ /* GDT_Int32, GDT_Float32, GDT_Float64 */
case (GDT_Byte):
{
dfNoDataVal = SG_NODATA_GDT_Byte;
break;
}
case (GDT_UInt16):
{
dfNoDataVal = SG_NODATA_GDT_UInt16;
break;
}
case (GDT_Int16):
{
dfNoDataVal = SG_NODATA_GDT_Int16;
break;
}
case (GDT_UInt32):
{
dfNoDataVal = SG_NODATA_GDT_UInt32;
break;
}
case (GDT_Int32):
{
dfNoDataVal = SG_NODATA_GDT_Int32;
break;
}
default:
case (GDT_Float32):
{
dfNoDataVal = SG_NODATA_GDT_Float32;
break;
}
case (GDT_Float64):
{
dfNoDataVal = SG_NODATA_GDT_Float64;
break;
}
}
}
GDALCopyWords(&dfNoDataVal, GDT_Float64, 0,
abyNoData, eType, 0, 1);
CPLString osHdrFilename = CPLResetExtension( pszFilename, "sgrd" );
CPLErr eErr = WriteHeader( osHdrFilename, eType,
nXSize, nYSize,
0.0, 0.0, 1.0,
dfNoDataVal, 1.0, false );
if( eErr != CE_None )
{
VSIFCloseL( fp );
return NULL;
}
if (CSLFetchBoolean( papszParmList , "FILL_NODATA", TRUE ))
{
int nDataTypeSize = GDALGetDataTypeSize(eType) / 8;
GByte* pabyNoDataBuf = (GByte*) VSIMalloc2(nDataTypeSize, nXSize);
if (pabyNoDataBuf == NULL)
{
VSIFCloseL( fp );
return NULL;
}
for( int iCol = 0; iCol < nXSize; iCol++)
{
memcpy(pabyNoDataBuf + iCol * nDataTypeSize, abyNoData, nDataTypeSize);
}
for( int iRow = 0; iRow < nYSize; iRow++ )
{
if( VSIFWriteL( pabyNoDataBuf, nDataTypeSize, nXSize, fp ) != (unsigned)nXSize )
{
VSIFCloseL( fp );
VSIFree(pabyNoDataBuf);
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write grid cell. Disk full?\n" );
return NULL;
}
}
VSIFree(pabyNoDataBuf);
}
VSIFCloseL( fp );
return (GDALDataset *)GDALOpen( pszFilename, GA_Update );
}
GDALDataset *NTv2Dataset::Create( const char * pszFilename,
int nXSize, int nYSize,
CPL_UNUSED int nBands,
GDALDataType eType,
char ** papszOptions )
{
if( eType != GDT_Float32 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Attempt to create NTv2 file with unsupported data type '%s'.",
GDALGetDataTypeName( eType ) );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Are we extending an existing file? */
/* -------------------------------------------------------------------- */
VSILFILE *fp;
GUInt32 nNumFile = 1;
int bAppend = CSLFetchBoolean(papszOptions,"APPEND_SUBDATASET",FALSE);
/* -------------------------------------------------------------------- */
/* Try to open or create file. */
/* -------------------------------------------------------------------- */
if( bAppend )
fp = VSIFOpenL( pszFilename, "rb+" );
else
fp = VSIFOpenL( pszFilename, "wb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to open/create file `%s' failed.\n",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a file level header if we are creating new. */
/* -------------------------------------------------------------------- */
char achHeader[11*16];
const char *pszValue;
if( !bAppend )
{
memset( achHeader, 0, sizeof(achHeader) );
memcpy( achHeader + 0*16, "NUM_OREC", 8 );
achHeader[ 0*16 + 8] = 0xb;
memcpy( achHeader + 1*16, "NUM_SREC", 8 );
achHeader[ 1*16 + 8] = 0xb;
memcpy( achHeader + 2*16, "NUM_FILE", 8 );
achHeader[ 2*16 + 8] = 0x1;
memcpy( achHeader + 3*16, "GS_TYPE ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "GS_TYPE", "SECONDS");
memcpy( achHeader + 3*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 4*16, "VERSION ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "VERSION", "" );
memcpy( achHeader + 4*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 5*16, "SYSTEM_F ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "SYSTEM_F", "" );
memcpy( achHeader + 5*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 6*16, "SYSTEM_T ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "SYSTEM_T", "" );
memcpy( achHeader + 6*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 7*16, "MAJOR_F ", 8);
memcpy( achHeader + 8*16, "MINOR_F ", 8 );
memcpy( achHeader + 9*16, "MAJOR_T ", 8 );
memcpy( achHeader + 10*16, "MINOR_T ", 8 );
VSIFWriteL( achHeader, 1, sizeof(achHeader), fp );
}
/* -------------------------------------------------------------------- */
/* Otherwise update the header with an increased subfile count, */
/* and advanced to the last record of the file. */
/* -------------------------------------------------------------------- */
else
{
VSIFSeekL( fp, 2*16 + 8, SEEK_SET );
VSIFReadL( &nNumFile, 1, 4, fp );
CPL_LSBPTR32( &nNumFile );
nNumFile++;
CPL_LSBPTR32( &nNumFile );
VSIFSeekL( fp, 2*16 + 8, SEEK_SET );
VSIFWriteL( &nNumFile, 1, 4, fp );
vsi_l_offset nEnd;
VSIFSeekL( fp, 0, SEEK_END );
nEnd = VSIFTellL( fp );
VSIFSeekL( fp, nEnd-16, SEEK_SET );
}
/* -------------------------------------------------------------------- */
/* Write the grid header. */
/* -------------------------------------------------------------------- */
memset( achHeader, 0, sizeof(achHeader) );
memcpy( achHeader + 0*16, "SUB_NAME ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "SUB_NAME", "" );
memcpy( achHeader + 0*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 1*16, "PARENT ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "PARENT", "NONE" );
memcpy( achHeader + 1*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 2*16, "CREATED ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "CREATED", "" );
memcpy( achHeader + 2*16+8, pszValue, MIN(16,strlen(pszValue)) );
memcpy( achHeader + 3*16, "UPDATED ", 16 );
pszValue = CSLFetchNameValueDef( papszOptions, "UPDATED", "" );
memcpy( achHeader + 3*16+8, pszValue, MIN(16,strlen(pszValue)) );
double dfValue;
memcpy( achHeader + 4*16, "S_LAT ", 8 );
dfValue = 0;
CPL_LSBPTR64( &dfValue );
memcpy( achHeader + 4*16 + 8, &dfValue, 8 );
memcpy( achHeader + 5*16, "N_LAT ", 8 );
dfValue = nYSize-1;
CPL_LSBPTR64( &dfValue );
memcpy( achHeader + 5*16 + 8, &dfValue, 8 );
memcpy( achHeader + 6*16, "E_LONG ", 8 );
dfValue = -1*(nXSize-1);
CPL_LSBPTR64( &dfValue );
memcpy( achHeader + 6*16 + 8, &dfValue, 8 );
memcpy( achHeader + 7*16, "W_LONG ", 8 );
dfValue = 0;
CPL_LSBPTR64( &dfValue );
memcpy( achHeader + 7*16 + 8, &dfValue, 8 );
memcpy( achHeader + 8*16, "LAT_INC ", 8 );
dfValue = 1;
CPL_LSBPTR64( &dfValue );
memcpy( achHeader + 8*16 + 8, &dfValue, 8 );
memcpy( achHeader + 9*16, "LONG_INC", 8 );
memcpy( achHeader + 9*16 + 8, &dfValue, 8 );
memcpy( achHeader + 10*16, "GS_COUNT", 8 );
GUInt32 nGSCount = nXSize * nYSize;
CPL_LSBPTR32( &nGSCount );
memcpy( achHeader + 10*16+8, &nGSCount, 4 );
VSIFWriteL( achHeader, 1, sizeof(achHeader), fp );
/* -------------------------------------------------------------------- */
/* Write zeroed grid data. */
/* -------------------------------------------------------------------- */
int i;
memset( achHeader, 0, 16 );
// Use -1 (0x000080bf) as the default error value.
memset( achHeader + 10, 0x80, 1 );
memset( achHeader + 11, 0xbf, 1 );
memset( achHeader + 14, 0x80, 1 );
memset( achHeader + 15, 0xbf, 1 );
for( i = 0; i < nXSize * nYSize; i++ )
VSIFWriteL( achHeader, 1, 16, fp );
/* -------------------------------------------------------------------- */
/* Write the end record. */
/* -------------------------------------------------------------------- */
memset( achHeader, 0, 16 );
memcpy( achHeader, "END ", 8 );
VSIFWriteL( achHeader, 1, 16, fp );
VSIFCloseL( fp );
if( nNumFile == 1 )
return (GDALDataset *) GDALOpen( pszFilename, GA_Update );
else
{
CPLString osSubDSName;
osSubDSName.Printf( "NTv2:%d:%s", nNumFile-1, pszFilename );
return (GDALDataset *) GDALOpen( osSubDSName, GA_Update );
}
}
int OutCoreInterp::outputFile(char *outputName, int outputFormat, unsigned int outputType, double *adfGeoTransform, const char* wkt)
{
int i, j, k, l, t;
FILE **arcFiles;
char arcFileName[1024];
FILE **gridFiles;
char gridFileName[1024];
const char *ext[6] = {".min", ".max", ".mean", ".idw", ".den", ".std"};
unsigned int type[6] = {OUTPUT_TYPE_MIN, OUTPUT_TYPE_MAX, OUTPUT_TYPE_MEAN, OUTPUT_TYPE_IDW, OUTPUT_TYPE_DEN, OUTPUT_TYPE_STD};
int numTypes = 6;
// open ArcGIS files
if(outputFormat == OUTPUT_FORMAT_ARC_ASCII || outputFormat == OUTPUT_FORMAT_ALL)
{
if((arcFiles = (FILE **)malloc(sizeof(FILE *) * numTypes)) == NULL)
{
cerr << "Arc File open error: " << endl;
return -1;
}
for(i = 0; i < numTypes; i++)
{
if(outputType & type[i])
{
strncpy(arcFileName, outputName, sizeof(arcFileName));
strncat(arcFileName, ext[i], strlen(ext[i]));
strncat(arcFileName, ".asc", strlen(".asc"));
if((arcFiles[i] = fopen(arcFileName, "w+")) == NULL)
{
cerr << "File open error: " << arcFileName << endl;
return -1;
}
} else {
arcFiles[i] = NULL;
}
}
} else {
arcFiles = NULL;
}
// open Grid ASCII files
if(outputFormat == OUTPUT_FORMAT_GRID_ASCII || outputFormat == OUTPUT_FORMAT_ALL)
{
if((gridFiles = (FILE **)malloc(sizeof(FILE *) * numTypes)) == NULL)
{
cerr << "File array allocation error" << endl;
return -1;
}
for(i = 0; i < numTypes; i++)
{
if(outputType & type[i])
{
strncpy(gridFileName, outputName, sizeof(arcFileName));
strncat(gridFileName, ext[i], strlen(ext[i]));
strncat(gridFileName, ".grid", strlen(".grid"));
if((gridFiles[i] = fopen(gridFileName, "w+")) == NULL)
{
cerr << "File open error: " << gridFileName << endl;
return -1;
}
} else {
gridFiles[i] = NULL;
}
}
} else {
gridFiles = NULL;
}
// print ArcGIS headers
if(arcFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(arcFiles[i] != NULL)
{
fprintf(arcFiles[i], "ncols %d\n", GRID_SIZE_X);
fprintf(arcFiles[i], "nrows %d\n", GRID_SIZE_Y);
fprintf(arcFiles[i], "xllcorner %f\n", min_x);
fprintf(arcFiles[i], "yllcorner %f\n", min_y);
fprintf(arcFiles[i], "cellsize %f\n", GRID_DIST_X);
fprintf(arcFiles[i], "NODATA_value -9999\n");
}
}
}
// print Grid headers
if(gridFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(gridFiles[i] != NULL)
{
fprintf(gridFiles[i], "north: %f\n", max_y);
fprintf(gridFiles[i], "south: %f\n", min_y);
fprintf(gridFiles[i], "east: %f\n", max_x);
fprintf(gridFiles[i], "west: %f\n", min_x);
fprintf(gridFiles[i], "rows: %d\n", GRID_SIZE_Y);
fprintf(gridFiles[i], "cols: %d\n", GRID_SIZE_X);
}
}
}
for(i = numFiles -1; i >= 0; i--)
{
GridFile *gf = gridMap[i]->getGridFile();
gf->map();
int start = gridMap[i]->getLowerBound() - gridMap[i]->getOverlapLowerBound();
int end = gridMap[i]->getUpperBound() - gridMap[i]->getOverlapLowerBound() + 1;
//int start = (gridMap[i]->getLowerBound() - gridMap[i]->getOverlapLowerBound()) * GRID_SIZE_X;
//int end = (gridMap[i]->getUpperBound() - gridMap[i]->getOverlapLowerBound() + 1) * GRID_SIZE_X;
cerr << "Merging " << i << ": from " << (start) << " to " << (end) << endl;
cerr << " " << i << ": from " << (start/GRID_SIZE_X) << " to " << (end/GRID_SIZE_X) << endl;
for(j = end - 1; j >= start; j--)
{
for(k = 0; k < GRID_SIZE_X; k++)
{
int index = j * GRID_SIZE_X + k;
if(arcFiles != NULL)
{
// Zmin
if(arcFiles[0] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
//if(gf->interp[k][j].Zmin == 0)
fprintf(arcFiles[0], "-9999 ");
else
//fprintf(arcFiles[0], "%f ", gf->interp[j][i].Zmin);
fprintf(arcFiles[0], "%f ", gf->interp[index].Zmin);
}
// Zmax
if(arcFiles[1] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[1], "-9999 ");
else
fprintf(arcFiles[1], "%f ", gf->interp[index].Zmax);
}
// Zmean
if(arcFiles[2] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[2], "-9999 ");
else
fprintf(arcFiles[2], "%f ", gf->interp[index].Zmean);
}
// Zidw
if(arcFiles[3] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[3], "-9999 ");
else
fprintf(arcFiles[3], "%f ", gf->interp[index].Zidw);
}
// count
if(arcFiles[4] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[4], "-9999 ");
else
fprintf(arcFiles[4], "%d ", gf->interp[index].count);
}
// Zstd
if(arcFiles[5] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(arcFiles[5], "-9999 ");
else
fprintf(arcFiles[5], "%f ", gf->interp[index].Zstd);
}
}
if(gridFiles != NULL)
{
// Zmin
if(gridFiles[0] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[0], "-9999 ");
else
fprintf(gridFiles[0], "%f ", gf->interp[index].Zmin);
}
// Zmax
if(gridFiles[1] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[1], "-9999 ");
else
fprintf(gridFiles[1], "%f ", gf->interp[index].Zmax);
}
// Zmean
if(gridFiles[2] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[2], "-9999 ");
else
fprintf(gridFiles[2], "%f ", gf->interp[index].Zmean);
}
// Zidw
if(gridFiles[3] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[3], "-9999 ");
else
fprintf(gridFiles[3], "%f ", gf->interp[index].Zidw);
}
// count
if(gridFiles[4] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[4], "-9999 ");
else
fprintf(gridFiles[4], "%d ", gf->interp[index].count);
}
// Zstd
if(gridFiles[5] != NULL)
{
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
fprintf(gridFiles[5], "-9999 ");
else
fprintf(gridFiles[5], "%f ", gf->interp[index].Zstd);
}
}
}
if(arcFiles != NULL)
for(l = 0; l < numTypes; l++)
{
if(arcFiles[l] != NULL)
fprintf(arcFiles[l], "\n");
}
if(gridFiles != NULL)
for(l = 0; l < numTypes; l++)
{
if(gridFiles[l] != NULL)
fprintf(gridFiles[l], "\n");
}
}
gf->unmap();
}
#ifdef HAVE_GDAL
GDALDataset **gdalFiles;
char gdalFileName[1024];
// open GDAL GeoTIFF files
if(outputFormat == OUTPUT_FORMAT_GDAL_GTIFF || outputFormat == OUTPUT_FORMAT_ALL)
{
GDALAllRegister();
if((gdalFiles = (GDALDataset **)malloc(sizeof(GDALDataset *) * numTypes)) == NULL)
{
cerr << "File array allocation error" << endl;
return -1;
}
for(i = 0; i < numTypes; i++)
{
if(outputType & type[i])
{
strncpy(gdalFileName, outputName, sizeof(gdalFileName));
strncat(gdalFileName, ext[i], strlen(ext[i]));
strncat(gdalFileName, ".tif", strlen(".tif"));
char **papszMetadata;
const char *pszFormat = "GTIFF";
GDALDriver* tpDriver = GetGDALDriverManager()->GetDriverByName(pszFormat);
if (tpDriver)
{
papszMetadata = tpDriver->GetMetadata();
if (CSLFetchBoolean(papszMetadata, GDAL_DCAP_CREATE, FALSE))
{
char **papszOptions = NULL;
gdalFiles[i] = tpDriver->Create(gdalFileName, GRID_SIZE_X, GRID_SIZE_Y, 1, GDT_Float32, papszOptions);
if (gdalFiles[i] == NULL)
{
cerr << "File open error: " << gdalFileName << endl;
return -1;
} else {
if (adfGeoTransform)
gdalFiles[i]->SetGeoTransform(adfGeoTransform);
if (wkt)
gdalFiles[i]->SetProjection(wkt);
}
}
}
} else {
gdalFiles[i] = NULL;
}
}
} else {
gdalFiles = NULL;
}
if(gdalFiles != NULL)
{
for(t = 0; t < numTypes; t++)
{
if(gdalFiles[t] != NULL)
{
for(i = numFiles -1; i >= 0; i--)
{
GridFile *gf = gridMap[i]->getGridFile();
gf->map();
int start = gridMap[i]->getLowerBound() - gridMap[i]->getOverlapLowerBound();
int end = gridMap[i]->getUpperBound() - gridMap[i]->getOverlapLowerBound() + 1;
cerr << "Merging " << i << ": from " << (start) << " to " << (end) << endl;
cerr << " " << i << ": from " << (start/GRID_SIZE_X) << " to " << (end/GRID_SIZE_X) << endl;
float *poRasterData = new float[GRID_SIZE_X*GRID_SIZE_Y];
for (int j = 0; j < GRID_SIZE_X*GRID_SIZE_Y; j++)
{
poRasterData[j] = 0;
}
for(j = end - 1; j >= start; j--)
{
for(k = 0; k < GRID_SIZE_X; k++)
{
int index = j * GRID_SIZE_X + k;
if(gf->interp[index].empty == 0 &&
gf->interp[index].filled == 0)
{
poRasterData[index] = -9999.f;
} else {
switch (t)
{
case 0:
poRasterData[index] = gf->interp[index].Zmin;
break;
case 1:
poRasterData[index] = gf->interp[index].Zmax;
break;
case 2:
poRasterData[index] = gf->interp[index].Zmean;
break;
case 3:
poRasterData[index] = gf->interp[index].Zidw;
break;
case 4:
poRasterData[index] = gf->interp[index].count;
break;
case 5:
poRasterData[index] = gf->interp[index].Zstd;
break;
}
}
}
}
GDALRasterBand *tBand = gdalFiles[t]->GetRasterBand(1);
tBand->SetNoDataValue(-9999.f);
if (GRID_SIZE_X > 0 && GRID_SIZE_Y > 0)
tBand->RasterIO(GF_Write, 0, 0, GRID_SIZE_X, GRID_SIZE_Y, poRasterData, GRID_SIZE_X, GRID_SIZE_Y, GDT_Float32, 0, 0);
GDALClose((GDALDatasetH) gdalFiles[t]);
delete [] poRasterData;
}
}
}
}
#endif // HAVE_GDAL
// close files
if(gridFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(gridFiles[i] != NULL)
fclose(gridFiles[i]);
}
}
if(arcFiles != NULL)
{
for(i = 0; i < numTypes; i++)
{
if(arcFiles[i] != NULL)
fclose(arcFiles[i]);
}
}
return 0;
}
