json_object* OGRGeoJSONWriteCoords( double const& fX, double const& fY, int nCoordPrecision )
{
json_object* poObjCoords = NULL;
if( CPLIsInf(fX) || CPLIsInf(fY) ||
CPLIsNan(fX) || CPLIsNan(fY) )
{
CPLError(CE_Warning, CPLE_AppDefined, "Infinite or NaN coordinate encountered");
return NULL;
}
poObjCoords = json_object_new_array();
json_object_array_add( poObjCoords, json_object_new_double_with_precision( fX, nCoordPrecision ) );
json_object_array_add( poObjCoords, json_object_new_double_with_precision( fY, nCoordPrecision ) );
return poObjCoords;
}
int GetJsonValueInt(json_object * pJSONObject, CPLString pszKey)
{
double fTmp = GetJsonValueDbl(pJSONObject, pszKey.c_str());
if (CPLIsNan(fTmp)) {
return -1;
}
return (int)fTmp;
}
static int GetJsonValueInt( json_object *pJSONObject, CPLString pszKey )
{
const double dfTmp = GetJsonValueDbl(pJSONObject, pszKey.c_str());
if (CPLIsNan(dfTmp)) {
return -1;
}
return static_cast<int>(dfTmp);
}
bool GDALNoDataMaskBand::IsNoDataInRange(double dfNoDataValue,
GDALDataType eDataType)
{
GDALDataType eWrkDT = GetWorkDataType( eDataType );
switch( eWrkDT )
{
case GDT_Byte:
{
return GDALIsValueInRange<GByte>(dfNoDataValue);
}
case GDT_UInt32:
{
return GDALIsValueInRange<GUInt32>(dfNoDataValue);
}
case GDT_Int32:
{
return GDALIsValueInRange<GInt32>(dfNoDataValue);
}
case GDT_Float32:
{
return CPLIsNan(dfNoDataValue) ||
CPLIsInf(dfNoDataValue) ||
GDALIsValueInRange<float>(dfNoDataValue);
}
case GDT_Float64:
{
return true;
}
default:
CPLAssert( false );
return false;
}
}
/**
* Checks the downloaded data to see if it is all valid.
*/
void genericSurfInitialization::checkForValidData()
{
//just make up a "dummy" timezone for use here
boost::local_time::time_zone_ptr zone(new boost::local_time::posix_time_zone("MST-07"));
//get time list
std::vector<boost::local_time::local_date_time> timeList( getTimeList(zone) );
boost::posix_time::ptime pt_low(boost::gregorian::date(1900,boost::gregorian::Jan,1), boost::posix_time::hours(12));
boost::posix_time::ptime pt_high(boost::gregorian::date(2100,boost::gregorian::Jan,1), boost::posix_time::hours(12));
boost::local_time::local_date_time low_time(pt_low, zone);
boost::local_time::local_date_time high_time(pt_high, zone);
//check times
for(unsigned int i = 0; i < timeList.size(); i++)
{
if(timeList[i].is_special()) //if time is any special value (not_a_date_time, infinity, etc.)
throw badForecastFile("Bad time in forecast file.");
if(timeList[i] < low_time || timeList[i] > high_time)
throw badForecastFile("Bad time in forecast file.");
}
// open ds variable by variable
GDALDataset *srcDS;
std::string temp;
std::string srcWkt;
int nBands = 0;
bool noDataValueExists;
bool noDataIsNan;
std::vector<std::string> varList = getVariableList();
//Acquire a lock to protect the non-thread safe netCDF library
#ifdef _OPENMP
omp_guard netCDF_guard(netCDF_lock);
#endif
for( unsigned int i = 0;i < varList.size();i++ ) {
temp = "NETCDF:" + wxModelFileName + ":" + varList[i];
srcDS = (GDALDataset*)GDALOpen( temp.c_str(), GA_ReadOnly );
if( srcDS == NULL )
throw badForecastFile("Cannot open forecast file.");
srcWkt = srcDS->GetProjectionRef();
if( srcWkt.empty() )
throw badForecastFile("Forecast file doesn't have projection information.");
//Get total bands (time steps)
nBands = srcDS->GetRasterCount();
int nXSize, nYSize;
GDALRasterBand *poBand;
int pbSuccess;
double dfNoData;
double *padfScanline;
nXSize = srcDS->GetRasterXSize();
nYSize = srcDS->GetRasterYSize();
//loop over all bands for this variable (bands are time steps)
for(int j = 1; j <= nBands; j++)
{
poBand = srcDS->GetRasterBand( j );
pbSuccess = 0;
dfNoData = poBand->GetNoDataValue( &pbSuccess );
if( pbSuccess == false )
noDataValueExists = false;
else
{
noDataValueExists = true;
noDataIsNan = CPLIsNan(dfNoData);
}
//set the data
padfScanline = new double[nXSize*nYSize];
poBand->RasterIO(GF_Read, 0, 0, nXSize, nYSize, padfScanline, nXSize, nYSize,
GDT_Float64, 0, 0);
for(int k = 0;k < nXSize*nYSize; k++)
{
//Check if value is no data (if no data value was defined in file)
if(noDataValueExists)
{
if(noDataIsNan)
{
if(CPLIsNan(padfScanline[k]))
throw badForecastFile("Forecast file contains no_data values.");
}else
{
if(padfScanline[k] == dfNoData)
throw badForecastFile("Forecast file contains no_data values.");
}
}
if( varList[i] == "Temperature_height_above_ground" ) //units are Kelvin
{
if(padfScanline[k] < 180.0 || padfScanline[k] > 340.0) //these are near the most extreme temperatures ever recored on earth
throw badForecastFile("Temperature is out of range in forecast file.");
}
else if( varList[i] == "V-component_of_wind_height_above_ground" ) //units are m/s
{
if(std::abs(padfScanline[k]) > 220.0)
throw badForecastFile("V-velocity is out of range in forecast file.");
}
else if( varList[i] == "U-component_of_wind_height_above_ground" ) //units are m/s
{
if(std::abs(padfScanline[k]) > 220.0)
throw badForecastFile("U-velocity is out of range in forecast file.");
}
else if( varList[i] == "Total_cloud_cover" ) //units are percent
{
if(padfScanline[k] < 0.0 || padfScanline[k] > 100.0)
throw badForecastFile("Total cloud cover is out of range in forecast file.");
}
}
delete [] padfScanline;
}
GDALClose((GDALDatasetH) srcDS );
}
}
void OGRCircularString::ExtendEnvelopeWithCircular(
OGREnvelope * psEnvelope ) const
{
if( !IsValidFast() || nPointCount == 0 )
return;
// Loop through circular portions and determine if they include some
// extremities of the circle.
for( int i = 0; i < nPointCount - 2; i += 2 )
{
const double x0 = paoPoints[i].x;
const double y0 = paoPoints[i].y;
const double x1 = paoPoints[i+1].x;
const double y1 = paoPoints[i+1].y;
const double x2 = paoPoints[i+2].x;
const double y2 = paoPoints[i+2].y;
double R = 0.0;
double cx = 0.0;
double cy = 0.0;
double alpha0 = 0.0;
double alpha1 = 0.0;
double alpha2 = 0.0;
if( OGRGeometryFactory::GetCurveParmeters(x0, y0, x1, y1, x2, y2,
R, cx, cy,
alpha0, alpha1, alpha2))
{
if( CPLIsNan(alpha0) || CPLIsNan(alpha2) ) {
CPLError(CE_Failure, CPLE_AppDefined,
"GetCurveParmeters returned NaN");
continue;
}
int quadrantStart =
static_cast<int>(std::floor(alpha0 / (M_PI / 2)));
int quadrantEnd = static_cast<int>(std::floor(alpha2 / (M_PI / 2)));
if( quadrantStart > quadrantEnd )
{
std::swap(quadrantStart, quadrantEnd);
}
// Transition trough quadrants in counter-clock wise direction.
for( int j = quadrantStart + 1; j <= quadrantEnd; ++j )
{
switch( (j + 8) % 4 )
{
case 0:
psEnvelope->MaxX = std::max(psEnvelope->MaxX, cx + R);
break;
case 1:
psEnvelope->MaxY = std::max(psEnvelope->MaxY, cy + R);
break;
case 2:
psEnvelope->MinX = std::min(psEnvelope->MinX, cx - R);
break;
case 3:
psEnvelope->MinY = std::min(psEnvelope->MaxY, cy - R);
break;
default:
CPLAssert(false);
break;
}
}
}
}
}
CPLErr GDALNoDataMaskBand::IReadBlock( int nXBlockOff, int nYBlockOff,
void * pImage )
{
GDALDataType eWrkDT;
/* -------------------------------------------------------------------- */
/* Decide on a working type. */
/* -------------------------------------------------------------------- */
switch( poParent->GetRasterDataType() )
{
case GDT_Byte:
eWrkDT = GDT_Byte;
break;
case GDT_UInt16:
case GDT_UInt32:
eWrkDT = GDT_UInt32;
break;
case GDT_Int16:
case GDT_Int32:
case GDT_CInt16:
case GDT_CInt32:
eWrkDT = GDT_Int32;
break;
case GDT_Float32:
case GDT_CFloat32:
eWrkDT = GDT_Float32;
break;
case GDT_Float64:
case GDT_CFloat64:
eWrkDT = GDT_Float64;
break;
default:
CPLAssert( FALSE );
eWrkDT = GDT_Float64;
break;
}
/* -------------------------------------------------------------------- */
/* Read the image data. */
/* -------------------------------------------------------------------- */
GByte *pabySrc;
CPLErr eErr;
pabySrc = (GByte *) VSIMalloc3( GDALGetDataTypeSize(eWrkDT)/8, nBlockXSize, nBlockYSize );
if (pabySrc == NULL)
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"GDALNoDataMaskBand::IReadBlock: Out of memory for buffer." );
return CE_Failure;
}
int nXSizeRequest = nBlockXSize;
if (nXBlockOff * nBlockXSize + nBlockXSize > nRasterXSize)
nXSizeRequest = nRasterXSize - nXBlockOff * nBlockXSize;
int nYSizeRequest = nBlockYSize;
if (nYBlockOff * nBlockYSize + nBlockYSize > nRasterYSize)
nYSizeRequest = nRasterYSize - nYBlockOff * nBlockYSize;
if (nXSizeRequest != nBlockXSize || nYSizeRequest != nBlockYSize)
{
/* memset the whole buffer to avoid Valgrind warnings in case we can't */
/* fetch a full block */
memset(pabySrc, 0, GDALGetDataTypeSize(eWrkDT)/8 * nBlockXSize * nBlockYSize );
}
eErr = poParent->RasterIO( GF_Read,
nXBlockOff * nBlockXSize, nYBlockOff * nBlockYSize,
nXSizeRequest, nYSizeRequest,
pabySrc, nXSizeRequest, nYSizeRequest,
eWrkDT, 0, nBlockXSize * (GDALGetDataTypeSize(eWrkDT)/8),
NULL );
if( eErr != CE_None )
{
CPLFree(pabySrc);
return eErr;
}
int bIsNoDataNan = CPLIsNan(dfNoDataValue);
/* -------------------------------------------------------------------- */
/* Process different cases. */
/* -------------------------------------------------------------------- */
int i;
switch( eWrkDT )
{
case GDT_Byte:
{
GByte byNoData = (GByte) dfNoDataValue;
for( i = nBlockXSize * nBlockYSize - 1; i >= 0; i-- )
{
if( pabySrc[i] == byNoData )
((GByte *) pImage)[i] = 0;
else
((GByte *) pImage)[i] = 255;
}
}
break;
case GDT_UInt32:
{
GUInt32 nNoData = (GUInt32) dfNoDataValue;
for( i = nBlockXSize * nBlockYSize - 1; i >= 0; i-- )
{
if( ((GUInt32 *)pabySrc)[i] == nNoData )
((GByte *) pImage)[i] = 0;
else
((GByte *) pImage)[i] = 255;
}
}
break;
case GDT_Int32:
{
GInt32 nNoData = (GInt32) dfNoDataValue;
for( i = nBlockXSize * nBlockYSize - 1; i >= 0; i-- )
{
if( ((GInt32 *)pabySrc)[i] == nNoData )
((GByte *) pImage)[i] = 0;
else
((GByte *) pImage)[i] = 255;
}
}
break;
case GDT_Float32:
{
float fNoData = (float) dfNoDataValue;
for( i = nBlockXSize * nBlockYSize - 1; i >= 0; i-- )
{
float fVal =((float *)pabySrc)[i];
if( bIsNoDataNan && CPLIsNan(fVal))
((GByte *) pImage)[i] = 0;
else if( ARE_REAL_EQUAL(fVal, fNoData) )
((GByte *) pImage)[i] = 0;
else
((GByte *) pImage)[i] = 255;
}
}
break;
case GDT_Float64:
{
for( i = nBlockXSize * nBlockYSize - 1; i >= 0; i-- )
{
double dfVal =((double *)pabySrc)[i];
if( bIsNoDataNan && CPLIsNan(dfVal))
((GByte *) pImage)[i] = 0;
else if( ARE_REAL_EQUAL(dfVal, dfNoDataValue) )
((GByte *) pImage)[i] = 0;
else
((GByte *) pImage)[i] = 255;
}
}
break;
default:
CPLAssert( FALSE );
break;
}
CPLFree( pabySrc );
return CE_None;
}
CPLXMLNode *GDALPamRasterBand::SerializeToXML( const char *pszUnused )
{
if( psPam == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Setup root node and attributes. */
/* -------------------------------------------------------------------- */
CPLString oFmt;
CPLXMLNode *psTree;
psTree = CPLCreateXMLNode( NULL, CXT_Element, "PAMRasterBand" );
if( GetBand() > 0 )
CPLSetXMLValue( psTree, "#band", oFmt.Printf( "%d", GetBand() ) );
/* -------------------------------------------------------------------- */
/* Serialize information of interest. */
/* -------------------------------------------------------------------- */
if( strlen(GetDescription()) > 0 )
CPLSetXMLValue( psTree, "Description", GetDescription() );
if( psPam->bNoDataValueSet )
{
if (CPLIsNan(psPam->dfNoDataValue))
CPLSetXMLValue( psTree, "NoDataValue", "nan" );
else
CPLSetXMLValue( psTree, "NoDataValue",
oFmt.Printf( "%.14E", psPam->dfNoDataValue ) );
/* hex encode real floating point values */
if( psPam->dfNoDataValue != floor(psPam->dfNoDataValue)
|| psPam->dfNoDataValue != atof(oFmt) )
{
double dfNoDataLittleEndian;
dfNoDataLittleEndian = psPam->dfNoDataValue;
CPL_LSBPTR64( &dfNoDataLittleEndian );
char *pszHexEncoding =
CPLBinaryToHex( 8, (GByte *) &dfNoDataLittleEndian );
CPLSetXMLValue( psTree, "NoDataValue.#le_hex_equiv",pszHexEncoding);
CPLFree( pszHexEncoding );
}
}
if( psPam->pszUnitType != NULL )
CPLSetXMLValue( psTree, "UnitType", psPam->pszUnitType );
if( psPam->dfOffset != 0.0 )
CPLSetXMLValue( psTree, "Offset",
oFmt.Printf( "%.16g", psPam->dfOffset ) );
if( psPam->dfScale != 1.0 )
CPLSetXMLValue( psTree, "Scale",
oFmt.Printf( "%.16g", psPam->dfScale ) );
if( psPam->eColorInterp != GCI_Undefined )
CPLSetXMLValue( psTree, "ColorInterp",
GDALGetColorInterpretationName( psPam->eColorInterp ));
/* -------------------------------------------------------------------- */
/* Category names. */
/* -------------------------------------------------------------------- */
if( psPam->papszCategoryNames != NULL )
{
CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,
"CategoryNames" );
for( int iEntry=0; psPam->papszCategoryNames[iEntry] != NULL; iEntry++)
{
CPLCreateXMLElementAndValue( psCT_XML, "Category",
psPam->papszCategoryNames[iEntry] );
}
}
/* -------------------------------------------------------------------- */
/* Color Table. */
/* -------------------------------------------------------------------- */
if( psPam->poColorTable != NULL )
{
CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,
"ColorTable" );
for( int iEntry=0; iEntry < psPam->poColorTable->GetColorEntryCount();
iEntry++ )
{
GDALColorEntry sEntry;
CPLXMLNode *psEntry_XML = CPLCreateXMLNode( psCT_XML, CXT_Element,
"Entry" );
psPam->poColorTable->GetColorEntryAsRGB( iEntry, &sEntry );
CPLSetXMLValue( psEntry_XML, "#c1", oFmt.Printf("%d",sEntry.c1) );
CPLSetXMLValue( psEntry_XML, "#c2", oFmt.Printf("%d",sEntry.c2) );
CPLSetXMLValue( psEntry_XML, "#c3", oFmt.Printf("%d",sEntry.c3) );
CPLSetXMLValue( psEntry_XML, "#c4", oFmt.Printf("%d",sEntry.c4) );
}
}
/* -------------------------------------------------------------------- */
/* Min/max. */
/* -------------------------------------------------------------------- */
if( psPam->bHaveMinMax )
{
CPLSetXMLValue( psTree, "Minimum",
oFmt.Printf( "%.16g", psPam->dfMin ) );
CPLSetXMLValue( psTree, "Maximum",
oFmt.Printf( "%.16g", psPam->dfMax ) );
}
/* -------------------------------------------------------------------- */
/* Statistics */
/* -------------------------------------------------------------------- */
if( psPam->bHaveStats )
{
CPLSetXMLValue( psTree, "Mean",
oFmt.Printf( "%.16g", psPam->dfMean ) );
CPLSetXMLValue( psTree, "StandardDeviation",
oFmt.Printf( "%.16g", psPam->dfStdDev ) );
}
/* -------------------------------------------------------------------- */
/* Histograms. */
/* -------------------------------------------------------------------- */
if( psPam->psSavedHistograms != NULL )
CPLAddXMLChild( psTree, CPLCloneXMLTree( psPam->psSavedHistograms ) );
/* -------------------------------------------------------------------- */
/* Raster Attribute Table */
/* -------------------------------------------------------------------- */
if( psPam->poDefaultRAT != NULL )
CPLAddXMLChild( psTree, psPam->poDefaultRAT->Serialize() );
/* -------------------------------------------------------------------- */
/* Metadata. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psMD;
psMD = oMDMD.Serialize();
if( psMD != NULL )
{
if( psMD->psChild == NULL )
CPLDestroyXMLNode( psMD );
else
CPLAddXMLChild( psTree, psMD );
}
/* -------------------------------------------------------------------- */
/* We don't want to return anything if we had no metadata to */
/* attach. */
/* -------------------------------------------------------------------- */
if( psTree->psChild == NULL || psTree->psChild->psNext == NULL )
{
CPLDestroyXMLNode( psTree );
psTree = NULL;
}
return psTree;
}
/**
* Sets the surface grids based on a ncep HRRR (surface only!) forecast.
* @param input The WindNinjaInputs for misc. info.
* @param airGrid The air temperature grid to be filled.
* @param cloudGrid The cloud cover grid to be filled.
* @param uGrid The u velocity grid to be filled.
* @param vGrid The v velocity grid to be filled.
* @param wGrid The w velocity grid to be filled (filled with zeros here?).
*/
void ncepHrrrSurfInitialization::setSurfaceGrids( WindNinjaInputs &input,
AsciiGrid<double> &airGrid,
AsciiGrid<double> &cloudGrid,
AsciiGrid<double> &uGrid,
AsciiGrid<double> &vGrid,
AsciiGrid<double> &wGrid )
{
int bandNum = -1;
GDALDataset *srcDS;
srcDS = (GDALDataset*)GDALOpenShared( input.forecastFilename.c_str(), GA_ReadOnly );
if( srcDS == NULL ) {
CPLDebug( "ncepHRRRSurfaceInitialization::identify()",
"Bad forecast file" );
}
GDALRasterBand *poBand;
const char *gc;
//get time list
std::vector<boost::local_time::local_date_time> timeList( getTimeList( input.ninjaTimeZone ) );
//Search time list for our time to identify our band number for cloud/speed/dir
//Right now, just one time step per file
std::vector<int> bandList;
for(unsigned int i = 0; i < timeList.size(); i++)
{
if(input.ninjaTime == timeList[i])
{
for(unsigned int j = 1; j < srcDS->GetRasterCount(); j++)
{
poBand = srcDS->GetRasterBand( j );
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
if( bandName.find( "Temperature [K]" ) != bandName.npos ){
gc = poBand->GetMetadataItem( "GRIB_SHORT_NAME" );
std::string bandName( gc );
if( bandName.find( "2-HTGL" ) != bandName.npos ){
bandList.push_back( j ); // 2t
break;
}
}
}
for(unsigned int j = 1; j < srcDS->GetRasterCount(); j++)
{
poBand = srcDS->GetRasterBand( j );
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
if( bandName.find( "v-component of wind [m/s]" ) != bandName.npos ){
gc = poBand->GetMetadataItem( "GRIB_SHORT_NAME" );
std::string bandName( gc );
if( bandName.find( "10-HTGL" ) != bandName.npos ){
bandList.push_back( j ); // 10v
break;
}
}
}
for(unsigned int j = 1; j < srcDS->GetRasterCount(); j++)
{
poBand = srcDS->GetRasterBand( j );
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
if( bandName.find( "u-component of wind [m/s]" ) != bandName.npos ){
gc = poBand->GetMetadataItem( "GRIB_SHORT_NAME" );
std::string bandName( gc );
if( bandName.find( "10-HTGL" ) != bandName.npos ){
bandList.push_back( j ); // 10u
break;
}
}
}
for(unsigned int j = 1; j < srcDS->GetRasterCount(); j++)
{
poBand = srcDS->GetRasterBand( j );
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
if( bandName.find( "Total cloud cover [%]" ) != bandName.npos ){
gc = poBand->GetMetadataItem( "GRIB_SHORT_NAME" );
std::string bandName( gc );
if( bandName.find( "0-RESERVED" ) != bandName.npos ){
bandList.push_back( j ); // Total cloud cover in %
break;
}
}
}
}
}
CPLDebug("HRRR", "2t: bandList[0] = %d", bandList[0]);
CPLDebug("HRRR", "10v: bandList[1] = %d", bandList[1]);
CPLDebug("HRRR", "10u: bandList[2] = %d", bandList[2]);
CPLDebug("HRRR", "tcc: bandList[3] = %d", bandList[3]);
if(bandList.size() < 4)
throw std::runtime_error("Could not match ninjaTime with a band number in the forecast file.");
std::string dstWkt;
dstWkt = input.dem.prjString;
GDALDataset *wrpDS;
std::string temp;
std::string srcWkt;
GDALWarpOptions* psWarpOptions;
srcWkt = srcDS->GetProjectionRef();
poBand = srcDS->GetRasterBand( 9 );
int pbSuccess;
double dfNoData = poBand->GetNoDataValue( &pbSuccess );
psWarpOptions = GDALCreateWarpOptions();
int nBandCount = bandList.size();
psWarpOptions->nBandCount = nBandCount;
psWarpOptions->panSrcBands =
(int*) CPLMalloc( sizeof( int ) * nBandCount );
psWarpOptions->panDstBands =
(int*) CPLMalloc( sizeof( int ) * nBandCount );
psWarpOptions->padfDstNoDataReal =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataImag =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataReal =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataImag =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
if( pbSuccess == false )
dfNoData = -9999.0;
psWarpOptions->panSrcBands =
(int *) CPLMalloc(sizeof(int) * psWarpOptions->nBandCount );
psWarpOptions->panSrcBands[0] = bandList[0];
psWarpOptions->panSrcBands[1] = bandList[1];
psWarpOptions->panSrcBands[2] = bandList[2];
psWarpOptions->panSrcBands[3] = bandList[3];
psWarpOptions->panDstBands =
(int *) CPLMalloc(sizeof(int) * psWarpOptions->nBandCount );
psWarpOptions->panDstBands[0] = 1;
psWarpOptions->panDstBands[1] = 2;
psWarpOptions->panDstBands[2] = 3;
psWarpOptions->panDstBands[3] = 4;
wrpDS = (GDALDataset*) GDALAutoCreateWarpedVRT( srcDS, srcWkt.c_str(),
dstWkt.c_str(),
GRA_NearestNeighbour,
1.0, psWarpOptions );
std::vector<std::string> varList = getVariableList();
for( unsigned int i = 0; i < varList.size(); i++ ) {
if( varList[i] == "2t" ) {
GDAL2AsciiGrid( wrpDS, i+1, airGrid );
if( CPLIsNan( dfNoData ) ) {
airGrid.set_noDataValue( -9999.0 );
airGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "10v" ) {
GDAL2AsciiGrid( wrpDS, i+1, vGrid );
if( CPLIsNan( dfNoData ) ) {
vGrid.set_noDataValue( -9999.0 );
vGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "10u" ) {
GDAL2AsciiGrid( wrpDS, i+1, uGrid );
if( CPLIsNan( dfNoData ) ) {
uGrid.set_noDataValue( -9999.0 );
uGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "tcc" ) {
GDAL2AsciiGrid( wrpDS, i+1, cloudGrid );
if( CPLIsNan( dfNoData ) ) {
cloudGrid.set_noDataValue( -9999.0 );
cloudGrid.replaceNan( -9999.0 );
}
}
}
//if there are any clouds set cloud fraction to 1, otherwise set to 0.
for(int i = 0; i < cloudGrid.get_nRows(); i++){
for(int j = 0; j < cloudGrid.get_nCols(); j++){
if(cloudGrid(i,j) < 0.0){
cloudGrid(i,j) = 0.0;
}
else{
cloudGrid(i,j) = 1.0;
}
}
}
wGrid.set_headerData( uGrid );
wGrid = 0.0;
airGrid += 273.15;
GDALDestroyWarpOptions( psWarpOptions );
GDALClose((GDALDatasetH) srcDS );
GDALClose((GDALDatasetH) wrpDS );
}
GDALDataset *DOQ1Dataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* We assume the user is pointing to the binary (i.e. .bil) file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 212 )
return NULL;
/* -------------------------------------------------------------------- */
/* Attempt to extract a few key values from the header. */
/* -------------------------------------------------------------------- */
const double dfWidth = DOQGetField(poOpenInfo->pabyHeader + 150, 6 );
const double dfHeight = DOQGetField(poOpenInfo->pabyHeader + 144, 6 );
const double dfBandStorage = DOQGetField(poOpenInfo->pabyHeader + 162, 3 );
const double dfBandTypes = DOQGetField(poOpenInfo->pabyHeader + 156, 3 );
/* -------------------------------------------------------------------- */
/* Do these values look coherent for a DOQ file? It would be */
/* nice to do a more comprehensive test than this! */
/* -------------------------------------------------------------------- */
if( dfWidth < 500 || dfWidth > 25000 || CPLIsNan(dfWidth)
|| dfHeight < 500 || dfHeight > 25000 || CPLIsNan(dfHeight)
|| dfBandStorage < 0 || dfBandStorage > 4 || CPLIsNan(dfBandStorage)
|| dfBandTypes < 1 || dfBandTypes > 9 || CPLIsNan(dfBandTypes) )
return NULL;
const int nWidth = static_cast<int>(dfWidth);
const int nHeight = static_cast<int>(dfHeight);
/*const int nBandStorage = static_cast<int>(dfBandStorage);*/
const int nBandTypes = static_cast<int>(dfBandTypes);
/* -------------------------------------------------------------------- */
/* Check the configuration. We don't currently handle all */
/* variations, only the common ones. */
/* -------------------------------------------------------------------- */
if( nBandTypes > 5 )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"DOQ Data Type (%d) is not a supported configuration.",
nBandTypes );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The DOQ1 driver does not support update access to existing "
"datasets." );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
DOQ1Dataset *poDS = new DOQ1Dataset();
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nWidth;
poDS->nRasterYSize = nHeight;
poDS->fpImage = VSIFOpenL(poOpenInfo->pszFilename, "rb");
if (poDS->fpImage == NULL)
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Compute layout of data. */
/* -------------------------------------------------------------------- */
int nBytesPerPixel = 0;
if( nBandTypes < 5 )
nBytesPerPixel = 1;
else if( nBandTypes == 5 )
nBytesPerPixel = 3;
const int nBytesPerLine = nBytesPerPixel * nWidth;
const int nSkipBytes = 4 * nBytesPerLine;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->nBands = nBytesPerPixel;
for( int i = 0; i < poDS->nBands; i++ )
{
poDS->SetBand( i+1,
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + i, nBytesPerPixel, nBytesPerLine,
GDT_Byte, TRUE, TRUE ) );
}
/* -------------------------------------------------------------------- */
/* Set the description. */
/* -------------------------------------------------------------------- */
DOQGetDescription(poDS, poOpenInfo->pabyHeader);
/* -------------------------------------------------------------------- */
/* Establish the projection string. */
/* -------------------------------------------------------------------- */
if( static_cast<int>( DOQGetField(poOpenInfo->pabyHeader + 195, 3) ) != 1 )
poDS->pszProjection = VSIStrdup("");
else
{
int nZone = static_cast<int>(
DOQGetField(poOpenInfo->pabyHeader + 198, 6) );
if( nZone < 0 || nZone > 60 )
nZone = 0;
const char *pszUnits = NULL;
if( static_cast<int>( DOQGetField(poOpenInfo->pabyHeader + 204, 3))
== 1 )
pszUnits = "UNIT[\"US survey foot\",0.304800609601219]";
else
pszUnits = "UNIT[\"metre\",1]";
const char *pszDatumLong = NULL;
const char *pszDatumShort = NULL;
switch( static_cast<int>(
DOQGetField(poOpenInfo->pabyHeader + 167, 2) ) )
{
case 1:
pszDatumLong = NAD27_DATUM;
pszDatumShort = "NAD 27";
break;
case 2:
pszDatumLong = WGS72_DATUM;
pszDatumShort = "WGS 72";
break;
case 3:
pszDatumLong = WGS84_DATUM;
pszDatumShort = "WGS 84";
break;
case 4:
pszDatumLong = NAD83_DATUM;
pszDatumShort = "NAD 83";
break;
default:
pszDatumLong = "DATUM[\"unknown\"]";
pszDatumShort = "unknown";
break;
}
poDS->pszProjection =
CPLStrdup(CPLSPrintf( UTM_FORMAT, pszDatumShort, nZone,
pszDatumLong, nZone * 6 - 183, pszUnits ));
}
/* -------------------------------------------------------------------- */
/* Read the georeferencing information. */
/* -------------------------------------------------------------------- */
unsigned char abyRecordData[500] = { '\0' };
if( VSIFSeekL( poDS->fpImage, nBytesPerLine * 2, SEEK_SET ) != 0
|| VSIFReadL( abyRecordData, sizeof(abyRecordData),
1, poDS->fpImage) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Header read error on %s.",
poOpenInfo->pszFilename );
delete poDS;
return NULL;
}
poDS->dfULX = DOQGetField( abyRecordData + 288, 24 );
poDS->dfULY = DOQGetField( abyRecordData + 312, 24 );
if( VSIFSeekL( poDS->fpImage, nBytesPerLine * 3, SEEK_SET ) != 0
|| VSIFReadL( abyRecordData, sizeof(abyRecordData),
1, poDS->fpImage) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Header read error on %s.",
poOpenInfo->pszFilename );
delete poDS;
return NULL;
}
poDS->dfXPixelSize = DOQGetField( abyRecordData + 59, 12 );
poDS->dfYPixelSize = DOQGetField( abyRecordData + 71, 12 );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
GDALDataset *ARGDataset::Open( GDALOpenInfo *poOpenInfo )
{
if ( !Identify( poOpenInfo ) || poOpenInfo->fpL == nullptr )
return nullptr;
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The ARG driver does not support update access to existing"
" datasets." );
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Check metadata settings in JSON. */
/* -------------------------------------------------------------------- */
json_object *pJSONObject = GetJsonObject(poOpenInfo->pszFilename);
if (pJSONObject == nullptr) {
CPLError(CE_Failure, CPLE_AppDefined, "Error parsing JSON.");
return nullptr;
}
// get the type (always 'arg')
const char *pszJSONStr = GetJsonValueStr(pJSONObject, "type");
if (pszJSONStr == nullptr ) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'type' is missing from the JSON file.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
else if (!EQUAL(pszJSONStr, "arg")) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'type' is not recognized: '%s'.", pszJSONStr);
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
double dfNoDataValue;
GDALDataType eType;
int nPixelOffset;
// get the datatype
pszJSONStr = GetJsonValueStr(pJSONObject, "datatype");
if (pszJSONStr == nullptr) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'datatype' is missing from the JSON file.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
else if (EQUAL(pszJSONStr, "int8")) {
CPLDebug("ARGDataset", "Open(): "
"int8 data is not supported in GDAL -- mapped to uint8");
eType = GDT_Byte;
nPixelOffset = 1;
dfNoDataValue = 128;
}
else if (EQUAL(pszJSONStr, "int16")) {
eType = GDT_Int16;
nPixelOffset = 2;
dfNoDataValue = -32767;
}
else if (EQUAL(pszJSONStr, "int32")) {
eType = GDT_Int32;
nPixelOffset = 4;
dfNoDataValue = -2e31;
}
else if (EQUAL(pszJSONStr, "uint8")) {
eType = GDT_Byte;
nPixelOffset = 1;
dfNoDataValue = 255;
}
else if (EQUAL(pszJSONStr, "uint16")) {
eType = GDT_UInt16;
nPixelOffset = 2;
dfNoDataValue = 65535;
}
else if (EQUAL(pszJSONStr, "uint32")) {
eType = GDT_UInt32;
nPixelOffset = 4;
dfNoDataValue = -2e31;
}
else if (EQUAL(pszJSONStr, "float32")) {
eType = GDT_Float32;
nPixelOffset = 4;
dfNoDataValue = std::numeric_limits<double>::quiet_NaN();
}
else if (EQUAL(pszJSONStr, "float64")) {
eType = GDT_Float64;
nPixelOffset = 8;
dfNoDataValue = std::numeric_limits<double>::quiet_NaN();
}
else {
if (EQUAL(pszJSONStr, "int64") ||
EQUAL(pszJSONStr, "uint64")) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'datatype' is unsupported in GDAL: '%s'.", pszJSONStr);
}
else {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'datatype' is unknown: '%s'.", pszJSONStr);
}
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
// get the xmin of the bounding box
const double dfXmin = GetJsonValueDbl(pJSONObject, "xmin");
if (CPLIsNan(dfXmin)) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'xmin' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
// get the ymin of the bounding box
const double dfYmin = GetJsonValueDbl(pJSONObject, "ymin");
if (CPLIsNan(dfYmin)) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'ymin' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
// get the xmax of the bounding boxfpL
const double dfXmax = GetJsonValueDbl(pJSONObject, "xmax");
if (CPLIsNan(dfXmax)) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'xmax' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
// get the ymax of the bounding box
const double dfYmax = GetJsonValueDbl(pJSONObject, "ymax");
if (CPLIsNan(dfYmax)) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'ymax' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
// get the cell width
const double dfCellwidth = GetJsonValueDbl(pJSONObject, "cellwidth");
if (CPLIsNan(dfCellwidth)) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'cellwidth' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
// get the cell height
const double dfCellheight = GetJsonValueDbl(pJSONObject, "cellheight");
if (CPLIsNan(dfCellheight)) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'cellheight' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
double dfXSkew = GetJsonValueDbl(pJSONObject, "xskew");
if (CPLIsNan(dfXSkew)) {
// not an error -- default to 0.0
dfXSkew = 0.0f;
}
double dfYSkew = GetJsonValueDbl(pJSONObject, "yskew");
if (CPLIsNan(dfYSkew)) {
// not an error -- default to 0.0
dfYSkew = 0.0f;
}
// get the rows
const int nRows = GetJsonValueInt(pJSONObject, "rows");
if (nRows < 0) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'rows' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
// get the columns
const int nCols = GetJsonValueInt(pJSONObject, "cols");
if (nCols < 0) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'cols' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
int nSrs = GetJsonValueInt(pJSONObject, "epsg");
if (nSrs < 0) {
// not an error -- default to web mercator
nSrs = 3857;
}
OGRSpatialReference oSRS;
OGRErr nErr = oSRS.importFromEPSG(nSrs);
if (nErr != OGRERR_NONE) {
nErr = oSRS.importFromEPSG(3857);
if (nErr == OGRERR_NONE) {
CPLDebug("ARGDataset", "Open(): "
"The EPSG provided did not import cleanly. "
"Defaulting to EPSG:3857");
}
else {
CPLError( CE_Failure, CPLE_AppDefined,
"The 'epsg' value did not translate to a known "
"spatial reference. "
"Please check the 'epsg' value and try again.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
}
char *pszWKT = nullptr;
nErr = oSRS.exportToWkt(&pszWKT);
if (nErr != OGRERR_NONE) {
CPLError(CE_Failure, CPLE_AppDefined,
"The spatial reference is known, but could not be set on the "
"dataset. Please check the 'epsg' value and try again.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
return nullptr;
}
// get the layer (always the file basename)
pszJSONStr = GetJsonValueStr(pJSONObject, "layer");
if (pszJSONStr == nullptr) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'layer' is missing from the JSON file.");
json_object_put(pJSONObject);
pJSONObject = nullptr;
CPLFree(pszWKT);
return nullptr;
}
char *pszLayer = CPLStrdup(pszJSONStr);
// done with the json object now
json_object_put(pJSONObject);
pJSONObject = nullptr;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
ARGDataset *poDS = new ARGDataset();
poDS->pszFilename = CPLStrdup(poOpenInfo->pszFilename);
poDS->SetMetadataItem("LAYER",pszLayer,nullptr);
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
poDS->SetProjection( pszWKT );
// done with the projection string
CPLFree(pszWKT);
CPLFree(pszLayer);
/* -------------------------------------------------------------------- */
/* Assume ownership of the file handled from the GDALOpenInfo. */
/* -------------------------------------------------------------------- */
poDS->fpImage = poOpenInfo->fpL;
poOpenInfo->fpL = nullptr;
poDS->adfGeoTransform[0] = dfXmin;
poDS->adfGeoTransform[1] = dfCellwidth;
poDS->adfGeoTransform[2] = dfXSkew;
poDS->adfGeoTransform[3] = dfYmax;
poDS->adfGeoTransform[4] = dfYSkew;
poDS->adfGeoTransform[5] = -dfCellheight;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
#ifdef CPL_LSB
bool bNative = false;
#else
bool bNative = true;
#endif
RawRasterBand *poBand
= new RawRasterBand( poDS, 1, poDS->fpImage,
0, nPixelOffset, nPixelOffset * nCols,
eType, bNative, RawRasterBand::OwnFP::NO );
poDS->SetBand( 1, poBand );
poBand->SetNoDataValue( dfNoDataValue );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
CPLErr VRTSourcedRasterBand::IRasterIO( GDALRWFlag eRWFlag,
int nXOff, int nYOff, int nXSize, int nYSize,
void * pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
int nPixelSpace, int nLineSpace )
{
int iSource;
CPLErr eErr = CE_None;
if( eRWFlag == GF_Write )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Writing through VRTSourcedRasterBand is not supported." );
return CE_Failure;
}
/* When using GDALProxyPoolDataset for sources, the recusion will not be */
/* detected at VRT opening but when doing RasterIO. As the proxy pool will */
/* return the already opened dataset, we can just test a member variable. */
if ( bAlreadyInIRasterIO )
{
CPLError( CE_Failure, CPLE_AppDefined,
"VRTSourcedRasterBand::IRasterIO() called recursively on the same band. "
"It looks like the VRT is referencing itself." );
return CE_Failure;
}
/* ==================================================================== */
/* Do we have overviews that would be appropriate to satisfy */
/* this request? */
/* ==================================================================== */
if( (nBufXSize < nXSize || nBufYSize < nYSize)
&& GetOverviewCount() > 0 )
{
if( OverviewRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace, nLineSpace ) == CE_None )
return CE_None;
}
/* -------------------------------------------------------------------- */
/* Initialize the buffer to some background value. Use the */
/* nodata value if available. */
/* -------------------------------------------------------------------- */
if ( nPixelSpace == GDALGetDataTypeSize(eBufType)/8 &&
(!bNoDataValueSet || (!CPLIsNan(dfNoDataValue) && dfNoDataValue == 0)) )
{
if (nLineSpace == nBufXSize * nPixelSpace)
{
memset( pData, 0, nBufYSize * nLineSpace );
}
else
{
int iLine;
for( iLine = 0; iLine < nBufYSize; iLine++ )
{
memset( ((GByte*)pData) + iLine * nLineSpace, 0, nBufXSize * nPixelSpace );
}
}
}
else if ( !bEqualAreas || bNoDataValueSet )
{
double dfWriteValue = 0.0;
int iLine;
if( bNoDataValueSet )
dfWriteValue = dfNoDataValue;
for( iLine = 0; iLine < nBufYSize; iLine++ )
{
GDALCopyWords( &dfWriteValue, GDT_Float64, 0,
((GByte *)pData) + nLineSpace * iLine,
eBufType, nPixelSpace, nBufXSize );
}
}
/* -------------------------------------------------------------------- */
/* Do we have overviews that would be appropriate to satisfy */
/* this request? */
/* -------------------------------------------------------------------- */
if( (nBufXSize < nXSize || nBufYSize < nYSize)
&& GetOverviewCount() > 0 )
{
if( OverviewRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace, nLineSpace ) == CE_None )
return CE_None;
}
bAlreadyInIRasterIO = TRUE;
/* -------------------------------------------------------------------- */
/* Overlay each source in turn over top this. */
/* -------------------------------------------------------------------- */
for( iSource = 0; eErr == CE_None && iSource < nSources; iSource++ )
{
eErr =
papoSources[iSource]->RasterIO( nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace, nLineSpace);
}
bAlreadyInIRasterIO = FALSE;
return eErr;
}
int CPL_STDCALL
GDALChecksumImage( GDALRasterBandH hBand,
int nXOff, int nYOff, int nXSize, int nYSize )
{
VALIDATE_POINTER1( hBand, "GDALChecksumImage", 0 );
const static int anPrimes[11] =
{ 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43 };
int iLine, i, nChecksum = 0, iPrime = 0, nCount;
GDALDataType eDataType = GDALGetRasterDataType( hBand );
int bComplex = GDALDataTypeIsComplex( eDataType );
if (eDataType == GDT_Float32 || eDataType == GDT_Float64 ||
eDataType == GDT_CFloat32 || eDataType == GDT_CFloat64)
{
double* padfLineData;
GDALDataType eDstDataType = (bComplex) ? GDT_CFloat64 : GDT_Float64;
padfLineData = (double *) VSIMalloc2(nXSize, sizeof(double) * 2);
if (padfLineData == NULL)
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"VSIMalloc2(): Out of memory in GDALChecksumImage. "
"Checksum value couldn't be computed\n");
return 0;
}
for( iLine = nYOff; iLine < nYOff + nYSize; iLine++ )
{
if (GDALRasterIO( hBand, GF_Read, nXOff, iLine, nXSize, 1,
padfLineData, nXSize, 1, eDstDataType, 0, 0 ) != CE_None)
{
CPLError( CE_Failure, CPLE_FileIO,
"Checksum value couldn't be computed due to I/O read error.\n");
break;
}
nCount = (bComplex) ? nXSize * 2 : nXSize;
for( i = 0; i < nCount; i++ )
{
double dfVal = padfLineData[i];
int nVal;
if (CPLIsNan(dfVal) || CPLIsInf(dfVal))
{
/* Most compilers seem to cast NaN or Inf to 0x80000000. */
/* but VC7 is an exception. So we force the result */
/* of such a cast */
nVal = 0x80000000;
}
else
{
/* Standard behaviour of GDALCopyWords when converting */
/* from floating point to Int32 */
dfVal += 0.5;
if( dfVal < -2147483647.0 )
nVal = -2147483647;
else if( dfVal > 2147483647 )
nVal = 2147483647;
else
nVal = (GInt32) floor(dfVal);
}
nChecksum += (nVal % anPrimes[iPrime++]);
if( iPrime > 10 )
iPrime = 0;
nChecksum &= 0xffff;
}
}
CPLFree(padfLineData);
}
else
{
int *panLineData;
GDALDataType eDstDataType = (bComplex) ? GDT_CInt32 : GDT_Int32;
panLineData = (GInt32 *) VSIMalloc2(nXSize, sizeof(GInt32) * 2);
if (panLineData == NULL)
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"VSIMalloc2(): Out of memory in GDALChecksumImage. "
"Checksum value couldn't be computed\n");
return 0;
}
for( iLine = nYOff; iLine < nYOff + nYSize; iLine++ )
{
if (GDALRasterIO( hBand, GF_Read, nXOff, iLine, nXSize, 1,
panLineData, nXSize, 1, eDstDataType, 0, 0 ) != CE_None)
{
CPLError( CE_Failure, CPLE_FileIO,
"Checksum value couldn't be computed due to I/O read error.\n");
break;
}
nCount = (bComplex) ? nXSize * 2 : nXSize;
for( i = 0; i < nCount; i++ )
{
nChecksum += (panLineData[i] % anPrimes[iPrime++]);
if( iPrime > 10 )
iPrime = 0;
nChecksum &= 0xffff;
}
}
CPLFree( panLineData );
}
return nChecksum;
}
GDALDataset *ARGDataset::Open( GDALOpenInfo * poOpenInfo )
{
json_object * pJSONObject;
const char * pszJSONStr;
char * pszLayer;
/***** items from the json metadata *****/
GDALDataType eType = GDT_Unknown;
double fXmin = 0.0;
double fYmin = 0.0;
double fXmax = 0.0;
double fYmax = 0.0;
double fCellwidth = 1.0;
double fCellheight = 1.0;
double fXSkew = 0.0;
double fYSkew = 0.0;
int nRows = 0;
int nCols = 0;
int nSrs = 3857;
/***** items from the json metadata *****/
int nPixelOffset = 0;
double fNoDataValue = NAN;
char * pszWKT = NULL;
OGRSpatialReference oSRS;
OGRErr nErr = OGRERR_NONE;
if ( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Check metadata settings in JSON. */
/* -------------------------------------------------------------------- */
pJSONObject = GetJsonObject(poOpenInfo->pszFilename);
if (pJSONObject == NULL) {
CPLError(CE_Failure, CPLE_AppDefined, "Error parsing JSON.");
return NULL;
}
// get the type (always 'arg')
pszJSONStr = GetJsonValueStr(pJSONObject, "type");
if (pszJSONStr == NULL ) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'type' is missing from the JSON file.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
else if (!EQUAL(pszJSONStr, "arg")) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'type' is not recognized: '%s'.", pszJSONStr);
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
// get the datatype
pszJSONStr = GetJsonValueStr(pJSONObject, "datatype");
if (pszJSONStr == NULL) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'datatype' is missing from the JSON file.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
else if (EQUAL(pszJSONStr, "int8")) {
CPLDebug("ARGDataset", "Open(): "
"int8 data is not supported in GDAL -- mapped to uint8");
eType = GDT_Byte;
nPixelOffset = 1;
fNoDataValue = 128;
}
else if (EQUAL(pszJSONStr, "int16")) {
eType = GDT_Int16;
nPixelOffset = 2;
fNoDataValue = -32767;
}
else if (EQUAL(pszJSONStr, "int32")) {
eType = GDT_Int32;
nPixelOffset = 4;
fNoDataValue = -2e31;
}
else if (EQUAL(pszJSONStr, "uint8")) {
eType = GDT_Byte;
nPixelOffset = 1;
fNoDataValue = 255;
}
else if (EQUAL(pszJSONStr, "uint16")) {
eType = GDT_UInt16;
nPixelOffset = 2;
fNoDataValue = 65535;
}
else if (EQUAL(pszJSONStr, "uint32")) {
eType = GDT_UInt32;
nPixelOffset = 4;
fNoDataValue = -2e31;
}
else if (EQUAL(pszJSONStr, "float32")) {
eType = GDT_Float32;
nPixelOffset = 4;
fNoDataValue = NAN;
}
else if (EQUAL(pszJSONStr, "float64")) {
eType = GDT_Float64;
nPixelOffset = 8;
fNoDataValue = NAN;
}
else {
if (EQUAL(pszJSONStr, "int64") ||
EQUAL(pszJSONStr, "uint64")) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'datatype' is unsupported in GDAL: '%s'.", pszJSONStr);
}
else {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'datatype' is unknown: '%s'.", pszJSONStr);
}
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
// get the xmin of the bounding box
fXmin = GetJsonValueDbl(pJSONObject, "xmin");
if (CPLIsNan(fXmin)) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'xmin' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
// get the ymin of the bounding box
fYmin = GetJsonValueDbl(pJSONObject, "ymin");
if (CPLIsNan(fYmin)) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'ymin' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
// get the xmax of the bounding box
fXmax = GetJsonValueDbl(pJSONObject, "xmax");
if (CPLIsNan(fXmax)) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'xmax' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
// get the ymax of the bounding box
fYmax = GetJsonValueDbl(pJSONObject, "ymax");
if (CPLIsNan(fYmax)) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'ymax' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
// get the cell width
fCellwidth = GetJsonValueDbl(pJSONObject, "cellwidth");
if (CPLIsNan(fCellwidth)) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'cellwidth' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
// get the cell height
fCellheight = GetJsonValueDbl(pJSONObject, "cellheight");
if (CPLIsNan(fCellheight)) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'cellheight' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
fXSkew = GetJsonValueDbl(pJSONObject, "xskew");
if (CPLIsNan(fXSkew)) {
// not an error -- default to 0.0
fXSkew = 0.0f;
}
fYSkew = GetJsonValueDbl(pJSONObject, "yskew");
if (CPLIsNan(fYSkew)) {
// not an error -- default to 0.0
fYSkew = 0.0f;
}
// get the rows
nRows = GetJsonValueInt(pJSONObject, "rows");
if (nRows < 0) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'rows' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
// get the columns
nCols = GetJsonValueInt(pJSONObject, "cols");
if (nCols < 0) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'cols' is missing or invalid.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
nSrs = GetJsonValueInt(pJSONObject, "epsg");
if (nSrs < 0) {
// not an error -- default to web mercator
nSrs = 3857;
}
nErr = oSRS.importFromEPSG(nSrs);
if (nErr != OGRERR_NONE) {
nErr = oSRS.importFromEPSG(3857);
if (nErr == OGRERR_NONE) {
CPLDebug("ARGDataset", "Open(): "
"The EPSG provided did not import cleanly. Defaulting to EPSG:3857");
}
else {
CPLError(CE_Failure, CPLE_AppDefined,
"The 'epsg' value did not transate to a known spatial reference."
" Please check the 'epsg' value and try again.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
}
nErr = oSRS.exportToWkt(&pszWKT);
if (nErr != OGRERR_NONE) {
CPLError(CE_Failure, CPLE_AppDefined,
"The spatial reference is known, but could not be set on the "
"dataset. Please check the 'epsg' value and try again.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
// get the layer (always the file basename)
pszJSONStr = GetJsonValueStr(pJSONObject, "layer");
if (pszJSONStr == NULL) {
CPLError(CE_Failure, CPLE_AppDefined,
"The ARG 'layer' is missing from the JSON file.");
json_object_put(pJSONObject);
pJSONObject = NULL;
return NULL;
}
pszLayer = CPLStrdup(pszJSONStr);
// done with the json object now
json_object_put(pJSONObject);
pJSONObject = NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
ARGDataset *poDS;
poDS = new ARGDataset();
poDS->pszFilename = CPLStrdup(poOpenInfo->pszFilename);
poDS->SetMetadataItem("LAYER",pszLayer,NULL);
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
poDS->SetProjection( pszWKT );
// done with the projection string
CPLFree(pszWKT);
CPLFree(pszLayer);
/* -------------------------------------------------------------------- */
/* Assume ownership of the file handled from the GDALOpenInfo. */
/* -------------------------------------------------------------------- */
poDS->fpImage = VSIFOpenL(poOpenInfo->pszFilename, "rb");
if (poDS->fpImage == NULL)
{
delete poDS;
CPLError(CE_Failure, CPLE_AppDefined,
"Could not open dataset '%s'", poOpenInfo->pszFilename);
return NULL;
}
poDS->adfGeoTransform[0] = fXmin;
poDS->adfGeoTransform[1] = fCellwidth;
poDS->adfGeoTransform[2] = fXSkew;
poDS->adfGeoTransform[3] = fYmax;
poDS->adfGeoTransform[4] = fYSkew;
poDS->adfGeoTransform[5] = -fCellheight;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
RawRasterBand *poBand;
#ifdef CPL_LSB
int bNative = FALSE;
#else
int bNative = TRUE;
#endif
poBand = new RawRasterBand( poDS, 1, poDS->fpImage,
0, nPixelOffset, nPixelOffset * nCols,
eType, bNative, TRUE );
poDS->SetBand( 1, poBand );
poBand->SetNoDataValue( fNoDataValue );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
CPLXMLNode *VRTRasterBand::SerializeToXML( const char *pszVRTPath )
{
CPLXMLNode *psTree;
psTree = CPLCreateXMLNode( NULL, CXT_Element, "VRTRasterBand" );
/* -------------------------------------------------------------------- */
/* Various kinds of metadata. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psMD;
CPLSetXMLValue( psTree, "#dataType",
GDALGetDataTypeName( GetRasterDataType() ) );
if( nBand > 0 )
CPLSetXMLValue( psTree, "#band", CPLSPrintf( "%d", GetBand() ) );
psMD = oMDMD.Serialize();
if( psMD != NULL )
CPLAddXMLChild( psTree, psMD );
if( strlen(GetDescription()) > 0 )
CPLSetXMLValue( psTree, "Description", GetDescription() );
if( bNoDataValueSet )
{
if (CPLIsNan(dfNoDataValue))
CPLSetXMLValue( psTree, "NoDataValue", "nan");
else
CPLSetXMLValue( psTree, "NoDataValue",
CPLSPrintf( "%.14E", dfNoDataValue ) );
}
if( bHideNoDataValue )
CPLSetXMLValue( psTree, "HideNoDataValue",
CPLSPrintf( "%d", bHideNoDataValue ) );
if( pszUnitType != NULL )
CPLSetXMLValue( psTree, "UnitType", pszUnitType );
if( dfOffset != 0.0 )
CPLSetXMLValue( psTree, "Offset",
CPLSPrintf( "%.16g", dfOffset ) );
if( dfScale != 1.0 )
CPLSetXMLValue( psTree, "Scale",
CPLSPrintf( "%.16g", dfScale ) );
if( eColorInterp != GCI_Undefined )
CPLSetXMLValue( psTree, "ColorInterp",
GDALGetColorInterpretationName( eColorInterp ) );
/* -------------------------------------------------------------------- */
/* Category names. */
/* -------------------------------------------------------------------- */
if( papszCategoryNames != NULL )
{
CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,
"CategoryNames" );
CPLXMLNode* psLastChild = NULL;
for( int iEntry=0; papszCategoryNames[iEntry] != NULL; iEntry++ )
{
CPLXMLNode *psNode = CPLCreateXMLElementAndValue( NULL, "Category",
papszCategoryNames[iEntry] );
if( psLastChild == NULL )
psCT_XML->psChild = psNode;
else
psLastChild->psNext = psNode;
psLastChild = psNode;
}
}
/* -------------------------------------------------------------------- */
/* Histograms. */
/* -------------------------------------------------------------------- */
if( psSavedHistograms != NULL )
CPLAddXMLChild( psTree, CPLCloneXMLTree( psSavedHistograms ) );
/* -------------------------------------------------------------------- */
/* Color Table. */
/* -------------------------------------------------------------------- */
if( poColorTable != NULL )
{
CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,
"ColorTable" );
CPLXMLNode* psLastChild = NULL;
for( int iEntry=0; iEntry < poColorTable->GetColorEntryCount();
iEntry++ )
{
GDALColorEntry sEntry;
CPLXMLNode *psEntry_XML = CPLCreateXMLNode( NULL, CXT_Element,
"Entry" );
if( psLastChild == NULL )
psCT_XML->psChild = psEntry_XML;
else
psLastChild->psNext = psEntry_XML;
psLastChild = psEntry_XML;
poColorTable->GetColorEntryAsRGB( iEntry, &sEntry );
CPLSetXMLValue( psEntry_XML, "#c1", CPLSPrintf("%d",sEntry.c1) );
CPLSetXMLValue( psEntry_XML, "#c2", CPLSPrintf("%d",sEntry.c2) );
CPLSetXMLValue( psEntry_XML, "#c3", CPLSPrintf("%d",sEntry.c3) );
CPLSetXMLValue( psEntry_XML, "#c4", CPLSPrintf("%d",sEntry.c4) );
}
}
/* ==================================================================== */
/* Overviews */
/* ==================================================================== */
for( int iOvr = 0; iOvr < (int)apoOverviews.size(); iOvr ++ )
{
CPLXMLNode *psOVR_XML = CPLCreateXMLNode( psTree, CXT_Element,
"Overview" );
int bRelativeToVRT;
const char *pszRelativePath;
VSIStatBufL sStat;
if( VSIStatExL( apoOverviews[iOvr].osFilename, &sStat, VSI_STAT_EXISTS_FLAG ) != 0 )
{
pszRelativePath = apoOverviews[iOvr].osFilename;
bRelativeToVRT = FALSE;
}
else
{
pszRelativePath =
CPLExtractRelativePath( pszVRTPath, apoOverviews[iOvr].osFilename,
&bRelativeToVRT );
}
CPLSetXMLValue( psOVR_XML, "SourceFilename", pszRelativePath );
CPLCreateXMLNode(
CPLCreateXMLNode( CPLGetXMLNode( psOVR_XML, "SourceFilename" ),
CXT_Attribute, "relativeToVRT" ),
CXT_Text, bRelativeToVRT ? "1" : "0" );
CPLSetXMLValue( psOVR_XML, "SourceBand",
CPLSPrintf("%d",apoOverviews[iOvr].nBand) );
}
/* ==================================================================== */
/* Mask band (specific to that raster band) */
/* ==================================================================== */
if( poMaskBand != NULL )
{
CPLXMLNode *psBandTree =
poMaskBand->SerializeToXML(pszVRTPath);
if( psBandTree != NULL )
{
CPLXMLNode *psMaskBandElement = CPLCreateXMLNode( psTree, CXT_Element,
"MaskBand" );
CPLAddXMLChild( psMaskBandElement, psBandTree );
}
}
return psTree;
}
OGRErr OGRPoint::importFromWkb( unsigned char * pabyData,
int nSize,
OGRwkbVariant eWkbVariant )
{
OGRwkbByteOrder eByteOrder = wkbNDR;
flags = 0;
OGRErr eErr =
importPreambuleFromWkb( pabyData, nSize, eByteOrder, eWkbVariant );
pabyData += 5;
if( eErr != OGRERR_NONE )
return eErr;
if( nSize != -1 )
{
if( (nSize < 37) && ((flags & OGR_G_3D) && (flags & OGR_G_MEASURED)) )
return OGRERR_NOT_ENOUGH_DATA;
else if( (nSize < 29) && ((flags & OGR_G_3D) ||
(flags & OGR_G_MEASURED)) )
return OGRERR_NOT_ENOUGH_DATA;
else if( nSize < 21 )
return OGRERR_NOT_ENOUGH_DATA;
}
/* -------------------------------------------------------------------- */
/* Get the vertex. */
/* -------------------------------------------------------------------- */
memcpy( &x, pabyData, 8 );
pabyData += 8;
memcpy( &y, pabyData, 8 );
pabyData += 8;
if( OGR_SWAP( eByteOrder ) )
{
CPL_SWAPDOUBLE( &x );
CPL_SWAPDOUBLE( &y );
}
if( flags & OGR_G_3D )
{
memcpy( &z, pabyData, 8 );
pabyData += 8;
if( OGR_SWAP( eByteOrder ) )
CPL_SWAPDOUBLE( &z );
}
else
{
z = 0;
}
if( flags & OGR_G_MEASURED )
{
memcpy( &m, pabyData, 8 );
/*pabyData += 8; */
if( OGR_SWAP( eByteOrder ) )
{
CPL_SWAPDOUBLE( &m );
}
}
else
{
m = 0;
}
// Detect coordinates are not NaN --> NOT EMPTY.
if( !(CPLIsNan(x) && CPLIsNan(y)) )
flags |= OGR_G_NOT_EMPTY_POINT;
return OGRERR_NONE;
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset = NULL;
GDALRasterBandH hBand = NULL;
int i, iBand;
double adfGeoTransform[6];
GDALDriverH hDriver;
char **papszMetadata;
int bComputeMinMax = FALSE, bSample = FALSE;
int bShowGCPs = TRUE, bShowMetadata = TRUE, bShowRAT=TRUE;
int bStats = FALSE, bApproxStats = TRUE, iMDD;
int bShowColorTable = TRUE, bComputeChecksum = FALSE;
int bReportHistograms = FALSE;
int bReportProj4 = FALSE;
int nSubdataset = -1;
const char *pszFilename = NULL;
char **papszExtraMDDomains = NULL, **papszFileList;
const char *pszProjection = NULL;
OGRCoordinateTransformationH hTransform = NULL;
int bShowFileList = TRUE;
/* Check that we are running against at least GDAL 1.5 */
/* Note to developers : if we use newer API, please change the requirement */
if (atoi(GDALVersionInfo("VERSION_NUM")) < 1500)
{
fprintf(stderr, "At least, GDAL >= 1.5.0 is required for this version of %s, "
"which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME);
exit(1);
}
EarlySetConfigOptions(argc, argv);
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i],"--help") )
Usage(NULL);
else if( EQUAL(argv[i], "-mm") )
bComputeMinMax = TRUE;
else if( EQUAL(argv[i], "-hist") )
bReportHistograms = TRUE;
else if( EQUAL(argv[i], "-proj4") )
bReportProj4 = TRUE;
else if( EQUAL(argv[i], "-stats") )
{
bStats = TRUE;
bApproxStats = FALSE;
}
else if( EQUAL(argv[i], "-approx_stats") )
{
bStats = TRUE;
bApproxStats = TRUE;
}
else if( EQUAL(argv[i], "-sample") )
bSample = TRUE;
else if( EQUAL(argv[i], "-checksum") )
bComputeChecksum = TRUE;
else if( EQUAL(argv[i], "-nogcp") )
bShowGCPs = FALSE;
else if( EQUAL(argv[i], "-nomd") )
bShowMetadata = FALSE;
else if( EQUAL(argv[i], "-norat") )
bShowRAT = FALSE;
else if( EQUAL(argv[i], "-noct") )
bShowColorTable = FALSE;
else if( EQUAL(argv[i], "-mdd") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszExtraMDDomains = CSLAddString( papszExtraMDDomains,
argv[++i] );
}
else if( EQUAL(argv[i], "-nofl") )
bShowFileList = FALSE;
else if( EQUAL(argv[i], "-sd") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
nSubdataset = atoi(argv[++i]);
}
else if( argv[i][0] == '-' )
Usage(CPLSPrintf("Unkown option name '%s'", argv[i]));
else if( pszFilename == NULL )
pszFilename = argv[i];
else
Usage("Too many command options.");
}
if( pszFilename == NULL )
Usage("No datasource specified.");
/* -------------------------------------------------------------------- */
/* Open dataset. */
/* -------------------------------------------------------------------- */
hDataset = GDALOpen( pszFilename, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"gdalinfo failed - unable to open '%s'.\n",
pszFilename );
/* -------------------------------------------------------------------- */
/* If argument is a VSIFILE, then print its contents */
/* -------------------------------------------------------------------- */
if ( strncmp( pszFilename, "/vsizip/", 8 ) == 0 ||
strncmp( pszFilename, "/vsitar/", 8 ) == 0 )
{
papszFileList = VSIReadDirRecursive( pszFilename );
if ( papszFileList )
{
int nCount = CSLCount( papszFileList );
fprintf( stdout,
"Unable to open source `%s' directly.\n"
"The archive contains %d files:\n",
pszFilename, nCount );
for ( i = 0; i < nCount; i++ )
{
fprintf( stdout, " %s/%s\n", pszFilename, papszFileList[i] );
}
CSLDestroy( papszFileList );
papszFileList = NULL;
}
}
CSLDestroy( argv );
CSLDestroy( papszExtraMDDomains );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* Read specified subdataset if requested. */
/* -------------------------------------------------------------------- */
if ( nSubdataset > 0 )
{
char **papszSubdatasets = GDALGetMetadata( hDataset, "SUBDATASETS" );
int nSubdatasets = CSLCount( papszSubdatasets );
if ( nSubdatasets > 0 && nSubdataset <= nSubdatasets )
{
char szKeyName[1024];
char *pszSubdatasetName;
snprintf( szKeyName, sizeof(szKeyName),
"SUBDATASET_%d_NAME", nSubdataset );
szKeyName[sizeof(szKeyName) - 1] = '\0';
pszSubdatasetName =
CPLStrdup( CSLFetchNameValue( papszSubdatasets, szKeyName ) );
GDALClose( hDataset );
hDataset = GDALOpen( pszSubdatasetName, GA_ReadOnly );
CPLFree( pszSubdatasetName );
}
else
{
fprintf( stderr,
"gdalinfo warning: subdataset %d of %d requested. "
"Reading the main dataset.\n",
nSubdataset, nSubdatasets );
}
}
/* -------------------------------------------------------------------- */
/* Report general info. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDatasetDriver( hDataset );
printf( "Driver: %s/%s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
papszFileList = GDALGetFileList( hDataset );
if( CSLCount(papszFileList) == 0 )
{
printf( "Files: none associated\n" );
}
else
{
printf( "Files: %s\n", papszFileList[0] );
if( bShowFileList )
{
for( i = 1; papszFileList[i] != NULL; i++ )
printf( " %s\n", papszFileList[i] );
}
}
CSLDestroy( papszFileList );
printf( "Size is %d, %d\n",
GDALGetRasterXSize( hDataset ),
GDALGetRasterYSize( hDataset ) );
/* -------------------------------------------------------------------- */
/* Report projection. */
/* -------------------------------------------------------------------- */
if( GDALGetProjectionRef( hDataset ) != NULL )
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetProjectionRef( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "Coordinate System is:\n%s\n", pszPrettyWkt );
CPLFree( pszPrettyWkt );
}
else
printf( "Coordinate System is `%s'\n",
GDALGetProjectionRef( hDataset ) );
if ( bReportProj4 )
{
char *pszProj4 = NULL;
OSRExportToProj4( hSRS, &pszProj4 );
printf("PROJ.4 string is:\n\'%s\'\n",pszProj4);
CPLFree( pszProj4 );
}
OSRDestroySpatialReference( hSRS );
}
/* -------------------------------------------------------------------- */
/* Report Geotransform. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
{
if( adfGeoTransform[2] == 0.0 && adfGeoTransform[4] == 0.0 )
{
printf( "Origin = (%.15f,%.15f)\n",
adfGeoTransform[0], adfGeoTransform[3] );
printf( "Pixel Size = (%.15f,%.15f)\n",
adfGeoTransform[1], adfGeoTransform[5] );
}
else
printf( "GeoTransform =\n"
" %.16g, %.16g, %.16g\n"
" %.16g, %.16g, %.16g\n",
adfGeoTransform[0],
adfGeoTransform[1],
adfGeoTransform[2],
adfGeoTransform[3],
adfGeoTransform[4],
adfGeoTransform[5] );
}
/* -------------------------------------------------------------------- */
/* Report GCPs. */
/* -------------------------------------------------------------------- */
if( bShowGCPs && GDALGetGCPCount( hDataset ) > 0 )
{
if (GDALGetGCPProjection(hDataset) != NULL)
{
OGRSpatialReferenceH hSRS;
char *pszProjection;
pszProjection = (char *) GDALGetGCPProjection( hDataset );
hSRS = OSRNewSpatialReference(NULL);
if( OSRImportFromWkt( hSRS, &pszProjection ) == CE_None )
{
char *pszPrettyWkt = NULL;
OSRExportToPrettyWkt( hSRS, &pszPrettyWkt, FALSE );
printf( "GCP Projection = \n%s\n", pszPrettyWkt );
CPLFree( pszPrettyWkt );
}
else
printf( "GCP Projection = %s\n",
GDALGetGCPProjection( hDataset ) );
OSRDestroySpatialReference( hSRS );
}
for( i = 0; i < GDALGetGCPCount(hDataset); i++ )
{
const GDAL_GCP *psGCP;
psGCP = GDALGetGCPs( hDataset ) + i;
printf( "GCP[%3d]: Id=%s, Info=%s\n"
" (%.15g,%.15g) -> (%.15g,%.15g,%.15g)\n",
i, psGCP->pszId, psGCP->pszInfo,
psGCP->dfGCPPixel, psGCP->dfGCPLine,
psGCP->dfGCPX, psGCP->dfGCPY, psGCP->dfGCPZ );
}
}
/* -------------------------------------------------------------------- */
/* Report metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, NULL ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
for( iMDD = 0; bShowMetadata && iMDD < CSLCount(papszExtraMDDomains); iMDD++ )
{
papszMetadata = GDALGetMetadata( hDataset, papszExtraMDDomains[iMDD] );
if( CSLCount(papszMetadata) > 0 )
{
printf( "Metadata (%s):\n", papszExtraMDDomains[iMDD]);
for( i = 0; papszMetadata[i] != NULL; i++ )
{
if (EQUALN(papszExtraMDDomains[iMDD], "xml:", 4))
printf( "%s\n", papszMetadata[i] );
else
printf( " %s\n", papszMetadata[i] );
}
}
}
/* -------------------------------------------------------------------- */
/* Report "IMAGE_STRUCTURE" metadata. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "IMAGE_STRUCTURE" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Image Structure Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report subdatasets. */
/* -------------------------------------------------------------------- */
papszMetadata = GDALGetMetadata( hDataset, "SUBDATASETS" );
if( CSLCount(papszMetadata) > 0 )
{
printf( "Subdatasets:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report geolocation. */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "GEOLOCATION" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "Geolocation:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Report RPCs */
/* -------------------------------------------------------------------- */
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hDataset, "RPC" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( "RPC Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
/* -------------------------------------------------------------------- */
/* Setup projected to lat/long transform if appropriate. */
/* -------------------------------------------------------------------- */
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
pszProjection = GDALGetProjectionRef(hDataset);
if( pszProjection != NULL && strlen(pszProjection) > 0 )
{
OGRSpatialReferenceH hProj, hLatLong = NULL;
hProj = OSRNewSpatialReference( pszProjection );
if( hProj != NULL )
hLatLong = OSRCloneGeogCS( hProj );
if( hLatLong != NULL )
{
CPLPushErrorHandler( CPLQuietErrorHandler );
hTransform = OCTNewCoordinateTransformation( hProj, hLatLong );
CPLPopErrorHandler();
OSRDestroySpatialReference( hLatLong );
}
if( hProj != NULL )
OSRDestroySpatialReference( hProj );
}
/* -------------------------------------------------------------------- */
/* Report corners. */
/* -------------------------------------------------------------------- */
printf( "Corner Coordinates:\n" );
GDALInfoReportCorner( hDataset, hTransform, "Upper Left",
0.0, 0.0 );
GDALInfoReportCorner( hDataset, hTransform, "Lower Left",
0.0, GDALGetRasterYSize(hDataset));
GDALInfoReportCorner( hDataset, hTransform, "Upper Right",
GDALGetRasterXSize(hDataset), 0.0 );
GDALInfoReportCorner( hDataset, hTransform, "Lower Right",
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
GDALInfoReportCorner( hDataset, hTransform, "Center",
GDALGetRasterXSize(hDataset)/2.0,
GDALGetRasterYSize(hDataset)/2.0 );
if( hTransform != NULL )
{
OCTDestroyCoordinateTransformation( hTransform );
hTransform = NULL;
}
/* ==================================================================== */
/* Loop over bands. */
/* ==================================================================== */
for( iBand = 0; iBand < GDALGetRasterCount( hDataset ); iBand++ )
{
double dfMin, dfMax, adfCMinMax[2], dfNoData;
int bGotMin, bGotMax, bGotNodata, bSuccess;
int nBlockXSize, nBlockYSize, nMaskFlags;
double dfMean, dfStdDev;
GDALColorTableH hTable;
CPLErr eErr;
hBand = GDALGetRasterBand( hDataset, iBand+1 );
if( bSample )
{
float afSample[10000];
int nCount;
nCount = GDALGetRandomRasterSample( hBand, 10000, afSample );
printf( "Got %d samples.\n", nCount );
}
GDALGetBlockSize( hBand, &nBlockXSize, &nBlockYSize );
printf( "Band %d Block=%dx%d Type=%s, ColorInterp=%s\n", iBand+1,
nBlockXSize, nBlockYSize,
GDALGetDataTypeName(
GDALGetRasterDataType(hBand)),
GDALGetColorInterpretationName(
GDALGetRasterColorInterpretation(hBand)) );
if( GDALGetDescription( hBand ) != NULL
&& strlen(GDALGetDescription( hBand )) > 0 )
printf( " Description = %s\n", GDALGetDescription(hBand) );
dfMin = GDALGetRasterMinimum( hBand, &bGotMin );
dfMax = GDALGetRasterMaximum( hBand, &bGotMax );
if( bGotMin || bGotMax || bComputeMinMax )
{
printf( " " );
if( bGotMin )
printf( "Min=%.3f ", dfMin );
if( bGotMax )
printf( "Max=%.3f ", dfMax );
if( bComputeMinMax )
{
CPLErrorReset();
GDALComputeRasterMinMax( hBand, FALSE, adfCMinMax );
if (CPLGetLastErrorType() == CE_None)
{
printf( " Computed Min/Max=%.3f,%.3f",
adfCMinMax[0], adfCMinMax[1] );
}
}
printf( "\n" );
}
eErr = GDALGetRasterStatistics( hBand, bApproxStats, bStats,
&dfMin, &dfMax, &dfMean, &dfStdDev );
if( eErr == CE_None )
{
printf( " Minimum=%.3f, Maximum=%.3f, Mean=%.3f, StdDev=%.3f\n",
dfMin, dfMax, dfMean, dfStdDev );
}
if( bReportHistograms )
{
int nBucketCount, *panHistogram = NULL;
eErr = GDALGetDefaultHistogram( hBand, &dfMin, &dfMax,
&nBucketCount, &panHistogram,
TRUE, GDALTermProgress, NULL );
if( eErr == CE_None )
{
int iBucket;
printf( " %d buckets from %g to %g:\n ",
nBucketCount, dfMin, dfMax );
for( iBucket = 0; iBucket < nBucketCount; iBucket++ )
printf( "%d ", panHistogram[iBucket] );
printf( "\n" );
CPLFree( panHistogram );
}
}
if ( bComputeChecksum)
{
printf( " Checksum=%d\n",
GDALChecksumImage(hBand, 0, 0,
GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset)));
}
dfNoData = GDALGetRasterNoDataValue( hBand, &bGotNodata );
if( bGotNodata )
{
if (CPLIsNan(dfNoData))
printf( " NoData Value=nan\n" );
else
printf( " NoData Value=%.18g\n", dfNoData );
}
if( GDALGetOverviewCount(hBand) > 0 )
{
int iOverview;
printf( " Overviews: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
const char *pszResampling = NULL;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
if (hOverview != NULL)
{
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
pszResampling =
GDALGetMetadataItem( hOverview, "RESAMPLING", "" );
if( pszResampling != NULL
&& EQUALN(pszResampling,"AVERAGE_BIT2",12) )
printf( "*" );
}
else
printf( "(null)" );
}
printf( "\n" );
if ( bComputeChecksum)
{
printf( " Overviews checksum: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hBand, iOverview );
if (hOverview)
printf( "%d",
GDALChecksumImage(hOverview, 0, 0,
GDALGetRasterBandXSize(hOverview),
GDALGetRasterBandYSize(hOverview)));
else
printf( "(null)" );
}
printf( "\n" );
}
}
if( GDALHasArbitraryOverviews( hBand ) )
{
printf( " Overviews: arbitrary\n" );
}
nMaskFlags = GDALGetMaskFlags( hBand );
if( (nMaskFlags & (GMF_NODATA|GMF_ALL_VALID)) == 0 )
{
GDALRasterBandH hMaskBand = GDALGetMaskBand(hBand) ;
printf( " Mask Flags: " );
if( nMaskFlags & GMF_PER_DATASET )
printf( "PER_DATASET " );
if( nMaskFlags & GMF_ALPHA )
printf( "ALPHA " );
if( nMaskFlags & GMF_NODATA )
printf( "NODATA " );
if( nMaskFlags & GMF_ALL_VALID )
printf( "ALL_VALID " );
printf( "\n" );
if( hMaskBand != NULL &&
GDALGetOverviewCount(hMaskBand) > 0 )
{
int iOverview;
printf( " Overviews of mask band: " );
for( iOverview = 0;
iOverview < GDALGetOverviewCount(hMaskBand);
iOverview++ )
{
GDALRasterBandH hOverview;
if( iOverview != 0 )
printf( ", " );
hOverview = GDALGetOverview( hMaskBand, iOverview );
printf( "%dx%d",
GDALGetRasterBandXSize( hOverview ),
GDALGetRasterBandYSize( hOverview ) );
}
printf( "\n" );
}
}
if( strlen(GDALGetRasterUnitType(hBand)) > 0 )
{
printf( " Unit Type: %s\n", GDALGetRasterUnitType(hBand) );
}
if( GDALGetRasterCategoryNames(hBand) != NULL )
{
char **papszCategories = GDALGetRasterCategoryNames(hBand);
int i;
printf( " Categories:\n" );
for( i = 0; papszCategories[i] != NULL; i++ )
printf( " %3d: %s\n", i, papszCategories[i] );
}
if( GDALGetRasterScale( hBand, &bSuccess ) != 1.0
|| GDALGetRasterOffset( hBand, &bSuccess ) != 0.0 )
printf( " Offset: %.15g, Scale:%.15g\n",
GDALGetRasterOffset( hBand, &bSuccess ),
GDALGetRasterScale( hBand, &bSuccess ) );
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hBand, NULL ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( " Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
papszMetadata = (bShowMetadata) ? GDALGetMetadata( hBand, "IMAGE_STRUCTURE" ) : NULL;
if( bShowMetadata && CSLCount(papszMetadata) > 0 )
{
printf( " Image Structure Metadata:\n" );
for( i = 0; papszMetadata[i] != NULL; i++ )
{
printf( " %s\n", papszMetadata[i] );
}
}
if( GDALGetRasterColorInterpretation(hBand) == GCI_PaletteIndex
&& (hTable = GDALGetRasterColorTable( hBand )) != NULL )
{
int i;
printf( " Color Table (%s with %d entries)\n",
GDALGetPaletteInterpretationName(
GDALGetPaletteInterpretation( hTable )),
GDALGetColorEntryCount( hTable ) );
if (bShowColorTable)
{
for( i = 0; i < GDALGetColorEntryCount( hTable ); i++ )
{
GDALColorEntry sEntry;
GDALGetColorEntryAsRGB( hTable, i, &sEntry );
printf( " %3d: %d,%d,%d,%d\n",
i,
sEntry.c1,
sEntry.c2,
sEntry.c3,
sEntry.c4 );
}
}
}
if( bShowRAT && GDALGetDefaultRAT( hBand ) != NULL )
{
GDALRasterAttributeTableH hRAT = GDALGetDefaultRAT( hBand );
GDALRATDumpReadable( hRAT, NULL );
}
}
GDALClose( hDataset );
CSLDestroy( papszExtraMDDomains );
CSLDestroy( argv );
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CPLDumpSharedList( NULL );
CPLCleanupTLS();
exit( 0 );
}
bool wxStation::check_station(wxStation station)
{
if(station.stationName.empty() || station.stationName == "")
{
cout<<"failed Name Check"<<endl;
return false;
}
if(station.coordType != GEOGCS && station.coordType != PROJCS)
{
cout<<"failed Coord Check"<<endl;
return false;
}
if(station.datumType != WGS84 && station.datumType != NAD83 && station.datumType !=NAD27)
{
cout<<"failed datum Check"<<endl;
return false;
}
if(station.lat < -90.0 || station.lat > 90.0)
{
cout<<"failed lat Check: "<<station.lat<<endl;
return false;
}
if(station.lon < -180.0 || station.lon > 360.0)
{
cout<<"failed lon Check: "<<station.lon<<endl;
return false;
}
for (int i=0;i<station.heightList.size();i++)
{
//Changing all isnan() to CPLIsNan() for MSVC2010
if(station.heightList[i] < 0.0|| CPLIsNan(station.heightList[i]))
{
cout<<"failed height Check on "<<i<<endl;
cout<<station.heightList[i]<<endl;
return false;
}
if(station.speedList[i] < 0.0 || CPLIsNan(station.speedList[i]) || station.speedList[i]>105.0)
{
cout<<"failed speed Check on "<<i<<endl;
cout<<station.speedList[i]<<endl;
return false;
}
if(station.directionList[i] < 0.0 || station.directionList[i] > 360.0 || CPLIsNan(station.directionList[i]))
{
cout<<"failed direction Check on "<<i<<endl;
cout<<station.directionList[i]<<endl;
return false;
}
if(station.temperatureList[i]< 173.15 || station.temperatureList[i] > 330.00 || CPLIsNan(station.temperatureList[i]))
{
cout<<"failed temperature Check on "<<i<<endl;
cout<<station.temperatureList[i]<<endl;
return false;
}
if(station.cloudCoverList[i]<0.0||station.cloudCoverList[i]>1.10 || CPLIsNan(station.cloudCoverList[i]))
{
cout<<"failed cloud check on "<<i<<endl;
cout<<station.cloudCoverList[i]<<endl;
// station.cloudCoverList[i]=0.0;
return false;
}
}
if(station.w_speed < 0.0 || CPLIsNan(station.w_speed))
{
cout<<"failed vert_speed Check"<<endl;
return false;
}
return true;
}
void OGRCircularString::segmentize( double dfMaxLength )
{
if( !IsValidFast() || nPointCount == 0 )
return;
// So as to make sure that the same line followed in both directions
// result in the same segmentized line.
if( paoPoints[0].x < paoPoints[nPointCount - 1].x ||
(paoPoints[0].x == paoPoints[nPointCount - 1].x &&
paoPoints[0].y < paoPoints[nPointCount - 1].y) )
{
reversePoints();
segmentize(dfMaxLength);
reversePoints();
}
std::vector<OGRRawPoint> aoRawPoint;
std::vector<double> adfZ;
for( int i = 0; i < nPointCount - 2; i += 2 )
{
const double x0 = paoPoints[i].x;
const double y0 = paoPoints[i].y;
const double x1 = paoPoints[i+1].x;
const double y1 = paoPoints[i+1].y;
const double x2 = paoPoints[i+2].x;
const double y2 = paoPoints[i+2].y;
double R = 0.0;
double cx = 0.0;
double cy = 0.0;
double alpha0 = 0.0;
double alpha1 = 0.0;
double alpha2 = 0.0;
aoRawPoint.push_back(OGRRawPoint(x0, y0));
if( padfZ )
adfZ.push_back(padfZ[i]);
// We have strong constraints on the number of intermediate points
// we can add.
if( OGRGeometryFactory::GetCurveParmeters(x0, y0, x1, y1, x2, y2,
R, cx, cy,
alpha0, alpha1, alpha2) )
{
// It is an arc circle.
const double dfSegmentLength1 = fabs(alpha1 - alpha0) * R;
const double dfSegmentLength2 = fabs(alpha2 - alpha1) * R;
if( dfSegmentLength1 > dfMaxLength ||
dfSegmentLength2 > dfMaxLength )
{
const double dfVal =
1 + 2 * std::floor(dfSegmentLength1 / dfMaxLength / 2.0);
if ( dfVal >= std::numeric_limits<int>::max() ||
dfVal < 0.0 ||
CPLIsNan(dfVal) )
{
CPLError(
CE_Failure, CPLE_AppDefined,
"segmentize nIntermediatePoints invalid: %lf", dfVal);
break;
}
const int nIntermediatePoints = static_cast<int>(dfVal);
const double dfStep =
(alpha1 - alpha0) / (nIntermediatePoints + 1);
for( int j = 1; j <= nIntermediatePoints; ++j )
{
double alpha = alpha0 + dfStep * j;
const double x = cx + R * cos(alpha);
const double y = cy + R * sin(alpha);
aoRawPoint.push_back(OGRRawPoint(x, y));
if( padfZ )
{
const double z =
padfZ[i] +
(padfZ[i+1] - padfZ[i]) * (alpha - alpha0) /
(alpha1 - alpha0);
adfZ.push_back(z);
}
}
}
aoRawPoint.push_back(OGRRawPoint(x1, y1));
if( padfZ )
adfZ.push_back(padfZ[i+1]);
if( dfSegmentLength1 > dfMaxLength ||
dfSegmentLength2 > dfMaxLength )
{
const double dfVal =
1 + 2 * std::floor(dfSegmentLength2 / dfMaxLength / 2.0);
if ( dfVal >= std::numeric_limits<int>::max() ||
dfVal < 0.0 ||
CPLIsNan(dfVal) )
{
CPLError(
CE_Failure, CPLE_AppDefined,
"segmentize nIntermediatePoints invalid 2: %lf", dfVal);
break;
}
int nIntermediatePoints = static_cast<int>(dfVal);
const double dfStep =
(alpha2 - alpha1) / (nIntermediatePoints + 1);
for( int j = 1; j <= nIntermediatePoints; ++j )
{
const double alpha = alpha1 + dfStep * j;
const double x = cx + R * cos(alpha);
const double y = cy + R * sin(alpha);
aoRawPoint.push_back(OGRRawPoint(x, y));
if( padfZ )
{
const double z =
padfZ[i+1] +
(padfZ[i+2] - padfZ[i+1]) *
(alpha - alpha1) / (alpha2 - alpha1);
adfZ.push_back(z);
}
}
}
}
else
{
// It is a straight line.
const double dfSegmentLength1 = dist(x0, y0, x1, y1);
const double dfSegmentLength2 = dist(x1, y1, x2, y2);
if( dfSegmentLength1 > dfMaxLength ||
dfSegmentLength2 > dfMaxLength )
{
const double dfVal =
1 + 2 * std::ceil(dfSegmentLength1 / dfMaxLength / 2.0);
if ( dfVal >= std::numeric_limits<int>::max() ||
dfVal < 0.0 ||
CPLIsNan(dfVal) )
{
CPLError(
CE_Failure, CPLE_AppDefined,
"segmentize nIntermediatePoints invalid 2: %lf", dfVal);
break;
}
int nIntermediatePoints = static_cast<int>(dfVal);
for( int j = 1; j <= nIntermediatePoints; ++j )
{
aoRawPoint.push_back(OGRRawPoint(
x0 + j * (x1-x0) / (nIntermediatePoints + 1),
y0 + j * (y1-y0) / (nIntermediatePoints + 1)));
if( padfZ )
adfZ.push_back(padfZ[i] + j * (padfZ[i+1]-padfZ[i]) /
(nIntermediatePoints + 1));
}
}
aoRawPoint.push_back(OGRRawPoint(x1, y1));
if( padfZ )
adfZ.push_back(padfZ[i+1]);
if( dfSegmentLength1 > dfMaxLength ||
dfSegmentLength2 > dfMaxLength )
{
const double dfVal =
1 + 2 * std::ceil(dfSegmentLength2 / dfMaxLength / 2.0);
if ( dfVal >= std::numeric_limits<int>::max() ||
dfVal < 0.0 ||
CPLIsNan(dfVal) )
{
CPLError(
CE_Failure, CPLE_AppDefined,
"segmentize nIntermediatePoints invalid 3: %lf", dfVal);
break;
}
const int nIntermediatePoints = static_cast<int>(dfVal);
for( int j = 1; j <= nIntermediatePoints; ++j )
{
aoRawPoint.push_back(OGRRawPoint(
x1 + j * (x2-x1) / (nIntermediatePoints + 1),
y1 + j * (y2-y1) / (nIntermediatePoints + 1)));
if( padfZ )
adfZ.push_back(padfZ[i+1] + j * (padfZ[i+2]-padfZ[i+1])
/ (nIntermediatePoints + 1));
}
}
}
}
aoRawPoint.push_back(paoPoints[nPointCount-1]);
if( padfZ )
adfZ.push_back(padfZ[nPointCount-1]);
CPLAssert(aoRawPoint.empty() ||
(aoRawPoint.size() >= 3 && (aoRawPoint.size() % 2) == 1));
if( padfZ )
{
CPLAssert(adfZ.size() == aoRawPoint.size());
}
// Is there actually something to modify?
if( nPointCount < static_cast<int>(aoRawPoint.size()) )
{
nPointCount = static_cast<int>(aoRawPoint.size());
paoPoints = static_cast<OGRRawPoint *>(
CPLRealloc(paoPoints, sizeof(OGRRawPoint) * nPointCount));
memcpy(paoPoints, &aoRawPoint[0], sizeof(OGRRawPoint) * nPointCount);
if( padfZ )
{
padfZ = static_cast<double *>(
CPLRealloc(padfZ, sizeof(double) * aoRawPoint.size()));
memcpy(padfZ, &adfZ[0], sizeof(double) * nPointCount);
}
}
}
/**
* Sets the surface grids based on a ncepNam (surface only!) forecast.
* @param input The WindNinjaInputs for misc. info.
* @param airGrid The air temperature grid to be filled.
* @param cloudGrid The cloud cover grid to be filled.
* @param uGrid The u velocity grid to be filled.
* @param vGrid The v velocity grid to be filled.
* @param wGrid The w velocity grid to be filled (filled with zeros here?).
*/
void genericSurfInitialization::setSurfaceGrids( WindNinjaInputs &input,
AsciiGrid<double> &airGrid,
AsciiGrid<double> &cloudGrid,
AsciiGrid<double> &uGrid,
AsciiGrid<double> &vGrid,
AsciiGrid<double> &wGrid )
{
int bandNum = -1;
//get time list
std::vector<boost::local_time::local_date_time> timeList( getTimeList(input.ninjaTimeZone) );
//Search time list for our time to identify our band number for cloud/speed/dir
for(unsigned int i = 0; i < timeList.size(); i++)
{
if(input.ninjaTime == timeList[i])
{
bandNum = i + 1;
break;
}
}
if(bandNum < 0)
throw std::runtime_error("Could not match ninjaTime with a band number in the forecast file.");
//get some info from the nam file in input
//Acquire a lock to protect the non-thread safe netCDF library
#ifdef _OPENMP
omp_guard netCDF_guard(netCDF_lock);
#endif
GDALDataset* poDS;
//attempt to grab the projection from the dem?
//check for member prjString first
std::string dstWkt;
dstWkt = input.dem.prjString;
if ( dstWkt.empty() ) {
//try to open original
poDS = (GDALDataset*)GDALOpen( input.dem.fileName.c_str(), GA_ReadOnly );
if( poDS == NULL ) {
CPLDebug( "ncepNdfdInitialization::setSurfaceGrids()",
"Bad projection reference" );
//throw();
}
dstWkt = poDS->GetProjectionRef();
if( dstWkt.empty() ) {
CPLDebug( "ncepNdfdInitialization::setSurfaceGrids()",
"Bad projection reference" );
//throw()
}
GDALClose((GDALDatasetH) poDS );
}
poDS = (GDALDataset*)GDALOpen( input.forecastFilename.c_str(), GA_ReadOnly );
if( poDS == NULL ) {
CPLDebug( "ncepNdfdInitialization::setSurfaceGrids()",
"Bad forecast file" );
}
else
GDALClose((GDALDatasetH) poDS );
// open ds one by one and warp, then write to grid
GDALDataset *srcDS, *wrpDS;
std::string temp;
std::string srcWkt;
std::vector<std::string> varList = getVariableList();
/*
* Set the initial values in the warped dataset to no data
*/
GDALWarpOptions* psWarpOptions;
for( unsigned int i = 0;i < varList.size();i++ ) {
temp = "NETCDF:" + input.forecastFilename + ":" + varList[i];
srcDS = (GDALDataset*)GDALOpenShared( temp.c_str(), GA_ReadOnly );
if( srcDS == NULL ) {
CPLDebug( "ncepNdfdInitialization::setSurfaceGrids()",
"Bad forecast file" );
}
srcWkt = srcDS->GetProjectionRef();
if( srcWkt.empty() ) {
CPLDebug( "ncepNdfdInitialization::setSurfaceGrids()",
"Bad forecast file" );
//throw
}
/*
* Grab the first band to get the nodata value for the variable,
* assume all bands have the same ndv
*/
GDALRasterBand *poBand = srcDS->GetRasterBand( 1 );
int pbSuccess;
double dfNoData = poBand->GetNoDataValue( &pbSuccess );
psWarpOptions = GDALCreateWarpOptions();
int nBandCount = srcDS->GetRasterCount();
psWarpOptions->nBandCount = nBandCount;
psWarpOptions->padfDstNoDataReal =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataImag =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
for( int b = 0;b < srcDS->GetRasterCount();b++ ) {
psWarpOptions->padfDstNoDataReal[b] = dfNoData;
psWarpOptions->padfDstNoDataImag[b] = dfNoData;
}
if( pbSuccess == false )
dfNoData = -9999.0;
psWarpOptions->papszWarpOptions =
CSLSetNameValue( psWarpOptions->papszWarpOptions,
"INIT_DEST", "NO_DATA" );
wrpDS = (GDALDataset*) GDALAutoCreateWarpedVRT( srcDS, srcWkt.c_str(),
dstWkt.c_str(),
GRA_NearestNeighbour,
1.0, psWarpOptions );
if( varList[i] == "Temperature_height_above_ground" ) {
GDAL2AsciiGrid( wrpDS, bandNum, airGrid );
if( CPLIsNan( dfNoData ) ) {
airGrid.set_noDataValue(-9999.0);
airGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "V-component_of_wind_height_above_ground" ) {
GDAL2AsciiGrid( wrpDS, bandNum, vGrid );
if( CPLIsNan( dfNoData ) ) {
vGrid.set_noDataValue(-9999.0);
vGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "U-component_of_wind_height_above_ground" ) {
GDAL2AsciiGrid( wrpDS, bandNum, uGrid );
if( CPLIsNan( dfNoData ) ) {
uGrid.set_noDataValue(-9999.0);
uGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "Total_cloud_cover" ) {
GDAL2AsciiGrid( wrpDS, bandNum, cloudGrid );
if( CPLIsNan( dfNoData ) ) {
cloudGrid.set_noDataValue(-9999.0);
cloudGrid.replaceNan( -9999.0 );
}
}
GDALDestroyWarpOptions( psWarpOptions );
GDALClose((GDALDatasetH) srcDS );
GDALClose((GDALDatasetH) wrpDS );
}
cloudGrid /= 100.0;
wGrid.set_headerData( uGrid );
wGrid = 0.0;
}
OGRErr OGRPGDumpLayer::CreateFeatureViaCopy( OGRFeature *poFeature )
{
int i;
CPLString osCommand;
/* First process geometry */
for( i = 0; i < poFeature->GetGeomFieldCount(); i++ )
{
OGRGeometry *poGeometry = poFeature->GetGeomFieldRef(i);
char *pszGeom = NULL;
if ( NULL != poGeometry /* && (bHasWkb || bHasPostGISGeometry || bHasPostGISGeography) */)
{
OGRPGDumpGeomFieldDefn* poGFldDefn =
(OGRPGDumpGeomFieldDefn*) poFeature->GetGeomFieldDefnRef(i);
poGeometry->closeRings();
poGeometry->setCoordinateDimension( poGFldDefn->nCoordDimension );
//CheckGeomTypeCompatibility(poGeometry);
/*if (bHasWkb)
pszGeom = GeometryToBYTEA( poGeometry );
else*/
pszGeom = OGRGeometryToHexEWKB( poGeometry, poGFldDefn->nSRSId );
}
if (osCommand.size() > 0)
osCommand += "\t";
if ( pszGeom )
{
osCommand += pszGeom,
CPLFree( pszGeom );
}
else
{
osCommand += "\\N";
}
}
/* Next process the field id column */
int nFIDIndex = -1;
if( bFIDColumnInCopyFields )
{
if (osCommand.size() > 0)
osCommand += "\t";
nFIDIndex = poFeatureDefn->GetFieldIndex( pszFIDColumn );
/* Set the FID */
if( poFeature->GetFID() != OGRNullFID )
{
osCommand += CPLString().Printf("%ld ", poFeature->GetFID());
}
else
{
osCommand += "\\N" ;
}
}
/* Now process the remaining fields */
int nFieldCount = poFeatureDefn->GetFieldCount();
int bAddTab = osCommand.size() > 0;
for( i = 0; i < nFieldCount; i++ )
{
if (i == nFIDIndex)
continue;
const char *pszStrValue = poFeature->GetFieldAsString(i);
char *pszNeedToFree = NULL;
if (bAddTab)
osCommand += "\t";
bAddTab = TRUE;
if( !poFeature->IsFieldSet( i ) )
{
osCommand += "\\N" ;
continue;
}
int nOGRFieldType = poFeatureDefn->GetFieldDefn(i)->GetType();
// We need special formatting for integer list values.
if( nOGRFieldType == OFTIntegerList )
{
int nCount, nOff = 0, j;
const int *panItems = poFeature->GetFieldAsIntegerList(i,&nCount);
pszNeedToFree = (char *) CPLMalloc(nCount * 13 + 10);
strcpy( pszNeedToFree, "{" );
for( j = 0; j < nCount; j++ )
{
if( j != 0 )
strcat( pszNeedToFree+nOff, "," );
nOff += strlen(pszNeedToFree+nOff);
sprintf( pszNeedToFree+nOff, "%d", panItems[j] );
}
strcat( pszNeedToFree+nOff, "}" );
pszStrValue = pszNeedToFree;
}
// We need special formatting for real list values.
else if( nOGRFieldType == OFTRealList )
{
int nCount, nOff = 0, j;
const double *padfItems =poFeature->GetFieldAsDoubleList(i,&nCount);
pszNeedToFree = (char *) CPLMalloc(nCount * 40 + 10);
strcpy( pszNeedToFree, "{" );
for( j = 0; j < nCount; j++ )
{
if( j != 0 )
strcat( pszNeedToFree+nOff, "," );
nOff += strlen(pszNeedToFree+nOff);
//Check for special values. They need to be quoted.
if( CPLIsNan(padfItems[j]) )
sprintf( pszNeedToFree+nOff, "NaN" );
else if( CPLIsInf(padfItems[j]) )
sprintf( pszNeedToFree+nOff, (padfItems[j] > 0) ? "Infinity" : "-Infinity" );
else
sprintf( pszNeedToFree+nOff, "%.16g", padfItems[j] );
}
strcat( pszNeedToFree+nOff, "}" );
pszStrValue = pszNeedToFree;
}
// We need special formatting for string list values.
else if( nOGRFieldType == OFTStringList )
{
CPLString osStr;
char **papszItems = poFeature->GetFieldAsStringList(i);
pszStrValue = pszNeedToFree = CPLStrdup(OGRPGDumpEscapeStringList(papszItems, FALSE));
}
// Binary formatting
else if( nOGRFieldType == OFTBinary )
{
int nLen = 0;
GByte* pabyData = poFeature->GetFieldAsBinary( i, &nLen );
char* pszBytea = GByteArrayToBYTEA( pabyData, nLen);
pszStrValue = pszNeedToFree = pszBytea;
}
else if( nOGRFieldType == OFTReal )
{
char* pszComma = strchr((char*)pszStrValue, ',');
if (pszComma)
*pszComma = '.';
//Check for special values. They need to be quoted.
double dfVal = poFeature->GetFieldAsDouble(i);
if( CPLIsNan(dfVal) )
pszStrValue = "NaN";
else if( CPLIsInf(dfVal) )
pszStrValue = (dfVal > 0) ? "Infinity" : "-Infinity";
}
if( nOGRFieldType != OFTIntegerList &&
nOGRFieldType != OFTRealList &&
nOGRFieldType != OFTInteger &&
nOGRFieldType != OFTReal &&
nOGRFieldType != OFTBinary )
{
int iChar;
int iUTFChar = 0;
int nMaxWidth = poFeatureDefn->GetFieldDefn(i)->GetWidth();
for( iChar = 0; pszStrValue[iChar] != '\0'; iChar++ )
{
//count of utf chars
if ((pszStrValue[iChar] & 0xc0) != 0x80)
{
if( nMaxWidth > 0 && iUTFChar == nMaxWidth )
{
CPLDebug( "PG",
"Truncated %s field value, it was too long.",
poFeatureDefn->GetFieldDefn(i)->GetNameRef() );
break;
}
iUTFChar++;
}
/* Escape embedded \, \t, \n, \r since they will cause COPY
to misinterpret a line of text and thus abort */
if( pszStrValue[iChar] == '\\' ||
pszStrValue[iChar] == '\t' ||
pszStrValue[iChar] == '\r' ||
pszStrValue[iChar] == '\n' )
{
osCommand += '\\';
}
osCommand += pszStrValue[iChar];
}
}
else
{
osCommand += pszStrValue;
}
if( pszNeedToFree )
CPLFree( pszNeedToFree );
}
/* Add end of line marker */
//osCommand += "\n";
/* ------------------------------------------------------------ */
/* Execute the copy. */
/* ------------------------------------------------------------ */
OGRErr result = OGRERR_NONE;
poDS->Log(osCommand, FALSE);
return result;
}
CPLErr GDALNoDataMaskBand::IReadBlock( int nXBlockOff, int nYBlockOff,
void * pImage )
{
GDALDataType eWrkDT = GDT_Unknown;
/* -------------------------------------------------------------------- */
/* Decide on a working type. */
/* -------------------------------------------------------------------- */
switch( poParent->GetRasterDataType() )
{
case GDT_Byte:
eWrkDT = GDT_Byte;
break;
case GDT_UInt16:
case GDT_UInt32:
eWrkDT = GDT_UInt32;
break;
case GDT_Int16:
case GDT_Int32:
case GDT_CInt16:
case GDT_CInt32:
eWrkDT = GDT_Int32;
break;
case GDT_Float32:
case GDT_CFloat32:
eWrkDT = GDT_Float32;
break;
case GDT_Float64:
case GDT_CFloat64:
eWrkDT = GDT_Float64;
break;
default:
CPLAssert( false );
eWrkDT = GDT_Float64;
break;
}
/* -------------------------------------------------------------------- */
/* Read the image data. */
/* -------------------------------------------------------------------- */
// TODO(schwehr): pabySrc would probably be better as a void ptr.
GByte *pabySrc = static_cast<GByte *>(
VSI_MALLOC3_VERBOSE( GDALGetDataTypeSizeBytes(eWrkDT),
nBlockXSize, nBlockYSize ) );
if (pabySrc == nullptr)
{
return CE_Failure;
}
int nXSizeRequest = nBlockXSize;
if (nXBlockOff * nBlockXSize + nBlockXSize > nRasterXSize)
nXSizeRequest = nRasterXSize - nXBlockOff * nBlockXSize;
int nYSizeRequest = nBlockYSize;
if (nYBlockOff * nBlockYSize + nBlockYSize > nRasterYSize)
nYSizeRequest = nRasterYSize - nYBlockOff * nBlockYSize;
if (nXSizeRequest != nBlockXSize || nYSizeRequest != nBlockYSize)
{
// memset the whole buffer to avoid Valgrind warnings in case RasterIO
// fetches a partial block.
memset( pabySrc, 0,
GDALGetDataTypeSizeBytes(eWrkDT) * nBlockXSize * nBlockYSize );
}
CPLErr eErr =
poParent->RasterIO( GF_Read,
nXBlockOff * nBlockXSize,
nYBlockOff * nBlockYSize,
nXSizeRequest, nYSizeRequest,
pabySrc, nXSizeRequest, nYSizeRequest,
eWrkDT, 0,
nBlockXSize * GDALGetDataTypeSizeBytes(eWrkDT),
nullptr );
if( eErr != CE_None )
{
CPLFree(pabySrc);
return eErr;
}
const bool bIsNoDataNan = CPLIsNan(dfNoDataValue) != 0;
/* -------------------------------------------------------------------- */
/* Process different cases. */
/* -------------------------------------------------------------------- */
switch( eWrkDT )
{
case GDT_Byte:
{
if( !GDALIsValueInRange<GByte>(dfNoDataValue) )
{
memset(pImage, 255, nBlockXSize * nBlockYSize);
}
else
{
GByte byNoData = static_cast<GByte>( dfNoDataValue );
for( int i = 0; i < nBlockXSize * nBlockYSize; i++ )
{
static_cast<GByte *>(pImage)[i] = pabySrc[i] == byNoData ? 0: 255;
}
}
}
break;
case GDT_UInt32:
{
if( !GDALIsValueInRange<GUInt32>(dfNoDataValue) )
{
memset(pImage, 255, nBlockXSize * nBlockYSize);
}
else
{
GUInt32 nNoData = static_cast<GUInt32>( dfNoDataValue );
for( int i = 0; i < nBlockXSize * nBlockYSize; i++ )
{
static_cast<GByte *>(pImage)[i] =
reinterpret_cast<GUInt32 *>(pabySrc)[i] == nNoData ? 0 : 255;
}
}
}
break;
case GDT_Int32:
{
if( !GDALIsValueInRange<GInt32>(dfNoDataValue) )
{
memset(pImage, 255, nBlockXSize * nBlockYSize);
}
else
{
GInt32 nNoData = static_cast<GInt32>( dfNoDataValue );
for( int i = 0; i < nBlockXSize * nBlockYSize; i++ )
{
static_cast<GByte *>(pImage)[i] =
reinterpret_cast<GInt32 *>(pabySrc)[i] == nNoData ? 0 : 255;
}
}
}
break;
case GDT_Float32:
{
if( !bIsNoDataNan && !CPLIsInf(dfNoDataValue) &&
!GDALIsValueInRange<float>(dfNoDataValue) )
{
memset(pImage, 255, nBlockXSize * nBlockYSize);
}
else
{
float fNoData = static_cast<float>( dfNoDataValue );
for( int i = 0; i < nBlockXSize * nBlockYSize; i++ )
{
const float fVal = reinterpret_cast<float *>(pabySrc)[i];
if( bIsNoDataNan && CPLIsNan(fVal))
static_cast<GByte *>(pImage)[i] = 0;
else if( ARE_REAL_EQUAL(fVal, fNoData) )
static_cast<GByte *>(pImage)[i] = 0;
else
static_cast<GByte *>(pImage)[i] = 255;
}
}
}
break;
case GDT_Float64:
{
for( int i = 0; i < nBlockXSize * nBlockYSize; i++ )
{
const double dfVal = reinterpret_cast<double *>(pabySrc)[i];
if( bIsNoDataNan && CPLIsNan(dfVal))
static_cast<GByte *>(pImage)[i] = 0;
else if( ARE_REAL_EQUAL(dfVal, dfNoDataValue) )
static_cast<GByte *>(pImage)[i] = 0;
else
static_cast<GByte *>(pImage)[i] = 255;
}
}
break;
default:
CPLAssert( false );
break;
}
CPLFree( pabySrc );
return CE_None;
}
void OGRPGDumpLayer::AppendFieldValue(CPLString& osCommand,
OGRFeature* poFeature, int i)
{
int nOGRFieldType = poFeatureDefn->GetFieldDefn(i)->GetType();
// We need special formatting for integer list values.
if( nOGRFieldType == OFTIntegerList )
{
int nCount, nOff = 0, j;
const int *panItems = poFeature->GetFieldAsIntegerList(i,&nCount);
char *pszNeedToFree = NULL;
pszNeedToFree = (char *) CPLMalloc(nCount * 13 + 10);
strcpy( pszNeedToFree, "'{" );
for( j = 0; j < nCount; j++ )
{
if( j != 0 )
strcat( pszNeedToFree+nOff, "," );
nOff += strlen(pszNeedToFree+nOff);
sprintf( pszNeedToFree+nOff, "%d", panItems[j] );
}
strcat( pszNeedToFree+nOff, "}'" );
osCommand += pszNeedToFree;
CPLFree(pszNeedToFree);
return;
}
// We need special formatting for real list values.
else if( nOGRFieldType == OFTRealList )
{
int nCount, nOff = 0, j;
const double *padfItems =poFeature->GetFieldAsDoubleList(i,&nCount);
char *pszNeedToFree = NULL;
pszNeedToFree = (char *) CPLMalloc(nCount * 40 + 10);
strcpy( pszNeedToFree, "'{" );
for( j = 0; j < nCount; j++ )
{
if( j != 0 )
strcat( pszNeedToFree+nOff, "," );
nOff += strlen(pszNeedToFree+nOff);
//Check for special values. They need to be quoted.
if( CPLIsNan(padfItems[j]) )
sprintf( pszNeedToFree+nOff, "NaN" );
else if( CPLIsInf(padfItems[j]) )
sprintf( pszNeedToFree+nOff, (padfItems[j] > 0) ? "Infinity" : "-Infinity" );
else
sprintf( pszNeedToFree+nOff, "%.16g", padfItems[j] );
}
strcat( pszNeedToFree+nOff, "}'" );
osCommand += pszNeedToFree;
CPLFree(pszNeedToFree);
return;
}
// We need special formatting for string list values.
else if( nOGRFieldType == OFTStringList )
{
char **papszItems = poFeature->GetFieldAsStringList(i);
osCommand += OGRPGDumpEscapeStringList(papszItems, TRUE);
return;
}
// Binary formatting
else if( nOGRFieldType == OFTBinary )
{
osCommand += "'";
int nLen = 0;
GByte* pabyData = poFeature->GetFieldAsBinary( i, &nLen );
char* pszBytea = GByteArrayToBYTEA( pabyData, nLen);
osCommand += pszBytea;
CPLFree(pszBytea);
osCommand += "'";
return;
}
// Flag indicating NULL or not-a-date date value
// e.g. 0000-00-00 - there is no year 0
OGRBoolean bIsDateNull = FALSE;
const char *pszStrValue = poFeature->GetFieldAsString(i);
// Check if date is NULL: 0000-00-00
if( nOGRFieldType == OFTDate )
{
if( EQUALN( pszStrValue, "0000", 4 ) )
{
pszStrValue = "NULL";
bIsDateNull = TRUE;
}
}
else if ( nOGRFieldType == OFTReal )
{
char* pszComma = strchr((char*)pszStrValue, ',');
if (pszComma)
*pszComma = '.';
//Check for special values. They need to be quoted.
double dfVal = poFeature->GetFieldAsDouble(i);
if( CPLIsNan(dfVal) )
pszStrValue = "'NaN'";
else if( CPLIsInf(dfVal) )
pszStrValue = (dfVal > 0) ? "'Infinity'" : "'-Infinity'";
}
if( nOGRFieldType != OFTInteger && nOGRFieldType != OFTReal
&& !bIsDateNull )
{
osCommand += OGRPGDumpEscapeString( pszStrValue,
poFeatureDefn->GetFieldDefn(i)->GetWidth(),
poFeatureDefn->GetFieldDefn(i)->GetNameRef() );
}
else
{
osCommand += pszStrValue;
}
}
GDALDataset * AAIGDataset::CreateCopy(
const char *pszFilename, GDALDataset *poSrcDS,
int /* bStrict */,
char **papszOptions,
GDALProgressFunc pfnProgress, void *pProgressData )
{
const int nBands = poSrcDS->GetRasterCount();
const int nXSize = poSrcDS->GetRasterXSize();
const int nYSize = poSrcDS->GetRasterYSize();
// Some rudimentary checks.
if( nBands != 1 )
{
CPLError(CE_Failure, CPLE_NotSupported,
"AAIG driver doesn't support %d bands. Must be 1 band.",
nBands);
return nullptr;
}
if( !pfnProgress(0.0, nullptr, pProgressData) )
return nullptr;
// Create the dataset.
VSILFILE *fpImage = VSIFOpenL(pszFilename, "wt");
if( fpImage == nullptr )
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Unable to create file %s.",
pszFilename);
return nullptr;
}
// Write ASCII Grid file header.
double adfGeoTransform[6] = {};
char szHeader[2000] = {};
const char *pszForceCellsize =
CSLFetchNameValue(papszOptions, "FORCE_CELLSIZE");
poSrcDS->GetGeoTransform(adfGeoTransform);
if( std::abs(adfGeoTransform[1] + adfGeoTransform[5]) < 0.0000001 ||
std::abs(adfGeoTransform[1]-adfGeoTransform[5]) < 0.0000001 ||
(pszForceCellsize && CPLTestBool(pszForceCellsize)) )
{
CPLsnprintf(
szHeader, sizeof(szHeader),
"ncols %d\n"
"nrows %d\n"
"xllcorner %.12f\n"
"yllcorner %.12f\n"
"cellsize %.12f\n",
nXSize, nYSize,
adfGeoTransform[0],
adfGeoTransform[3] - nYSize * adfGeoTransform[1],
adfGeoTransform[1]);
}
else
{
if( pszForceCellsize == nullptr )
CPLError(CE_Warning, CPLE_AppDefined,
"Producing a Golden Surfer style file with DX and DY "
"instead of CELLSIZE since the input pixels are "
"non-square. Use the FORCE_CELLSIZE=TRUE creation "
"option to force use of DX for even though this will "
"be distorted. Most ASCII Grid readers (ArcGIS "
"included) do not support the DX and DY parameters.");
CPLsnprintf(
szHeader, sizeof(szHeader),
"ncols %d\n"
"nrows %d\n"
"xllcorner %.12f\n"
"yllcorner %.12f\n"
"dx %.12f\n"
"dy %.12f\n",
nXSize, nYSize,
adfGeoTransform[0],
adfGeoTransform[3] + nYSize * adfGeoTransform[5],
adfGeoTransform[1],
fabs(adfGeoTransform[5]));
}
// Builds the format string used for printing float values.
char szFormatFloat[32] = { '\0' };
strcpy(szFormatFloat, " %.20g");
const char *pszDecimalPrecision =
CSLFetchNameValue(papszOptions, "DECIMAL_PRECISION");
const char *pszSignificantDigits =
CSLFetchNameValue(papszOptions, "SIGNIFICANT_DIGITS");
bool bIgnoreSigDigits = false;
if( pszDecimalPrecision && pszSignificantDigits )
{
CPLError(CE_Warning, CPLE_AppDefined,
"Conflicting precision arguments, using DECIMAL_PRECISION");
bIgnoreSigDigits = true;
}
int nPrecision;
if ( pszSignificantDigits && !bIgnoreSigDigits )
{
nPrecision = atoi(pszSignificantDigits);
if (nPrecision >= 0)
snprintf(szFormatFloat, sizeof(szFormatFloat), " %%.%dg",
nPrecision);
CPLDebug("AAIGrid", "Setting precision format: %s", szFormatFloat);
}
else if( pszDecimalPrecision )
{
nPrecision = atoi(pszDecimalPrecision);
if ( nPrecision >= 0 )
snprintf(szFormatFloat, sizeof(szFormatFloat), " %%.%df",
nPrecision);
CPLDebug("AAIGrid", "Setting precision format: %s", szFormatFloat);
}
// Handle nodata (optionally).
GDALRasterBand *poBand = poSrcDS->GetRasterBand(1);
const bool bReadAsInt =
poBand->GetRasterDataType() == GDT_Byte ||
poBand->GetRasterDataType() == GDT_Int16 ||
poBand->GetRasterDataType() == GDT_UInt16 ||
poBand->GetRasterDataType() == GDT_Int32;
// Write `nodata' value to header if it is exists in source dataset
int bSuccess = FALSE;
const double dfNoData = poBand->GetNoDataValue(&bSuccess);
if ( bSuccess )
{
snprintf(szHeader + strlen(szHeader),
sizeof(szHeader) - strlen(szHeader), "%s", "NODATA_value ");
if( bReadAsInt )
snprintf(szHeader + strlen(szHeader),
sizeof(szHeader) - strlen(szHeader), "%d",
static_cast<int>(dfNoData));
else
CPLsnprintf(szHeader + strlen(szHeader),
sizeof(szHeader) - strlen(szHeader),
szFormatFloat, dfNoData);
snprintf(szHeader + strlen(szHeader),
sizeof(szHeader) - strlen(szHeader), "%s", "\n");
}
if( VSIFWriteL(szHeader, strlen(szHeader), 1, fpImage) != 1)
{
CPL_IGNORE_RET_VAL(VSIFCloseL(fpImage));
return nullptr;
}
// Loop over image, copying image data.
// Write scanlines to output file
int *panScanline = bReadAsInt
? static_cast<int *>(CPLMalloc(
nXSize * GDALGetDataTypeSizeBytes(GDT_Int32)))
: nullptr;
double *padfScanline =
bReadAsInt ? nullptr
: static_cast<double *>(CPLMalloc(
nXSize * GDALGetDataTypeSizeBytes(GDT_Float64)));
CPLErr eErr = CE_None;
bool bHasOutputDecimalDot = false;
for( int iLine = 0; eErr == CE_None && iLine < nYSize; iLine++ )
{
CPLString osBuf;
eErr = poBand->RasterIO(
GF_Read, 0, iLine, nXSize, 1,
bReadAsInt ? reinterpret_cast<void *>(panScanline) :
reinterpret_cast<void *>(padfScanline),
nXSize, 1, bReadAsInt ? GDT_Int32 : GDT_Float64,
0, 0, nullptr);
if( bReadAsInt )
{
for ( int iPixel = 0; iPixel < nXSize; iPixel++ )
{
snprintf(szHeader, sizeof(szHeader),
" %d", panScanline[iPixel]);
osBuf += szHeader;
if( (iPixel & 1023) == 0 || iPixel == nXSize - 1 )
{
if ( VSIFWriteL(osBuf, static_cast<int>(osBuf.size()), 1,
fpImage) != 1 )
{
eErr = CE_Failure;
CPLError(CE_Failure, CPLE_AppDefined,
"Write failed, disk full?");
break;
}
osBuf = "";
}
}
}
else
{
for ( int iPixel = 0; iPixel < nXSize; iPixel++ )
{
CPLsnprintf(szHeader, sizeof(szHeader),
szFormatFloat, padfScanline[iPixel]);
// Make sure that as least one value has a decimal point (#6060)
if( !bHasOutputDecimalDot )
{
if( strchr(szHeader, '.') || strchr(szHeader, 'e') ||
strchr(szHeader, 'E') )
{
bHasOutputDecimalDot = true;
}
else if( !CPLIsInf(padfScanline[iPixel]) &&
!CPLIsNan(padfScanline[iPixel]) )
{
strcat(szHeader, ".0");
bHasOutputDecimalDot = true;
}
}
osBuf += szHeader;
if( (iPixel & 1023) == 0 || iPixel == nXSize - 1 )
{
if ( VSIFWriteL(osBuf, static_cast<int>(osBuf.size()), 1,
fpImage) != 1 )
{
eErr = CE_Failure;
CPLError(CE_Failure, CPLE_AppDefined,
"Write failed, disk full?");
break;
}
osBuf = "";
}
}
}
if( VSIFWriteL("\n", 1, 1, fpImage) != 1 )
eErr = CE_Failure;
if( eErr == CE_None &&
!pfnProgress((iLine + 1) / static_cast<double>(nYSize), nullptr,
pProgressData) )
{
eErr = CE_Failure;
CPLError(CE_Failure, CPLE_UserInterrupt,
"User terminated CreateCopy()");
}
}
CPLFree(panScanline);
CPLFree(padfScanline);
if( VSIFCloseL(fpImage) != 0 )
eErr = CE_Failure;
if( eErr != CE_None )
return nullptr;
// Try to write projection file.
const char *pszOriginalProjection = poSrcDS->GetProjectionRef();
if( !EQUAL(pszOriginalProjection, "") )
{
char *pszDirname = CPLStrdup(CPLGetPath(pszFilename));
char *pszBasename = CPLStrdup(CPLGetBasename(pszFilename));
char *pszPrjFilename =
CPLStrdup(CPLFormFilename(pszDirname, pszBasename, "prj"));
VSILFILE *fp = VSIFOpenL(pszPrjFilename, "wt");
if (fp != nullptr)
{
OGRSpatialReference oSRS;
oSRS.importFromWkt(pszOriginalProjection);
oSRS.morphToESRI();
char *pszESRIProjection = nullptr;
oSRS.exportToWkt(&pszESRIProjection);
CPL_IGNORE_RET_VAL(VSIFWriteL(pszESRIProjection, 1,
strlen(pszESRIProjection), fp));
CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
CPLFree(pszESRIProjection);
}
else
{
CPLError(CE_Failure, CPLE_FileIO, "Unable to create file %s.",
pszPrjFilename);
}
CPLFree(pszDirname);
CPLFree(pszBasename);
CPLFree(pszPrjFilename);
}
// Re-open dataset, and copy any auxiliary pam information.
// If writing to stdout, we can't reopen it, so return
// a fake dataset to make the caller happy.
CPLPushErrorHandler(CPLQuietErrorHandler);
GDALPamDataset *poDS =
reinterpret_cast<GDALPamDataset *>(GDALOpen(pszFilename, GA_ReadOnly));
CPLPopErrorHandler();
if (poDS)
{
poDS->CloneInfo(poSrcDS, GCIF_PAM_DEFAULT);
return poDS;
}
CPLErrorReset();
AAIGDataset *poAAIG_DS = new AAIGDataset();
poAAIG_DS->nRasterXSize = nXSize;
poAAIG_DS->nRasterYSize = nYSize;
poAAIG_DS->nBands = 1;
poAAIG_DS->SetBand(1, new AAIGRasterBand(poAAIG_DS, 1));
return poAAIG_DS;
}
/**
* Sets the surface grids based on a ncep HRRR (surface only!) forecast.
* @param input The WindNinjaInputs for misc. info.
* @param airGrid The air temperature grid to be filled.
* @param cloudGrid The cloud cover grid to be filled.
* @param uGrid The u velocity grid to be filled.
* @param vGrid The v velocity grid to be filled.
* @param wGrid The w velocity grid to be filled (filled with zeros here?).
*/
void ncepHrrrSurfInitialization::setSurfaceGrids( WindNinjaInputs &input,
AsciiGrid<double> &airGrid,
AsciiGrid<double> &cloudGrid,
AsciiGrid<double> &uGrid,
AsciiGrid<double> &vGrid,
AsciiGrid<double> &wGrid )
{
int bandNum = -1;
GDALDataset *srcDS;
srcDS = (GDALDataset*)GDALOpenShared( input.forecastFilename.c_str(), GA_ReadOnly );
if( srcDS == NULL ) {
CPLDebug( "ncepHRRRSurfaceInitialization::identify()",
"Bad forecast file" );
}
GDALRasterBand *poBand = srcDS->GetRasterBand( 49 );
const char *gc;
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
//get time list
std::vector<boost::local_time::local_date_time> timeList( getTimeList( input.ninjaTimeZone ) );
//Search time list for our time to identify our band number for cloud/speed/dir
//Right now, just one time step per file
std::vector<int> bandList;
for(unsigned int i = 0; i < timeList.size(); i++)
{
if(input.ninjaTime == timeList[i])
{
//check which HRRR format we have
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){ //if band 49 isn't u10, it's either 2010 or 2012 format
GDALRasterBand *poBand = srcDS->GetRasterBand( 50 );
const char *gc;
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){ //if band 50 isn't u10, it's the 2010 format
bandList.push_back( 29 ); // 2t
bandList.push_back( 34 ); // 10v
bandList.push_back( 33 ); // 10u
bandList.push_back( 52 ); // geopotential height at cloud top
}
else{
bandList.push_back( 45 ); // 2t
bandList.push_back( 51 ); // 10v
bandList.push_back( 50 ); // 10u
bandList.push_back( 78 ); // geopotential height at cloud top
}
}
else{ //otherwise, should be 2011 format, but check for u10 band to be sure
poBand = srcDS->GetRasterBand( 44 );
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
bandName = gc;
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){
CPLDebug( "ncepHRRRSurfaceInitialization::identify()",
"Can't find the u-10 band in the forecast file." );
}
bandList.push_back( 44 ); // 2t
bandList.push_back( 50 ); // 10v
bandList.push_back( 49 ); // 10u
bandList.push_back( 73 ); // geopotential height at cloud top
}
break;
}
}
if(bandList.size() < 4)
throw std::runtime_error("Could not match ninjaTime with a band number in the forecast file.");
std::string dstWkt;
dstWkt = input.dem.prjString;
GDALDataset *wrpDS;
std::string temp;
std::string srcWkt;
GDALWarpOptions* psWarpOptions;
srcWkt = srcDS->GetProjectionRef();
poBand = srcDS->GetRasterBand( 9 );
int pbSuccess;
double dfNoData = poBand->GetNoDataValue( &pbSuccess );
psWarpOptions = GDALCreateWarpOptions();
int nBandCount = bandList.size();
psWarpOptions->nBandCount = nBandCount;
psWarpOptions->panSrcBands =
(int*) CPLMalloc( sizeof( int ) * nBandCount );
psWarpOptions->panDstBands =
(int*) CPLMalloc( sizeof( int ) * nBandCount );
psWarpOptions->padfDstNoDataReal =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataImag =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataReal =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataImag =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
if( pbSuccess == false )
dfNoData = -9999.0;
psWarpOptions->panSrcBands =
(int *) CPLMalloc(sizeof(int) * psWarpOptions->nBandCount );
psWarpOptions->panSrcBands[0] = bandList[0];
psWarpOptions->panSrcBands[1] = bandList[1];
psWarpOptions->panSrcBands[2] = bandList[2];
psWarpOptions->panSrcBands[3] = bandList[3];
psWarpOptions->panDstBands =
(int *) CPLMalloc(sizeof(int) * psWarpOptions->nBandCount );
psWarpOptions->panDstBands[0] = 1;
psWarpOptions->panDstBands[1] = 2;
psWarpOptions->panDstBands[2] = 3;
psWarpOptions->panDstBands[3] = 4;
wrpDS = (GDALDataset*) GDALAutoCreateWarpedVRT( srcDS, srcWkt.c_str(),
dstWkt.c_str(),
GRA_NearestNeighbour,
1.0, psWarpOptions );
std::vector<std::string> varList = getVariableList();
for( unsigned int i = 0; i < varList.size(); i++ ) {
if( varList[i] == "2t" ) {
GDAL2AsciiGrid( wrpDS, i+1, airGrid );
if( CPLIsNan( dfNoData ) ) {
airGrid.set_noDataValue( -9999.0 );
airGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "10v" ) {
GDAL2AsciiGrid( wrpDS, i+1, vGrid );
if( CPLIsNan( dfNoData ) ) {
vGrid.set_noDataValue( -9999.0 );
vGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "10u" ) {
GDAL2AsciiGrid( wrpDS, i+1, uGrid );
if( CPLIsNan( dfNoData ) ) {
uGrid.set_noDataValue( -9999.0 );
uGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "gh" ) {
GDAL2AsciiGrid( wrpDS, i+1, cloudGrid );
if( CPLIsNan( dfNoData ) ) {
cloudGrid.set_noDataValue( -9999.0 );
cloudGrid.replaceNan( -9999.0 );
}
}
}
//if there are any clouds set cloud fraction to 1, otherwise set to 0.
for(int i = 0; i < cloudGrid.get_nRows(); i++){
for(int j = 0; j < cloudGrid.get_nCols(); j++){
if(cloudGrid(i,j) < 0.0){
cloudGrid(i,j) = 0.0;
}
else{
cloudGrid(i,j) = 1.0;
}
}
}
wGrid.set_headerData( uGrid );
wGrid = 0.0;
airGrid += 273.15;
GDALDestroyWarpOptions( psWarpOptions );
GDALClose((GDALDatasetH) srcDS );
GDALClose((GDALDatasetH) wrpDS );
}
