CPLErr GSBGDataset::SetGeoTransform( double *padfGeoTransform ) { if( eAccess == GA_ReadOnly ) { CPLError( CE_Failure, CPLE_NoWriteAccess, "Unable to set GeoTransform, dataset opened read only.\n" ); return CE_Failure; } GSBGRasterBand *poGRB = dynamic_cast<GSBGRasterBand *>(GetRasterBand( 1 )); if( poGRB == NULL || padfGeoTransform == NULL) return CE_Failure; /* non-zero transform 2 or 4 or negative 1 or 5 not supported natively */ CPLErr eErr = CE_None; /*if( padfGeoTransform[2] != 0.0 || padfGeoTransform[4] != 0.0 || padfGeoTransform[1] < 0.0 || padfGeoTransform[5] < 0.0 ) eErr = GDALPamDataset::SetGeoTransform( padfGeoTransform ); if( eErr != CE_None ) return eErr;*/ double dfMinX = padfGeoTransform[0] + padfGeoTransform[1] / 2; double dfMaxX = padfGeoTransform[1] * (nRasterXSize - 0.5) + padfGeoTransform[0]; double dfMinY = padfGeoTransform[5] * (nRasterYSize - 0.5) + padfGeoTransform[3]; double dfMaxY = padfGeoTransform[3] + padfGeoTransform[5] / 2; eErr = WriteHeader( fp, (GInt16) poGRB->nRasterXSize, (GInt16) poGRB->nRasterYSize, dfMinX, dfMaxX, dfMinY, dfMaxY, poGRB->dfMinZ, poGRB->dfMaxZ ); if( eErr == CE_None ) { poGRB->dfMinX = dfMinX; poGRB->dfMaxX = dfMaxX; poGRB->dfMinY = dfMinY; poGRB->dfMaxY = dfMaxY; } return eErr; }
void GDALPamDataset::PamInitialize() { #ifdef PAM_ENABLED static const char *pszPamDefault = "YES"; #else static const char *pszPamDefault = "NO"; #endif if( psPam || (nPamFlags & GPF_DISABLED) ) return; if( !CSLTestBoolean( CPLGetConfigOption( "GDAL_PAM_ENABLED", pszPamDefault ) ) ) { nPamFlags |= GPF_DISABLED; return; } if( EQUAL( CPLGetConfigOption( "GDAL_PAM_MODE", "PAM" ), "AUX") ) nPamFlags |= GPF_AUXMODE; psPam = new GDALDatasetPamInfo; psPam->pszPamFilename = NULL; psPam->pszProjection = NULL; psPam->bHaveGeoTransform = FALSE; psPam->nGCPCount = 0; psPam->pasGCPList = NULL; psPam->pszGCPProjection = NULL; int iBand; for( iBand = 0; iBand < GetRasterCount(); iBand++ ) { GDALPamRasterBand *poBand = (GDALPamRasterBand *) GetRasterBand(iBand+1); if( poBand == NULL || !(poBand->GetMOFlags() & GMO_PAM_CLASS) ) continue; poBand->PamInitialize(); } }
CPLErr GS7BGDataset::GetGeoTransform( double *padfGeoTransform ) { if( padfGeoTransform == NULL ) return CE_Failure; GS7BGRasterBand *poGRB = (GS7BGRasterBand *)GetRasterBand( 1 ); if( poGRB == NULL ) { padfGeoTransform[0] = 0; padfGeoTransform[1] = 1; padfGeoTransform[2] = 0; padfGeoTransform[3] = 0; padfGeoTransform[4] = 0; padfGeoTransform[5] = 1; return CE_Failure; } /* check if we have a PAM GeoTransform stored */ CPLPushErrorHandler( CPLQuietErrorHandler ); CPLErr eErr = GDALPamDataset::GetGeoTransform( padfGeoTransform ); CPLPopErrorHandler(); if( eErr == CE_None ) return CE_None; /* calculate pixel size first */ padfGeoTransform[1] = (poGRB->dfMaxX - poGRB->dfMinX)/(nRasterXSize - 1); padfGeoTransform[5] = (poGRB->dfMinY - poGRB->dfMaxY)/(nRasterYSize - 1); /* then calculate image origin */ padfGeoTransform[0] = poGRB->dfMinX - padfGeoTransform[1] / 2; padfGeoTransform[3] = poGRB->dfMaxY - padfGeoTransform[5] / 2; /* tilt/rotation does not supported by the GS grids */ padfGeoTransform[4] = 0.0; padfGeoTransform[2] = 0.0; return CE_None; }
CPLErr SAGADataset::GetGeoTransform( double *padfGeoTransform ) { if( padfGeoTransform == NULL ) return CE_Failure; SAGARasterBand *poGRB = dynamic_cast<SAGARasterBand *>(GetRasterBand( 1 )); if( poGRB == NULL ) { padfGeoTransform[0] = 0; padfGeoTransform[1] = 1; padfGeoTransform[2] = 0; padfGeoTransform[3] = 0; padfGeoTransform[4] = 0; padfGeoTransform[5] = 1; return CE_Failure; } /* check if we have a PAM GeoTransform stored */ CPLPushErrorHandler( CPLQuietErrorHandler ); CPLErr eErr = GDALPamDataset::GetGeoTransform( padfGeoTransform ); CPLPopErrorHandler(); if( eErr == CE_None ) return CE_None; padfGeoTransform[1] = poGRB->m_Cellsize; padfGeoTransform[5] = poGRB->m_Cellsize * -1.0; padfGeoTransform[0] = poGRB->m_Xmin - poGRB->m_Cellsize / 2; padfGeoTransform[3] = poGRB->m_Ymin + (nRasterYSize - 1) * poGRB->m_Cellsize + poGRB->m_Cellsize / 2; /* tilt/rotation is not supported by SAGA grids */ padfGeoTransform[4] = 0.0; padfGeoTransform[2] = 0.0; return CE_None; }
void LANDataset::CheckForStatistics() { /* -------------------------------------------------------------------- */ /* Do we have a statistics file? */ /* -------------------------------------------------------------------- */ osSTAFilename = CPLResetExtension(GetDescription(),"sta"); VSILFILE *fpSTA = VSIFOpenL( osSTAFilename, "r" ); if( fpSTA == NULL && VSIIsCaseSensitiveFS(osSTAFilename) ) { osSTAFilename = CPLResetExtension(GetDescription(),"STA"); fpSTA = VSIFOpenL( osSTAFilename, "r" ); } if( fpSTA == NULL ) { osSTAFilename = ""; return; } /* -------------------------------------------------------------------- */ /* Read it one band at a time. */ /* -------------------------------------------------------------------- */ GByte abyBandInfo[1152] = { '\0' }; for( int iBand = 0; iBand < nBands; iBand++ ) { if( VSIFReadL( abyBandInfo, 1152, 1, fpSTA ) != 1 ) break; const int nBandNumber = abyBandInfo[7]; GDALRasterBand *poBand = GetRasterBand(nBandNumber); if( poBand == NULL ) break; GInt16 nMin = 0; GInt16 nMax = 0; if( poBand->GetRasterDataType() != GDT_Byte ) { memcpy( &nMin, abyBandInfo + 28, 2 ); memcpy( &nMax, abyBandInfo + 30, 2 ); CPL_LSBPTR16( &nMin ); CPL_LSBPTR16( &nMax ); } else { nMin = abyBandInfo[9]; nMax = abyBandInfo[8]; } float fMean = 0.0; float fStdDev = 0.0; memcpy( &fMean, abyBandInfo + 12, 4 ); memcpy( &fStdDev, abyBandInfo + 24, 4 ); CPL_LSBPTR32( &fMean ); CPL_LSBPTR32( &fStdDev ); poBand->SetStatistics( nMin, nMax, fMean, fStdDev ); } CPL_IGNORE_RET_VAL(VSIFCloseL( fpSTA )); }
void IDADataset::ReadColorTable() { /* -------------------------------------------------------------------- */ /* Decide what .clr file to look for and try to open. */ /* -------------------------------------------------------------------- */ CPLString osCLRFilename; osCLRFilename = CPLGetConfigOption( "IDA_COLOR_FILE", "" ); if( strlen(osCLRFilename) == 0 ) osCLRFilename = CPLResetExtension(GetDescription(), "clr" ); FILE *fp = VSIFOpen( osCLRFilename, "r" ); if( fp == NULL ) { osCLRFilename = CPLResetExtension(osCLRFilename, "CLR" ); fp = VSIFOpen( osCLRFilename, "r" ); } if( fp == NULL ) return; /* -------------------------------------------------------------------- */ /* Skip first line, with the column titles. */ /* -------------------------------------------------------------------- */ CPLReadLine( fp ); /* -------------------------------------------------------------------- */ /* Create a RAT to populate. */ /* -------------------------------------------------------------------- */ GDALRasterAttributeTable *poRAT = new GDALDefaultRasterAttributeTable(); poRAT->CreateColumn( "FROM", GFT_Integer, GFU_Min ); poRAT->CreateColumn( "TO", GFT_Integer, GFU_Max ); poRAT->CreateColumn( "RED", GFT_Integer, GFU_Red ); poRAT->CreateColumn( "GREEN", GFT_Integer, GFU_Green ); poRAT->CreateColumn( "BLUE", GFT_Integer, GFU_Blue ); poRAT->CreateColumn( "LEGEND", GFT_String, GFU_Name ); /* -------------------------------------------------------------------- */ /* Apply lines. */ /* -------------------------------------------------------------------- */ const char *pszLine = CPLReadLine( fp ); int iRow = 0; while( pszLine != NULL ) { char **papszTokens = CSLTokenizeStringComplex( pszLine, " \t", FALSE, FALSE ); if( CSLCount( papszTokens ) >= 5 ) { poRAT->SetValue( iRow, 0, atoi(papszTokens[0]) ); poRAT->SetValue( iRow, 1, atoi(papszTokens[1]) ); poRAT->SetValue( iRow, 2, atoi(papszTokens[2]) ); poRAT->SetValue( iRow, 3, atoi(papszTokens[3]) ); poRAT->SetValue( iRow, 4, atoi(papszTokens[4]) ); // find name, first nonspace after 5th token. const char *pszName = pszLine; // skip from while( *pszName == ' ' || *pszName == '\t' ) pszName++; while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' ) pszName++; // skip to while( *pszName == ' ' || *pszName == '\t' ) pszName++; while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' ) pszName++; // skip red while( *pszName == ' ' || *pszName == '\t' ) pszName++; while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' ) pszName++; // skip green while( *pszName == ' ' || *pszName == '\t' ) pszName++; while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' ) pszName++; // skip blue while( *pszName == ' ' || *pszName == '\t' ) pszName++; while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' ) pszName++; // skip pre-name white space while( *pszName == ' ' || *pszName == '\t' ) pszName++; poRAT->SetValue( iRow, 5, pszName ); iRow++; } CSLDestroy( papszTokens ); pszLine = CPLReadLine( fp ); } VSIFClose( fp ); /* -------------------------------------------------------------------- */ /* Attach RAT to band. */ /* -------------------------------------------------------------------- */ ((IDARasterBand *) GetRasterBand( 1 ))->poRAT = poRAT; /* -------------------------------------------------------------------- */ /* Build a conventional color table from this. */ /* -------------------------------------------------------------------- */ ((IDARasterBand *) GetRasterBand( 1 ))->poColorTable = poRAT->TranslateToColorTable(); }
CPLErr VRTWarpedDataset::IBuildOverviews( const char *pszResampling, int nOverviews, int *panOverviewList, int nListBands, int *panBandList, GDALProgressFunc pfnProgress, void * pProgressData ) { /* -------------------------------------------------------------------- */ /* Initial progress result. */ /* -------------------------------------------------------------------- */ if( !pfnProgress( 0.0, NULL, pProgressData ) ) { CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" ); return CE_Failure; } /* -------------------------------------------------------------------- */ /* Establish which of the overview levels we already have, and */ /* which are new. */ /* -------------------------------------------------------------------- */ int i, nNewOverviews, *panNewOverviewList = NULL; nNewOverviews = 0; panNewOverviewList = (int *) CPLCalloc(sizeof(int),nOverviews); for( i = 0; i < nOverviews; i++ ) { int j; for( j = 0; j < nOverviewCount; j++ ) { int nOvFactor; VRTWarpedDataset *poOverview = papoOverviews[j]; nOvFactor = (int) (0.5+GetRasterXSize() / (double) poOverview->GetRasterXSize()); if( nOvFactor == panOverviewList[i] || nOvFactor == GDALOvLevelAdjust( panOverviewList[i], GetRasterXSize() ) ) panOverviewList[i] *= -1; } if( panOverviewList[i] > 0 ) panNewOverviewList[nNewOverviews++] = panOverviewList[i]; } /* -------------------------------------------------------------------- */ /* Create each missing overview (we don't need to do anything */ /* to update existing overviews). */ /* -------------------------------------------------------------------- */ for( i = 0; i < nNewOverviews; i++ ) { int nOXSize, nOYSize, iBand; VWOTInfo *psInfo; VRTWarpedDataset *poOverviewDS; /* -------------------------------------------------------------------- */ /* What size should this overview be. */ /* -------------------------------------------------------------------- */ nOXSize = (GetRasterXSize() + panNewOverviewList[i] - 1) / panNewOverviewList[i]; nOYSize = (GetRasterYSize() + panNewOverviewList[i] - 1) / panNewOverviewList[i]; /* -------------------------------------------------------------------- */ /* Create the overview dataset. */ /* -------------------------------------------------------------------- */ poOverviewDS = new VRTWarpedDataset( nOXSize, nOYSize ); for( iBand = 0; iBand < GetRasterCount(); iBand++ ) { GDALRasterBand *poOldBand = GetRasterBand(iBand+1); VRTWarpedRasterBand *poNewBand = new VRTWarpedRasterBand( poOverviewDS, iBand+1, poOldBand->GetRasterDataType() ); poNewBand->CopyCommonInfoFrom( poOldBand ); poOverviewDS->SetBand( iBand+1, poNewBand ); } nOverviewCount++; papoOverviews = (VRTWarpedDataset **) CPLRealloc( papoOverviews, sizeof(void*) * nOverviewCount ); papoOverviews[nOverviewCount-1] = poOverviewDS; /* -------------------------------------------------------------------- */ /* Prepare update transformation information that will apply */ /* the overview decimation. */ /* -------------------------------------------------------------------- */ GDALWarpOptions *psWO = (GDALWarpOptions *) poWarper->GetOptions(); psInfo = (VWOTInfo *) CPLCalloc(sizeof(VWOTInfo),1); strcpy( psInfo->sTI.szSignature, "GTI" ); psInfo->sTI.pszClassName = "VRTWarpedOverviewTransform"; psInfo->sTI.pfnTransform = VRTWarpedOverviewTransform; psInfo->sTI.pfnCleanup = VRTWarpedOverviewCleanup; psInfo->sTI.pfnSerialize = NULL; psInfo->pfnBaseTransformer = psWO->pfnTransformer; psInfo->pBaseTransformerArg = psWO->pTransformerArg; psInfo->dfXOverviewFactor = GetRasterXSize() / (double) nOXSize; psInfo->dfYOverviewFactor = GetRasterYSize() / (double) nOYSize; /* -------------------------------------------------------------------- */ /* Initialize the new dataset with adjusted warp options, and */ /* then restore to original condition. */ /* -------------------------------------------------------------------- */ psWO->pfnTransformer = VRTWarpedOverviewTransform; psWO->pTransformerArg = psInfo; poOverviewDS->Initialize( psWO ); psWO->pfnTransformer = psInfo->pfnBaseTransformer; psWO->pTransformerArg = psInfo->pBaseTransformerArg; } CPLFree( panNewOverviewList ); /* -------------------------------------------------------------------- */ /* Progress finished. */ /* -------------------------------------------------------------------- */ pfnProgress( 1.0, NULL, pProgressData ); SetNeedsFlush(); return CE_None; }
CPLErr VRTWarpedDataset::ProcessBlock( int iBlockX, int iBlockY ) { if( poWarper == NULL ) return CE_Failure; const GDALWarpOptions *psWO = poWarper->GetOptions(); /* -------------------------------------------------------------------- */ /* Allocate block of memory large enough to hold all the bands */ /* for this block. */ /* -------------------------------------------------------------------- */ int iBand; GByte *pabyDstBuffer; int nDstBufferSize; int nWordSize = (GDALGetDataTypeSize(psWO->eWorkingDataType) / 8); // FIXME? : risk of overflow in multiplication if nBlockXSize or nBlockYSize are very large nDstBufferSize = nBlockXSize * nBlockYSize * psWO->nBandCount * nWordSize; pabyDstBuffer = (GByte *) VSIMalloc(nDstBufferSize); if( pabyDstBuffer == NULL ) { CPLError( CE_Failure, CPLE_OutOfMemory, "Out of memory allocating %d byte buffer in VRTWarpedDataset::ProcessBlock()", nDstBufferSize ); return CE_Failure; } memset( pabyDstBuffer, 0, nDstBufferSize ); /* -------------------------------------------------------------------- */ /* Process INIT_DEST option to initialize the buffer prior to */ /* warping into it. */ /* NOTE:The following code is 99% similar in gdalwarpoperation.cpp and */ /* vrtwarped.cpp. Be careful to keep it in sync ! */ /* -------------------------------------------------------------------- */ const char *pszInitDest = CSLFetchNameValue( psWO->papszWarpOptions, "INIT_DEST" ); if( pszInitDest != NULL && !EQUAL(pszInitDest, "") ) { char **papszInitValues = CSLTokenizeStringComplex( pszInitDest, ",", FALSE, FALSE ); int nInitCount = CSLCount(papszInitValues); for( iBand = 0; iBand < psWO->nBandCount; iBand++ ) { double adfInitRealImag[2]; GByte *pBandData; int nBandSize = nBlockXSize * nBlockYSize * nWordSize; const char *pszBandInit = papszInitValues[MIN(iBand,nInitCount-1)]; if( EQUAL(pszBandInit,"NO_DATA") && psWO->padfDstNoDataReal != NULL ) { adfInitRealImag[0] = psWO->padfDstNoDataReal[iBand]; adfInitRealImag[1] = psWO->padfDstNoDataImag[iBand]; } else { CPLStringToComplex( pszBandInit, adfInitRealImag + 0, adfInitRealImag + 1); } pBandData = ((GByte *) pabyDstBuffer) + iBand * nBandSize; if( psWO->eWorkingDataType == GDT_Byte ) memset( pBandData, MAX(0,MIN(255,(int)adfInitRealImag[0])), nBandSize); else if( adfInitRealImag[0] == 0.0 && adfInitRealImag[1] == 0 ) { memset( pBandData, 0, nBandSize ); } else if( adfInitRealImag[1] == 0.0 ) { GDALCopyWords( &adfInitRealImag, GDT_Float64, 0, pBandData,psWO->eWorkingDataType,nWordSize, nBlockXSize * nBlockYSize ); } else { GDALCopyWords( &adfInitRealImag, GDT_CFloat64, 0, pBandData,psWO->eWorkingDataType,nWordSize, nBlockXSize * nBlockYSize ); } } CSLDestroy( papszInitValues ); } /* -------------------------------------------------------------------- */ /* Warp into this buffer. */ /* -------------------------------------------------------------------- */ CPLErr eErr; eErr = poWarper->WarpRegionToBuffer( iBlockX * nBlockXSize, iBlockY * nBlockYSize, nBlockXSize, nBlockYSize, pabyDstBuffer, psWO->eWorkingDataType ); if( eErr != CE_None ) { VSIFree( pabyDstBuffer ); return eErr; } /* -------------------------------------------------------------------- */ /* Copy out into cache blocks for each band. */ /* -------------------------------------------------------------------- */ for( iBand = 0; iBand < psWO->nBandCount; iBand++ ) { GDALRasterBand *poBand; GDALRasterBlock *poBlock; poBand = GetRasterBand(iBand+1); poBlock = poBand->GetLockedBlockRef( iBlockX, iBlockY, TRUE ); CPLAssert( poBlock != NULL && poBlock->GetDataRef() != NULL ); GDALCopyWords( pabyDstBuffer + iBand*nBlockXSize*nBlockYSize*nWordSize, psWO->eWorkingDataType, nWordSize, poBlock->GetDataRef(), poBlock->GetDataType(), GDALGetDataTypeSize(poBlock->GetDataType())/8, nBlockXSize * nBlockYSize ); poBlock->DropLock(); } VSIFree( pabyDstBuffer ); return CE_None; }
int JPEG2000Dataset::DecodeImage() { if (bAlreadyDecoded) return psImage != NULL; bAlreadyDecoded = TRUE; if ( !( psImage = jas_image_decode(psStream, iFormat, 0) ) ) { CPLDebug( "JPEG2000", "Unable to decode image. Format: %s, %d", jas_image_fmttostr( iFormat ), iFormat ); return FALSE; } /* Case of a JP2 image : check that the properties given by */ /* the JP2 boxes match the ones of the code stream */ if (nBands != 0) { if (nBands != jas_image_numcmpts( psImage )) { CPLError(CE_Failure, CPLE_AppDefined, "The number of components indicated in the IHDR box (%d) mismatch " "the value specified in the code stream (%d)", nBands, jas_image_numcmpts( psImage )); jas_image_destroy( psImage ); psImage = NULL; return FALSE; } if (nRasterXSize != jas_image_cmptwidth( psImage, 0 ) || nRasterYSize != jas_image_cmptheight( psImage, 0 ) ) { CPLError(CE_Failure, CPLE_AppDefined, "The dimensions indicated in the IHDR box (%d x %d) mismatch " "the value specified in the code stream (%d x %d)", nRasterXSize, nRasterYSize, jas_image_cmptwidth( psImage, 0 ), jas_image_cmptheight( psImage, 0 )); jas_image_destroy( psImage ); psImage = NULL; return FALSE; } int iBand; for ( iBand = 0; iBand < nBands; iBand++ ) { JPEG2000RasterBand* poBand = (JPEG2000RasterBand*) GetRasterBand(iBand+1); if (poBand->iDepth != jas_image_cmptprec( psImage, iBand ) || poBand->bSignedness != jas_image_cmptsgnd( psImage, iBand )) { CPLError(CE_Failure, CPLE_AppDefined, "The bit depth of band %d indicated in the IHDR box (%d) mismatch " "the value specified in the code stream (%d)", iBand + 1, poBand->iDepth, jas_image_cmptprec( psImage, iBand )); jas_image_destroy( psImage ); psImage = NULL; return FALSE; } } } /* Ask for YCbCr -> RGB translation */ if ( jas_clrspc_fam( jas_image_clrspc( psImage ) ) == JAS_CLRSPC_FAM_YCBCR ) { jas_image_t *psRGBImage; jas_cmprof_t *psRGBProf; CPLDebug( "JPEG2000", "forcing conversion to sRGB"); if (!(psRGBProf = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB))) { CPLDebug( "JPEG2000", "cannot create sRGB profile"); return TRUE; } if (!(psRGBImage = jas_image_chclrspc(psImage, psRGBProf, JAS_CMXFORM_INTENT_PER))) { CPLDebug( "JPEG2000", "cannot convert to sRGB"); jas_cmprof_destroy(psRGBProf); return TRUE; } jas_image_destroy(psImage); jas_cmprof_destroy(psRGBProf); psImage = psRGBImage; } return TRUE; }
void ROIPACDataset::FlushCache( void ) { RawDataset::FlushCache(); GDALRasterBand *band = (GetRasterCount() > 0) ? GetRasterBand(1) : NULL; if ( eAccess == GA_ReadOnly || band == NULL ) return; // If opening an existing file in Update mode (i.e. "r+") we need to make // sure any existing content is cleared, otherwise the file may contain // trailing content from the previous write. CPL_IGNORE_RET_VAL(VSIFTruncateL( fpRsc, 0 )); CPL_IGNORE_RET_VAL(VSIFSeekL( fpRsc, 0, SEEK_SET )); /* -------------------------------------------------------------------- */ /* Rewrite out the header. */ /* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */ /* Raster dimensions. */ /* -------------------------------------------------------------------- */ CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %d\n", "WIDTH", nRasterXSize )); CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %d\n", "FILE_LENGTH", nRasterYSize )); /* -------------------------------------------------------------------- */ /* Georeferencing. */ /* -------------------------------------------------------------------- */ if ( pszProjection != NULL ) { char *pszProjectionTmp = pszProjection; OGRSpatialReference oSRS; if( oSRS.importFromWkt( &pszProjectionTmp ) == OGRERR_NONE ) { int bNorth; int iUTMZone = oSRS.GetUTMZone( &bNorth ); if ( iUTMZone != 0 ) { CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s%d\n", "PROJECTION", "UTM", iUTMZone )); } else if ( oSRS.IsGeographic() ) { CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "PROJECTION", "LL" )); } else { CPLError( CE_Warning, CPLE_AppDefined, "ROI_PAC format only support Latitude/Longitude and " "UTM projections, discarding projection."); } if ( oSRS.GetAttrValue( "DATUM" ) != NULL ) { if ( strcmp( oSRS.GetAttrValue( "DATUM" ), "WGS_1984" ) == 0 ) { CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "DATUM", "WGS84" )); } else { CPLError( CE_Warning, CPLE_AppDefined, "Datum \"%s\" probably not supported in the " "ROI_PAC format, saving it anyway", oSRS.GetAttrValue( "DATUM" ) ); CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "DATUM", oSRS.GetAttrValue( "DATUM" ) )); } } if ( oSRS.GetAttrValue( "UNIT" ) != NULL ) { CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "X_UNIT", oSRS.GetAttrValue( "UNIT" ) )); CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "Y_UNIT", oSRS.GetAttrValue( "UNIT" ) )); } } } if( bValidGeoTransform ) { if ( adfGeoTransform[2] != 0 || adfGeoTransform[4] != 0 ) { CPLError( CE_Warning, CPLE_AppDefined, "ROI_PAC format do not support geotransform with " "rotation, discarding info."); } else { CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "X_FIRST", adfGeoTransform[0] )); CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "X_STEP", adfGeoTransform[1] )); CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "Y_FIRST", adfGeoTransform[3] )); CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "Y_STEP", adfGeoTransform[5] )); CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "Z_OFFSET", band->GetOffset(NULL) )); CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "Z_SCALE", band->GetScale(NULL) )); } } /* -------------------------------------------------------------------- */ /* Metadata stored in the ROI_PAC domain. */ /* -------------------------------------------------------------------- */ char** papszROIPACMetadata = GetMetadata( "ROI_PAC" ); for (int i = 0; i < CSLCount( papszROIPACMetadata ); i++) { /* Get the tokens from the metadata item */ char **papszTokens = CSLTokenizeString2( papszROIPACMetadata[i], "=", CSLT_STRIPLEADSPACES | CSLT_STRIPENDSPACES); if ( CSLCount( papszTokens ) != 2 ) { CPLDebug("ROI_PAC", "Line of header file could not be split at = into two elements: %s", papszROIPACMetadata[i]); CSLDestroy( papszTokens ); continue; } /* Don't write it out if it is one of the bits of metadata that is * written out elsewhere in this routine */ if ( strcmp( papszTokens[0], "WIDTH" ) == 0 || strcmp( papszTokens[0], "FILE_LENGTH" ) == 0 ) { CSLDestroy( papszTokens ); continue; } CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", papszTokens[0], papszTokens[1] )); CSLDestroy( papszTokens ); } }
void ISCEDataset::FlushCache( void ) { RawDataset::FlushCache(); GDALRasterBand *band = (GetRasterCount() > 0) ? GetRasterBand(1) : NULL; if ( eAccess == GA_ReadOnly || band == NULL ) return; /* -------------------------------------------------------------------- */ /* Recreate a XML doc with the dataset information. */ /* -------------------------------------------------------------------- */ char sBuf[64]; CPLXMLNode *psDocNode = CPLCreateXMLNode( NULL, CXT_Element, "imageFile" ); CPLXMLNode *psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" ); CPLAddXMLAttributeAndValue( psTmpNode, "name", "WIDTH" ); snprintf(sBuf, sizeof(sBuf), "%d", nRasterXSize); CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf ); psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" ); CPLAddXMLAttributeAndValue( psTmpNode, "name", "LENGTH" ); snprintf(sBuf, sizeof(sBuf), "%d", nRasterYSize); CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf ); psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" ); CPLAddXMLAttributeAndValue( psTmpNode, "name", "NUMBER_BANDS" ); snprintf(sBuf, sizeof(sBuf), "%d", nBands); CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf ); const char *sType = GDALGetDataTypeName( band->GetRasterDataType() ); psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" ); CPLAddXMLAttributeAndValue( psTmpNode, "name", "DATA_TYPE" ); CPLCreateXMLElementAndValue( psTmpNode, "value", CSLFetchNameValue( (char **)apszGDAL2ISCEDatatypes, sType ) ); const char *sScheme = apszSchemeNames[eScheme]; psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" ); CPLAddXMLAttributeAndValue( psTmpNode, "name", "SCHEME" ); CPLCreateXMLElementAndValue( psTmpNode, "value", sScheme ); psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" ); CPLAddXMLAttributeAndValue( psTmpNode, "name", "BYTE_ORDER" ); #ifdef CPL_LSB CPLCreateXMLElementAndValue( psTmpNode, "value", "l" ); #else CPLCreateXMLElementAndValue( psTmpNode, "value", "b" ); #endif /* -------------------------------------------------------------------- */ /* Then, add the ISCE domain metadata. */ /* -------------------------------------------------------------------- */ char **papszISCEMetadata = GetMetadata( "ISCE" ); for (int i = 0; i < CSLCount( papszISCEMetadata ); i++) { /* Get the tokens from the metadata item */ char **papszTokens = CSLTokenizeString2( papszISCEMetadata[i], "=", CSLT_STRIPLEADSPACES | CSLT_STRIPENDSPACES); if ( CSLCount( papszTokens ) != 2 ) { CPLDebug( "ISCE", "Line of header file could not be split at = into two" " elements: %s", papszISCEMetadata[i] ); CSLDestroy( papszTokens ); continue; } /* Don't write it out if it is one of the bits of metadata that is * written out elsewhere in this routine */ if ( strcmp( papszTokens[0], "WIDTH" ) == 0 || strcmp( papszTokens[0], "LENGTH" ) == 0 || strcmp( papszTokens[0], "NUMBER_BANDS" ) == 0 || strcmp( papszTokens[0], "DATA_TYPE" ) == 0 || strcmp( papszTokens[0], "SCHEME" ) == 0 || strcmp( papszTokens[0], "BYTE_ORDER" ) == 0 ) { CSLDestroy( papszTokens ); continue; } psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" ); CPLAddXMLAttributeAndValue( psTmpNode, "name", papszTokens[0] ); CPLCreateXMLElementAndValue( psTmpNode, "value", papszTokens[1] ); CSLDestroy( papszTokens ); } /* -------------------------------------------------------------------- */ /* Write the XML file. */ /* -------------------------------------------------------------------- */ CPLSerializeXMLTreeToFile( psDocNode, pszXMLFilename ); /* -------------------------------------------------------------------- */ /* Free the XML Doc. */ /* -------------------------------------------------------------------- */ CPLDestroyXMLNode( psDocNode ); }
bool GDALApplyVSGDataset::IsInitOK() { GDALApplyVSGRasterBand* poBand = reinterpret_cast<GDALApplyVSGRasterBand*>(GetRasterBand(1)); return poBand->m_pafSrcData != nullptr && poBand->m_pafGridData != nullptr; }
int NTv2Dataset::OpenGrid( char *pachHeader, vsi_l_offset nGridOffset ) { this->nGridOffset = nGridOffset; /* -------------------------------------------------------------------- */ /* Read the grid header. */ /* -------------------------------------------------------------------- */ double s_lat, n_lat, e_long, w_long, lat_inc, long_inc; CaptureMetadataItem( pachHeader + 0*16 ); CaptureMetadataItem( pachHeader + 1*16 ); CaptureMetadataItem( pachHeader + 2*16 ); CaptureMetadataItem( pachHeader + 3*16 ); memcpy( &s_lat, pachHeader + 4*16 + 8, 8 ); memcpy( &n_lat, pachHeader + 5*16 + 8, 8 ); memcpy( &e_long, pachHeader + 6*16 + 8, 8 ); memcpy( &w_long, pachHeader + 7*16 + 8, 8 ); memcpy( &lat_inc, pachHeader + 8*16 + 8, 8 ); memcpy( &long_inc, pachHeader + 9*16 + 8, 8 ); e_long *= -1; w_long *= -1; nRasterXSize = (int) floor((e_long - w_long) / long_inc + 1.5); nRasterYSize = (int) floor((n_lat - s_lat) / lat_inc + 1.5); if (!GDALCheckDatasetDimensions(nRasterXSize, nRasterYSize)) return FALSE; /* -------------------------------------------------------------------- */ /* Create band information object. */ /* */ /* We use unusual offsets to remap from bottom to top, to top */ /* to bottom orientation, and also to remap east to west, to */ /* west to east. */ /* -------------------------------------------------------------------- */ int iBand; for( iBand = 0; iBand < 4; iBand++ ) { RawRasterBand *poBand = new RawRasterBand( this, iBand+1, fpImage, nGridOffset + 4*iBand + 11*16 + (nRasterXSize-1) * 16 + (nRasterYSize-1) * 16 * nRasterXSize, -16, -16 * nRasterXSize, GDT_Float32, CPL_IS_LSB, TRUE, FALSE ); SetBand( iBand+1, poBand ); } GetRasterBand(1)->SetDescription( "Latitude Offset (arc seconds)" ); GetRasterBand(2)->SetDescription( "Longitude Offset (arc seconds)" ); GetRasterBand(3)->SetDescription( "Latitude Error" ); GetRasterBand(4)->SetDescription( "Longitude Error" ); /* -------------------------------------------------------------------- */ /* Setup georeferencing. */ /* -------------------------------------------------------------------- */ adfGeoTransform[0] = (w_long - long_inc*0.5) / 3600.0; adfGeoTransform[1] = long_inc / 3600.0; adfGeoTransform[2] = 0.0; adfGeoTransform[3] = (n_lat + lat_inc*0.5) / 3600.0; adfGeoTransform[4] = 0.0; adfGeoTransform[5] = (-1 * lat_inc) / 3600.0; return TRUE; }
CPLErr RasterliteDataset::CreateOverviewLevel(const char * pszResampling, int nOvrFactor, char** papszOptions, GDALProgressFunc pfnProgress, void * pProgressData) { double dfXResolution = padfXResolutions[0] * nOvrFactor; double dfYResolution = padfXResolutions[0] * nOvrFactor; CPLString osSQL; int nOvrXSize = nRasterXSize / nOvrFactor; int nOvrYSize = nRasterYSize / nOvrFactor; if (nOvrXSize == 0 || nOvrYSize == 0) return CE_Failure; int bTiled = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "TILED", "YES")); int nBlockXSize, nBlockYSize; if (bTiled) { nBlockXSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKXSIZE", "256")); nBlockYSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKYSIZE", "256")); if (nBlockXSize < 64) nBlockXSize = 64; else if (nBlockXSize > 4096) nBlockXSize = 4096; if (nBlockYSize < 64) nBlockYSize = 64; else if (nBlockYSize > 4096) nBlockYSize = 4096; } else { nBlockXSize = nOvrXSize; nBlockYSize = nOvrYSize; } int nXBlocks = (nOvrXSize + nBlockXSize - 1) / nBlockXSize; int nYBlocks = (nOvrYSize + nBlockYSize - 1) / nBlockYSize; const char* pszDriverName = CSLFetchNameValueDef(papszOptions, "DRIVER", "GTiff"); if (EQUAL(pszDriverName, "MEM") || EQUAL(pszDriverName, "VRT")) { CPLError(CE_Failure, CPLE_AppDefined, "GDAL %s driver cannot be used as underlying driver", pszDriverName); return CE_Failure; } GDALDriverH hTileDriver = GDALGetDriverByName(pszDriverName); if (hTileDriver == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL %s driver", pszDriverName); return CE_Failure; } GDALDriverH hMemDriver = GDALGetDriverByName("MEM"); if (hMemDriver == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL MEM driver"); return CE_Failure; } GDALDataType eDataType = GetRasterBand(1)->GetRasterDataType(); int nDataTypeSize = GDALGetDataTypeSize(eDataType) / 8; GByte* pabyMEMDSBuffer = (GByte*)VSIMalloc3(nBlockXSize, nBlockYSize, nBands * nDataTypeSize); if (pabyMEMDSBuffer == NULL) { return CE_Failure; } CPLString osTempFileName; osTempFileName.Printf("/vsimem/%p", hDS); int nTileId = 0; int nBlocks = 0; int nTotalBlocks = nXBlocks * nYBlocks; CPLString osRasterLayer; osRasterLayer.Printf("%s_rasters", osTableName.c_str()); CPLString osMetatadataLayer; osMetatadataLayer.Printf("%s_metadata", osTableName.c_str()); OGRLayerH hRasterLayer = OGR_DS_GetLayerByName(hDS, osRasterLayer.c_str()); OGRLayerH hMetadataLayer = OGR_DS_GetLayerByName(hDS, osMetatadataLayer.c_str()); CPLString osSourceName = "unknown"; osSQL.Printf("SELECT source_name FROM \"%s\" WHERE " "%s LIMIT 1", osMetatadataLayer.c_str(), RasterliteGetPixelSizeCond(padfXResolutions[0], padfYResolutions[0]).c_str()); OGRLayerH hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL); if (hSQLLyr) { OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr); if (hFeat) { const char* pszVal = OGR_F_GetFieldAsString(hFeat, 0); if (pszVal) osSourceName = pszVal; OGR_F_Destroy(hFeat); } OGR_DS_ReleaseResultSet(hDS, hSQLLyr); } /* -------------------------------------------------------------------- */ /* Compute up to which existing overview level we can use for */ /* computing the requested overview */ /* -------------------------------------------------------------------- */ int iLev; nLimitOvrCount = 0; for(iLev=1;iLev<nResolutions;iLev++) { if (!(padfXResolutions[iLev] < dfXResolution - 1e-10 && padfYResolutions[iLev] < dfYResolution - 1e-10)) { break; } nLimitOvrCount++; } /* -------------------------------------------------------------------- */ /* Allocate buffer for tile of previous overview level */ /* -------------------------------------------------------------------- */ GDALDataset* poPrevOvrLevel = (papoOverviews != NULL && iLev >= 2 && iLev <= nResolutions && papoOverviews[iLev-2]) ? papoOverviews[iLev-2] : this; double dfRatioPrevOvr = poPrevOvrLevel->GetRasterBand(1)->GetXSize() / nOvrXSize; int nPrevOvrBlockXSize = (int)(nBlockXSize * dfRatioPrevOvr + 0.5); int nPrevOvrBlockYSize = (int)(nBlockYSize * dfRatioPrevOvr + 0.5); GByte* pabyPrevOvrMEMDSBuffer = NULL; if( !EQUALN(pszResampling, "NEAR", 4)) { pabyPrevOvrMEMDSBuffer = (GByte*)VSIMalloc3(nPrevOvrBlockXSize, nPrevOvrBlockYSize, nBands * nDataTypeSize); if (pabyPrevOvrMEMDSBuffer == NULL) { VSIFree(pabyMEMDSBuffer); return CE_Failure; } } /* -------------------------------------------------------------------- */ /* Iterate over blocks to add data into raster and metadata tables */ /* -------------------------------------------------------------------- */ char** papszTileDriverOptions = RasterliteGetTileDriverOptions(papszOptions); OGR_DS_ExecuteSQL(hDS, "BEGIN", NULL, NULL); CPLErr eErr = CE_None; int nBlockXOff, nBlockYOff; for(nBlockYOff=0;eErr == CE_None && nBlockYOff<nYBlocks;nBlockYOff++) { for(nBlockXOff=0;eErr == CE_None && nBlockXOff<nXBlocks;nBlockXOff++) { GDALDatasetH hPrevOvrMemDS = NULL; /* -------------------------------------------------------------------- */ /* Create in-memory tile */ /* -------------------------------------------------------------------- */ int nReqXSize = nBlockXSize, nReqYSize = nBlockYSize; if ((nBlockXOff+1) * nBlockXSize > nOvrXSize) nReqXSize = nOvrXSize - nBlockXOff * nBlockXSize; if ((nBlockYOff+1) * nBlockYSize > nOvrYSize) nReqYSize = nOvrYSize - nBlockYOff * nBlockYSize; if( pabyPrevOvrMEMDSBuffer != NULL ) { int nPrevOvrReqXSize = (int)(nReqXSize * dfRatioPrevOvr + 0.5); int nPrevOvrReqYSize = (int)(nReqYSize * dfRatioPrevOvr + 0.5); eErr = RasterIO(GF_Read, nBlockXOff * nBlockXSize * nOvrFactor, nBlockYOff * nBlockYSize * nOvrFactor, nReqXSize * nOvrFactor, nReqYSize * nOvrFactor, pabyPrevOvrMEMDSBuffer, nPrevOvrReqXSize, nPrevOvrReqYSize, eDataType, nBands, NULL, 0, 0, 0, NULL); if (eErr != CE_None) { break; } hPrevOvrMemDS = GDALCreate(hMemDriver, "MEM:::", nPrevOvrReqXSize, nPrevOvrReqYSize, 0, eDataType, NULL); if (hPrevOvrMemDS == NULL) { eErr = CE_Failure; break; } int iBand; for(iBand = 0; iBand < nBands; iBand ++) { char** papszOptions = NULL; char szTmp[64]; memset(szTmp, 0, sizeof(szTmp)); CPLPrintPointer(szTmp, pabyPrevOvrMEMDSBuffer + iBand * nDataTypeSize * nPrevOvrReqXSize * nPrevOvrReqYSize, sizeof(szTmp)); papszOptions = CSLSetNameValue(papszOptions, "DATAPOINTER", szTmp); GDALAddBand(hPrevOvrMemDS, eDataType, papszOptions); CSLDestroy(papszOptions); } } else { eErr = RasterIO(GF_Read, nBlockXOff * nBlockXSize * nOvrFactor, nBlockYOff * nBlockYSize * nOvrFactor, nReqXSize * nOvrFactor, nReqYSize * nOvrFactor, pabyMEMDSBuffer, nReqXSize, nReqYSize, eDataType, nBands, NULL, 0, 0, 0, NULL); if (eErr != CE_None) { break; } } GDALDatasetH hMemDS = GDALCreate(hMemDriver, "MEM:::", nReqXSize, nReqYSize, 0, eDataType, NULL); if (hMemDS == NULL) { eErr = CE_Failure; break; } int iBand; for(iBand = 0; iBand < nBands; iBand ++) { char** papszOptions = NULL; char szTmp[64]; memset(szTmp, 0, sizeof(szTmp)); CPLPrintPointer(szTmp, pabyMEMDSBuffer + iBand * nDataTypeSize * nReqXSize * nReqYSize, sizeof(szTmp)); papszOptions = CSLSetNameValue(papszOptions, "DATAPOINTER", szTmp); GDALAddBand(hMemDS, eDataType, papszOptions); CSLDestroy(papszOptions); } if( hPrevOvrMemDS != NULL ) { for(iBand = 0; iBand < nBands; iBand ++) { GDALRasterBandH hDstOvrBand = GDALGetRasterBand(hMemDS, iBand+1); eErr = GDALRegenerateOverviews( GDALGetRasterBand(hPrevOvrMemDS, iBand+1), 1, &hDstOvrBand, pszResampling, NULL, NULL ); if( eErr != CE_None ) break; } GDALClose(hPrevOvrMemDS); } GDALDatasetH hOutDS = GDALCreateCopy(hTileDriver, osTempFileName.c_str(), hMemDS, FALSE, papszTileDriverOptions, NULL, NULL); GDALClose(hMemDS); if (hOutDS) GDALClose(hOutDS); else { eErr = CE_Failure; break; } /* -------------------------------------------------------------------- */ /* Insert new entry into raster table */ /* -------------------------------------------------------------------- */ vsi_l_offset nDataLength; GByte *pabyData = VSIGetMemFileBuffer( osTempFileName.c_str(), &nDataLength, FALSE); OGRFeatureH hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hRasterLayer) ); OGR_F_SetFieldBinary(hFeat, 0, (int)nDataLength, pabyData); OGR_L_CreateFeature(hRasterLayer, hFeat); /* Query raster ID to set it as the ID of the associated metadata */ int nRasterID = (int)OGR_F_GetFID(hFeat); OGR_F_Destroy(hFeat); VSIUnlink(osTempFileName.c_str()); /* -------------------------------------------------------------------- */ /* Insert new entry into metadata table */ /* -------------------------------------------------------------------- */ hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hMetadataLayer) ); OGR_F_SetFID(hFeat, nRasterID); OGR_F_SetFieldString(hFeat, 0, osSourceName); OGR_F_SetFieldInteger(hFeat, 1, nTileId ++); OGR_F_SetFieldInteger(hFeat, 2, nReqXSize); OGR_F_SetFieldInteger(hFeat, 3, nReqYSize); OGR_F_SetFieldDouble(hFeat, 4, dfXResolution); OGR_F_SetFieldDouble(hFeat, 5, dfYResolution); double minx, maxx, maxy, miny; minx = adfGeoTransform[0] + (nBlockXSize * nBlockXOff) * dfXResolution; maxx = adfGeoTransform[0] + (nBlockXSize * nBlockXOff + nReqXSize) * dfXResolution; maxy = adfGeoTransform[3] + (nBlockYSize * nBlockYOff) * (-dfYResolution); miny = adfGeoTransform[3] + (nBlockYSize * nBlockYOff + nReqYSize) * (-dfYResolution); OGRGeometryH hRectangle = OGR_G_CreateGeometry(wkbPolygon); OGRGeometryH hLinearRing = OGR_G_CreateGeometry(wkbLinearRing); OGR_G_AddPoint_2D(hLinearRing, minx, miny); OGR_G_AddPoint_2D(hLinearRing, minx, maxy); OGR_G_AddPoint_2D(hLinearRing, maxx, maxy); OGR_G_AddPoint_2D(hLinearRing, maxx, miny); OGR_G_AddPoint_2D(hLinearRing, minx, miny); OGR_G_AddGeometryDirectly(hRectangle, hLinearRing); OGR_F_SetGeometryDirectly(hFeat, hRectangle); OGR_L_CreateFeature(hMetadataLayer, hFeat); OGR_F_Destroy(hFeat); nBlocks++; if (pfnProgress && !pfnProgress(1.0 * nBlocks / nTotalBlocks, NULL, pProgressData)) eErr = CE_Failure; } } nLimitOvrCount = -1; if (eErr == CE_None) OGR_DS_ExecuteSQL(hDS, "COMMIT", NULL, NULL); else OGR_DS_ExecuteSQL(hDS, "ROLLBACK", NULL, NULL); VSIFree(pabyMEMDSBuffer); VSIFree(pabyPrevOvrMEMDSBuffer); CSLDestroy(papszTileDriverOptions); papszTileDriverOptions = NULL; /* -------------------------------------------------------------------- */ /* Update raster_pyramids table */ /* -------------------------------------------------------------------- */ if (eErr == CE_None) { OGRLayerH hRasterPyramidsLyr = OGR_DS_GetLayerByName(hDS, "raster_pyramids"); if (hRasterPyramidsLyr == NULL) { osSQL.Printf ("CREATE TABLE raster_pyramids (" "table_prefix TEXT NOT NULL," "pixel_x_size DOUBLE NOT NULL," "pixel_y_size DOUBLE NOT NULL," "tile_count INTEGER NOT NULL)"); OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL); /* Re-open the DB to take into account the new tables*/ OGRReleaseDataSource(hDS); hDS = RasterliteOpenSQLiteDB(osFileName.c_str(), GA_Update); hRasterPyramidsLyr = OGR_DS_GetLayerByName(hDS, "raster_pyramids"); if (hRasterPyramidsLyr == NULL) return CE_Failure; } OGRFeatureDefnH hFDefn = OGR_L_GetLayerDefn(hRasterPyramidsLyr); /* Insert base resolution into raster_pyramids if not already done */ int bHasBaseResolution = FALSE; osSQL.Printf("SELECT * FROM raster_pyramids WHERE " "table_prefix = '%s' AND %s", osTableName.c_str(), RasterliteGetPixelSizeCond(padfXResolutions[0], padfYResolutions[0]).c_str()); hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL); if (hSQLLyr) { OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr); if (hFeat) { bHasBaseResolution = TRUE; OGR_F_Destroy(hFeat); } OGR_DS_ReleaseResultSet(hDS, hSQLLyr); } if (!bHasBaseResolution) { osSQL.Printf("SELECT COUNT(*) FROM \"%s\" WHERE %s", osMetatadataLayer.c_str(), RasterliteGetPixelSizeCond(padfXResolutions[0], padfYResolutions[0]).c_str()); int nBlocksMainRes = 0; hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL); if (hSQLLyr) { OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr); if (hFeat) { nBlocksMainRes = OGR_F_GetFieldAsInteger(hFeat, 0); OGR_F_Destroy(hFeat); } OGR_DS_ReleaseResultSet(hDS, hSQLLyr); } OGRFeatureH hFeat = OGR_F_Create( hFDefn ); OGR_F_SetFieldString(hFeat, OGR_FD_GetFieldIndex(hFDefn, "table_prefix"), osTableName.c_str()); OGR_F_SetFieldDouble(hFeat, OGR_FD_GetFieldIndex(hFDefn, "pixel_x_size"), padfXResolutions[0]); OGR_F_SetFieldDouble(hFeat, OGR_FD_GetFieldIndex(hFDefn, "pixel_y_size"), padfYResolutions[0]); OGR_F_SetFieldInteger(hFeat, OGR_FD_GetFieldIndex(hFDefn, "tile_count"), nBlocksMainRes); OGR_L_CreateFeature(hRasterPyramidsLyr, hFeat); OGR_F_Destroy(hFeat); } OGRFeatureH hFeat = OGR_F_Create( hFDefn ); OGR_F_SetFieldString(hFeat, OGR_FD_GetFieldIndex(hFDefn, "table_prefix"), osTableName.c_str()); OGR_F_SetFieldDouble(hFeat, OGR_FD_GetFieldIndex(hFDefn, "pixel_x_size"), dfXResolution); OGR_F_SetFieldDouble(hFeat, OGR_FD_GetFieldIndex(hFDefn, "pixel_y_size"), dfYResolution); OGR_F_SetFieldInteger(hFeat, OGR_FD_GetFieldIndex(hFDefn, "tile_count"), nTotalBlocks); OGR_L_CreateFeature(hRasterPyramidsLyr, hFeat); OGR_F_Destroy(hFeat); } return eErr; }
CPLErr GDALPamDataset::CloneInfo( GDALDataset *poSrcDS, int nCloneFlags ) { int bOnlyIfMissing = nCloneFlags & GCIF_ONLY_IF_MISSING; int nSavedMOFlags = GetMOFlags(); PamInitialize(); /* -------------------------------------------------------------------- */ /* Supress NotImplemented error messages - mainly needed if PAM */ /* disabled. */ /* -------------------------------------------------------------------- */ SetMOFlags( nSavedMOFlags | GMO_IGNORE_UNIMPLEMENTED ); /* -------------------------------------------------------------------- */ /* GeoTransform */ /* -------------------------------------------------------------------- */ if( nCloneFlags & GCIF_GEOTRANSFORM ) { double adfGeoTransform[6]; if( poSrcDS->GetGeoTransform( adfGeoTransform ) == CE_None ) { double adfOldGT[6]; if( !bOnlyIfMissing || GetGeoTransform( adfOldGT ) != CE_None ) SetGeoTransform( adfGeoTransform ); } } /* -------------------------------------------------------------------- */ /* Projection */ /* -------------------------------------------------------------------- */ if( nCloneFlags & GCIF_PROJECTION ) { const char *pszWKT = poSrcDS->GetProjectionRef(); if( pszWKT != NULL && strlen(pszWKT) > 0 ) { if( !bOnlyIfMissing || GetProjectionRef() == NULL || strlen(GetProjectionRef()) == 0 ) SetProjection( pszWKT ); } } /* -------------------------------------------------------------------- */ /* GCPs */ /* -------------------------------------------------------------------- */ if( nCloneFlags & GCIF_GCPS ) { if( poSrcDS->GetGCPCount() > 0 ) { if( !bOnlyIfMissing || GetGCPCount() == 0 ) { SetGCPs( poSrcDS->GetGCPCount(), poSrcDS->GetGCPs(), poSrcDS->GetGCPProjection() ); } } } /* -------------------------------------------------------------------- */ /* Metadata */ /* -------------------------------------------------------------------- */ if( nCloneFlags & GCIF_METADATA ) { if( poSrcDS->GetMetadata() != NULL ) { if( !bOnlyIfMissing || CSLCount(GetMetadata()) != CSLCount(poSrcDS->GetMetadata()) ) { SetMetadata( poSrcDS->GetMetadata() ); } } if( poSrcDS->GetMetadata("RPC") != NULL ) { if( !bOnlyIfMissing || CSLCount(GetMetadata("RPC")) != CSLCount(poSrcDS->GetMetadata("RPC")) ) { SetMetadata( poSrcDS->GetMetadata("RPC"), "RPC" ); } } } /* -------------------------------------------------------------------- */ /* Process bands. */ /* -------------------------------------------------------------------- */ if( nCloneFlags & GCIF_PROCESS_BANDS ) { int iBand; for( iBand = 0; iBand < GetRasterCount(); iBand++ ) { GDALPamRasterBand *poBand = (GDALPamRasterBand *) GetRasterBand(iBand+1); if( poBand == NULL || !(poBand->GetMOFlags() & GMO_PAM_CLASS) ) continue; if( poSrcDS->GetRasterCount() >= iBand+1 ) poBand->CloneInfo( poSrcDS->GetRasterBand(iBand+1), nCloneFlags ); else CPLDebug( "GDALPamDataset", "Skipping CloneInfo for band not in source, this is a bit unusual!" ); } } /* -------------------------------------------------------------------- */ /* Copy masks. These are really copied at a lower level using */ /* GDALDefaultOverviews, for formats with no native mask */ /* support but this is a convenient central point to put this */ /* for most drivers. */ /* -------------------------------------------------------------------- */ if( nCloneFlags & GCIF_MASK ) { GDALDriver::DefaultCopyMasks( poSrcDS, this, FALSE ); } /* -------------------------------------------------------------------- */ /* Restore MO flags. */ /* -------------------------------------------------------------------- */ SetMOFlags( nSavedMOFlags ); return CE_None; }
CPLErr GDALPamDataset::XMLInit( CPLXMLNode *psTree, const char *pszVRTPath ) { /* -------------------------------------------------------------------- */ /* Check for an SRS node. */ /* -------------------------------------------------------------------- */ if( strlen(CPLGetXMLValue(psTree, "SRS", "")) > 0 ) { OGRSpatialReference oSRS; CPLFree( psPam->pszProjection ); psPam->pszProjection = NULL; if( oSRS.SetFromUserInput( CPLGetXMLValue(psTree, "SRS", "") ) == OGRERR_NONE ) oSRS.exportToWkt( &(psPam->pszProjection) ); } /* -------------------------------------------------------------------- */ /* Check for a GeoTransform node. */ /* -------------------------------------------------------------------- */ if( strlen(CPLGetXMLValue(psTree, "GeoTransform", "")) > 0 ) { const char *pszGT = CPLGetXMLValue(psTree, "GeoTransform", ""); char **papszTokens; papszTokens = CSLTokenizeStringComplex( pszGT, ",", FALSE, FALSE ); if( CSLCount(papszTokens) != 6 ) { CPLError( CE_Warning, CPLE_AppDefined, "GeoTransform node does not have expected six values."); } else { for( int iTA = 0; iTA < 6; iTA++ ) psPam->adfGeoTransform[iTA] = atof(papszTokens[iTA]); psPam->bHaveGeoTransform = TRUE; } CSLDestroy( papszTokens ); } /* -------------------------------------------------------------------- */ /* Check for GCPs. */ /* -------------------------------------------------------------------- */ CPLXMLNode *psGCPList = CPLGetXMLNode( psTree, "GCPList" ); if( psGCPList != NULL ) { CPLXMLNode *psXMLGCP; OGRSpatialReference oSRS; const char *pszRawProj = CPLGetXMLValue(psGCPList, "Projection", ""); CPLFree( psPam->pszGCPProjection ); if( strlen(pszRawProj) > 0 && oSRS.SetFromUserInput( pszRawProj ) == OGRERR_NONE ) oSRS.exportToWkt( &(psPam->pszGCPProjection) ); else psPam->pszGCPProjection = CPLStrdup(""); // Count GCPs. int nGCPMax = 0; for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL; psXMLGCP = psXMLGCP->psNext ) nGCPMax++; psPam->pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),nGCPMax); for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL; psXMLGCP = psXMLGCP->psNext ) { GDAL_GCP *psGCP = psPam->pasGCPList + psPam->nGCPCount; if( !EQUAL(psXMLGCP->pszValue,"GCP") || psXMLGCP->eType != CXT_Element ) continue; GDALInitGCPs( 1, psGCP ); CPLFree( psGCP->pszId ); psGCP->pszId = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Id","")); CPLFree( psGCP->pszInfo ); psGCP->pszInfo = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Info","")); psGCP->dfGCPPixel = atof(CPLGetXMLValue(psXMLGCP,"Pixel","0.0")); psGCP->dfGCPLine = atof(CPLGetXMLValue(psXMLGCP,"Line","0.0")); psGCP->dfGCPX = atof(CPLGetXMLValue(psXMLGCP,"X","0.0")); psGCP->dfGCPY = atof(CPLGetXMLValue(psXMLGCP,"Y","0.0")); psGCP->dfGCPZ = atof(CPLGetXMLValue(psXMLGCP,"Z","0.0")); psPam->nGCPCount++; } } /* -------------------------------------------------------------------- */ /* Apply any dataset level metadata. */ /* -------------------------------------------------------------------- */ oMDMD.XMLInit( psTree, TRUE ); /* -------------------------------------------------------------------- */ /* Process bands. */ /* -------------------------------------------------------------------- */ CPLXMLNode *psBandTree; for( psBandTree = psTree->psChild; psBandTree != NULL; psBandTree = psBandTree->psNext ) { if( psBandTree->eType != CXT_Element || !EQUAL(psBandTree->pszValue,"PAMRasterBand") ) continue; int nBand = atoi(CPLGetXMLValue( psBandTree, "band", "0")); if( nBand < 1 || nBand > GetRasterCount() ) continue; GDALPamRasterBand *poBand = (GDALPamRasterBand *) GetRasterBand(nBand); if( poBand == NULL || !(poBand->GetMOFlags() & GMO_PAM_CLASS) ) continue; poBand->XMLInit( psBandTree, pszVRTPath ); } /* -------------------------------------------------------------------- */ /* Clear dirty flag. */ /* -------------------------------------------------------------------- */ nPamFlags &= ~GPF_DIRTY; return CE_None; }
void LANDataset::CheckForStatistics() { /* -------------------------------------------------------------------- */ /* Do we have a statistics file? */ /* -------------------------------------------------------------------- */ osSTAFilename = CPLResetExtension(GetDescription(),"sta"); FILE *fpSTA = VSIFOpenL( osSTAFilename, "r" ); #ifndef WIN32 if( fpSTA == NULL ) { osSTAFilename = CPLResetExtension(GetDescription(),"STA"); fpSTA = VSIFOpenL( osSTAFilename, "r" ); } #endif if( fpSTA == NULL ) { osSTAFilename = ""; return; } /* -------------------------------------------------------------------- */ /* Read it one band at a time. */ /* -------------------------------------------------------------------- */ GByte abyBandInfo[1152]; int iBand; for( iBand = 0; iBand < nBands; iBand++ ) { if( VSIFReadL( abyBandInfo, 1152, 1, fpSTA ) != 1 ) break; int nBandNumber = abyBandInfo[7]; GDALRasterBand *poBand = GetRasterBand(nBandNumber); if( poBand == NULL ) break; float fMean, fStdDev; GInt16 nMin, nMax; if( poBand->GetRasterDataType() != GDT_Byte ) { memcpy( &nMin, abyBandInfo + 28, 2 ); memcpy( &nMax, abyBandInfo + 30, 2 ); CPL_LSBPTR16( &nMin ); CPL_LSBPTR16( &nMax ); } else { nMin = abyBandInfo[9]; nMax = abyBandInfo[8]; } memcpy( &fMean, abyBandInfo + 12, 4 ); memcpy( &fStdDev, abyBandInfo + 24, 4 ); CPL_LSBPTR32( &fMean ); CPL_LSBPTR32( &fStdDev ); poBand->SetStatistics( nMin, nMax, fMean, fStdDev ); } VSIFCloseL( fpSTA ); }
CPLXMLNode *GDALPamDataset::SerializeToXML( const char *pszVRTPath ) { CPLString oFmt; if( psPam == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* Setup root node and attributes. */ /* -------------------------------------------------------------------- */ CPLXMLNode *psDSTree; psDSTree = CPLCreateXMLNode( NULL, CXT_Element, "PAMDataset" ); /* -------------------------------------------------------------------- */ /* SRS */ /* -------------------------------------------------------------------- */ if( psPam->pszProjection != NULL && strlen(psPam->pszProjection) > 0 ) CPLSetXMLValue( psDSTree, "SRS", psPam->pszProjection ); /* -------------------------------------------------------------------- */ /* GeoTransform. */ /* -------------------------------------------------------------------- */ if( psPam->bHaveGeoTransform ) { CPLSetXMLValue( psDSTree, "GeoTransform", oFmt.Printf( "%24.16e,%24.16e,%24.16e,%24.16e,%24.16e,%24.16e", psPam->adfGeoTransform[0], psPam->adfGeoTransform[1], psPam->adfGeoTransform[2], psPam->adfGeoTransform[3], psPam->adfGeoTransform[4], psPam->adfGeoTransform[5] ) ); } /* -------------------------------------------------------------------- */ /* Metadata. */ /* -------------------------------------------------------------------- */ CPLXMLNode *psMD; psMD = oMDMD.Serialize(); if( psMD != NULL ) { if( psMD->psChild == NULL ) CPLDestroyXMLNode( psMD ); else CPLAddXMLChild( psDSTree, psMD ); } /* -------------------------------------------------------------------- */ /* GCPs */ /* -------------------------------------------------------------------- */ if( psPam->nGCPCount > 0 ) { CPLXMLNode *psPamGCPList = CPLCreateXMLNode( psDSTree, CXT_Element, "GCPList" ); if( psPam->pszGCPProjection != NULL && strlen(psPam->pszGCPProjection) > 0 ) CPLSetXMLValue( psPamGCPList, "#Projection", psPam->pszGCPProjection ); for( int iGCP = 0; iGCP < psPam->nGCPCount; iGCP++ ) { CPLXMLNode *psXMLGCP; GDAL_GCP *psGCP = psPam->pasGCPList + iGCP; psXMLGCP = CPLCreateXMLNode( psPamGCPList, CXT_Element, "GCP" ); CPLSetXMLValue( psXMLGCP, "#Id", psGCP->pszId ); if( psGCP->pszInfo != NULL && strlen(psGCP->pszInfo) > 0 ) CPLSetXMLValue( psXMLGCP, "Info", psGCP->pszInfo ); CPLSetXMLValue( psXMLGCP, "#Pixel", oFmt.Printf( "%.4f", psGCP->dfGCPPixel ) ); CPLSetXMLValue( psXMLGCP, "#Line", oFmt.Printf( "%.4f", psGCP->dfGCPLine ) ); CPLSetXMLValue( psXMLGCP, "#X", oFmt.Printf( "%.12E", psGCP->dfGCPX ) ); CPLSetXMLValue( psXMLGCP, "#Y", oFmt.Printf( "%.12E", psGCP->dfGCPY ) ); if( psGCP->dfGCPZ != 0.0 ) CPLSetXMLValue( psXMLGCP, "#GCPZ", oFmt.Printf( "%.12E", psGCP->dfGCPZ ) ); } } /* -------------------------------------------------------------------- */ /* Process bands. */ /* -------------------------------------------------------------------- */ int iBand; for( iBand = 0; iBand < GetRasterCount(); iBand++ ) { CPLXMLNode *psBandTree; GDALPamRasterBand *poBand = (GDALPamRasterBand *) GetRasterBand(iBand+1); if( poBand == NULL || !(poBand->GetMOFlags() & GMO_PAM_CLASS) ) continue; psBandTree = poBand->SerializeToXML( pszVRTPath ); if( psBandTree != NULL ) CPLAddXMLChild( psDSTree, psBandTree ); } /* -------------------------------------------------------------------- */ /* We don't want to return anything if we had no metadata to */ /* attach. */ /* -------------------------------------------------------------------- */ if( psDSTree->psChild == NULL ) { CPLDestroyXMLNode( psDSTree ); psDSTree = NULL; } return psDSTree; }
CPLErr GDALPamDataset::TryLoadAux() { /* -------------------------------------------------------------------- */ /* Initialize PAM. */ /* -------------------------------------------------------------------- */ PamInitialize(); if( psPam == NULL ) return CE_None; /* -------------------------------------------------------------------- */ /* What is the name of the physical file we are referencing? */ /* We allow an override via the psPam->pszPhysicalFile item. */ /* -------------------------------------------------------------------- */ const char *pszPhysicalFile = psPam->osPhysicalFilename; if( strlen(pszPhysicalFile) == 0 && GetDescription() != NULL ) pszPhysicalFile = GetDescription(); if( strlen(pszPhysicalFile) == 0 ) return CE_None; /* -------------------------------------------------------------------- */ /* Try to open .aux file. */ /* -------------------------------------------------------------------- */ GDALDataset *poAuxDS = GDALFindAssociatedAuxFile( pszPhysicalFile, GA_ReadOnly, this ); if( poAuxDS == NULL ) return CE_None; /* -------------------------------------------------------------------- */ /* Do we have an SRS on the aux file? */ /* -------------------------------------------------------------------- */ if( strlen(poAuxDS->GetProjectionRef()) > 0 ) GDALPamDataset::SetProjection( poAuxDS->GetProjectionRef() ); /* -------------------------------------------------------------------- */ /* Geotransform. */ /* -------------------------------------------------------------------- */ if( poAuxDS->GetGeoTransform( psPam->adfGeoTransform ) == CE_None ) psPam->bHaveGeoTransform = TRUE; /* -------------------------------------------------------------------- */ /* GCPs */ /* -------------------------------------------------------------------- */ if( poAuxDS->GetGCPCount() > 0 ) { psPam->nGCPCount = poAuxDS->GetGCPCount(); psPam->pasGCPList = GDALDuplicateGCPs( psPam->nGCPCount, poAuxDS->GetGCPs() ); } /* -------------------------------------------------------------------- */ /* Apply metadata. We likely ought to be merging this in rather */ /* than overwriting everything that was there. */ /* -------------------------------------------------------------------- */ char **papszMD = poAuxDS->GetMetadata(); if( CSLCount(papszMD) > 0 ) { char **papszMerged = CSLMerge( CSLDuplicate(GetMetadata()), papszMD ); GDALPamDataset::SetMetadata( papszMerged ); CSLDestroy( papszMerged ); } papszMD = poAuxDS->GetMetadata("XFORMS"); if( CSLCount(papszMD) > 0 ) { char **papszMerged = CSLMerge( CSLDuplicate(GetMetadata("XFORMS")), papszMD ); GDALPamDataset::SetMetadata( papszMerged, "XFORMS" ); CSLDestroy( papszMerged ); } /* ==================================================================== */ /* Process bands. */ /* ==================================================================== */ int iBand; for( iBand = 0; iBand < poAuxDS->GetRasterCount(); iBand++ ) { if( iBand >= GetRasterCount() ) break; GDALRasterBand *poAuxBand = poAuxDS->GetRasterBand( iBand+1 ); GDALRasterBand *poBand = GetRasterBand( iBand+1 ); papszMD = poAuxBand->GetMetadata(); if( CSLCount(papszMD) > 0 ) { char **papszMerged = CSLMerge( CSLDuplicate(poBand->GetMetadata()), papszMD ); poBand->SetMetadata( papszMerged ); CSLDestroy( papszMerged ); } if( poAuxBand->GetCategoryNames() != NULL ) poBand->SetCategoryNames( poAuxBand->GetCategoryNames() ); if( poAuxBand->GetColorTable() != NULL && poBand->GetColorTable() == NULL ) poBand->SetColorTable( poAuxBand->GetColorTable() ); // histograms? double dfMin, dfMax; int nBuckets, *panHistogram=NULL; if( poAuxBand->GetDefaultHistogram( &dfMin, &dfMax, &nBuckets, &panHistogram, FALSE, NULL, NULL ) == CE_None ) { poBand->SetDefaultHistogram( dfMin, dfMax, nBuckets, panHistogram ); CPLFree( panHistogram ); } // RAT if( poAuxBand->GetDefaultRAT() != NULL ) poBand->SetDefaultRAT( poAuxBand->GetDefaultRAT() ); // NoData int bSuccess = FALSE; double dfNoDataValue = poAuxBand->GetNoDataValue( &bSuccess ); if( bSuccess ) poBand->SetNoDataValue( dfNoDataValue ); } GDALClose( poAuxDS ); /* -------------------------------------------------------------------- */ /* Mark PAM info as clean. */ /* -------------------------------------------------------------------- */ nPamFlags &= ~GPF_DIRTY; return CE_Failure; }
bool OsmAnd::HeightmapTileProvider_P::obtainData( const TileId tileId, const ZoomLevel zoom, std::shared_ptr<MapTiledData>& outTiledData, const IQueryController* const queryController) { // Obtain raw data from DB QByteArray data; bool ok = _tileDb.obtainTileData(tileId, zoom, data); if (!ok || data.length() == 0) { // There was no data at all, to avoid further requests, mark this tile as empty outTiledData.reset(); return true; } // We have the data, use GDAL to decode this GeoTIFF const auto tileSize = getTileSize(); bool success = false; QString vmemFilename; vmemFilename.sprintf("/vsimem/heightmapTile@%p", data.data()); VSIFileFromMemBuffer(qPrintable(vmemFilename), reinterpret_cast<GByte*>(data.data()), data.length(), FALSE); auto dataset = reinterpret_cast<GDALDataset*>(GDALOpen(qPrintable(vmemFilename), GA_ReadOnly)); if (dataset != nullptr) { bool bad = false; bad = bad || dataset->GetRasterCount() != 1; bad = bad || dataset->GetRasterXSize() != tileSize; bad = bad || dataset->GetRasterYSize() != tileSize; if (bad) { if (dataset->GetRasterCount() != 1) LogPrintf(LogSeverityLevel::Error, "Height tile %dx%d@%d has %d bands instead of 1", tileId.x, tileId.y, zoom, dataset->GetRasterCount()); if (dataset->GetRasterXSize() != tileSize || dataset->GetRasterYSize() != tileSize) { LogPrintf(LogSeverityLevel::Error, "Height tile %dx%d@%d has %dx%x size instead of %d", tileId.x, tileId.y, zoom, dataset->GetRasterXSize(), dataset->GetRasterYSize(), tileSize); } } else { auto band = dataset->GetRasterBand(1); bad = bad || band->GetColorTable() != nullptr; bad = bad || band->GetRasterDataType() != GDT_Int16; if (bad) { if (band->GetColorTable() != nullptr) LogPrintf(LogSeverityLevel::Error, "Height tile %dx%d@%d has color table", tileId.x, tileId.y, zoom); if (band->GetRasterDataType() != GDT_Int16) LogPrintf(LogSeverityLevel::Error, "Height tile %dx%d@%d has %s data type in band 1", tileId.x, tileId.y, zoom, GDALGetDataTypeName(band->GetRasterDataType())); } else { auto buffer = new float[tileSize*tileSize]; auto res = dataset->RasterIO(GF_Read, 0, 0, tileSize, tileSize, buffer, tileSize, tileSize, GDT_Float32, 1, nullptr, 0, 0, 0); if (res != CE_None) { delete[] buffer; LogPrintf(LogSeverityLevel::Error, "Failed to decode height tile %dx%d@%d: %s", tileId.x, tileId.y, zoom, CPLGetLastErrorMsg()); } else { outTiledData.reset(new ElevationDataTile(buffer, sizeof(float)*tileSize, tileSize, tileId, zoom)); success = true; } } } GDALClose(dataset); } VSIUnlink(qPrintable(vmemFilename)); return success; }
CPLErr MEMDataset::IRasterIO( GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, void * pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nBandCount, int *panBandMap, GSpacing nPixelSpaceBuf, GSpacing nLineSpaceBuf, GSpacing nBandSpaceBuf, GDALRasterIOExtraArg* psExtraArg) { const int eBufTypeSize = GDALGetDataTypeSize(eBufType) / 8; // Detect if we have a pixel-interleaved buffer and a pixel-interleaved // dataset. if( nXSize == nBufXSize && nYSize == nBufYSize && nBandCount == nBands && nBands > 1 && nBandSpaceBuf == eBufTypeSize && nPixelSpaceBuf == nBandSpaceBuf * nBands ) { GDALDataType eDT = GDT_Unknown; GByte* pabyData = NULL; GSpacing nPixelOffset = 0; GSpacing nLineOffset = 0; int eDTSize = 0; int iBandIndex; for( iBandIndex = 0; iBandIndex < nBandCount; iBandIndex++ ) { if( panBandMap[iBandIndex] != iBandIndex + 1 ) break; MEMRasterBand *poBand = reinterpret_cast<MEMRasterBand *>( GetRasterBand(iBandIndex + 1) ); if( iBandIndex == 0 ) { eDT = poBand->GetRasterDataType(); pabyData = poBand->pabyData; nPixelOffset = poBand->nPixelOffset; nLineOffset = poBand->nLineOffset; eDTSize = GDALGetDataTypeSize(eDT) / 8; if( nPixelOffset != static_cast<GSpacing>(nBands) * eDTSize ) break; } else if( poBand->GetRasterDataType() != eDT || nPixelOffset != poBand->nPixelOffset || nLineOffset != poBand->nLineOffset || poBand->pabyData != pabyData + iBandIndex * eDTSize ) { break; } } if( iBandIndex == nBandCount ) { FlushCache(); if( eRWFlag == GF_Read ) { for(int iLine=0;iLine<nYSize;iLine++) { GDALCopyWords( pabyData + nLineOffset*static_cast<size_t>(iLine + nYOff) + nXOff*nPixelOffset, eDT, eDTSize, reinterpret_cast<GByte *>( pData ) + nLineSpaceBuf * static_cast<size_t>(iLine), eBufType, eBufTypeSize, nXSize * nBands ); } } else { for(int iLine=0;iLine<nYSize;iLine++) { GDALCopyWords( reinterpret_cast<GByte *>( pData ) + nLineSpaceBuf*(size_t)iLine, eBufType, eBufTypeSize, pabyData + nLineOffset * static_cast<size_t>(iLine + nYOff) + nXOff*nPixelOffset, eDT, eDTSize, nXSize * nBands); } } return CE_None; } } if( nBufXSize != nXSize || nBufYSize != nYSize ) return GDALDataset::IRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, nBandCount, panBandMap, nPixelSpaceBuf, nLineSpaceBuf, nBandSpaceBuf, psExtraArg ); GDALProgressFunc pfnProgressGlobal = psExtraArg->pfnProgress; void *pProgressDataGlobal = psExtraArg->pProgressData; CPLErr eErr = CE_None; for( int iBandIndex = 0; iBandIndex < nBandCount && eErr == CE_None; iBandIndex++ ) { GDALRasterBand *poBand = GetRasterBand(panBandMap[iBandIndex]); if (poBand == NULL) { eErr = CE_Failure; break; } GByte *pabyBandData = reinterpret_cast<GByte *>(pData) + iBandIndex * nBandSpaceBuf; psExtraArg->pfnProgress = GDALScaledProgress; psExtraArg->pProgressData = GDALCreateScaledProgress( 1.0 * iBandIndex / nBandCount, 1.0 * (iBandIndex + 1) / nBandCount, pfnProgressGlobal, pProgressDataGlobal ); eErr = poBand->RasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize, reinterpret_cast<void *>( pabyBandData ), nBufXSize, nBufYSize, eBufType, nPixelSpaceBuf, nLineSpaceBuf, psExtraArg ); GDALDestroyScaledProgress( psExtraArg->pProgressData ); } psExtraArg->pfnProgress = pfnProgressGlobal; psExtraArg->pProgressData = pProgressDataGlobal; return eErr; }
CPLErr SDEDataset::ComputeRasterInfo() { long nSDEErr; SE_RASTERINFO raster; nSDEErr = SE_rasterinfo_create(&raster); if( nSDEErr != SE_SUCCESS ) { IssueSDEError( nSDEErr, "SE_rasterinfo_create" ); return CE_Fatal; } LONG nRasterColumnId = 0; nSDEErr = SE_rascolinfo_get_id( hRasterColumn, &nRasterColumnId); if( nSDEErr != SE_SUCCESS ) { IssueSDEError( nSDEErr, "SE_rascolinfo_get_id" ); return CE_Fatal; } nSDEErr = SE_raster_get_info_by_id( hConnection, nRasterColumnId, 1, raster); if( nSDEErr != SE_SUCCESS ) { IssueSDEError( nSDEErr, "SE_rascolinfo_get_id" ); return CE_Fatal; } LONG nBandsRet; nSDEErr = SE_raster_get_bands( hConnection, raster, &paohSDERasterBands, &nBandsRet); if( nSDEErr != SE_SUCCESS ) { IssueSDEError( nSDEErr, "SE_raster_get_bands" ); return CE_Fatal; } nBands = nBandsRet; SE_RASBANDINFO band; // grab our other stuff from the first band and hope for the best band = paohSDERasterBands[0]; LONG nXSRet, nYSRet; nSDEErr = SE_rasbandinfo_get_band_size( band, &nXSRet, &nYSRet ); if( nSDEErr != SE_SUCCESS ) { IssueSDEError( nSDEErr, "SE_rasbandinfo_get_band_size" ); return CE_Fatal; } nRasterXSize = nXSRet; nRasterYSize = nYSRet; SE_ENVELOPE extent; nSDEErr = SE_rasbandinfo_get_extent(band, &extent); if( nSDEErr != SE_SUCCESS ) { IssueSDEError( nSDEErr, "SE_rasbandinfo_get_extent" ); return CE_Fatal; } dfMinX = extent.minx; dfMinY = extent.miny; dfMaxX = extent.maxx; dfMaxY = extent.maxy; CPLDebug("SDERASTER", "minx: %.5f, miny: %.5f, maxx: %.5f, maxy: %.5f", dfMinX, dfMinY, dfMaxX, dfMaxY); // x0 roughly corresponds to dfMinX // y0 roughly corresponds to dfMaxY // They can be different than the extent parameters because // SDE uses offsets. The following info is from Duarte Carreira // in relation to bug #2063 http://trac.osgeo.org/gdal/ticket/2063 : // Depending on how the data was loaded, the pixel width // or pixel height may include a pixel offset from the nearest // tile boundary. An offset will be indicated by aplus sign // "+" followed by a value. The value indicates the number // of pixels the nearest tile boundary is to the left of // the image for the x dimension or the number of // pixels the nearest tile boundary is above the image for // the y dimension. The offset information is only useful // for advanced application developers who need to know // where the image begins in relation to the underlying tile structure LFLOAT x0, y0; nSDEErr = SE_rasbandinfo_get_tile_origin(band, &x0, &y0); if( nSDEErr != SE_SUCCESS ) { IssueSDEError( nSDEErr, "SE_rasbandinfo_get_tile_origin" ); return CE_Fatal; } CPLDebug("SDERASTER", "Tile origin: %.5f, %.5f", x0, y0); // we also need to adjust dfMaxX and dfMinY otherwise the cell size will change dfMaxX = (x0-dfMinX) + dfMaxX; dfMinY = (y0-dfMaxY) + dfMinY; // adjust the bbox based on the tile origin. dfMinX = MIN(x0, dfMinX); dfMaxY = MAX(y0, dfMaxY); nSDEErr = SE_rasterattr_create(&hAttributes, false); if( nSDEErr != SE_SUCCESS ) { IssueSDEError( nSDEErr, "SE_rasterattr_create" ); return CE_Fatal; } // Grab the pointer for our member variable nSDEErr = SE_stream_create(hConnection, &hStream); if( nSDEErr != SE_SUCCESS ) { IssueSDEError( nSDEErr, "SE_stream_create" ); return CE_Fatal; } for (int i=0; i < nBands; i++) { SetBand( i+1, new SDERasterBand( this, i+1, -1, &(paohSDERasterBands[i]) )); } GDALRasterBand* b = GetRasterBand(1); eDataType = b->GetRasterDataType(); SE_rasterinfo_free(raster); return CE_None; }
CPLErr GSAGDataset::UpdateHeader() { GSAGRasterBand *poBand = (GSAGRasterBand *)GetRasterBand( 1 ); if( poBand == NULL ) { CPLError( CE_Failure, CPLE_FileIO, "Unable to open raster band.\n" ); return CE_Failure; } std::ostringstream ssOutBuf; ssOutBuf.precision( nFIELD_PRECISION ); ssOutBuf.setf( std::ios::uppercase ); /* signature */ ssOutBuf << "DSAA" << szEOL; /* columns rows */ ssOutBuf << nRasterXSize << " " << nRasterYSize << szEOL; /* x range */ ssOutBuf << poBand->dfMinX << " " << poBand->dfMaxX << szEOL; /* y range */ ssOutBuf << poBand->dfMinY << " " << poBand->dfMaxY << szEOL; /* z range */ ssOutBuf << poBand->dfMinZ << " " << poBand->dfMaxZ << szEOL; CPLString sOut = ssOutBuf.str(); if( sOut.length() != poBand->panLineOffset[0] ) { int nShiftSize = (int) (sOut.length() - poBand->panLineOffset[0]); if( ShiftFileContents( fp, poBand->panLineOffset[0], nShiftSize, szEOL ) != CE_None ) { CPLError( CE_Failure, CPLE_FileIO, "Unable to update grid header, " "failure shifting file contents.\n" ); return CE_Failure; } for( size_t iLine=0; iLine < static_cast<unsigned>(nRasterYSize+1) && poBand->panLineOffset[iLine] != 0; iLine++ ) poBand->panLineOffset[iLine] += nShiftSize; } if( VSIFSeekL( fp, 0, SEEK_SET ) != 0 ) { CPLError( CE_Failure, CPLE_FileIO, "Unable to seek to start of grid file.\n" ); return CE_Failure; } if( VSIFWriteL( sOut.c_str(), 1, sOut.length(), fp ) != sOut.length() ) { CPLError( CE_Failure, CPLE_FileIO, "Unable to update file header. Disk full?\n" ); return CE_Failure; } return CE_None; }
CPLErr RasterliteDataset::CreateOverviewLevel(int nOvrFactor, GDALProgressFunc pfnProgress, void * pProgressData) { double dfXResolution = padfXResolutions[0] * nOvrFactor; double dfYResolution = padfXResolutions[0] * nOvrFactor; CPLString osSQL; int nBlockXSize = 256; int nBlockYSize = 256; int nOvrXSize = nRasterXSize / nOvrFactor; int nOvrYSize = nRasterYSize / nOvrFactor; if (nOvrXSize == 0 || nOvrYSize == 0) return CE_Failure; int nXBlocks = (nOvrXSize + nBlockXSize - 1) / nBlockXSize; int nYBlocks = (nOvrYSize + nBlockYSize - 1) / nBlockYSize; const char* pszDriverName = "GTiff"; GDALDriverH hTileDriver = GDALGetDriverByName(pszDriverName); if (hTileDriver == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL %s driver", pszDriverName); return CE_Failure; } GDALDriverH hMemDriver = GDALGetDriverByName("MEM"); if (hMemDriver == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL MEM driver"); return CE_Failure; } GDALDataType eDataType = GetRasterBand(1)->GetRasterDataType(); int nDataTypeSize = GDALGetDataTypeSize(eDataType) / 8; GByte* pabyMEMDSBuffer = (GByte*)VSIMalloc3(nBlockXSize, nBlockYSize, nBands * nDataTypeSize); if (pabyMEMDSBuffer == NULL) { return CE_Failure; } char** papszTileDriverOptions = NULL; CPLString osTempFileName; osTempFileName.Printf("/vsimem/%p", hDS); int nTileId = 0; int nBlocks = 0; int nTotalBlocks = nXBlocks * nYBlocks; CPLString osRasterLayer; osRasterLayer.Printf("%s_rasters", osTableName.c_str()); CPLString osMetatadataLayer; osMetatadataLayer.Printf("%s_metadata", osTableName.c_str()); OGRLayerH hRasterLayer = OGR_DS_GetLayerByName(hDS, osRasterLayer.c_str()); OGRLayerH hMetadataLayer = OGR_DS_GetLayerByName(hDS, osMetatadataLayer.c_str()); CPLString osSourceName = "unknown"; osSQL.Printf("SELECT source_name FROM \"%s\" WHERE " "pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND " "pixel_y_size >= %.15f AND pixel_y_size <= %.15f LIMIT 1", osMetatadataLayer.c_str(), padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15, padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15); OGRLayerH hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL); if (hSQLLyr) { OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr); if (hFeat) { const char* pszVal = OGR_F_GetFieldAsString(hFeat, 0); if (pszVal) osSourceName = pszVal; OGR_F_Destroy(hFeat); } OGR_DS_ReleaseResultSet(hDS, hSQLLyr); } /* -------------------------------------------------------------------- */ /* Compute up to which existing overview level we can use for */ /* computing the requested overview */ /* -------------------------------------------------------------------- */ int iLev; nLimitOvrCount = 0; for(iLev=1;iLev<nResolutions;iLev++) { if (!(padfXResolutions[iLev] < dfXResolution - 1e-10 && padfYResolutions[iLev] < dfYResolution - 1e-10)) { break; } nLimitOvrCount++; } /* -------------------------------------------------------------------- */ /* Iterate over blocks to add data into raster and metadata tables */ /* -------------------------------------------------------------------- */ OGR_DS_ExecuteSQL(hDS, "BEGIN", NULL, NULL); CPLErr eErr = CE_None; int nBlockXOff, nBlockYOff; for(nBlockYOff=0;eErr == CE_None && nBlockYOff<nYBlocks;nBlockYOff++) { for(nBlockXOff=0;eErr == CE_None && nBlockXOff<nXBlocks;nBlockXOff++) { /* -------------------------------------------------------------------- */ /* Create in-memory tile */ /* -------------------------------------------------------------------- */ int nReqXSize = nBlockXSize, nReqYSize = nBlockYSize; if ((nBlockXOff+1) * nBlockXSize > nOvrXSize) nReqXSize = nOvrXSize - nBlockXOff * nBlockXSize; if ((nBlockYOff+1) * nBlockYSize > nOvrYSize) nReqYSize = nOvrYSize - nBlockYOff * nBlockYSize; eErr = RasterIO(GF_Read, nBlockXOff * nBlockXSize * nOvrFactor, nBlockYOff * nBlockYSize * nOvrFactor, nReqXSize * nOvrFactor, nReqYSize * nOvrFactor, pabyMEMDSBuffer, nReqXSize, nReqYSize, eDataType, nBands, NULL, 0, 0, 0); if (eErr != CE_None) { break; } GDALDatasetH hMemDS = GDALCreate(hMemDriver, "MEM:::", nReqXSize, nReqYSize, 0, eDataType, NULL); if (hMemDS == NULL) { eErr = CE_Failure; break; } int iBand; for(iBand = 0; iBand < nBands; iBand ++) { char** papszOptions = NULL; char szTmp[64]; memset(szTmp, 0, sizeof(szTmp)); CPLPrintPointer(szTmp, pabyMEMDSBuffer + iBand * nDataTypeSize * nReqXSize * nReqYSize, sizeof(szTmp)); papszOptions = CSLSetNameValue(papszOptions, "DATAPOINTER", szTmp); GDALAddBand(hMemDS, eDataType, papszOptions); CSLDestroy(papszOptions); } GDALDatasetH hOutDS = GDALCreateCopy(hTileDriver, osTempFileName.c_str(), hMemDS, FALSE, papszTileDriverOptions, NULL, NULL); GDALClose(hMemDS); if (hOutDS) GDALClose(hOutDS); else { eErr = CE_Failure; break; } /* -------------------------------------------------------------------- */ /* Insert new entry into raster table */ /* -------------------------------------------------------------------- */ vsi_l_offset nDataLength; GByte *pabyData = VSIGetMemFileBuffer( osTempFileName.c_str(), &nDataLength, FALSE); OGRFeatureH hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hRasterLayer) ); OGR_F_SetFieldBinary(hFeat, 0, (int)nDataLength, pabyData); OGR_L_CreateFeature(hRasterLayer, hFeat); /* Query raster ID to set it as the ID of the associated metadata */ int nRasterID = (int)OGR_F_GetFID(hFeat); OGR_F_Destroy(hFeat); VSIUnlink(osTempFileName.c_str()); /* -------------------------------------------------------------------- */ /* Insert new entry into metadata table */ /* -------------------------------------------------------------------- */ hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hMetadataLayer) ); OGR_F_SetFID(hFeat, nRasterID); OGR_F_SetFieldString(hFeat, 0, osSourceName); OGR_F_SetFieldInteger(hFeat, 1, nTileId ++); OGR_F_SetFieldInteger(hFeat, 2, nReqXSize); OGR_F_SetFieldInteger(hFeat, 3, nReqYSize); OGR_F_SetFieldDouble(hFeat, 4, dfXResolution); OGR_F_SetFieldDouble(hFeat, 5, dfYResolution); double minx, maxx, maxy, miny; minx = adfGeoTransform[0] + (nBlockXSize * nBlockXOff) * dfXResolution; maxx = adfGeoTransform[0] + (nBlockXSize * nBlockXOff + nReqXSize) * dfXResolution; maxy = adfGeoTransform[3] + (nBlockYSize * nBlockYOff) * (-dfYResolution); miny = adfGeoTransform[3] + (nBlockYSize * nBlockYOff + nReqYSize) * (-dfYResolution); OGRGeometryH hRectangle = OGR_G_CreateGeometry(wkbPolygon); OGRGeometryH hLinearRing = OGR_G_CreateGeometry(wkbLinearRing); OGR_G_AddPoint_2D(hLinearRing, minx, miny); OGR_G_AddPoint_2D(hLinearRing, minx, maxy); OGR_G_AddPoint_2D(hLinearRing, maxx, maxy); OGR_G_AddPoint_2D(hLinearRing, maxx, miny); OGR_G_AddPoint_2D(hLinearRing, minx, miny); OGR_G_AddGeometryDirectly(hRectangle, hLinearRing); OGR_F_SetGeometryDirectly(hFeat, hRectangle); OGR_L_CreateFeature(hMetadataLayer, hFeat); OGR_F_Destroy(hFeat); nBlocks++; if (pfnProgress && !pfnProgress(1.0 * nBlocks / nTotalBlocks, NULL, pProgressData)) eErr = CE_Failure; } } nLimitOvrCount = -1; if (eErr == CE_None) OGR_DS_ExecuteSQL(hDS, "COMMIT", NULL, NULL); else OGR_DS_ExecuteSQL(hDS, "ROLLBACK", NULL, NULL); VSIFree(pabyMEMDSBuffer); /* -------------------------------------------------------------------- */ /* Update raster_pyramids table */ /* -------------------------------------------------------------------- */ if (eErr == CE_None) { OGRLayerH hRasterPyramidsLyr = OGR_DS_GetLayerByName(hDS, "raster_pyramids"); if (hRasterPyramidsLyr == NULL) { osSQL.Printf ("CREATE TABLE raster_pyramids (" "table_prefix TEXT NOT NULL," "pixel_x_size DOUBLE NOT NULL," "pixel_y_size DOUBLE NOT NULL," "tile_count INTEGER NOT NULL)"); OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL); /* Re-open the DB to take into account the new tables*/ OGRReleaseDataSource(hDS); CPLString osOldVal = CPLGetConfigOption("SQLITE_LIST_ALL_TABLES", "FALSE"); CPLSetThreadLocalConfigOption("SQLITE_LIST_ALL_TABLES", "TRUE"); hDS = OGROpen(osFileName.c_str(), TRUE, NULL); CPLSetThreadLocalConfigOption("SQLITE_LIST_ALL_TABLES", osOldVal.c_str()); } /* Insert base resolution into raster_pyramids if not already done */ int bHasBaseResolution = FALSE; osSQL.Printf("SELECT * FROM raster_pyramids WHERE " "table_prefix = '%s' AND pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND " "pixel_y_size >= %.15f AND pixel_y_size <= %.15f", osTableName.c_str(), padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15, padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15); hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL); if (hSQLLyr) { OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr); if (hFeat) { bHasBaseResolution = TRUE; OGR_F_Destroy(hFeat); } OGR_DS_ReleaseResultSet(hDS, hSQLLyr); } if (!bHasBaseResolution) { osSQL.Printf("SELECT COUNT(*) FROM \"%s\" WHERE " "pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND " "pixel_y_size >= %.15f AND pixel_y_size <= %.15f", osMetatadataLayer.c_str(), padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15, padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15); int nBlocksMainRes = 0; hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL); if (hSQLLyr) { OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr); if (hFeat) { nBlocksMainRes = OGR_F_GetFieldAsInteger(hFeat, 0); OGR_F_Destroy(hFeat); } OGR_DS_ReleaseResultSet(hDS, hSQLLyr); } osSQL.Printf("INSERT INTO raster_pyramids " "( table_prefix, pixel_x_size, pixel_y_size, tile_count ) " "VALUES ( '%s', %.18f, %.18f, %d )", osTableName.c_str(), padfXResolutions[0], padfYResolutions[0], nBlocksMainRes); OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL); } osSQL.Printf("INSERT INTO raster_pyramids " "( table_prefix, pixel_x_size, pixel_y_size, tile_count ) " "VALUES ( '%s', %.18f, %.18f, %d )", osTableName.c_str(), dfXResolution, dfYResolution, nTotalBlocks); OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL); } return eErr; }
CPLErr RawDataset::IRasterIO( GDALRWFlag eRWFlag, int nXOff, int nYOff, int nXSize, int nYSize, void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, int nBandCount, int *panBandMap, GSpacing nPixelSpace, GSpacing nLineSpace, GSpacing nBandSpace, GDALRasterIOExtraArg* psExtraArg ) { const char* pszInterleave; /* The default GDALDataset::IRasterIO() implementation would go to */ /* BlockBasedRasterIO if the dataset is interleaved. However if the */ /* access pattern is compatible with DirectIO() we don't want to go */ /* BlockBasedRasterIO, but rather used our optimized path in RawRasterBand::IRasterIO() */ if (nXSize == nBufXSize && nYSize == nBufYSize && nBandCount > 1 && (pszInterleave = GetMetadataItem("INTERLEAVE", "IMAGE_STRUCTURE")) != NULL && EQUAL(pszInterleave, "PIXEL")) { int iBandIndex; for(iBandIndex = 0; iBandIndex < nBandCount; iBandIndex ++ ) { RawRasterBand* poBand = (RawRasterBand*) GetRasterBand(panBandMap[iBandIndex]); if( !poBand->CanUseDirectIO(nXOff, nYOff, nXSize, nYSize, eBufType ) ) { break; } } if( iBandIndex == nBandCount ) { GDALProgressFunc pfnProgressGlobal = psExtraArg->pfnProgress; void *pProgressDataGlobal = psExtraArg->pProgressData; CPLErr eErr = CE_None; for( iBandIndex = 0; iBandIndex < nBandCount && eErr == CE_None; iBandIndex++ ) { GDALRasterBand *poBand = GetRasterBand(panBandMap[iBandIndex]); GByte *pabyBandData; if (poBand == NULL) { eErr = CE_Failure; break; } pabyBandData = ((GByte *) pData) + iBandIndex * nBandSpace; psExtraArg->pfnProgress = GDALScaledProgress; psExtraArg->pProgressData = GDALCreateScaledProgress( 1.0 * iBandIndex / nBandCount, 1.0 * (iBandIndex + 1) / nBandCount, pfnProgressGlobal, pProgressDataGlobal ); eErr = poBand->RasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize, (void *) pabyBandData, nBufXSize, nBufYSize, eBufType, nPixelSpace, nLineSpace, psExtraArg ); GDALDestroyScaledProgress( psExtraArg->pProgressData ); } psExtraArg->pfnProgress = pfnProgressGlobal; psExtraArg->pProgressData = pProgressDataGlobal; return eErr; } } return GDALDataset::IRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, nBandCount, panBandMap, nPixelSpace, nLineSpace, nBandSpace, psExtraArg); }