void DicomInstanceToStore::ComputeMissingInformation()
{
if (buffer_.HasContent() &&
summary_.HasContent() &&
json_.HasContent())
{
// Fine, everything is available
return;
}
if (!buffer_.HasContent())
{
if (!parsed_.HasContent())
{
throw OrthancException(ErrorCode_NotImplemented);
}
else
{
// Serialize the parsed DICOM file
buffer_.Allocate();
if (!FromDcmtkBridge::SaveToMemoryBuffer(buffer_.GetContent(), GetDataset(parsed_.GetContent())))
{
LOG(ERROR) << "Unable to serialize a DICOM file to a memory buffer";
throw OrthancException(ErrorCode_InternalError);
}
}
}
if (summary_.HasContent() &&
json_.HasContent())
{
return;
}
// At this point, we know that the DICOM file is available as a
// memory buffer, but that its summary or its JSON version is
// missing
if (!parsed_.HasContent())
{
parsed_.TakeOwnership(new ParsedDicomFile(buffer_.GetConstContent()));
}
// At this point, we have parsed the DICOM file
if (!summary_.HasContent())
{
summary_.Allocate();
FromDcmtkBridge::Convert(summary_.GetContent(), GetDataset(parsed_.GetContent()));
}
if (!json_.HasContent())
{
json_.Allocate();
FromDcmtkBridge::ToJson(json_.GetContent(), GetDataset(parsed_.GetContent()));
}
}
void GDALPamRasterBand::PamInitialize()
{
if( psPam )
return;
GDALPamDataset *poParentDS = (GDALPamDataset *) GetDataset();
if( poParentDS == NULL || !(poParentDS->GetMOFlags() & GMO_PAM_CLASS) )
return;
poParentDS->PamInitialize();
if( poParentDS->psPam == NULL )
return;
// Often (always?) initializing our parent will have initialized us.
if( psPam != NULL )
return;
psPam = (GDALRasterBandPamInfo *)
CPLCalloc(sizeof(GDALRasterBandPamInfo),1);
psPam->dfScale = 1.0;
psPam->poParentDS = poParentDS;
psPam->dfNoDataValue = -1e10;
psPam->poDefaultRAT = NULL;
}
void XYPlot::DrawDatasets(wxDC &dc, wxRect rc)
{
for (size_t nData = 0; nData < GetDatasetCount(); nData++) {
XYDataset *dataset = (XYDataset *) GetDataset(nData);
DrawXYDataset(dc, rc, dataset);
}
}
void BarPlot::DrawDatasets(wxDC &dc, wxRect rc)
{
for (size_t nData = 0; nData < GetDatasetCount(); nData++) {
CategoryDataset *dataset = (CategoryDataset *) GetDataset(nData);
BarRenderer *renderer = dataset->GetRenderer();
wxCHECK_RET(renderer != NULL, wxT("no renderer for data"));
Axis *vertAxis = GetDatasetVerticalAxis(dataset);
Axis *horizAxis = GetDatasetHorizontalAxis(dataset);
wxCHECK_RET(vertAxis != NULL, wxT("no axis for data"));
wxCHECK_RET(horizAxis != NULL, wxT("no axis for data"));
bool verticalBars;
if (wxDynamicCast(horizAxis, CategoryAxis) != NULL ||
wxDynamicCast(horizAxis, DateAxis) != NULL) {
verticalBars = true;
}
else if (wxDynamicCast(vertAxis, CategoryAxis) != NULL ||
wxDynamicCast(vertAxis, DateAxis) != NULL) {
verticalBars = false;
}
else {
// wrong plot configuration, TODO be handled not here
return ;
}
renderer->Draw(dc, rc, horizAxis, vertAxis, verticalBars, dataset);
}
}
void wxGxPostGISFeatureDatasetUI::EditProperties(wxWindow *parent)
{
wxPropertySheetDialog PropertySheetDialog;
if (!PropertySheetDialog.Create(parent, wxID_ANY, _("Properties"), wxDefaultPosition, wxSize( 480,640 ), wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER))
return;
PropertySheetDialog.SetIcon(properties_xpm);
PropertySheetDialog.CreateButtons(wxOK);
wxWindow* pParentWnd = static_cast<wxWindow*>(PropertySheetDialog.GetBookCtrl());
wxGISVectorPropertyPage* VectorPropertyPage = new wxGISVectorPropertyPage(this, pParentWnd);
PropertySheetDialog.GetBookCtrl()->AddPage(VectorPropertyPage, VectorPropertyPage->GetPageName());
wxGISDataset* pDset = GetDataset();
if(pDset)
{
wxGISSpatialReferencePropertyPage* SpatialReferencePropertyPage = new wxGISSpatialReferencePropertyPage(pDset->GetSpatialReference(), pParentWnd);
PropertySheetDialog.GetBookCtrl()->AddPage(SpatialReferencePropertyPage, SpatialReferencePropertyPage->GetPageName());
wsDELETE(pDset);
}
//PropertySheetDialog.LayoutDialog();
PropertySheetDialog.SetSize(480,640);
PropertySheetDialog.Center();
PropertySheetDialog.ShowModal();
}
wxThread::ExitCode wxGxMLDatasetUI::Entry()
{
//ITrackCancel trackcancel;
wxGISDataset* pDSet = GetDataset(false);
wxGxCatalogUI* pCat = wxDynamicCast(GetGxCatalog(), wxGxCatalogUI);
if(pDSet)
{
for(size_t i = 0; i < pDSet->GetSubsetsCount(); ++i)
{
wxGISDataset* pwxGISFeatureSuDataset = m_pwxGISDataset->GetSubset(i);
wxString sSubsetName = pwxGISFeatureSuDataset->GetName();
wxGxMLSubDatasetUI* pGxMLSubDatasetUI = new wxGxMLSubDatasetUI((wxGISEnumVectorDatasetType)GetSubType(), pwxGISFeatureSuDataset, wxStaticCast(this, wxGxObject), sSubsetName, wxGxObjectContainer::GetPath(), m_LargeSubIcon, m_SmallSubIcon);
wxGIS_GXCATALOG_EVENT_ID(ObjectAdded, pGxMLSubDatasetUI->GetId());
}
wsDELETE(pDSet);
}
if(m_nPendUId != wxNOT_FOUND && pCat)
{
pCat->RemovePending(m_nPendUId);
m_nPendUId = wxNOT_FOUND;
}
//wxGIS_GXCATALOG_EVENT(ObjectChanged);
return (wxThread::ExitCode)wxTHREAD_NO_ERROR;
}
void BubblePlot::DrawDatasets(wxDC &dc, wxRect rc)
{
for (size_t nData = 0; nData < GetDatasetCount(); nData++) {
XYZDataset *dataset = (XYZDataset *) GetDataset(nData);
XYZRenderer *renderer = dataset->GetRenderer();
wxCHECK_RET(renderer != NULL, wxT("no renderer for data"));
Axis *vertAxis = GetDatasetVerticalAxis(dataset);
Axis *horizAxis = GetDatasetHorizontalAxis(dataset);
wxCHECK_RET(vertAxis != NULL, wxT("no axis for data"));
wxCHECK_RET(horizAxis != NULL, wxT("no axis for data"));
renderer->Draw(dc, rc, horizAxis, vertAxis, dataset);
}
}
void OHLCPlot::DrawDatasets(wxDC &dc, wxRect rc)
{
for (size_t nData = 0; nData < GetDatasetCount(); nData++) {
Dataset *dataset = GetDataset(nData);
OHLCDataset *ohlcDataset = wxDynamicCast(dataset, OHLCDataset);
if (ohlcDataset != NULL) {
DrawOHLCDataset(dc, rc, ohlcDataset);
}
else {
XYDataset *xyDataset = wxDynamicCast(dataset, XYDataset);
if (xyDataset != NULL) {
DrawXYDataset(dc, rc, xyDataset);
}
}
}
}
bool AxisPlot::ToDataCoords(size_t nData, wxDC &dc, wxRect rc, wxCoord gx, wxCoord gy, double *x, double *y)
{
Dataset *dataset = GetDataset(nData);
wxCHECK_MSG(dataset != NULL, false, wxT("AxisPlot::ToDataCoords: Invalid dataset index"));
Axis *horizAxis = GetDatasetHorizontalAxis(dataset);
Axis *vertAxis = GetDatasetVerticalAxis(dataset);
wxCHECK_MSG(horizAxis != NULL && vertAxis != NULL, false, wxT("AxisPlot::ToDataCoords: dataset not linked with horizontal or vertical axis"));
wxRect rcData;
wxRect rcLegend;
CalcDataArea(dc, rc, rcData, rcLegend);
if (!rcData.Contains(gx, gy)) {
return false;
}
*x = horizAxis->ToData(dc, rcData.x, rcData.width, gx);
*y = vertAxis->ToData(dc, rcData.y, rcData.height, gy);
return true;
}
void GDALPamRasterBand::PamInitialize()
{
if( psPam )
return;
GDALDataset* poNonPamParentDS = GetDataset();
if( poNonPamParentDS == nullptr ||
!(poNonPamParentDS->GetMOFlags() & GMO_PAM_CLASS) )
return;
GDALPamDataset *poParentDS =
dynamic_cast<GDALPamDataset *>( poNonPamParentDS );
if( poParentDS == nullptr ) {
// Should never happen.
CPLAssert(false);
return;
}
poParentDS->PamInitialize();
if( poParentDS->psPam == nullptr )
return;
// Often (always?) initializing our parent will have initialized us.
if( psPam != nullptr )
return;
psPam = static_cast<GDALRasterBandPamInfo *>(
VSI_CALLOC_VERBOSE(sizeof(GDALRasterBandPamInfo), 1) );
if( psPam == nullptr )
return;
psPam->dfScale = 1.0;
psPam->poParentDS = poParentDS;
psPam->dfNoDataValue = -1e10;
psPam->poDefaultRAT = nullptr;
}
const char *VRTSourcedRasterBand::GetMetadataItem( const char * pszName,
const char * pszDomain )
{
/* ==================================================================== */
/* LocationInfo handling. */
/* ==================================================================== */
if( pszDomain != NULL
&& EQUAL(pszDomain,"LocationInfo")
&& (EQUALN(pszName,"Pixel_",6) || EQUALN(pszName,"GeoPixel_",9)) )
{
int iPixel, iLine;
/* -------------------------------------------------------------------- */
/* What pixel are we aiming at? */
/* -------------------------------------------------------------------- */
if( EQUALN(pszName,"Pixel_",6) )
{
if( sscanf( pszName+6, "%d_%d", &iPixel, &iLine ) != 2 )
return NULL;
}
else if( EQUALN(pszName,"GeoPixel_",9) )
{
double adfGeoTransform[6];
double adfInvGeoTransform[6];
double dfGeoX, dfGeoY;
if( sscanf( pszName+9, "%lf_%lf", &dfGeoX, &dfGeoY ) != 2 )
return NULL;
if( GetDataset() == NULL )
return NULL;
if( GetDataset()->GetGeoTransform( adfGeoTransform ) != CE_None )
return NULL;
if( !GDALInvGeoTransform( adfGeoTransform, adfInvGeoTransform ) )
return NULL;
iPixel = (int) floor(
adfInvGeoTransform[0]
+ adfInvGeoTransform[1] * dfGeoX
+ adfInvGeoTransform[2] * dfGeoY );
iLine = (int) floor(
adfInvGeoTransform[3]
+ adfInvGeoTransform[4] * dfGeoX
+ adfInvGeoTransform[5] * dfGeoY );
}
else
return NULL;
if( iPixel < 0 || iLine < 0
|| iPixel >= GetXSize()
|| iLine >= GetYSize() )
return NULL;
/* -------------------------------------------------------------------- */
/* Find the file(s) at this location. */
/* -------------------------------------------------------------------- */
char **papszFileList = NULL;
int nListMaxSize = 0, nListSize = 0;
CPLHashSet* hSetFiles = CPLHashSetNew(CPLHashSetHashStr,
CPLHashSetEqualStr,
NULL);
for( int iSource = 0; iSource < nSources; iSource++ )
{
int nReqXOff, nReqYOff, nReqXSize, nReqYSize;
int nOutXOff, nOutYOff, nOutXSize, nOutYSize;
if (!papoSources[iSource]->IsSimpleSource())
continue;
VRTSimpleSource *poSrc = (VRTSimpleSource *) papoSources[iSource];
if( !poSrc->GetSrcDstWindow( iPixel, iLine, 1, 1, 1, 1,
&nReqXOff, &nReqYOff,
&nReqXSize, &nReqYSize,
&nOutXOff, &nOutYOff,
&nOutXSize, &nOutYSize ) )
continue;
poSrc->GetFileList( &papszFileList, &nListSize, &nListMaxSize,
hSetFiles );
}
/* -------------------------------------------------------------------- */
/* Format into XML. */
/* -------------------------------------------------------------------- */
int i;
osLastLocationInfo = "<LocationInfo>";
for( i = 0; i < nListSize; i++ )
{
osLastLocationInfo += "<File>";
char* pszXMLEscaped = CPLEscapeString(papszFileList[i], -1, CPLES_XML);
osLastLocationInfo += pszXMLEscaped;
CPLFree(pszXMLEscaped);
osLastLocationInfo += "</File>";
}
osLastLocationInfo += "</LocationInfo>";
CSLDestroy( papszFileList );
CPLHashSetDestroy( hSetFiles );
return osLastLocationInfo.c_str();
}
/* ==================================================================== */
/* Other domains. */
/* ==================================================================== */
else
return GDALRasterBand::GetMetadataItem( pszName, pszDomain );
}
CPLErr VRTRasterBand::XMLInit( CPLXMLNode * psTree,
const char *pszVRTPath )
{
/* -------------------------------------------------------------------- */
/* Validate a bit. */
/* -------------------------------------------------------------------- */
if( psTree == NULL || psTree->eType != CXT_Element
|| !EQUAL(psTree->pszValue,"VRTRasterBand") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Invalid node passed to VRTRasterBand::XMLInit()." );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Set the band if provided as an attribute. */
/* -------------------------------------------------------------------- */
const char* pszBand = CPLGetXMLValue( psTree, "band", NULL);
if( pszBand != NULL )
{
nBand = atoi(pszBand);
}
/* -------------------------------------------------------------------- */
/* Set the band if provided as an attribute. */
/* -------------------------------------------------------------------- */
const char *pszDataType = CPLGetXMLValue( psTree, "dataType", NULL);
if( pszDataType != NULL )
{
eDataType = GDALGetDataTypeByName(pszDataType);
}
/* -------------------------------------------------------------------- */
/* Apply any band level metadata. */
/* -------------------------------------------------------------------- */
oMDMD.XMLInit( psTree, TRUE );
/* -------------------------------------------------------------------- */
/* Collect various other items of metadata. */
/* -------------------------------------------------------------------- */
SetDescription( CPLGetXMLValue( psTree, "Description", "" ) );
if( CPLGetXMLValue( psTree, "NoDataValue", NULL ) != NULL )
SetNoDataValue( CPLAtofM(CPLGetXMLValue( psTree, "NoDataValue", "0" )) );
if( CPLGetXMLValue( psTree, "HideNoDataValue", NULL ) != NULL )
bHideNoDataValue = CSLTestBoolean( CPLGetXMLValue( psTree, "HideNoDataValue", "0" ) );
SetUnitType( CPLGetXMLValue( psTree, "UnitType", NULL ) );
SetOffset( atof(CPLGetXMLValue( psTree, "Offset", "0.0" )) );
SetScale( atof(CPLGetXMLValue( psTree, "Scale", "1.0" )) );
if( CPLGetXMLValue( psTree, "ColorInterp", NULL ) != NULL )
{
const char *pszInterp = CPLGetXMLValue( psTree, "ColorInterp", NULL );
SetColorInterpretation(GDALGetColorInterpretationByName(pszInterp));
}
/* -------------------------------------------------------------------- */
/* Category names. */
/* -------------------------------------------------------------------- */
if( CPLGetXMLNode( psTree, "CategoryNames" ) != NULL )
{
CPLXMLNode *psEntry;
CSLDestroy( papszCategoryNames );
papszCategoryNames = NULL;
CPLStringList oCategoryNames;
for( psEntry = CPLGetXMLNode( psTree, "CategoryNames" )->psChild;
psEntry != NULL; psEntry = psEntry->psNext )
{
if( psEntry->eType != CXT_Element
|| !EQUAL(psEntry->pszValue,"Category")
|| (psEntry->psChild != NULL && psEntry->psChild->eType != CXT_Text) )
continue;
oCategoryNames.AddString(
(psEntry->psChild) ? psEntry->psChild->pszValue : "");
}
papszCategoryNames = oCategoryNames.StealList();
}
/* -------------------------------------------------------------------- */
/* Collect a color table. */
/* -------------------------------------------------------------------- */
if( CPLGetXMLNode( psTree, "ColorTable" ) != NULL )
{
CPLXMLNode *psEntry;
GDALColorTable oTable;
int iEntry = 0;
for( psEntry = CPLGetXMLNode( psTree, "ColorTable" )->psChild;
psEntry != NULL; psEntry = psEntry->psNext )
{
GDALColorEntry sCEntry;
sCEntry.c1 = (short) atoi(CPLGetXMLValue( psEntry, "c1", "0" ));
sCEntry.c2 = (short) atoi(CPLGetXMLValue( psEntry, "c2", "0" ));
sCEntry.c3 = (short) atoi(CPLGetXMLValue( psEntry, "c3", "0" ));
sCEntry.c4 = (short) atoi(CPLGetXMLValue( psEntry, "c4", "255" ));
oTable.SetColorEntry( iEntry++, &sCEntry );
}
SetColorTable( &oTable );
}
/* -------------------------------------------------------------------- */
/* Histograms */
/* -------------------------------------------------------------------- */
CPLXMLNode *psHist = CPLGetXMLNode( psTree, "Histograms" );
if( psHist != NULL )
{
CPLXMLNode *psNext = psHist->psNext;
psHist->psNext = NULL;
psSavedHistograms = CPLCloneXMLTree( psHist );
psHist->psNext = psNext;
}
/* ==================================================================== */
/* Overviews */
/* ==================================================================== */
CPLXMLNode *psNode;
for( psNode = psTree->psChild; psNode != NULL; psNode = psNode->psNext )
{
if( psNode->eType != CXT_Element
|| !EQUAL(psNode->pszValue,"Overview") )
continue;
/* -------------------------------------------------------------------- */
/* Prepare filename. */
/* -------------------------------------------------------------------- */
char *pszSrcDSName = NULL;
CPLXMLNode* psFileNameNode=CPLGetXMLNode(psNode,"SourceFilename");
const char *pszFilename =
psFileNameNode ? CPLGetXMLValue(psFileNameNode,NULL, NULL) : NULL;
if( pszFilename == NULL )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Missing <SourceFilename> element in Overview." );
return CE_Failure;
}
if (EQUALN(pszFilename, "MEM:::", 6) && pszVRTPath != NULL &&
!CSLTestBoolean(CPLGetConfigOption("VRT_ALLOW_MEM_DRIVER", "NO")))
{
CPLError( CE_Failure, CPLE_AppDefined,
"<SourceFilename> points to a MEM dataset, which is rather suspect! "
"If you know what you are doing, define the VRT_ALLOW_MEM_DRIVER configuration option to YES" );
return CE_Failure;
}
if( pszVRTPath != NULL
&& atoi(CPLGetXMLValue( psFileNameNode, "relativetoVRT", "0")) )
{
pszSrcDSName = CPLStrdup(
CPLProjectRelativeFilename( pszVRTPath, pszFilename ) );
}
else
pszSrcDSName = CPLStrdup( pszFilename );
/* -------------------------------------------------------------------- */
/* Get the raster band. */
/* -------------------------------------------------------------------- */
int nSrcBand = atoi(CPLGetXMLValue(psNode,"SourceBand","1"));
apoOverviews.resize( apoOverviews.size() + 1 );
apoOverviews[apoOverviews.size()-1].osFilename = pszSrcDSName;
apoOverviews[apoOverviews.size()-1].nBand = nSrcBand;
CPLFree( pszSrcDSName );
}
/* ==================================================================== */
/* Mask band (specific to that raster band) */
/* ==================================================================== */
CPLXMLNode* psMaskBandNode = CPLGetXMLNode(psTree, "MaskBand");
if (psMaskBandNode)
psNode = psMaskBandNode->psChild;
else
psNode = NULL;
for( ; psNode != NULL; psNode = psNode->psNext )
{
if( psNode->eType != CXT_Element
|| !EQUAL(psNode->pszValue,"VRTRasterBand") )
continue;
if( ((VRTDataset*)poDS)->poMaskBand != NULL)
{
CPLError( CE_Warning, CPLE_AppDefined,
"Illegal mask band at raster band level when a dataset mask band already exists." );
break;
}
const char *pszSubclass = CPLGetXMLValue( psNode, "subclass",
"VRTSourcedRasterBand" );
VRTRasterBand *poBand = NULL;
if( EQUAL(pszSubclass,"VRTSourcedRasterBand") )
poBand = new VRTSourcedRasterBand( GetDataset(), 0 );
else if( EQUAL(pszSubclass, "VRTDerivedRasterBand") )
poBand = new VRTDerivedRasterBand( GetDataset(), 0 );
else if( EQUAL(pszSubclass, "VRTRawRasterBand") )
poBand = new VRTRawRasterBand( GetDataset(), 0 );
else if( EQUAL(pszSubclass, "VRTWarpedRasterBand") )
poBand = new VRTWarpedRasterBand( GetDataset(), 0 );
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"VRTRasterBand of unrecognised subclass '%s'.",
pszSubclass );
break;
}
if( poBand->XMLInit( psNode, pszVRTPath ) == CE_None )
{
SetMaskBand(poBand);
}
break;
}
return CE_None;
}
const char *GDALWMSRasterBand::GetMetadataItem( const char * pszName,
const char * pszDomain )
{
/* ==================================================================== */
/* LocationInfo handling. */
/* ==================================================================== */
if( pszDomain != NULL
&& EQUAL(pszDomain,"LocationInfo")
&& (EQUALN(pszName,"Pixel_",6) || EQUALN(pszName,"GeoPixel_",9)) )
{
int iPixel, iLine;
/* -------------------------------------------------------------------- */
/* What pixel are we aiming at? */
/* -------------------------------------------------------------------- */
if( EQUALN(pszName,"Pixel_",6) )
{
if( sscanf( pszName+6, "%d_%d", &iPixel, &iLine ) != 2 )
return NULL;
}
else if( EQUALN(pszName,"GeoPixel_",9) )
{
double adfGeoTransform[6];
double adfInvGeoTransform[6];
double dfGeoX, dfGeoY;
{
CPLLocaleC oLocaleEnforcer;
if( sscanf( pszName+9, "%lf_%lf", &dfGeoX, &dfGeoY ) != 2 )
return NULL;
}
if( GetDataset() == NULL )
return NULL;
if( GetDataset()->GetGeoTransform( adfGeoTransform ) != CE_None )
return NULL;
if( !GDALInvGeoTransform( adfGeoTransform, adfInvGeoTransform ) )
return NULL;
iPixel = (int) floor(
adfInvGeoTransform[0]
+ adfInvGeoTransform[1] * dfGeoX
+ adfInvGeoTransform[2] * dfGeoY );
iLine = (int) floor(
adfInvGeoTransform[3]
+ adfInvGeoTransform[4] * dfGeoX
+ adfInvGeoTransform[5] * dfGeoY );
/* The GetDataset() for the WMS driver is always the main overview level, so rescale */
/* the values if we are an overview */
if (m_overview >= 0)
{
iPixel = (int) (1.0 * iPixel * GetXSize() / GetDataset()->GetRasterBand(1)->GetXSize());
iLine = (int) (1.0 * iLine * GetYSize() / GetDataset()->GetRasterBand(1)->GetYSize());
}
}
else
return NULL;
if( iPixel < 0 || iLine < 0
|| iPixel >= GetXSize()
|| iLine >= GetYSize() )
return NULL;
if (nBand != 1)
{
GDALRasterBand* poFirstBand = m_parent_dataset->GetRasterBand(1);
if (m_overview >= 0)
poFirstBand = poFirstBand->GetOverview(m_overview);
if (poFirstBand)
return poFirstBand->GetMetadataItem(pszName, pszDomain);
}
GDALWMSImageRequestInfo iri;
GDALWMSTiledImageRequestInfo tiri;
int nBlockXOff = iPixel / nBlockXSize;
int nBlockYOff = iLine / nBlockYSize;
ComputeRequestInfo(iri, tiri, nBlockXOff, nBlockYOff);
CPLString url;
m_parent_dataset->m_mini_driver->GetTiledImageInfo(&url,
iri, tiri,
iPixel % nBlockXSize,
iLine % nBlockXSize);
char* pszRes = NULL;
if (url.size() != 0)
{
if (url == osMetadataItemURL)
{
return osMetadataItem.size() != 0 ? osMetadataItem.c_str() : NULL;
}
osMetadataItemURL = url;
char **http_request_opts = BuildHTTPRequestOpts();
CPLHTTPResult* psResult = CPLHTTPFetch( url.c_str(), http_request_opts);
if( psResult && psResult->pabyData )
pszRes = CPLStrdup((const char*) psResult->pabyData);
CPLHTTPDestroyResult(psResult);
CSLDestroy(http_request_opts);
}
if (pszRes)
{
osMetadataItem = "<LocationInfo>";
CPLPushErrorHandler(CPLQuietErrorHandler);
CPLXMLNode* psXML = CPLParseXMLString(pszRes);
CPLPopErrorHandler();
if (psXML != NULL && psXML->eType == CXT_Element)
{
if (strcmp(psXML->pszValue, "?xml") == 0)
{
if (psXML->psNext)
{
char* pszXML = CPLSerializeXMLTree(psXML->psNext);
osMetadataItem += pszXML;
CPLFree(pszXML);
}
}
else
{
osMetadataItem += pszRes;
}
}
else
{
char* pszEscapedXML = CPLEscapeString(pszRes, -1, CPLES_XML_BUT_QUOTES);
osMetadataItem += pszEscapedXML;
CPLFree(pszEscapedXML);
}
if (psXML != NULL)
CPLDestroyXMLNode(psXML);
osMetadataItem += "</LocationInfo>";
CPLFree(pszRes);
return osMetadataItem.c_str();
}
else
{
osMetadataItem = "";
return NULL;
}
}
return GDALPamRasterBand::GetMetadataItem(pszName, pszDomain);
}
//----------------------------------------
CDataset* CDatasetTreeCtrl::GetCurrentDataset()
{
wxTreeItemId id = GetSelection();
return GetDataset(id);
}