CPLErr MEMDataset::AddBand( GDALDataType eType, char **papszOptions )
{
int nBandId = GetRasterCount() + 1;
GByte *pData;
int nPixelSize = (GDALGetDataTypeSize(eType) / 8);
/* -------------------------------------------------------------------- */
/* Do we need to allocate the memory ourselves? This is the */
/* simple case. */
/* -------------------------------------------------------------------- */
if( CSLFetchNameValue( papszOptions, "DATAPOINTER" ) == NULL )
{
pData = (GByte *)
VSICalloc(nPixelSize * GetRasterXSize(), GetRasterYSize() );
if( pData == NULL )
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"Unable to create band arrays ... out of memory." );
return CE_Failure;
}
SetBand( nBandId,
new MEMRasterBand( this, nBandId, pData, eType, nPixelSize,
nPixelSize * GetRasterXSize(), TRUE ) );
return CE_None;
}
/* -------------------------------------------------------------------- */
/* Get layout of memory and other flags. */
/* -------------------------------------------------------------------- */
const char *pszOption;
int nPixelOffset, nLineOffset;
const char *pszDataPointer;
pszDataPointer = CSLFetchNameValue(papszOptions,"DATAPOINTER");
pData = (GByte *) CPLScanPointer(pszDataPointer,
strlen(pszDataPointer));
pszOption = CSLFetchNameValue(papszOptions,"PIXELOFFSET");
if( pszOption == NULL )
nPixelOffset = nPixelSize;
else
nPixelOffset = atoi(pszOption);
pszOption = CSLFetchNameValue(papszOptions,"LINEOFFSET");
if( pszOption == NULL )
nLineOffset = GetRasterXSize() * nPixelOffset;
else
nLineOffset = atoi(pszOption);
SetBand( nBandId,
new MEMRasterBand( this, nBandId, pData, eType,
nPixelOffset, nLineOffset, FALSE ) );
return CE_None;
}
MyDataset()
{
eAccess = GA_Update;
nRasterXSize = 2;
nRasterYSize = 1;
SetBand(1, new MyRasterBand());
}
int PDSDataset::ParseCompressedImage()
{
CPLString osFileName = GetKeyword( "COMPRESSED_FILE.FILE_NAME", "" );
CleanString( osFileName );
CPLString osPath = CPLGetPath(GetDescription());
CPLString osFullFileName = CPLFormFilename( osPath, osFileName, NULL );
int iBand;
poCompressedDS = (GDALDataset*) GDALOpen( osFullFileName, GA_ReadOnly );
if( poCompressedDS == NULL )
return FALSE;
nRasterXSize = poCompressedDS->GetRasterXSize();
nRasterYSize = poCompressedDS->GetRasterYSize();
for( iBand = 0; iBand < poCompressedDS->GetRasterCount(); iBand++ )
{
SetBand( iBand+1, new PDSWrapperRasterBand( poCompressedDS->GetRasterBand( iBand+1 ) ) );
}
return TRUE;
}
/*!
\param map PCRaster map handle. It is ours to close.
*/
PCRasterDataset::PCRasterDataset(
MAP* map)
: GDALPamDataset(),
d_map(map), d_west(0.0), d_north(0.0), d_cellSize(0.0)
{
// Read header info.
nRasterXSize = RgetNrCols(d_map);
nRasterYSize = RgetNrRows(d_map);
d_west = static_cast<double>(RgetXUL(d_map));
d_north = static_cast<double>(RgetYUL(d_map));
d_cellSize = static_cast<double>(RgetCellSize(d_map));
d_cellRepresentation = RgetUseCellRepr(d_map);
CPLAssert(d_cellRepresentation != CR_UNDEFINED);
d_valueScale = RgetValueScale(d_map);
CPLAssert(d_valueScale != VS_UNDEFINED);
d_defaultNoDataValue = ::missingValue(d_cellRepresentation);
d_location_changed = false;
// Create band information objects.
nBands = 1;
SetBand(1, new PCRasterRasterBand(this));
SetMetadataItem("PCRASTER_VALUESCALE", valueScale2String(
d_valueScale).c_str());
}
CALSWrapperSrcDataset( GDALDataset* poSrcDS, const char* pszPadding )
{
nRasterXSize = poSrcDS->GetRasterXSize();
nRasterYSize = poSrcDS->GetRasterYSize();
SetBand(1, new CALSWrapperSrcBand(poSrcDS));
SetMetadataItem("TIFFTAG_DOCUMENTNAME", pszPadding);
}
CPLErr VRTWarpedDataset::AddBand( GDALDataType eType, char **papszOptions )
{
UNREFERENCED_PARAM( papszOptions );
SetBand( GetRasterCount() + 1,
new VRTWarpedRasterBand( this, GetRasterCount() + 1, eType ) );
return CE_None;
}
GDALOverviewDataset::GDALOverviewDataset(GDALDataset* poMainDS,
int nOvrLevel,
int bThisLevelOnly,
int bOwnDS)
{
this->poMainDS = poMainDS;
this->nOvrLevel = nOvrLevel;
this->bOwnDS = bOwnDS;
this->bThisLevelOnly = bThisLevelOnly;
eAccess = poMainDS->GetAccess();
nRasterXSize = poMainDS->GetRasterBand(1)->GetOverview(nOvrLevel)->GetXSize();
nRasterYSize = poMainDS->GetRasterBand(1)->GetOverview(nOvrLevel)->GetYSize();
poOvrDS = poMainDS->GetRasterBand(1)->GetOverview(nOvrLevel)->GetDataset();
if( poOvrDS != NULL && poOvrDS == poMainDS )
{
CPLDebug("GDAL", "Dataset of overview is the same as the main band. This is not expected");
poOvrDS = NULL;
}
nBands = poMainDS->GetRasterCount();
for(int i=0; i<nBands; i++)
{
SetBand(i+1, new GDALOverviewBand(this, i+1));
}
nGCPCount = 0;
pasGCPList = NULL;
papszMD_RPC = NULL;
papszMD_GEOLOCATION = NULL;
/* We create a fake driver that has the same name as the original */
/* one, but we cannot use the real driver object, so that code */
/* doesn't try to cast the GDALOverviewDataset* as a native dataset */
/* object */
if( poMainDS->GetDriver() != NULL )
{
poDriver = new GDALDriver();
poDriver->SetDescription(poMainDS->GetDriver()->GetDescription());
poDriver->SetMetadata(poMainDS->GetDriver()->GetMetadata());
}
SetDescription( poMainDS->GetDescription() );
CPLDebug( "GDAL", "GDALOverviewDataset(%s, this=%p) creation.",
poMainDS->GetDescription(), this );
papszOpenOptions = CSLDuplicate(poMainDS->GetOpenOptions());
/* Add OVERVIEW_LEVEL if not called from GDALOpenEx() but directly */
papszOpenOptions = CSLSetNameValue(papszOpenOptions, "OVERVIEW_LEVEL",
CPLSPrintf("%d", nOvrLevel));
}
void UART1::SetUpUart(){
/* ピン設定
* UART TX PORTB(2) digtal out pull-up
* UART RX PORTB(3) digtal in pull-up
*/
//入出力設定
TRISBbits.TRISB2=false;
TRISBbits.TRISB3=true;
//デジタルピンに設定
ANSELBbits.ANSB2=false;
ANSELBbits.ANSB3=false;
//Pull-up
CNPUBbits.CNPUB2=true;
CNPUBbits.CNPUB3=true;
//Pull-down
CNPDBbits.CNPDB2=false;
CNPDBbits.CNPDB3=false;
//module conection
U1RXR=0b0100;//RB2
RPB3R=0b0001;//TX
//uart configuration
U1MODEbits.ON=false;//for changing
//極性設定
U1MODEbits.RXINV=false;//Rx
U1STAbits.UTXINV=false;//Tx
//送受信許可
U1STAbits.URXEN=true;//Recive
U1STAbits.UTXEN=false;//Tramsmit
//RTS CTS
U1MODEbits.UEN=0b00;//no use
//通信フォーマット
U1MODEbits.PDSEL=DATA_8BIT_EVEN;
U1MODEbits.STSEL=false;//Stop Bit
U1MODEbits.BRGH=true;//高速通信モード
SetBand(9600);
U1STAbits.ADM_EN=false;//no use addressing mode
//割り込みタイミング
U1STAbits.UTXISEL=0b10;//when buffer empty
U1STAbits.URXISEL=0b10;//when buffer has 3 datas.
//DMA設定
}
void RasdamanDataset::getTypes(const r_Base_Type* baseType, int &counter, int pos) {
if (baseType->isStructType()) {
r_Structure_Type* tp = (r_Structure_Type*) baseType;
int elem = tp->count_elements();
for (int i=0; i<elem; ++i) {
r_Attribute attr = (*tp)[i];
getTypes(&attr.type_of(), counter, attr.global_offset());
}
}
if (baseType->isPrimitiveType()) {
r_Primitive_Type *primType = (r_Primitive_Type*)baseType;
r_Type::r_Type_Id typeId = primType->type_id();
SetBand(counter, new RasdamanRasterBand(this, counter, mapRasdamanTypesToGDAL(typeId), pos, primType->size(), this->tileXSize, this->tileYSize));
counter ++;
}
}
GDALApplyVSGDataset::GDALApplyVSGDataset( GDALDataset* poSrcDataset,
GDALDataset* poReprojectedGrid,
GDALDataType eDT,
bool bInverse,
double dfSrcUnitToMeter,
double dfDstUnitToMeter,
int nBlockSize ) :
m_poSrcDataset(poSrcDataset),
m_poReprojectedGrid(poReprojectedGrid),
m_bInverse(bInverse),
m_dfSrcUnitToMeter(dfSrcUnitToMeter),
m_dfDstUnitToMeter(dfDstUnitToMeter)
{
m_poSrcDataset->Reference();
m_poReprojectedGrid->Reference();
nRasterXSize = poSrcDataset->GetRasterXSize();
nRasterYSize = poSrcDataset->GetRasterYSize();
SetBand( 1, new GDALApplyVSGRasterBand( eDT, nBlockSize ) );
}
ECRGTOCProxyRasterDataSet::ECRGTOCProxyRasterDataSet
(ECRGTOCSubDataset* poSubDataset,
const char* fileName,
int nXSize, int nYSize,
double dfMinX, double dfMaxY,
double dfPixelXSize, double dfPixelYSize) :
/* Mark as shared since the VRT will take several references if we are in RGBA mode (4 bands for this dataset) */
GDALProxyPoolDataset(fileName, nXSize, nYSize, GA_ReadOnly, TRUE, SRS_WKT_WGS84)
{
int i;
this->poSubDataset = poSubDataset;
this->dfMinX = dfMinX;
this->dfMaxY = dfMaxY;
this->dfPixelXSize = dfPixelXSize;
this->dfPixelYSize = dfPixelYSize;
checkDone = FALSE;
checkOK = FALSE;
for(i=0;i<3;i++)
{
SetBand(i + 1, new GDALProxyPoolRasterBand(this, i+1, GDT_Byte, nXSize, 1));
}
}
ECRGTOCProxyRasterDataSet::ECRGTOCProxyRasterDataSet(
ECRGTOCSubDataset* /* poSubDatasetIn */,
const char* fileNameIn,
int nXSizeIn, int nYSizeIn,
double dfMinXIn, double dfMaxYIn,
double dfPixelXSizeIn, double dfPixelYSizeIn ) :
// Mark as shared since the VRT will take several references if we are in
// RGBA mode (4 bands for this dataset).
GDALProxyPoolDataset(fileNameIn, nXSizeIn, nYSizeIn, GA_ReadOnly,
TRUE, SRS_WKT_WGS84),
checkDone(FALSE),
checkOK(FALSE),
dfMinX(dfMinXIn),
dfMaxY(dfMaxYIn),
dfPixelXSize(dfPixelXSizeIn),
dfPixelYSize(dfPixelYSizeIn)
{
for( int i = 0; i < 3; i++ )
{
SetBand(i + 1,
new GDALProxyPoolRasterBand(this, i+1, GDT_Byte, nXSizeIn, 1));
}
}
CPLErr GDALWMSDataset::Initialize(CPLXMLNode *config) {
CPLErr ret = CE_None;
char* pszXML = CPLSerializeXMLTree( config );
if (pszXML)
{
m_osXML = pszXML;
CPLFree(pszXML);
}
// Initialize the minidriver, which can set parameters for the dataset using member functions
CPLXMLNode *service_node = CPLGetXMLNode(config, "Service");
if (service_node != NULL)
{
const CPLString service_name = CPLGetXMLValue(service_node, "name", "");
if (!service_name.empty())
{
GDALWMSMiniDriverManager *const mdm = GetGDALWMSMiniDriverManager();
GDALWMSMiniDriverFactory *const mdf = mdm->Find(service_name);
if (mdf != NULL)
{
m_mini_driver = mdf->New();
m_mini_driver->m_parent_dataset = this;
if (m_mini_driver->Initialize(service_node) == CE_None)
{
m_mini_driver_caps.m_capabilities_version = -1;
m_mini_driver->GetCapabilities(&m_mini_driver_caps);
if (m_mini_driver_caps.m_capabilities_version == -1)
{
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Internal error, mini-driver capabilities version not set.");
ret = CE_Failure;
}
}
else
{
delete m_mini_driver;
m_mini_driver = NULL;
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Failed to initialize minidriver.");
ret = CE_Failure;
}
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"GDALWMS: No mini-driver registered for '%s'.", service_name.c_str());
ret = CE_Failure;
}
}
else
{
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: No Service specified.");
ret = CE_Failure;
}
}
else
{
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: No Service specified.");
ret = CE_Failure;
}
/*
Parameters that could be set by minidriver already, based on server side information.
If the size is set, minidriver has done this already
A "server" side minidriver needs to set at least:
- Blocksize (x and y)
- Clamp flag (defaults to true)
- DataWindow
- Band Count
- Data Type
It should also initialize and register the bands and overviews.
*/
if (m_data_window.m_sx<1)
{
int nOverviews = 0;
if (ret == CE_None)
{
m_block_size_x = atoi(CPLGetXMLValue(config, "BlockSizeX", CPLString().Printf("%d", m_default_block_size_x)));
m_block_size_y = atoi(CPLGetXMLValue(config, "BlockSizeY", CPLString().Printf("%d", m_default_block_size_y)));
if (m_block_size_x <= 0 || m_block_size_y <= 0)
{
CPLError( CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value in BlockSizeX or BlockSizeY" );
ret = CE_Failure;
}
}
if (ret == CE_None)
{
m_clamp_requests = StrToBool(CPLGetXMLValue(config, "ClampRequests", "true"));
if (m_clamp_requests<0)
{
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ClampRequests, true/false expected.");
ret = CE_Failure;
}
}
if (ret == CE_None)
{
CPLXMLNode *data_window_node = CPLGetXMLNode(config, "DataWindow");
if (data_window_node == NULL && m_bNeedsDataWindow)
{
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: DataWindow missing.");
ret = CE_Failure;
}
else
{
CPLString osDefaultX0, osDefaultX1, osDefaultY0, osDefaultY1;
CPLString osDefaultTileCountX, osDefaultTileCountY, osDefaultTileLevel;
CPLString osDefaultOverviewCount;
osDefaultX0.Printf("%.8f", m_default_data_window.m_x0);
osDefaultX1.Printf("%.8f", m_default_data_window.m_x1);
osDefaultY0.Printf("%.8f", m_default_data_window.m_y0);
osDefaultY1.Printf("%.8f", m_default_data_window.m_y1);
osDefaultTileCountX.Printf("%d", m_default_tile_count_x);
osDefaultTileCountY.Printf("%d", m_default_tile_count_y);
if (m_default_data_window.m_tlevel >= 0)
osDefaultTileLevel.Printf("%d", m_default_data_window.m_tlevel);
if (m_default_overview_count >= 0)
osDefaultOverviewCount.Printf("%d", m_default_overview_count);
const char *overview_count = CPLGetXMLValue(config, "OverviewCount", osDefaultOverviewCount);
const char *ulx = CPLGetXMLValue(data_window_node, "UpperLeftX", osDefaultX0);
const char *uly = CPLGetXMLValue(data_window_node, "UpperLeftY", osDefaultY0);
const char *lrx = CPLGetXMLValue(data_window_node, "LowerRightX", osDefaultX1);
const char *lry = CPLGetXMLValue(data_window_node, "LowerRightY", osDefaultY1);
const char *sx = CPLGetXMLValue(data_window_node, "SizeX", "");
const char *sy = CPLGetXMLValue(data_window_node, "SizeY", "");
const char *tx = CPLGetXMLValue(data_window_node, "TileX", "0");
const char *ty = CPLGetXMLValue(data_window_node, "TileY", "0");
const char *tlevel = CPLGetXMLValue(data_window_node, "TileLevel", osDefaultTileLevel);
const char *str_tile_count_x = CPLGetXMLValue(data_window_node, "TileCountX", osDefaultTileCountX);
const char *str_tile_count_y = CPLGetXMLValue(data_window_node, "TileCountY", osDefaultTileCountY);
const char *y_origin = CPLGetXMLValue(data_window_node, "YOrigin", "default");
if (ret == CE_None)
{
if ((ulx[0] != '\0') && (uly[0] != '\0') && (lrx[0] != '\0') && (lry[0] != '\0'))
{
m_data_window.m_x0 = CPLAtof(ulx);
m_data_window.m_y0 = CPLAtof(uly);
m_data_window.m_x1 = CPLAtof(lrx);
m_data_window.m_y1 = CPLAtof(lry);
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"GDALWMS: Mandatory elements of DataWindow missing: UpperLeftX, UpperLeftY, LowerRightX, LowerRightY.");
ret = CE_Failure;
}
}
m_data_window.m_tlevel = atoi(tlevel);
if (ret == CE_None)
{
if ((sx[0] != '\0') && (sy[0] != '\0'))
{
m_data_window.m_sx = atoi(sx);
m_data_window.m_sy = atoi(sy);
}
else if ((tlevel[0] != '\0') && (str_tile_count_x[0] != '\0') && (str_tile_count_y[0] != '\0'))
{
int tile_count_x = atoi(str_tile_count_x);
int tile_count_y = atoi(str_tile_count_y);
m_data_window.m_sx = tile_count_x * m_block_size_x * (1 << m_data_window.m_tlevel);
m_data_window.m_sy = tile_count_y * m_block_size_y * (1 << m_data_window.m_tlevel);
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"GDALWMS: Mandatory elements of DataWindow missing: SizeX, SizeY.");
ret = CE_Failure;
}
}
if (ret == CE_None)
{
if ((tx[0] != '\0') && (ty[0] != '\0'))
{
m_data_window.m_tx = atoi(tx);
m_data_window.m_ty = atoi(ty);
}
else
{
CPLError(CE_Failure, CPLE_AppDefined,
"GDALWMS: Mandatory elements of DataWindow missing: TileX, TileY.");
ret = CE_Failure;
}
}
if (ret == CE_None)
{
if (overview_count[0] != '\0')
{
nOverviews = atoi(overview_count);
}
else if (tlevel[0] != '\0')
{
nOverviews = m_data_window.m_tlevel;
}
else
{
const int min_overview_size = MAX(32, MIN(m_block_size_x, m_block_size_y));
double a = log(static_cast<double>(MIN(m_data_window.m_sx, m_data_window.m_sy))) / log(2.0)
- log(static_cast<double>(min_overview_size)) / log(2.0);
nOverviews = MAX(0, MIN(static_cast<int>(ceil(a)), 32));
}
}
if (ret == CE_None)
{
CPLString y_origin_str = y_origin;
if (y_origin_str == "top") {
m_data_window.m_y_origin = GDALWMSDataWindow::TOP;
} else if (y_origin_str == "bottom") {
m_data_window.m_y_origin = GDALWMSDataWindow::BOTTOM;
} else if (y_origin_str == "default") {
m_data_window.m_y_origin = GDALWMSDataWindow::DEFAULT;
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: DataWindow YOrigin must be set to "
"one of 'default', 'top', or 'bottom', not '%s'.", y_origin_str.c_str());
ret = CE_Failure;
}
}
}
}
if (ret == CE_None)
{
if (nBands<1)
nBands=atoi(CPLGetXMLValue(config,"BandsCount","3"));
if (nBands<1)
{
CPLError(CE_Failure, CPLE_AppDefined,
"GDALWMS: Bad number of bands.");
ret = CE_Failure;
}
}
if (ret == CE_None)
{
const char *data_type = CPLGetXMLValue(config, "DataType", "Byte");
m_data_type = GDALGetDataTypeByName( data_type );
if ( m_data_type == GDT_Unknown || m_data_type >= GDT_TypeCount )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GDALWMS: Invalid value in DataType. Data type \"%s\" is not supported.", data_type );
ret = CE_Failure;
}
}
// Initialize the bands and the overviews. Assumes overviews are powers of two
if (ret == CE_None)
{
nRasterXSize = m_data_window.m_sx;
nRasterYSize = m_data_window.m_sy;
if (!GDALCheckDatasetDimensions(nRasterXSize, nRasterYSize) ||
!GDALCheckBandCount(nBands, TRUE))
{
return CE_Failure;
}
GDALColorInterp default_color_interp[4][4] = {
{ GCI_GrayIndex, GCI_Undefined, GCI_Undefined, GCI_Undefined },
{ GCI_GrayIndex, GCI_AlphaBand, GCI_Undefined, GCI_Undefined },
{ GCI_RedBand, GCI_GreenBand, GCI_BlueBand, GCI_Undefined },
{ GCI_RedBand, GCI_GreenBand, GCI_BlueBand, GCI_AlphaBand }
};
for (int i = 0; i < nBands; ++i)
{
GDALColorInterp color_interp = (nBands <= 4 && i <= 3 ? default_color_interp[nBands - 1][i] : GCI_Undefined);
GDALWMSRasterBand *band = new GDALWMSRasterBand(this, i, 1.0);
band->m_color_interp = color_interp;
SetBand(i + 1, band);
double scale = 0.5;
for (int j = 0; j < nOverviews; ++j)
{
band->AddOverview(scale);
band->m_color_interp = color_interp;
scale *= 0.5;
}
}
}
}
// UserPwd
const char *pszUserPwd = CPLGetXMLValue(config, "UserPwd", "");
if (pszUserPwd[0] != '\0')
m_osUserPwd = pszUserPwd;
const char *pszUserAgent = CPLGetXMLValue(config, "UserAgent", "");
if (pszUserAgent[0] != '\0')
m_osUserAgent = pszUserAgent;
const char *pszReferer = CPLGetXMLValue(config, "Referer", "");
if (pszReferer[0] != '\0')
m_osReferer = pszReferer;
if (ret == CE_None) {
const char *pszHttpZeroBlockCodes = CPLGetXMLValue(config, "ZeroBlockHttpCodes", "");
if(pszHttpZeroBlockCodes[0] == '\0') {
m_http_zeroblock_codes.push_back(204);
} else {
char **kv = CSLTokenizeString2(pszHttpZeroBlockCodes,",",CSLT_HONOURSTRINGS);
int nCount = CSLCount(kv);
for(int i=0; i<nCount; i++) {
int code = atoi(kv[i]);
if(code <= 0) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ZeroBlockHttpCodes \"%s\", comma separated HTTP response codes expected.",
kv[i]);
ret = CE_Failure;
break;
}
m_http_zeroblock_codes.push_back(code);
}
CSLDestroy(kv);
}
}
if (ret == CE_None) {
const char *pszZeroExceptions = CPLGetXMLValue(config, "ZeroBlockOnServerException", "");
if(pszZeroExceptions[0] != '\0') {
m_zeroblock_on_serverexceptions = StrToBool(pszZeroExceptions);
if (m_zeroblock_on_serverexceptions == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ZeroBlockOnServerException \"%s\", true/false expected.",
pszZeroExceptions);
ret = CE_Failure;
}
}
}
if (ret == CE_None) {
const char *max_conn = CPLGetXMLValue(config, "MaxConnections", "");
if (max_conn[0] != '\0') {
m_http_max_conn = atoi(max_conn);
} else {
m_http_max_conn = 2;
}
}
if (ret == CE_None) {
const char *timeout = CPLGetXMLValue(config, "Timeout", "");
if (timeout[0] != '\0') {
m_http_timeout = atoi(timeout);
} else {
m_http_timeout = 300;
}
}
if (ret == CE_None) {
const char *offline_mode = CPLGetXMLValue(config, "OfflineMode", "");
if (offline_mode[0] != '\0') {
const int offline_mode_bool = StrToBool(offline_mode);
if (offline_mode_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of OfflineMode, true / false expected.");
ret = CE_Failure;
} else {
m_offline_mode = offline_mode_bool;
}
} else {
m_offline_mode = 0;
}
}
if (ret == CE_None) {
const char *advise_read = CPLGetXMLValue(config, "AdviseRead", "");
if (advise_read[0] != '\0') {
const int advise_read_bool = StrToBool(advise_read);
if (advise_read_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of AdviseRead, true / false expected.");
ret = CE_Failure;
} else {
m_use_advise_read = advise_read_bool;
}
} else {
m_use_advise_read = 0;
}
}
if (ret == CE_None) {
const char *verify_advise_read = CPLGetXMLValue(config, "VerifyAdviseRead", "");
if (m_use_advise_read) {
if (verify_advise_read[0] != '\0') {
const int verify_advise_read_bool = StrToBool(verify_advise_read);
if (verify_advise_read_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of VerifyAdviseRead, true / false expected.");
ret = CE_Failure;
} else {
m_verify_advise_read = verify_advise_read_bool;
}
} else {
m_verify_advise_read = 1;
}
}
}
// Let the local configuration override the minidriver supplied projection
if (ret == CE_None) {
const char *proj = CPLGetXMLValue(config, "Projection", "");
if (proj[0] != '\0') {
m_projection = ProjToWKT(proj);
if (m_projection.size() == 0) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Bad projection specified.");
ret = CE_Failure;
}
}
}
// Same for Min, Max and NoData, defined per band or per dataset
// If they are set as null strings, they clear the server declared values
if (ret == CE_None) {
// Data values are attributes, they include NoData Min and Max
// TODO: document those options
if (0!=CPLGetXMLNode(config,"DataValues")) {
const char *nodata=CPLGetXMLValue(config,"DataValues.NoData",NULL);
if (nodata!=NULL) WMSSetNoDataValue(nodata);
const char *min=CPLGetXMLValue(config,"DataValues.min",NULL);
if (min!=NULL) WMSSetMinValue(min);
const char *max=CPLGetXMLValue(config,"DataValues.max",NULL);
if (max!=NULL) WMSSetMaxValue(max);
}
}
if (ret == CE_None) {
CPLXMLNode *cache_node = CPLGetXMLNode(config, "Cache");
if (cache_node != NULL) {
m_cache = new GDALWMSCache();
if (m_cache->Initialize(cache_node) != CE_None) {
delete m_cache;
m_cache = NULL;
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Failed to initialize cache.");
ret = CE_Failure;
}
}
}
if (ret == CE_None) {
const int v = StrToBool(CPLGetXMLValue(config, "UnsafeSSL", "false"));
if (v == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of UnsafeSSL: true or false expected.");
ret = CE_Failure;
} else {
m_unsafeSsl = v;
}
}
if (ret == CE_None) {
/* If we dont have projection already set ask mini-driver. */
if (!m_projection.size()) {
const char *proj = m_mini_driver->GetProjectionInWKT();
if (proj != NULL) {
m_projection = proj;
}
}
}
return ret;
}
void GDALProxyPoolDataset::AddSrcBandDescription( GDALDataType eDataType, int nBlockXSize, int nBlockYSize)
{
SetBand(nBands + 1, new GDALProxyPoolRasterBand(this, nBands + 1, eDataType, nBlockXSize, nBlockYSize));
}
CPLErr VRTDataset::AddBand( GDALDataType eType, char **papszOptions )
{
int i;
const char *pszSubClass = CSLFetchNameValue(papszOptions, "subclass");
bNeedsFlush = 1;
/* ==================================================================== */
/* Handle a new raw band. */
/* ==================================================================== */
if( pszSubClass != NULL && EQUAL(pszSubClass,"VRTRawRasterBand") )
{
int nWordDataSize = GDALGetDataTypeSize( eType ) / 8;
vsi_l_offset nImageOffset = 0;
int nPixelOffset = nWordDataSize;
int nLineOffset = nWordDataSize * GetRasterXSize();
const char *pszFilename;
const char *pszByteOrder = NULL;
int bRelativeToVRT = FALSE;
/* -------------------------------------------------------------------- */
/* Collect required information. */
/* -------------------------------------------------------------------- */
if( CSLFetchNameValue(papszOptions, "ImageOffset") != NULL )
nImageOffset = atoi(CSLFetchNameValue(papszOptions, "ImageOffset"));
if( CSLFetchNameValue(papszOptions, "PixelOffset") != NULL )
nPixelOffset = atoi(CSLFetchNameValue(papszOptions,"PixelOffset"));
if( CSLFetchNameValue(papszOptions, "LineOffset") != NULL )
nLineOffset = atoi(CSLFetchNameValue(papszOptions, "LineOffset"));
if( CSLFetchNameValue(papszOptions, "ByteOrder") != NULL )
pszByteOrder = CSLFetchNameValue(papszOptions, "ByteOrder");
if( CSLFetchNameValue(papszOptions, "SourceFilename") != NULL )
pszFilename = CSLFetchNameValue(papszOptions, "SourceFilename");
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"AddBand() requires a SourceFilename option for VRTRawRasterBands." );
return CE_Failure;
}
bRelativeToVRT =
CSLFetchBoolean( papszOptions, "RelativeToVRT", FALSE );
/* -------------------------------------------------------------------- */
/* Create and initialize the band. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
VRTRawRasterBand *poBand =
new VRTRawRasterBand( this, GetRasterCount() + 1, eType );
eErr =
poBand->SetRawLink( pszFilename, NULL, FALSE,
nImageOffset, nPixelOffset, nLineOffset,
pszByteOrder );
if( eErr != CE_None )
{
delete poBand;
return eErr;
}
SetBand( GetRasterCount() + 1, poBand );
return CE_None;
}
/* ==================================================================== */
/* Handle a new "sourced" band. */
/* ==================================================================== */
else
{
VRTSourcedRasterBand *poBand;
/* ---- Check for our sourced band 'derived' subclass ---- */
if(pszSubClass != NULL && EQUAL(pszSubClass,"VRTDerivedRasterBand")) {
/* We'll need a pointer to the subclass in case we need */
/* to set the new band's pixel function below. */
VRTDerivedRasterBand* poDerivedBand;
poDerivedBand = new VRTDerivedRasterBand
(this, GetRasterCount() + 1, eType,
GetRasterXSize(), GetRasterYSize());
/* Set the pixel function options it provided. */
const char* pszFuncName =
CSLFetchNameValue(papszOptions, "PixelFunctionType");
if (pszFuncName != NULL)
poDerivedBand->SetPixelFunctionName(pszFuncName);
const char* pszTransferTypeName =
CSLFetchNameValue(papszOptions, "SourceTransferType");
if (pszTransferTypeName != NULL) {
GDALDataType eTransferType =
GDALGetDataTypeByName(pszTransferTypeName);
if (eTransferType == GDT_Unknown) {
CPLError( CE_Failure, CPLE_AppDefined,
"invalid SourceTransferType: \"%s\".",
pszTransferTypeName);
delete poDerivedBand;
return CE_Failure;
}
poDerivedBand->SetSourceTransferType(eTransferType);
}
/* We're done with the derived band specific stuff, so */
/* we can assigned the base class pointer now. */
poBand = poDerivedBand;
}
else {
/* ---- Standard sourced band ---- */
poBand = new VRTSourcedRasterBand
(this, GetRasterCount() + 1, eType,
GetRasterXSize(), GetRasterYSize());
}
SetBand( GetRasterCount() + 1, poBand );
for( i=0; papszOptions != NULL && papszOptions[i] != NULL; i++ )
{
if( EQUALN(papszOptions[i],"AddFuncSource=", 14) )
{
VRTImageReadFunc pfnReadFunc = NULL;
void *pCBData = NULL;
double dfNoDataValue = VRT_NODATA_UNSET;
char **papszTokens = CSLTokenizeStringComplex( papszOptions[i]+14,
",", TRUE, FALSE );
if( CSLCount(papszTokens) < 1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"AddFuncSource() ... required argument missing." );
}
sscanf( papszTokens[0], "%p", &pfnReadFunc );
if( CSLCount(papszTokens) > 1 )
sscanf( papszTokens[1], "%p", &pCBData );
if( CSLCount(papszTokens) > 2 )
dfNoDataValue = atof( papszTokens[2] );
poBand->AddFuncSource( pfnReadFunc, pCBData, dfNoDataValue );
}
}
return CE_None;
}
}
CPLErr VRTDataset::XMLInit( CPLXMLNode *psTree, const char *pszVRTPath )
{
if( pszVRTPath != NULL )
this->pszVRTPath = CPLStrdup(pszVRTPath);
/* -------------------------------------------------------------------- */
/* Check for an SRS node. */
/* -------------------------------------------------------------------- */
if( strlen(CPLGetXMLValue(psTree, "SRS", "")) > 0 )
{
OGRSpatialReference oSRS;
CPLFree( pszProjection );
pszProjection = NULL;
if( oSRS.SetFromUserInput( CPLGetXMLValue(psTree, "SRS", "") )
== OGRERR_NONE )
oSRS.exportToWkt( &pszProjection );
}
/* -------------------------------------------------------------------- */
/* Check for a GeoTransform node. */
/* -------------------------------------------------------------------- */
if( strlen(CPLGetXMLValue(psTree, "GeoTransform", "")) > 0 )
{
const char *pszGT = CPLGetXMLValue(psTree, "GeoTransform", "");
char **papszTokens;
papszTokens = CSLTokenizeStringComplex( pszGT, ",", FALSE, FALSE );
if( CSLCount(papszTokens) != 6 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"GeoTransform node does not have expected six values.");
}
else
{
for( int iTA = 0; iTA < 6; iTA++ )
adfGeoTransform[iTA] = atof(papszTokens[iTA]);
bGeoTransformSet = TRUE;
}
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Check for GCPs. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psGCPList = CPLGetXMLNode( psTree, "GCPList" );
if( psGCPList != NULL )
{
CPLXMLNode *psXMLGCP;
OGRSpatialReference oSRS;
const char *pszRawProj = CPLGetXMLValue(psGCPList, "Projection", "");
CPLFree( pszGCPProjection );
if( strlen(pszRawProj) > 0
&& oSRS.SetFromUserInput( pszRawProj ) == OGRERR_NONE )
oSRS.exportToWkt( &pszGCPProjection );
else
pszGCPProjection = CPLStrdup("");
// Count GCPs.
int nGCPMax = 0;
for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;
psXMLGCP = psXMLGCP->psNext )
nGCPMax++;
pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),nGCPMax);
for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;
psXMLGCP = psXMLGCP->psNext )
{
GDAL_GCP *psGCP = pasGCPList + nGCPCount;
if( !EQUAL(psXMLGCP->pszValue,"GCP") ||
psXMLGCP->eType != CXT_Element )
continue;
GDALInitGCPs( 1, psGCP );
CPLFree( psGCP->pszId );
psGCP->pszId = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Id",""));
CPLFree( psGCP->pszInfo );
psGCP->pszInfo = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Info",""));
psGCP->dfGCPPixel = atof(CPLGetXMLValue(psXMLGCP,"Pixel","0.0"));
psGCP->dfGCPLine = atof(CPLGetXMLValue(psXMLGCP,"Line","0.0"));
psGCP->dfGCPX = atof(CPLGetXMLValue(psXMLGCP,"X","0.0"));
psGCP->dfGCPY = atof(CPLGetXMLValue(psXMLGCP,"Y","0.0"));
psGCP->dfGCPZ = atof(CPLGetXMLValue(psXMLGCP,"Z","0.0"));
nGCPCount++;
}
}
/* -------------------------------------------------------------------- */
/* Apply any dataset level metadata. */
/* -------------------------------------------------------------------- */
oMDMD.XMLInit( psTree, TRUE );
/* -------------------------------------------------------------------- */
/* Create dataset mask band. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psChild;
/* Parse dataset mask band first */
CPLXMLNode* psMaskBandNode = CPLGetXMLNode(psTree, "MaskBand");
if (psMaskBandNode)
psChild = psMaskBandNode->psChild;
else
psChild = NULL;
for( ; psChild != NULL; psChild=psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(psChild->pszValue,"VRTRasterBand") )
{
VRTRasterBand *poBand = NULL;
const char *pszSubclass = CPLGetXMLValue( psChild, "subclass",
"VRTSourcedRasterBand" );
if( EQUAL(pszSubclass,"VRTSourcedRasterBand") )
poBand = new VRTSourcedRasterBand( this, 0 );
else if( EQUAL(pszSubclass, "VRTDerivedRasterBand") )
poBand = new VRTDerivedRasterBand( this, 0 );
else if( EQUAL(pszSubclass, "VRTRawRasterBand") )
poBand = new VRTRawRasterBand( this, 0 );
else if( EQUAL(pszSubclass, "VRTWarpedRasterBand") )
poBand = new VRTWarpedRasterBand( this, 0 );
else
CPLError( CE_Failure, CPLE_AppDefined,
"VRTRasterBand of unrecognised subclass '%s'.",
pszSubclass );
if( poBand != NULL
&& poBand->XMLInit( psChild, pszVRTPath ) == CE_None )
{
SetMaskBand(poBand);
break;
}
else
{
if( poBand )
delete poBand;
return CE_Failure;
}
}
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
int nBands = 0;
for( psChild=psTree->psChild; psChild != NULL; psChild=psChild->psNext )
{
if( psChild->eType == CXT_Element
&& EQUAL(psChild->pszValue,"VRTRasterBand") )
{
VRTRasterBand *poBand = NULL;
const char *pszSubclass = CPLGetXMLValue( psChild, "subclass",
"VRTSourcedRasterBand" );
if( EQUAL(pszSubclass,"VRTSourcedRasterBand") )
poBand = new VRTSourcedRasterBand( this, nBands+1 );
else if( EQUAL(pszSubclass, "VRTDerivedRasterBand") )
poBand = new VRTDerivedRasterBand( this, nBands+1 );
else if( EQUAL(pszSubclass, "VRTRawRasterBand") )
poBand = new VRTRawRasterBand( this, nBands+1 );
else if( EQUAL(pszSubclass, "VRTWarpedRasterBand") )
poBand = new VRTWarpedRasterBand( this, nBands+1 );
else
CPLError( CE_Failure, CPLE_AppDefined,
"VRTRasterBand of unrecognised subclass '%s'.",
pszSubclass );
if( poBand != NULL
&& poBand->XMLInit( psChild, pszVRTPath ) == CE_None )
{
SetBand( ++nBands, poBand );
}
else
{
if( poBand )
delete poBand;
return CE_Failure;
}
}
}
return CE_None;
}
CPLErr SDEDataset::ComputeRasterInfo() {
long nSDEErr;
SE_RASTERINFO raster;
nSDEErr = SE_rasterinfo_create(&raster);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rasterinfo_create" );
return CE_Fatal;
}
LONG nRasterColumnId = 0;
nSDEErr = SE_rascolinfo_get_id( hRasterColumn,
&nRasterColumnId);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rascolinfo_get_id" );
return CE_Fatal;
}
nSDEErr = SE_raster_get_info_by_id( hConnection,
nRasterColumnId,
1,
raster);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rascolinfo_get_id" );
return CE_Fatal;
}
LONG nBandsRet;
nSDEErr = SE_raster_get_bands( hConnection,
raster,
&paohSDERasterBands,
&nBandsRet);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_raster_get_bands" );
return CE_Fatal;
}
nBands = nBandsRet;
SE_RASBANDINFO band;
// grab our other stuff from the first band and hope for the best
band = paohSDERasterBands[0];
LONG nXSRet, nYSRet;
nSDEErr = SE_rasbandinfo_get_band_size( band, &nXSRet, &nYSRet );
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rasbandinfo_get_band_size" );
return CE_Fatal;
}
nRasterXSize = nXSRet;
nRasterYSize = nYSRet;
SE_ENVELOPE extent;
nSDEErr = SE_rasbandinfo_get_extent(band, &extent);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rasbandinfo_get_extent" );
return CE_Fatal;
}
dfMinX = extent.minx;
dfMinY = extent.miny;
dfMaxX = extent.maxx;
dfMaxY = extent.maxy;
CPLDebug("SDERASTER", "minx: %.5f, miny: %.5f, maxx: %.5f, maxy: %.5f", dfMinX, dfMinY, dfMaxX, dfMaxY);
// x0 roughly corresponds to dfMinX
// y0 roughly corresponds to dfMaxY
// They can be different than the extent parameters because
// SDE uses offsets. The following info is from Duarte Carreira
// in relation to bug #2063 http://trac.osgeo.org/gdal/ticket/2063 :
// Depending on how the data was loaded, the pixel width
// or pixel height may include a pixel offset from the nearest
// tile boundary. An offset will be indicated by aplus sign
// "+" followed by a value. The value indicates the number
// of pixels the nearest tile boundary is to the left of
// the image for the x dimension or the number of
// pixels the nearest tile boundary is above the image for
// the y dimension. The offset information is only useful
// for advanced application developers who need to know
// where the image begins in relation to the underlying tile structure
LFLOAT x0, y0;
nSDEErr = SE_rasbandinfo_get_tile_origin(band, &x0, &y0);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rasbandinfo_get_tile_origin" );
return CE_Fatal;
}
CPLDebug("SDERASTER", "Tile origin: %.5f, %.5f", x0, y0);
// we also need to adjust dfMaxX and dfMinY otherwise the cell size will change
dfMaxX = (x0-dfMinX) + dfMaxX;
dfMinY = (y0-dfMaxY) + dfMinY;
// adjust the bbox based on the tile origin.
dfMinX = MIN(x0, dfMinX);
dfMaxY = MAX(y0, dfMaxY);
nSDEErr = SE_rasterattr_create(&hAttributes, false);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rasterattr_create" );
return CE_Fatal;
}
// Grab the pointer for our member variable
nSDEErr = SE_stream_create(hConnection, &hStream);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_stream_create" );
return CE_Fatal;
}
for (int i=0; i < nBands; i++) {
SetBand( i+1, new SDERasterBand( this, i+1, -1, &(paohSDERasterBands[i]) ));
}
GDALRasterBand* b = GetRasterBand(1);
eDataType = b->GetRasterDataType();
SE_rasterinfo_free(raster);
return CE_None;
}
int NTv2Dataset::OpenGrid( char *pachHeader, vsi_l_offset nGridOffset )
{
this->nGridOffset = nGridOffset;
/* -------------------------------------------------------------------- */
/* Read the grid header. */
/* -------------------------------------------------------------------- */
double s_lat, n_lat, e_long, w_long, lat_inc, long_inc;
CaptureMetadataItem( pachHeader + 0*16 );
CaptureMetadataItem( pachHeader + 1*16 );
CaptureMetadataItem( pachHeader + 2*16 );
CaptureMetadataItem( pachHeader + 3*16 );
memcpy( &s_lat, pachHeader + 4*16 + 8, 8 );
memcpy( &n_lat, pachHeader + 5*16 + 8, 8 );
memcpy( &e_long, pachHeader + 6*16 + 8, 8 );
memcpy( &w_long, pachHeader + 7*16 + 8, 8 );
memcpy( &lat_inc, pachHeader + 8*16 + 8, 8 );
memcpy( &long_inc, pachHeader + 9*16 + 8, 8 );
e_long *= -1;
w_long *= -1;
nRasterXSize = (int) floor((e_long - w_long) / long_inc + 1.5);
nRasterYSize = (int) floor((n_lat - s_lat) / lat_inc + 1.5);
if (!GDALCheckDatasetDimensions(nRasterXSize, nRasterYSize))
return FALSE;
/* -------------------------------------------------------------------- */
/* Create band information object. */
/* */
/* We use unusual offsets to remap from bottom to top, to top */
/* to bottom orientation, and also to remap east to west, to */
/* west to east. */
/* -------------------------------------------------------------------- */
int iBand;
for( iBand = 0; iBand < 4; iBand++ )
{
RawRasterBand *poBand =
new RawRasterBand( this, iBand+1, fpImage,
nGridOffset + 4*iBand + 11*16
+ (nRasterXSize-1) * 16
+ (nRasterYSize-1) * 16 * nRasterXSize,
-16, -16 * nRasterXSize,
GDT_Float32, CPL_IS_LSB, TRUE, FALSE );
SetBand( iBand+1, poBand );
}
GetRasterBand(1)->SetDescription( "Latitude Offset (arc seconds)" );
GetRasterBand(2)->SetDescription( "Longitude Offset (arc seconds)" );
GetRasterBand(3)->SetDescription( "Latitude Error" );
GetRasterBand(4)->SetDescription( "Longitude Error" );
/* -------------------------------------------------------------------- */
/* Setup georeferencing. */
/* -------------------------------------------------------------------- */
adfGeoTransform[0] = (w_long - long_inc*0.5) / 3600.0;
adfGeoTransform[1] = long_inc / 3600.0;
adfGeoTransform[2] = 0.0;
adfGeoTransform[3] = (n_lat + lat_inc*0.5) / 3600.0;
adfGeoTransform[4] = 0.0;
adfGeoTransform[5] = (-1 * lat_inc) / 3600.0;
return TRUE;
}
CPLErr GDALWMSDataset::Initialize(CPLXMLNode *config) {
CPLErr ret = CE_None;
if (ret == CE_None) {
const char *max_conn = CPLGetXMLValue(config, "MaxConnections", "");
if (max_conn[0] != '\0') {
m_http_max_conn = atoi(max_conn);
} else {
m_http_max_conn = 2;
}
}
if (ret == CE_None) {
const char *timeout = CPLGetXMLValue(config, "Timeout", "");
if (timeout[0] != '\0') {
m_http_timeout = atoi(timeout);
} else {
m_http_timeout = 300;
}
}
if (ret == CE_None) {
const char *offline_mode = CPLGetXMLValue(config, "OfflineMode", "");
if (offline_mode[0] != '\0') {
const int offline_mode_bool = StrToBool(offline_mode);
if (offline_mode_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of OfflineMode, true / false expected.");
ret = CE_Failure;
} else {
m_offline_mode = offline_mode_bool;
}
} else {
m_offline_mode = 0;
}
}
if (ret == CE_None) {
const char *advise_read = CPLGetXMLValue(config, "AdviseRead", "");
if (advise_read[0] != '\0') {
const int advise_read_bool = StrToBool(advise_read);
if (advise_read_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of AdviseRead, true / false expected.");
ret = CE_Failure;
} else {
m_use_advise_read = advise_read_bool;
}
} else {
m_use_advise_read = 0;
}
}
if (ret == CE_None) {
const char *verify_advise_read = CPLGetXMLValue(config, "VerifyAdviseRead", "");
if (m_use_advise_read) {
if (verify_advise_read[0] != '\0') {
const int verify_advise_read_bool = StrToBool(verify_advise_read);
if (verify_advise_read_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of VerifyAdviseRead, true / false expected.");
ret = CE_Failure;
} else {
m_verify_advise_read = verify_advise_read_bool;
}
} else {
m_verify_advise_read = 1;
}
}
}
if (ret == CE_None) {
const char *block_size_x = CPLGetXMLValue(config, "BlockSizeX", "1024");
const char *block_size_y = CPLGetXMLValue(config, "BlockSizeY", "1024");
m_block_size_x = atoi(block_size_x);
m_block_size_y = atoi(block_size_y);
if (m_block_size_x <= 0 || m_block_size_y <= 0)
{
CPLError( CE_Failure, CPLE_AppDefined,
"GDALWMS: Invalid value in BlockSizeX or BlockSizeY" );
ret = CE_Failure;
}
}
if (ret == CE_None)
{
const char *data_type = CPLGetXMLValue(config, "DataType", "Byte");
m_data_type = GDALGetDataTypeByName( data_type );
if ( m_data_type == GDT_Unknown || m_data_type >= GDT_TypeCount )
{
CPLError( CE_Failure, CPLE_AppDefined,
"GDALWMS: Invalid value in DataType. Data type \"%s\" is not supported.", data_type );
ret = CE_Failure;
}
}
if (ret == CE_None) {
const int clamp_requests_bool = StrToBool(CPLGetXMLValue(config, "ClampRequests", "true"));
if (clamp_requests_bool == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Invalid value of ClampRequests, true / false expected.");
ret = CE_Failure;
} else {
m_clamp_requests = clamp_requests_bool;
}
}
if (ret == CE_None) {
CPLXMLNode *data_window_node = CPLGetXMLNode(config, "DataWindow");
if (data_window_node == NULL) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: DataWindow missing.");
ret = CE_Failure;
} else {
const char *overview_count = CPLGetXMLValue(config, "OverviewCount", "");
const char *ulx = CPLGetXMLValue(data_window_node, "UpperLeftX", "-180.0");
const char *uly = CPLGetXMLValue(data_window_node, "UpperLeftY", "90.0");
const char *lrx = CPLGetXMLValue(data_window_node, "LowerRightX", "180.0");
const char *lry = CPLGetXMLValue(data_window_node, "LowerRightY", "-90.0");
const char *sx = CPLGetXMLValue(data_window_node, "SizeX", "");
const char *sy = CPLGetXMLValue(data_window_node, "SizeY", "");
const char *tx = CPLGetXMLValue(data_window_node, "TileX", "0");
const char *ty = CPLGetXMLValue(data_window_node, "TileY", "0");
const char *tlevel = CPLGetXMLValue(data_window_node, "TileLevel", "");
const char *str_tile_count_x = CPLGetXMLValue(data_window_node, "TileCountX", "1");
const char *str_tile_count_y = CPLGetXMLValue(data_window_node, "TileCountY", "1");
const char *y_origin = CPLGetXMLValue(data_window_node, "YOrigin", "default");
if (ret == CE_None) {
if ((ulx[0] != '\0') && (uly[0] != '\0') && (lrx[0] != '\0') && (lry[0] != '\0')) {
m_data_window.m_x0 = atof(ulx);
m_data_window.m_y0 = atof(uly);
m_data_window.m_x1 = atof(lrx);
m_data_window.m_y1 = atof(lry);
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Mandatory elements of DataWindow missing: UpperLeftX, UpperLeftY, LowerRightX, LowerRightY.");
ret = CE_Failure;
}
}
if (ret == CE_None) {
if (tlevel[0] != '\0') {
m_data_window.m_tlevel = atoi(tlevel);
} else {
m_data_window.m_tlevel = 0;
}
}
if (ret == CE_None) {
if ((sx[0] != '\0') && (sy[0] != '\0')) {
m_data_window.m_sx = atoi(sx);
m_data_window.m_sy = atoi(sy);
} else if ((tlevel[0] != '\0') && (str_tile_count_x[0] != '\0') && (str_tile_count_y[0] != '\0')) {
int tile_count_x = atoi(str_tile_count_x);
int tile_count_y = atoi(str_tile_count_y);
m_data_window.m_sx = tile_count_x * m_block_size_x * (1 << m_data_window.m_tlevel);
m_data_window.m_sy = tile_count_y * m_block_size_y * (1 << m_data_window.m_tlevel);
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Mandatory elements of DataWindow missing: SizeX, SizeY.");
ret = CE_Failure;
}
}
if (ret == CE_None) {
if ((tx[0] != '\0') && (ty[0] != '\0')) {
m_data_window.m_tx = atoi(tx);
m_data_window.m_ty = atoi(ty);
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Mandatory elements of DataWindow missing: TileX, TileY.");
ret = CE_Failure;
}
}
if (ret == CE_None) {
if (overview_count[0] != '\0') {
m_overview_count = atoi(overview_count);
} else if (tlevel[0] != '\0') {
m_overview_count = m_data_window.m_tlevel;
} else {
const int min_overview_size = MAX(32, MIN(m_block_size_x, m_block_size_y));
double a = log(static_cast<double>(MIN(m_data_window.m_sx, m_data_window.m_sy))) / log(2.0)
- log(static_cast<double>(min_overview_size)) / log(2.0);
m_overview_count = MAX(0, MIN(static_cast<int>(ceil(a)), 32));
}
}
if (ret == CE_None) {
CPLString y_origin_str = y_origin;
if (y_origin_str == "top") {
m_data_window.m_y_origin = GDALWMSDataWindow::TOP;
} else if (y_origin_str == "bottom") {
m_data_window.m_y_origin = GDALWMSDataWindow::BOTTOM;
} else if (y_origin_str == "default") {
m_data_window.m_y_origin = GDALWMSDataWindow::DEFAULT;
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: DataWindow YOrigin must be set to "
"one of 'default', 'top', or 'bottom', not '%s'.", y_origin_str.c_str());
ret = CE_Failure;
}
}
}
}
if (ret == CE_None) {
const char *proj = CPLGetXMLValue(config, "Projection", "");
if (proj[0] != '\0') {
m_projection = ProjToWKT(proj);
if (m_projection.size() == 0) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Bad projection specified.");
ret = CE_Failure;
}
}
}
const char *bands_count = CPLGetXMLValue(config, "BandsCount", "3");
int nBandCount = atoi(bands_count);
if (ret == CE_None) {
CPLXMLNode *cache_node = CPLGetXMLNode(config, "Cache");
if (cache_node != NULL) {
m_cache = new GDALWMSCache();
if (m_cache->Initialize(cache_node) != CE_None) {
delete m_cache;
m_cache = NULL;
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Failed to initialize cache.");
ret = CE_Failure;
}
}
}
if (ret == CE_None) {
CPLXMLNode *service_node = CPLGetXMLNode(config, "Service");
if (service_node != NULL) {
const char *service_name = CPLGetXMLValue(service_node, "name", "");
if (service_name[0] != '\0') {
GDALWMSMiniDriverManager *const mdm = GetGDALWMSMiniDriverManager();
GDALWMSMiniDriverFactory *const mdf = mdm->Find(CPLString(service_name));
if (mdf != NULL) {
m_mini_driver = mdf->New();
m_mini_driver->m_parent_dataset = this;
if (m_mini_driver->Initialize(service_node) == CE_None) {
m_mini_driver_caps.m_capabilities_version = -1;
m_mini_driver->GetCapabilities(&m_mini_driver_caps);
if (m_mini_driver_caps.m_capabilities_version == -1) {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Internal error, mini-driver capabilities version not set.");
ret = CE_Failure;
}
} else {
delete m_mini_driver;
m_mini_driver = NULL;
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: Failed to initialize minidriver.");
ret = CE_Failure;
}
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: No mini-driver registered for '%s'.", service_name);
ret = CE_Failure;
}
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: No Service specified.");
ret = CE_Failure;
}
} else {
CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: No Service specified.");
ret = CE_Failure;
}
}
if (ret == CE_None) {
nRasterXSize = m_data_window.m_sx;
nRasterYSize = m_data_window.m_sy;
if (!GDALCheckDatasetDimensions(nRasterXSize, nRasterYSize) ||
!GDALCheckBandCount(nBandCount, TRUE))
{
return CE_Failure;
}
for (int i = 0; i < nBandCount; ++i) {
GDALWMSRasterBand *band = new GDALWMSRasterBand(this, i, 1.0);
SetBand(i + 1, band);
double scale = 0.5;
for (int j = 0; j < m_overview_count; ++j) {
band->AddOverview(scale);
scale *= 0.5;
}
}
}
if (ret == CE_None) {
/* If we dont have projection already set ask mini-driver. */
if (!m_projection.size()) {
const char *proj = m_mini_driver->GetProjectionInWKT();
if (proj != NULL) {
m_projection = proj;
}
}
}
return ret;
}
// Evaluate dynamic programming matrix. Create transcript.
CNWAligner::TScore CSplicedAligner32::x_Align (SAlignInOut* data)
{
// use the banded version if there is no space for introns
const int len_dif (data->m_len2 - data->m_len1);
if(len_dif < 2 * int (m_IntronMinSize) / 3) {
const Uint1 where (len_dif < 0? 0: 1);
const size_t shift (abs(len_dif) / 2);
const size_t band (abs(len_dif) + 2*(max(data->m_len1,data->m_len2)/20 + 1));
SetShift(where, shift);
SetBand(band);
return CBandAligner::x_Align(data);
}
// redefine TScore as a floating-point type for this procedure only
typedef double TScore;
const TScore cds_penalty_extra = -2e-6;
const size_t N1 = data->m_len1 + 1;
const size_t N2 = data->m_len2 + 1;
vector<TScore> stl_rowV (N2), stl_rowF (N2);
TScore* rowV = &stl_rowV[0];
TScore* rowF = &stl_rowF[0];
// index calculation: [i,j] = i*n2 + j
SAllocator<Uint4> alloc_bm (N1*N2);
Uint4* backtrace_matrix (alloc_bm.GetPointer());
TScore* pV = rowV - 1;
const char* seq1 = m_Seq1 + data->m_offset1 - 1;
const char* seq2 = m_Seq2 + data->m_offset2 - 1;
const TNCBIScore (*sm) [NCBI_FSM_DIM] = m_ScoreMatrix.s;
bool bFreeGapLeft1 = data->m_esf_L1 && data->m_offset1 == 0;
bool bFreeGapRight1 = data->m_esf_R1 &&
m_SeqLen1 == data->m_offset1 + data->m_len1;
bool bFreeGapLeft2 = data->m_esf_L2 && data->m_offset1 == 0;
bool bFreeGapRight2 = data->m_esf_R2 &&
m_SeqLen2 == data->m_offset2 + data->m_len2;
TScore wgleft1 = bFreeGapLeft1? 0: m_Wg;
TScore wsleft1 = bFreeGapLeft1? 0: m_Ws;
TScore wg1 = wgleft1, ws1 = wsleft1;
// recurrences
TScore wgleft2 = bFreeGapLeft2? 0: m_Wg;
TScore wsleft2 = bFreeGapLeft2? 0: m_Ws;
TScore V = 0;
TScore V0 = 0;
TScore E, G, n0;
Uint4 type;
// store candidate donors
size_t* jAllDonors [splice_type_count_32];
TScore* vAllDonors [splice_type_count_32];
vector<size_t> stl_jAllDonors (splice_type_count_32 * N2);
vector<TScore> stl_vAllDonors (splice_type_count_32 * N2);
for(unsigned char st = 0; st < splice_type_count_32; ++st) {
jAllDonors[st] = &stl_jAllDonors[st*N2];
vAllDonors[st] = &stl_vAllDonors[st*N2];
}
size_t jTail[splice_type_count_32], jHead[splice_type_count_32];
TScore vBestDonor [splice_type_count_32];
size_t jBestDonor [splice_type_count_32] = {0};
// place to store gap opening starts
size_t ins_start;
vector<size_t> stl_del_start(N2);
size_t* del_start = &stl_del_start[0];
// donor/acceptor matrix
const Uint1 * dnr_acc_matrix = g_dnr_acc_matrix.GetMatrix();
// fake row (above lambda)
rowV[0] = kInfMinus;
size_t k;
for (k = 0; k < N2; k++) {
rowV[k] = rowF[k] = kInfMinus;
del_start[k] = k;
}
k = 0;
size_t cds_start = m_cds_start, cds_stop = m_cds_stop;
if(cds_start < cds_stop) {
cds_start -= data->m_offset1;
cds_stop -= data->m_offset1;
}
size_t i, j = 0, k0;
unsigned char ci;
for(i = 0; i < N1; ++i, j = 0) {
V = i > 0? (V0 += wsleft2) : 0;
E = kInfMinus;
ins_start = k0 = k;
backtrace_matrix[k++] = kTypeGap; // | del_start[0]
ci = i > 0? seq1[i]: 'N';
for(unsigned char st = 0; st < splice_type_count_32; ++st) {
jTail[st] = jHead[st] = 0;
vBestDonor[st] = kInfMinus;
}
if(i == N1 - 1 && bFreeGapRight1) {
wg1 = ws1 = 0;
}
TScore wg2 = m_Wg, ws2 = m_Ws;
// detect donor candidate
if(N2 > 2) {
unsigned char d1 = seq2[1], d2 = seq2[2];
Uint1 dnr_type = 0xF0 & dnr_acc_matrix[(size_t(d1)<<8)|d2];
for(Uint1 st = 0; st < splice_type_count_32; ++st ) {
jAllDonors[st][jTail[st]] = j;
if(dnr_type & (0x10 << st)) {
vAllDonors[st][jTail[st]] =
( d1 == g_nwspl32_donor[st][0] &&
d2 == g_nwspl32_donor[st][1] ) ? V: (V + m_Wd1);
}
else { // both chars distorted
vAllDonors[st][jTail[st]] = V + m_Wd2;
}
++(jTail[st]);
}
}
if(cds_start <= i && i < cds_stop) {
if(i != 0 || ! bFreeGapLeft1) {
ws1 += cds_penalty_extra;
}
if(j != 0 || ! bFreeGapLeft2) {
ws2 += cds_penalty_extra;
}
}
for (j = 1; j < N2; ++j, ++k) {
G = pV[j] + sm[ci][(unsigned char)seq2[j]];
pV[j] = V;
n0 = V + wg1;
if(E >= n0) {
E += ws1; // continue the gap
}
else {
E = n0 + ws1; // open a new gap
ins_start = k-1;
}
if(j == N2 - 1 && bFreeGapRight2) {
wg2 = ws2 = 0;
}
n0 = rowV[j] + wg2;
if(rowF[j] >= n0) {
rowF[j] += ws2;
}
else {
rowF[j] = n0 + ws2;
del_start[j] = k-N2;
}
// evaluate the score (V)
if (E >= rowF[j]) {
if(E >= G) {
V = E;
type = kTypeGap | ins_start;
}
else {
V = G;
type = kTypeDiag;
}
} else {
if(rowF[j] >= G) {
V = rowF[j];
type = kTypeGap | del_start[j];
}
else {
V = G;
type = kTypeDiag;
}
}
// find out if there are new donors
for(unsigned char st = 0; st < splice_type_count_32; ++st) {
if(jTail[st] > jHead[st]) {
if(j - jAllDonors[st][jHead[st]] >= m_IntronMinSize) {
if(vAllDonors[st][jHead[st]] > vBestDonor[st]) {
vBestDonor[st] = vAllDonors[st][jHead[st]];
jBestDonor[st] = jAllDonors[st][jHead[st]];
}
++(jHead[st]);
}
}
}
// check splice signal
Uint4 dnr_pos = kMax_UI4;
unsigned char c1 = seq2[j-1], c2 = seq2[j];
Uint1 acc_mask = 0x0F & dnr_acc_matrix[(size_t(c1)<<8)|c2];
for(Uint1 st = 0; st < splice_type_count_32; ++st ) {
if(acc_mask & (0x01 << st)) {
TScore vAcc = vBestDonor[st] + m_Wi[st];
if( c1 != g_nwspl32_acceptor[st][0] ||
c2 != g_nwspl32_acceptor[st][1] ) {
vAcc += m_Wd1;
}
if(vAcc > V) {
V = vAcc;
dnr_pos = k0 + jBestDonor[st];
}
}
else { // try arbitrary splice
TScore vAcc = vBestDonor[st] + m_Wi[st] + m_Wd2;
if(vAcc > V) {
V = vAcc;
dnr_pos = k0 + jBestDonor[st];
}
}
}
if(dnr_pos != kMax_UI4) {
type = kTypeIntron | dnr_pos;
}
backtrace_matrix[k] = type;
// detect donor candidates
if(j < N2 - 2) {
unsigned char d1 = seq2[j+1], d2 = seq2[j+2];
Uint1 dnr_mask = 0xF0 & dnr_acc_matrix[(size_t(d1)<<8)|d2];
for(Uint1 st = 0; st < splice_type_count_32; ++st ) {
if( dnr_mask & (0x10 << st) ) {
if( d1 == g_nwspl32_donor[st][0] &&
d2 == g_nwspl32_donor[st][1] ) {
if(V > vBestDonor[st]) {
jAllDonors[st][jTail[st]] = j;
vAllDonors[st][jTail[st]] = V;
++(jTail[st]);
}
} else {
TScore v = V + m_Wd1;
if(v > vBestDonor[st]) {
jAllDonors[st][jTail[st]] = j;
vAllDonors[st][jTail[st]] = v;
++(jTail[st]);
}
}
}
else { // both chars distorted
TScore v = V + m_Wd2;
if(v > vBestDonor[st]) {
jAllDonors[st][jTail[st]] = j;
vAllDonors[st][jTail[st]] = v;
++(jTail[st]);
}
}
}
}
}
pV[j] = V;
if(i == 0) {
V0 = wgleft2;
wg1 = m_Wg;
ws1 = m_Ws;
}
}
try {
x_DoBackTrace(backtrace_matrix, data);
}
catch(exception&) { // GCC hack
throw;
}
return CNWAligner::TScore(V);
}
int PDSDataset::ParseImage( CPLString osPrefix )
{
/* ------------------------------------------------------------------- */
/* We assume the user is pointing to the label (ie. .lbl) file. */
/* ------------------------------------------------------------------- */
// IMAGE can be inline or detached and point to an image name
// ^IMAGE = 3
// ^IMAGE = "GLOBAL_ALBEDO_8PPD.IMG"
// ^IMAGE = "MEGT90N000CB.IMG"
// ^IMAGE = ("BLAH.IMG",1) -- start at record 1 (1 based)
// ^IMAGE = ("BLAH.IMG") -- still start at record 1 (equiv of "BLAH.IMG")
// ^IMAGE = ("BLAH.IMG", 5 <BYTES>) -- start at byte 5 (the fifth byte in the file)
// ^IMAGE = 10851 <BYTES>
// ^SPECTRAL_QUBE = 5 for multi-band images
CPLString osImageKeyword = osPrefix + "^IMAGE";
CPLString osQube = GetKeyword( osImageKeyword, "" );
CPLString osTargetFile = GetDescription();
if (EQUAL(osQube,"")) {
osImageKeyword = "^SPECTRAL_QUBE";
osQube = GetKeyword( osImageKeyword );
}
int nQube = atoi(osQube);
int nDetachedOffset = 0;
int bDetachedOffsetInBytes = FALSE;
if( osQube.size() && osQube[0] == '(' )
{
osQube = "\"";
osQube += GetKeywordSub( osImageKeyword, 1 );
osQube += "\"";
nDetachedOffset = atoi(GetKeywordSub( osImageKeyword, 2, "1")) - 1;
// If this is not explicitly in bytes, then it is assumed to be in
// records, and we need to translate to bytes.
if (strstr(GetKeywordSub(osImageKeyword,2),"<BYTES>") != NULL)
bDetachedOffsetInBytes = TRUE;
}
if( osQube.size() && osQube[0] == '"' )
{
CPLString osTPath = CPLGetPath(GetDescription());
CPLString osFilename = osQube;
CleanString( osFilename );
osTargetFile = CPLFormCIFilename( osTPath, osFilename, NULL );
osExternalCube = osTargetFile;
}
GDALDataType eDataType = GDT_Byte;
//image parameters
int nRows, nCols, nBands = 1;
int nSkipBytes = 0;
int itype;
int record_bytes;
char chByteOrder = 'M'; //default to MSB
double dfNoData = 0.0;
/* -------------------------------------------------------------------- */
/* Checks to see if this is raw PDS image not compressed image */
/* so ENCODING_TYPE either does not exist or it equals "N/A". */
/* Compressed types will not be supported in this routine */
/* -------------------------------------------------------------------- */
const char *value;
CPLString osEncodingType = GetKeyword(osPrefix+"IMAGE.ENCODING_TYPE","N/A");
CleanString(osEncodingType);
if ( !EQUAL(osEncodingType.c_str(),"N/A") )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"*** PDS image file has an ENCODING_TYPE parameter:\n"
"*** gdal pds driver does not support compressed image types\n"
"found: (%s)\n\n", osEncodingType.c_str() );
return FALSE;
}
/**************** end ENCODING_TYPE check ***********************/
/*********** Grab layout type (BSQ, BIP, BIL) ************/
// AXIS_NAME = (SAMPLE,LINE,BAND)
/*********** Grab samples lines band **************/
/** if AXIS_NAME = "" then Bands=1 and Sample and Lines **/
/** are there own keywords "LINES" and "LINE_SAMPLES" **/
/** if not NULL then CORE_ITEMS keyword i.e. (234,322,2) **/
/***********************************************************/
char szLayout[10] = "BSQ"; //default to band seq.
value = GetKeyword( osPrefix+"IMAGE.AXIS_NAME", "" );
if (EQUAL(value,"(SAMPLE,LINE,BAND)") ) {
strcpy(szLayout,"BSQ");
nCols = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",1));
nRows = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",2));
nBands = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",3));
}
else if (EQUAL(value,"(BAND,LINE,SAMPLE)") ) {
strcpy(szLayout,"BIP");
nBands = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",1));
nRows = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",2));
nCols = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",3));
}
else if (EQUAL(value,"(SAMPLE,BAND,LINE)") ) {
strcpy(szLayout,"BIL");
nCols = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",1));
nBands = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",2));
nRows = atoi(GetKeywordSub(osPrefix+"IMAGE.CORE_ITEMS",3));
}
else if ( EQUAL(value,"") ) {
strcpy(szLayout,"BSQ");
nCols = atoi(GetKeyword(osPrefix+"IMAGE.LINE_SAMPLES",""));
nRows = atoi(GetKeyword(osPrefix+"IMAGE.LINES",""));
nBands = atoi(GetKeyword(osPrefix+"IMAGE.BANDS","1"));
}
else {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout not supported. Abort\n\n", value);
return FALSE;
}
/*********** Grab Qube record bytes **********/
record_bytes = atoi(GetKeyword(osPrefix+"IMAGE.RECORD_BYTES"));
if (record_bytes == 0)
record_bytes = atoi(GetKeyword(osPrefix+"RECORD_BYTES"));
// this can happen with "record_type = undefined".
if( record_bytes == 0 )
record_bytes = 1;
if( nQube >0 && osQube.find("<BYTES>") != CPLString::npos )
nSkipBytes = nQube - 1;
else if (nQube > 0 )
nSkipBytes = (nQube - 1) * record_bytes;
else if( nDetachedOffset > 0 )
{
if (bDetachedOffsetInBytes)
nSkipBytes = nDetachedOffset;
else
nSkipBytes = nDetachedOffset * record_bytes;
}
else
nSkipBytes = 0;
nSkipBytes += atoi(GetKeyword(osPrefix+"IMAGE.LINE_PREFIX_BYTES",""));
/*********** Grab SAMPLE_TYPE *****************/
/** if keyword not found leave as "M" or "MSB" **/
CPLString osST = GetKeyword( osPrefix+"IMAGE.SAMPLE_TYPE" );
if( osST.size() >= 2 && osST[0] == '"' && osST[osST.size()-1] == '"' )
osST = osST.substr( 1, osST.size() - 2 );
if( (EQUAL(osST,"LSB_INTEGER")) ||
(EQUAL(osST,"LSB")) || // just incase
(EQUAL(osST,"LSB_UNSIGNED_INTEGER")) ||
(EQUAL(osST,"LSB_SIGNED_INTEGER")) ||
(EQUAL(osST,"UNSIGNED_INTEGER")) ||
(EQUAL(osST,"VAX_REAL")) ||
(EQUAL(osST,"VAX_INTEGER")) ||
(EQUAL(osST,"PC_INTEGER")) || //just incase
(EQUAL(osST,"PC_REAL")) ) {
chByteOrder = 'I';
}
/**** Grab format type - pds supports 1,2,4,8,16,32,64 (in theory) **/
/**** I have only seen 8, 16, 32 (float) in released datasets **/
itype = atoi(GetKeyword(osPrefix+"IMAGE.SAMPLE_BITS",""));
switch(itype) {
case 8 :
eDataType = GDT_Byte;
dfNoData = NULL1;
break;
case 16 :
if( strstr(osST,"UNSIGNED") != NULL )
eDataType = GDT_UInt16;
else
eDataType = GDT_Int16;
dfNoData = NULL2;
break;
case 32 :
eDataType = GDT_Float32;
dfNoData = NULL3;
break;
case 64 :
eDataType = GDT_Float64;
dfNoData = NULL3;
break;
default :
CPLError( CE_Failure, CPLE_AppDefined,
"Sample_bits of %d is not supported in this gdal PDS reader.",
itype);
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Is there a specific nodata value in the file? Either the */
/* MISSING or MISSING_CONSTANT keywords are nodata. */
/* -------------------------------------------------------------------- */
if( GetKeyword( osPrefix+"IMAGE.MISSING", NULL ) != NULL )
dfNoData = CPLAtofM( GetKeyword( osPrefix+"IMAGE.MISSING", "" ) );
if( GetKeyword( osPrefix+"IMAGE.MISSING_CONSTANT", NULL ) != NULL )
dfNoData = CPLAtofM( GetKeyword( osPrefix+"IMAGE.MISSING_CONSTANT",""));
/* -------------------------------------------------------------------- */
/* Did we get the required keywords? If not we return with */
/* this never having been considered to be a match. This isn't */
/* an error! */
/* -------------------------------------------------------------------- */
if( nRows < 1 || nCols < 1 || nBands < 1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"File %s appears to be a PDS file, but failed to find some required keywords.",
GetDescription() );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
nRasterXSize = nCols;
nRasterYSize = nRows;
/* -------------------------------------------------------------------- */
/* Open target binary file. */
/* -------------------------------------------------------------------- */
if( eAccess == GA_ReadOnly )
{
fpImage = VSIFOpenL( osTargetFile, "rb" );
if( fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s.\n%s",
osTargetFile.c_str(),
VSIStrerror( errno ) );
return FALSE;
}
}
else
{
fpImage = VSIFOpenL( osTargetFile, "r+b" );
if( fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s with write permission.\n%s",
osTargetFile.c_str(),
VSIStrerror( errno ) );
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Compute the line offset. */
/* -------------------------------------------------------------------- */
int nItemSize = GDALGetDataTypeSize(eDataType)/8;
int nLineOffset = record_bytes;
int nPixelOffset, nBandOffset;
if( EQUAL(szLayout,"BIP") )
{
nPixelOffset = nItemSize * nBands;
nBandOffset = nItemSize;
nLineOffset = ((nPixelOffset * nCols + record_bytes - 1)/record_bytes)
* record_bytes;
}
else if( EQUAL(szLayout,"BSQ") )
{
nPixelOffset = nItemSize;
nLineOffset = ((nPixelOffset * nCols + record_bytes - 1)/record_bytes)
* record_bytes;
nBandOffset = nLineOffset * nRows;
}
else /* assume BIL */
{
nPixelOffset = nItemSize;
nBandOffset = nItemSize * nCols;
nLineOffset = ((nBandOffset * nCols + record_bytes - 1)/record_bytes)
* record_bytes;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
int i;
for( i = 0; i < nBands; i++ )
{
RawRasterBand *poBand;
poBand =
new RawRasterBand( this, i+1, fpImage,
nSkipBytes + nBandOffset * i,
nPixelOffset, nLineOffset, eDataType,
#ifdef CPL_LSB
chByteOrder == 'I' || chByteOrder == 'L',
#else
chByteOrder == 'M',
#endif
TRUE );
if( nBands == 1 )
{
const char* pszMin = GetKeyword(osPrefix+"IMAGE.MINIMUM", NULL);
const char* pszMax = GetKeyword(osPrefix+"IMAGE.MAXIMUM", NULL);
const char* pszMean = GetKeyword(osPrefix+"IMAGE.MEAN", NULL);
const char* pszStdDev= GetKeyword(osPrefix+"IMAGE.STANDARD_DEVIATION", NULL);
if (pszMin != NULL && pszMax != NULL &&
pszMean != NULL && pszStdDev != NULL)
{
poBand->SetStatistics( CPLAtofM(pszMin),
CPLAtofM(pszMax),
CPLAtofM(pszMean),
CPLAtofM(pszStdDev));
}
}
poBand->SetNoDataValue( dfNoData );
SetBand( i+1, poBand );
// Set offset/scale values at the PAM level.
poBand->SetOffset(
CPLAtofM(GetKeyword(osPrefix+"IMAGE.OFFSET","0.0")));
poBand->SetScale(
CPLAtofM(GetKeyword(osPrefix+"IMAGE.SCALING_FACTOR","1.0")));
}
return TRUE;
}
/*
* Init()
*/
bool OGRNGWDataset::Init(int nOpenFlagsIn)
{
// NOTE: Skip check API version at that moment. We expected API v3.
// Get resource details.
CPLJSONDocument oResourceDetailsReq;
char **papszHTTPOptions = GetHeaders();
bool bResult = oResourceDetailsReq.LoadUrl( NGWAPI::GetResource( osUrl,
osResourceId ), papszHTTPOptions );
CPLDebug("NGW", "Get resource %s details %s", osResourceId.c_str(),
bResult ? "success" : "failed");
if( bResult )
{
CPLJSONObject oRoot = oResourceDetailsReq.GetRoot();
if( oRoot.IsValid() )
{
std::string osResourceType = oRoot.GetString("resource/cls");
FillMetadata( oRoot );
if( osResourceType == "resource_group" )
{
// Check feature paging.
FillCapabilities( papszHTTPOptions );
if( oRoot.GetBool( "resource/children", false ) ) {
// Get child resources.
bResult = FillResources( papszHTTPOptions, nOpenFlagsIn );
}
}
else if( (osResourceType == "vector_layer" ||
osResourceType == "postgis_layer") )
{
// Cehck feature paging.
FillCapabilities( papszHTTPOptions );
// Add vector layer.
AddLayer( oRoot, papszHTTPOptions, nOpenFlagsIn );
}
else if( osResourceType == "mapserver_style" ||
osResourceType == "qgis_vector_style" ||
osResourceType == "raster_style" ||
osResourceType == "wmsclient_layer" )
{
// GetExtent from parent.
OGREnvelope stExtent;
std::string osParentId = oRoot.GetString("resource/parent/id");
bool bExtentResult = NGWAPI::GetExtent(osUrl, osParentId,
papszHTTPOptions, 3857, stExtent);
if( !bExtentResult )
{
// Set full extent for EPSG:3857.
stExtent.MinX = -20037508.34;
stExtent.MaxX = 20037508.34;
stExtent.MinY = -20037508.34;
stExtent.MaxY = 20037508.34;
}
CPLDebug("NGW", "Raster extent is: %f, %f, %f, %f",
stExtent.MinX, stExtent.MinY,
stExtent.MaxX, stExtent.MaxY);
int nEPSG = 3857;
// Get parent details. We can skip this as default SRS in NGW is 3857.
if( osResourceType == "wmsclient_layer" )
{
nEPSG = oRoot.GetInteger("wmsclient_layer/srs/id", nEPSG);
}
else
{
CPLJSONDocument oResourceReq;
bResult = oResourceReq.LoadUrl( NGWAPI::GetResource( osUrl,
osResourceId ), papszHTTPOptions );
if( bResult )
{
CPLJSONObject oParentRoot = oResourceReq.GetRoot();
if( osResourceType == "mapserver_style" ||
osResourceType == "qgis_vector_style" )
{
nEPSG = oParentRoot.GetInteger("vector_layer/srs/id", nEPSG);
}
else if( osResourceType == "raster_style")
{
nEPSG = oParentRoot.GetInteger("raster_layer/srs/id", nEPSG);
}
}
}
// Create raster dataset.
std::string osRasterUrl = NGWAPI::GetTMS(osUrl, osResourceId);
char* pszRasterUrl = CPLEscapeString(osRasterUrl.c_str(), -1, CPLES_XML);
const char *pszConnStr = CPLSPrintf("<GDAL_WMS><Service name=\"TMS\">"
"<ServerUrl>%s</ServerUrl></Service><DataWindow>"
"<UpperLeftX>-20037508.34</UpperLeftX><UpperLeftY>20037508.34</UpperLeftY>"
"<LowerRightX>20037508.34</LowerRightX><LowerRightY>-20037508.34</LowerRightY>"
"<TileLevel>%d</TileLevel><TileCountX>1</TileCountX>"
"<TileCountY>1</TileCountY><YOrigin>top</YOrigin></DataWindow>"
"<Projection>EPSG:%d</Projection><BlockSizeX>256</BlockSizeX>"
"<BlockSizeY>256</BlockSizeY><BandsCount>%d</BandsCount>"
"<Cache><Type>file</Type><Expires>%d</Expires><MaxSize>%d</MaxSize>"
"</Cache><ZeroBlockHttpCodes>204,404</ZeroBlockHttpCodes></GDAL_WMS>",
pszRasterUrl,
22, // NOTE: We have no limit in zoom levels.
nEPSG, // NOTE: Default SRS is EPSG:3857.
4,
nCacheExpires,
nCacheMaxSize);
CPLFree( pszRasterUrl );
poRasterDS = reinterpret_cast<GDALDataset*>(GDALOpenEx(pszConnStr,
GDAL_OF_READONLY | GDAL_OF_RASTER | GDAL_OF_INTERNAL, nullptr,
nullptr, nullptr));
if( poRasterDS )
{
bResult = true;
nRasterXSize = poRasterDS->GetRasterXSize();
nRasterYSize = poRasterDS->GetRasterYSize();
for( int iBand = 1; iBand <= poRasterDS->GetRasterCount();
iBand++ )
{
SetBand( iBand, new NGWWrapperRasterBand(
poRasterDS->GetRasterBand( iBand )) );
}
// Set pixel limits.
bool bHasTransform = false;
double geoTransform[6] = { 0.0 };
double invGeoTransform[6] = { 0.0 };
if(poRasterDS->GetGeoTransform(geoTransform) == CE_None)
{
bHasTransform = GDALInvGeoTransform(geoTransform,
invGeoTransform) == TRUE;
}
if(bHasTransform)
{
GDALApplyGeoTransform(invGeoTransform, stExtent.MinX,
stExtent.MinY, &stPixelExtent.MinX, &stPixelExtent.MaxY);
GDALApplyGeoTransform(invGeoTransform, stExtent.MaxX,
stExtent.MaxY, &stPixelExtent.MaxX, &stPixelExtent.MinY);
CPLDebug("NGW", "Raster extent in px is: %f, %f, %f, %f",
stPixelExtent.MinX, stPixelExtent.MinY,
stPixelExtent.MaxX, stPixelExtent.MaxY);
}
else
{
stPixelExtent.MinX = 0.0;
stPixelExtent.MinY = 0.0;
stPixelExtent.MaxX = std::numeric_limits<double>::max();
stPixelExtent.MaxY = std::numeric_limits<double>::max();
}
}
else
{
bResult = false;
}
}
else if( osResourceType == "raster_layer" ) //FIXME: Do we need this check? && nOpenFlagsIn & GDAL_OF_RASTER )
{
AddRaster( oRoot, papszHTTPOptions );
}
else
{
bResult = false;
}
// TODO: Add support for baselayers, webmap, wfsserver_service, wmsserver_service.
}
}
CSLDestroy( papszHTTPOptions );
return bResult;
}
CPLErr MEMDataset::AddBand( GDALDataType eType, char **papszOptions )
{
const int nBandId = GetRasterCount() + 1;
const GSpacing nPixelSize = GDALGetDataTypeSizeBytes(eType);
/* -------------------------------------------------------------------- */
/* Do we need to allocate the memory ourselves? This is the */
/* simple case. */
/* -------------------------------------------------------------------- */
if( CSLFetchNameValue( papszOptions, "DATAPOINTER" ) == NULL )
{
const GSpacing nTmp = nPixelSize * GetRasterXSize();
GByte *pData = NULL;
#if SIZEOF_VOIDP == 4
if( nTmp > INT_MAX )
pData = NULL;
else
#endif
pData = reinterpret_cast<GByte *>(
VSI_CALLOC_VERBOSE((size_t)nTmp, GetRasterYSize() ) );
if( pData == NULL )
{
return CE_Failure;
}
SetBand( nBandId,
new MEMRasterBand( this, nBandId, pData, eType, nPixelSize,
nPixelSize * GetRasterXSize(), TRUE ) );
return CE_None;
}
/* -------------------------------------------------------------------- */
/* Get layout of memory and other flags. */
/* -------------------------------------------------------------------- */
const char *pszDataPointer = CSLFetchNameValue(papszOptions, "DATAPOINTER");
GByte *pData = reinterpret_cast<GByte *>(
CPLScanPointer( pszDataPointer,
static_cast<int>(strlen(pszDataPointer)) ) );
const char *pszOption = CSLFetchNameValue(papszOptions, "PIXELOFFSET");
GSpacing nPixelOffset;
if( pszOption == NULL )
nPixelOffset = nPixelSize;
else
nPixelOffset = CPLAtoGIntBig(pszOption);
pszOption = CSLFetchNameValue(papszOptions, "LINEOFFSET");
GSpacing nLineOffset;
if( pszOption == NULL )
nLineOffset = GetRasterXSize() * static_cast<size_t>( nPixelOffset );
else
nLineOffset = CPLAtoGIntBig(pszOption);
SetBand( nBandId,
new MEMRasterBand( this, nBandId, pData, eType,
nPixelOffset, nLineOffset, FALSE ) );
return CE_None;
}