void OGR::writeDensity(hexer::HexGrid *grid)
{
int counter(0);
for (hexer::HexIter iter = grid->hexBegin(); iter != grid->hexEnd(); ++iter)
{
hexer::HexInfo hi = *iter;
OGRGeometryH polygon = collectHexagon(hi, grid);
OGRFeatureH hFeature;
hFeature = OGR_F_Create(OGR_L_GetLayerDefn(m_layer));
OGR_F_SetFieldInteger( hFeature, OGR_F_GetFieldIndex(hFeature, "ID"),
counter);
OGR_F_SetFieldInteger( hFeature, OGR_F_GetFieldIndex(hFeature, "COUNT"),
hi.m_density);
OGR_F_SetGeometry(hFeature, polygon);
OGR_G_DestroyGeometry(polygon);
if( OGR_L_CreateFeature( m_layer, hFeature ) != OGRERR_NONE )
{
std::ostringstream oss;
oss << "Unable to create feature for multipolygon with error '"
<< CPLGetLastErrorMsg() << "'";
throw pdal::pdal_error(oss.str());
}
OGR_F_Destroy( hFeature );
counter++;
}
}
void OGR::collectPath(hexer::Path* path, OGRGeometryH polygon)
{
OGRGeometryH ring = OGR_G_CreateGeometry(wkbLinearRing);
vector<hexer::Point> pts = path->points();
vector<hexer::Point>::const_iterator i;
for (i = pts.begin(); i != pts.end(); ++i)
{
OGR_G_AddPoint_2D(ring, i->m_x, i->m_y);
}
if( OGR_G_AddGeometryDirectly(polygon, ring) != OGRERR_NONE )
{
std::ostringstream oss;
oss << "Unable to add geometry with error '" <<
CPLGetLastErrorMsg() << "'";
throw pdal::pdal_error(oss.str());
}
vector<hexer::Path *> paths = path->subPaths();
for (vector<hexer::Path*>::size_type pi = 0; pi != paths.size(); ++pi)
{
hexer::Path* p = paths[pi];
collectPath(p, polygon);
}
}
bool wxGxOpenFileGDB::Rename(const wxString &sNewName)
{
wxGISDataset* pDSet = GetDatasetFast();
if (NULL != pDSet)
{
pDSet->Close();
wsDELETE(pDSet);
}
wxFileName PathName(wxString(m_sPath, wxConvUTF8));
PathName.SetName(ClearExt(sNewName));
wxString sNewPath = PathName.GetFullPath();
CPLString szNewPath(sNewPath.mb_str(wxConvUTF8));
if (RenameFile(m_sPath, szNewPath))
{
if (m_bIsChildrenLoaded)
Refresh();
return true;
}
else
{
const char* err = CPLGetLastErrorMsg();
wxLogError(_("Operation '%s' failed! GDAL error: %s, file '%s'"), _("Rename"), wxString(err, wxConvUTF8).c_str(), wxString(m_sPath, wxConvUTF8).c_str());
return false;
}
return false;
}
// Add a bit of debugging information to the error.
int
simplet_set_error(simplet_errorable_t *error, simplet_status_t status, const char *msg){
int res = 1;
switch(status){
case SIMPLET_ERR:
error->status = SIMPLET_ERR;
res = asprintf(&error->error_msg, "simple tiles error: %s", msg);
break;
case SIMPLET_OOM:
error->status = SIMPLET_OOM;
res = asprintf(&error->error_msg, "out of memory for allocation, %s", msg);
break;
case SIMPLET_CAIRO_ERR:
error->status = SIMPLET_CAIRO_ERR;
res = asprintf(&error->error_msg, "cairo error: %s", msg);
break;
case SIMPLET_OGR_ERR:
error->status = SIMPLET_OGR_ERR;
res = asprintf(&error->error_msg, "OGR error: %s, %s", CPLGetLastErrorMsg(), msg);
break;
case SIMPLET_OK:
error->status = SIMPLET_OK;
res = asprintf(&error->error_msg, "%s", msg);
}
return res;
}
void SpatialReference::setFromUserInput(std::string const& v)
{
if (v.empty())
{
m_wkt.clear();
return;
}
OGRSpatialReference srs(NULL);
CPLErrorReset();
const char* input = v.c_str();
OGRErr err = srs.SetFromUserInput(const_cast<char *>(input));
if (err != OGRERR_NONE)
{
std::ostringstream oss;
std::string msg = CPLGetLastErrorMsg();
if (msg.empty())
msg = "(unknown reason)";
oss << "Could not import coordinate system '" << input << "': " <<
msg << ".";
throw pdal_error(oss.str());
}
char *poWKT = 0;
srs.exportToWkt(&poWKT);
std::string tmp(poWKT);
CPLFree(poWKT);
setWKT(tmp);
}
bool wxGxOpenFileGDB::Move(const CPLString &szDestPath, ITrackCancel* const pTrackCancel)
{
wxGISDataset* pDSet = GetDatasetFast();
if (NULL != pDSet)
{
pDSet->Close();
wsDELETE(pDSet);
}
if (pTrackCancel)
pTrackCancel->PutMessage(wxString::Format(_("%s %s %s"), _("Move"), GetCategory().c_str(), m_sName.c_str()), wxNOT_FOUND, enumGISMessageInfo);
//CPLString szFullDestPath = CPLFormFilename(szDestPath, CPLGetFilename(m_sPath), NULL);
CPLString szFullDestPath = CheckUniqPath(szDestPath, CPLGetFilename(m_sPath), true, " ");
bool bRet = MoveDir(m_sPath, szFullDestPath, 777, pTrackCancel);
if (!bRet)
{
const char* err = CPLGetLastErrorMsg();
wxString sErr = wxString::Format(_("Operation '%s' failed! GDAL error: %s, %s '%s'"), _("Move"), GetCategory().c_str(), wxString(err, wxConvUTF8).c_str(), wxString(m_sPath, wxConvUTF8).c_str());
wxLogError(sErr);
if (pTrackCancel)
pTrackCancel->PutMessage(sErr, wxNOT_FOUND, enumGISMessageErr);
return false;
}
return true;
}
shared_ptr<OGRDataSource> OgrUtilities::createDataSource(QString url)
{
const char* driverName = NULL;
int i = 0;
while (extensions[i][0] != NULL)
{
if (url.endsWith(extensions[i][0]))
{
driverName = extensions[i][1];
}
i++;
}
i = 0;
while (beginName[i][0] != NULL)
{
if (url.startsWith(beginName[i][0]))
{
driverName = beginName[i][1];
}
i++;
}
if (driverName == NULL)
{
throw HootException("No driver found for: " + url);
}
OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driverName);
if (driver == 0)
{
throw HootException("Error getting driver by name: " + QString(driverName));
}
// if the user specifies a shapefile then crop off the .shp and create a directory.
if (url.toLower().endsWith(".shp"))
{
url = url.mid(0, url.length() - 4);
}
shared_ptr<OGRDataSource> result(driver->CreateDataSource(url.toAscii()));
if (result == NULL)
{
throw HootException("Unable to create data source: " + url +
" (" + QString(CPLGetLastErrorMsg()) + ")");
}
result->SetDriver(driver);
if (QString(driverName) == "FileGDB")
{
long v = GDAL_VERSION_MAJOR * 1000000 + GDAL_VERSION_MINOR * 1000 + GDAL_VERSION_REV;
long lowest = 1 * 1000000 + 10 * 1000 + 1;
if (v < lowest)
{
LOG_WARN("Writing to FileGDB with GDAL v" << GDAL_RELEASE_NAME << ". FileGDB with a GDAL "
"v1.9.0 is known to create files that can't be read by ArcMap 10.2. "
"GDAL v1.10.1 is known to work.");
}
}
return result;
}
OGRGeometryH OGR::collectHexagon(hexer::HexInfo const& info, hexer::HexGrid const* grid)
{
OGRGeometryH ring = OGR_G_CreateGeometry(wkbLinearRing);
hexer::Point pos = info.m_center;
pos += grid->origin();
OGR_G_AddPoint_2D(ring, pos.m_x, pos.m_y);
for (int i = 1; i <= 5; ++i)
{
hexer::Point p = pos + grid->offset(i);
OGR_G_AddPoint_2D(ring, p.m_x, p.m_y);
}
OGR_G_AddPoint_2D(ring, pos.m_x, pos.m_y);
OGRGeometryH polygon = OGR_G_CreateGeometry(wkbPolygon);
if( OGR_G_AddGeometryDirectly(polygon, ring ) != OGRERR_NONE )
{
std::ostringstream oss;
oss << "Unable to add ring to polygon in collectHexagon '"
<< CPLGetLastErrorMsg() << "'";
throw pdal::pdal_error(oss.str());
}
return polygon;
}
CPLXMLNode *WCTSCollectRequest()
{
if( getenv("REQUEST_METHOD") == NULL )
WCTSEmitServiceException( "REQUEST_METHOD not set." );
if( EQUAL(getenv("REQUEST_METHOD"),"GET") )
return WCTSCollectKVPRequest();
/* -------------------------------------------------------------------- */
/* Read the body of the POST message into a buffer. */
/* -------------------------------------------------------------------- */
int nContentLength = 0;
char *pszXML = NULL;
if( getenv("CONTENT_LENGTH") != NULL )
{
nContentLength = atoi(getenv("CONTENT_LENGTH"));
pszXML = (char *) CPLMalloc(nContentLength+1);
if( (int) fread(pszXML, 1, nContentLength, stdin) < nContentLength )
WCTSEmitServiceException( "POST body is short." );
pszXML[nContentLength] = '\0';
}
else
{
int nXMLMax, nXMLLen=0;
nXMLMax = 100;
pszXML = (char *) CPLMalloc(nXMLMax);
while( !feof(stdin) )
{
pszXML[nXMLLen++] = fgetc(stdin);
if( nXMLLen == nXMLMax )
{
nXMLMax = nXMLMax * 2;
pszXML = (char *) CPLRealloc(pszXML, nXMLMax);
}
}
pszXML[nXMLLen] = '\0';
}
/* -------------------------------------------------------------------- */
/* Convert into an XML document. */
/* -------------------------------------------------------------------- */
CPLErrorReset();
CPLXMLNode *psTree = CPLParseXMLString( pszXML );
CPLFree( pszXML );
if( CPLGetLastErrorType() == CE_Failure )
WCTSEmitServiceException( CPLGetLastErrorMsg() );
return psTree;
}
/*
* Initializes the object, assuming that filename, origin, size, etc are already set on the
* member variables. Makes sure the raster can be opened, sets the block size, NODATA value,
* pixel size, and the extent of the raster. If not using the full image then makes sure that
* the subset chosen (based on origin and size) is valid. If using the full image then sets the
* size and origin is assumed to be 0,0 and is set in the constructor.
* @param fullImage True if using the full image, False if using a subset.
*/
void Raster::Init(bool bFullImage)
{
Init();
GDALDataset * ds = (GDALDataset*) GDALOpen(m_sFilePath, GA_ReadOnly);
if (ds == NULL)
throw RasterManagerException(INPUT_FILE_NOT_VALID, CPLGetLastErrorMsg());
GDALRasterBand * band = ds->GetRasterBand(1);
double dRMin, dRMax, dRMean, dRStdDev;
// Get some easy stats that GDAL gives us
band->GetStatistics( 0 , true, &dRMin, &dRMax, &dRMean, &dRStdDev );
m_dRasterMax = dRMax;
m_dRasterMin = dRMin;
m_dRasterMean = dRMean;
m_dRasterStdDev = dRStdDev;
OGRLinearRing ring = OGRLinearRing();
if (bFullImage)
{
SetCols( band->GetXSize() );
SetRows( band->GetYSize() );
ring.addPoint(GetLeft(), GetTop());
ring.addPoint(GetLeft(), GetTop() + (GetCellHeight() * GetRows()));
ring.addPoint(GetLeft() + (GetCellWidth() * GetCols()), GetTop() + (GetCellHeight() * GetRows()));
ring.addPoint(GetLeft() + (GetCellWidth() * GetCols()), GetTop());
ring.closeRings();
}
else
{
if ((GetLeft() + GetCols() > band->GetXSize()) || (GetTop() + GetRows() > band->GetYSize()))
{
QString sErr = QString("Invalid origin ( %1, %2 ) and size ( %5, %6 ) for file: %7")
.arg(GetLeft())
.arg(GetTop())
.arg(GetCols())
.arg(GetRows())
.arg(FilePath());
throw RasterManagerException(INPUT_FILE_NOT_VALID, sErr);
}
double xMapOrigin = GetLeft() + (GetLeft() * GetCellWidth());
double yMapOrigin = GetTop() + (GetTop() * GetCellHeight());
ring.addPoint(xMapOrigin, yMapOrigin);
ring.addPoint(xMapOrigin, yMapOrigin + (GetCellHeight() * GetRows()));
ring.addPoint(xMapOrigin + (GetCellWidth() * GetCols()), yMapOrigin + (GetCellHeight() * GetRows()));
ring.addPoint(xMapOrigin + (GetCellWidth() * GetCols()), yMapOrigin);
ring.closeRings();
}
GDALClose(ds);
}
void ReprojectionFilter::transform(double& x, double& y, double& z)
{
int ret = OCTTransform(m_transform_ptr, 1, &x, &y, &z);
if (ret == 0)
{
std::ostringstream msg;
msg << "Could not project point for ReprojectionTransform::" <<
CPLGetLastErrorMsg() << ret;
throw pdal_error(msg.str());
}
}
bool wxGxFile::Delete(void)
{
if(DeleteFile(m_sPath))
{
return true;
}
else
{
const char* err = CPLGetLastErrorMsg();
wxLogError(_("Operation '%s' failed! GDAL error: %s, file '%s'"), _("Delete"), wxString(err, wxConvUTF8).c_str(), wxString(m_sPath, wxConvUTF8).c_str());
return false;
}
}
SEXP
RGDAL_OpenDataset(SEXP filename, SEXP read_only, SEXP silent) {
const char *fn = asString(filename);
GDALAccess RWFlag;
if (asLogical(read_only))
RWFlag = GA_ReadOnly;
else
RWFlag = GA_Update;
/* Modification suggested by Even Rouault, 2009-08-08: */
CPLErrorReset();
if (asLogical(silent))
CPLPushErrorHandler(CPLQuietErrorHandler);
else
installErrorHandler();
GDALDataset *pDataset = (GDALDataset *) GDALOpen(fn, RWFlag);
if (pDataset == NULL)
error("%s\n", CPLGetLastErrorMsg());
if (asLogical(silent))
CPLPopErrorHandler();
else
uninstallErrorHandlerAndTriggerError();
/* Similarly to SWIG bindings, the following lines will cause
RGDAL_OpenDataset() to fail on - uncleared - errors even if pDataset is not
NULL. They could also be just removed. While pDataset != NULL, there's some
hope ;-) */
/* CPLErr eclass = CPLGetLastErrorType();
if (pDataset != NULL && eclass == CE_Failure) {
GDALClose(pDataset);
pDataset = NULL;
__errorHandler(eclass, CPLGetLastErrorNo(), CPLGetLastErrorMsg());
}*/
SEXP sxpHandle = R_MakeExternalPtr((void *) pDataset,
mkChar("GDAL Dataset"),
R_NilValue);
return(sxpHandle);
}
void GeoRasterValue::tryToOpenSource()
{
// GDALOpenShared to allow copy then close of this raster in virtual format (see http://www.gdal.org/gdal_vrttut.html)
mp_Data = static_cast<GDALDataset*>(GDALOpenShared(m_AbsolutePath.c_str(),
GA_ReadOnly));
if (!mp_Data)
{
throw openfluid::base::FrameworkException(OPENFLUID_CODE_LOCATION,
"Error while trying to open file " + m_AbsolutePath +
" (" + CPLGetLastErrorMsg() + ")");
}
}
void MapReprojector::reproject(const shared_ptr<Geometry>& g,
const shared_ptr<OGRSpatialReference>& srs1, const shared_ptr<OGRSpatialReference>& srs2)
{
OGRCoordinateTransformation* t(OGRCreateCoordinateTransformation(srs1.get(), srs2.get()));
if (t == 0)
{
throw HootException(QString("Error creating transformation object: ") + CPLGetLastErrorMsg());
}
ReprojectCoordinateFilter filter(t);
g->apply_rw(&filter);
OGRCoordinateTransformation::DestroyCT(t);
}
void debug_print_last_error()
{
if (! is_valid_)
{
const std::string err = CPLGetLastErrorMsg();
if (err.size() == 0)
{
MAPNIK_LOG_DEBUG(ogr) << "ogr_layer_ptr: Error getting layer";
}
else
{
MAPNIK_LOG_DEBUG(ogr) << "ogr_layer_ptr: " << err;
}
}
}
void OGR::writeBoundary(hexer::HexGrid *grid)
{
OGRGeometryH multi = OGR_G_CreateGeometry(wkbMultiPolygon);
const std::vector<hexer::Path *>& paths = grid->rootPaths();
for (auto pi = paths.begin(); pi != paths.end(); ++pi)
{
OGRGeometryH polygon = OGR_G_CreateGeometry(wkbPolygon);
collectPath(*pi, polygon);
if( OGR_G_AddGeometryDirectly(multi, polygon ) != OGRERR_NONE )
{
std::ostringstream oss;
oss << "Unable to add polygon to multipolygon with error '"
<< CPLGetLastErrorMsg() << "'";
throw pdal::pdal_error(oss.str());
}
}
OGRFeatureH hFeature;
hFeature = OGR_F_Create(OGR_L_GetLayerDefn(m_layer));
OGR_F_SetFieldInteger( hFeature, OGR_F_GetFieldIndex(hFeature, "ID"), 0);
OGR_F_SetGeometry(hFeature, multi);
OGR_G_DestroyGeometry(multi);
if( OGR_L_CreateFeature( m_layer, hFeature ) != OGRERR_NONE )
{
std::ostringstream oss;
oss << "Unable to create feature for multipolygon with error '"
<< CPLGetLastErrorMsg() << "'";
throw pdal::pdal_error(oss.str());
}
OGR_F_Destroy( hFeature );
}
void MapReprojector::reproject(shared_ptr<OsmMap> map,
shared_ptr<OGRSpatialReference> ref)
{
shared_ptr<OGRSpatialReference> sourceSrs = map->getProjection();
OGRCoordinateTransformation* t(OGRCreateCoordinateTransformation(sourceSrs.get(), ref.get()));
if (t == 0)
{
throw HootException(QString("Error creating transformation object: ") + CPLGetLastErrorMsg());
}
ReprojectCoordinateFilter rcf(t);
int count = 0;
const NodeMap& nodes = map->getNodeMap();
for (NodeMap::const_iterator it = nodes.begin(); it != nodes.end(); ++it)
{
Node* n = it->second.get();
Coordinate c = n->toCoordinate();
try
{
rcf.project(&c);
}
catch(IllegalArgumentException& e)
{
LOG_WARN("Failure projecting node: " << n->toString());
throw e;
}
n->setX(c.x);
n->setY(c.y);
if (count % 1000 == 0 && Log::getInstance().isInfoEnabled())
{
cout << "Reprojecting " << count << " / " << nodes.size() << " \r";
cout.flush();
}
count++;
}
if (Log::getInstance().isInfoEnabled())
{
cout << endl;
}
map->setProjection(ref);
OGRCoordinateTransformation::DestroyCT(t);
}
ERMsg COGRDataSource::Open(const char * pszName, int bUpdate)
{
ERMsg msg;
m_poDS = OGRSFDriverRegistrar::Open(pszName, bUpdate);
if (m_poDS == NULL)
{
const char* pError = CPLGetLastErrorMsg();
if (pError && *pError)
msg.ajoute(pError);
else msg.ajoute("File doesn't exist");
return msg;
}
return msg;
}
bool wxGxFile::Rename(const wxString &sNewName)
{
wxFileName PathName(wxString(m_sPath, wxConvUTF8));
PathName.SetName(ClearExt(sNewName));
wxString sNewPath = PathName.GetFullPath();
CPLString szNewPath(sNewPath.mb_str(wxConvUTF8));
if(RenameFile(m_sPath, szNewPath))
{
return true;
}
else
{
const char* err = CPLGetLastErrorMsg();
wxLogError(_("Operation '%s' failed! GDAL error: %s, file '%s'"), _("Rename"), wxString(err, wxConvUTF8).c_str(), wxString(m_sPath, wxConvUTF8).c_str());
return false;
}
return false;
}
Coordinate MapReprojector::reproject(const Coordinate& c, shared_ptr<OGRSpatialReference> srs1,
shared_ptr<OGRSpatialReference> srs2)
{
OGRCoordinateTransformation* t(OGRCreateCoordinateTransformation(srs1.get(), srs2.get()));
if (t == 0)
{
throw HootException(QString("Error creating transformation object: ") + CPLGetLastErrorMsg());
}
Coordinate result;
result.x = c.x;
result.y = c.y;
ReprojectCoordinateFilter(t).project(&result);
OGRCoordinateTransformation::DestroyCT(t);
return result;
}
void Reprojection::transform(double& x, double& y, double& z) const
{
#ifdef PDAL_HAVE_GDAL
int ret = 0;
ret = OCTTransform(m_transform_ptr.get(), 1, &x, &y, &z);
if (!ret)
{
std::ostringstream msg;
msg << "Could not project point for ReprojectionTransform::" << CPLGetLastErrorMsg() << ret;
throw pdal_error(msg.str());
}
#else
boost::ignore_unused_variable_warning(x);
boost::ignore_unused_variable_warning(y);
boost::ignore_unused_variable_warning(z);
#endif
return;
}
Geometry(const std::string& wkt, const SpatialRef& srs)
{
OGRGeometryH geom;
char *p_wkt = const_cast<char *>(wkt.data());
OGRSpatialReferenceH ref = srs.get();
if (srs.empty())
{
ref = NULL;
}
bool isJson = wkt.find("{") != wkt.npos ||
wkt.find("}") != wkt.npos;
if (!isJson)
{
OGRErr err = OGR_G_CreateFromWkt(&p_wkt, ref, &geom);
if (err != OGRERR_NONE)
{
std::cout << "wkt: " << wkt << std::endl;
std::ostringstream oss;
oss << "unable to construct OGR Geometry";
oss << " '" << CPLGetLastErrorMsg() << "'";
throw pdal::pdal_error(oss.str());
}
}
else
{
// Assume it is GeoJSON and try constructing from that
geom = OGR_G_CreateGeometryFromJson(p_wkt);
if (!geom)
throw pdal_error("Unable to create geometry from "
"input GeoJSON");
OGR_G_AssignSpatialReference(geom, ref);
}
newRef(geom);
}
bool wxGxOpenFileGDB::Delete(void)
{
wxGISDataset* pDSet = GetDatasetFast();
if (NULL != pDSet)
{
pDSet->Close();
wsDELETE(pDSet);
}
if (DeleteDir(m_sPath))
{
return true;
}
else
{
const char* err = CPLGetLastErrorMsg();
wxLogError(_("Operation '%s' failed! GDAL error: %s, file '%s'"), _("Delete"), wxString(err, wxConvUTF8).c_str(), wxString(m_sPath, wxConvUTF8).c_str());
return false;
}
return false;
}
boost::shared_ptr<GDALDataset> OgrUtilities::createDataSource(const QString& url)
{
QString source = url;
OgrDriverInfo driverInfo = getDriverInfo(url, false);
if (driverInfo._driverName == NULL)
throw HootException("Error getting driver info for: " + url);
GDALDriver *driver = GetGDALDriverManager()->GetDriverByName(driverInfo._driverName);
if (driver == 0)
throw HootException("Error getting driver by name: " + QString(driverInfo._driverName));
// if the user specifies a shapefile then crop off the .shp and create a directory.
if (url.toLower().endsWith(".shp"))
source = url.mid(0, url.length() - 4);
boost::shared_ptr<GDALDataset> result(driver->Create(source.toAscii(), 0, 0, 0, GDT_Unknown, NULL));
if (result == NULL)
{
throw HootException("Unable to create data source: " + source +
" (" + QString(CPLGetLastErrorMsg()) + ")");
}
return result;
}
wxGISDataset* const wxGxMLDatasetUI::GetDataset(bool bCache, ITrackCancel* const pTrackCancel)
{
wxGISFeatureDataset* pwxGISFeatureDataset = wxDynamicCast(GetDatasetFast(), wxGISFeatureDataset);
if(pwxGISFeatureDataset && !pwxGISFeatureDataset->IsOpened())
{
if (!pwxGISFeatureDataset->Open(0, TRUE, bCache, pTrackCancel))
{
const char* err = CPLGetLastErrorMsg();
wxString sErr = wxString::Format(_("Operation '%s' failed! GDAL error: %s"), _("Open"), wxString(err, wxConvUTF8).c_str());
wxLogError(sErr);
if (pTrackCancel)
{
pTrackCancel->PutMessage(sErr, wxNOT_FOUND, enumGISMessageErr);
}
wsDELETE(pwxGISFeatureDataset);
return NULL;
}
wxGIS_GXCATALOG_EVENT(ObjectChanged);
}
wsGET( m_pwxGISDataset );
}
wxGISDataset* const wxGxOpenFileGDB::GetDataset(bool bCached, ITrackCancel* const pTrackCancel)
{
wxGISDataSource* pwxGISDataSource = wxDynamicCast(GetDatasetFast(), wxGISDataSource);
if (NULL != pwxGISDataSource && !pwxGISDataSource->IsOpened())
{
if (!pwxGISDataSource->Open(TRUE))
{
wsDELETE(pwxGISDataSource);
const char* err = CPLGetLastErrorMsg();
wxString sErr = wxString::Format(_("Operation '%s' failed! GDAL error: %s"), _("Open"), wxString(err, wxConvUTF8).c_str());
wxLogError(sErr);
if (pTrackCancel)
pTrackCancel->PutMessage(sErr, wxNOT_FOUND, enumGISMessageErr);
return NULL;
}
wxGIS_GXCATALOG_EVENT(ObjectChanged);
wsDELETE(pwxGISDataSource);
}
wsGET(m_pwxGISDataset);
}
bool wxGxArchive::Delete(void)
{
int nCount = 0;
for(size_t i = 1; i < m_sPath.length(); ++i)
{
nCount++;
if(m_sPath[i] == '/')
break;
}
m_sPath.erase(0, nCount + 1);
if(DeleteFile(m_sPath))
{
return true;
}
else
{
const char* err = CPLGetLastErrorMsg();
wxLogError(_("Operation '%s' failed! GDAL error: %s, file '%s'"), _("Delete"), wxString(err, wxConvUTF8).c_str(), wxString(m_sPath, wxConvUTF8).c_str());
return false;
}
return false;
}
// Add a bit of debugging information to the error.
void
simplet_set_error(simplet_error_t *error, simplet_status_t status, const char *msg){
switch(status){
case SIMPLET_ERR:
error->status = SIMPLET_ERR;
snprintf(error->msg, SIMPLET_MAX_ERROR, "simple tiles error: %s", msg);
break;
case SIMPLET_OOM:
error->status = SIMPLET_OOM;
snprintf(error->msg, SIMPLET_MAX_ERROR, "out of memory for allocation, %s", msg);
break;
case SIMPLET_CAIRO_ERR:
error->status = SIMPLET_CAIRO_ERR;
snprintf(error->msg, SIMPLET_MAX_ERROR, "cairo error: %s", msg);
break;
case SIMPLET_OGR_ERR:
error->status = SIMPLET_OGR_ERR;
snprintf(error->msg, SIMPLET_MAX_ERROR, "OGR error: %s, %s", CPLGetLastErrorMsg(), msg);
break;
case SIMPLET_OK:
error->status = SIMPLET_OK;
snprintf(error->msg, SIMPLET_MAX_ERROR, "%s", msg);
}
}
shared_ptr<OgrFeatureProvider> OgrFeatureProvider::openDataSource(const QString& ds)
{
static bool first = true;
if (first == true)
{
OGRRegisterAll();
first = false;
}
OGRDataSource* dataSource(OGRSFDriverRegistrar::Open(ds.toAscii(), FALSE));
QString errorMsg = CPLGetLastErrorMsg();
qDebug() << errorMsg;
if (dataSource->GetLayerCount() != 1)
{
throw Exception("Invalid layer count.");
}
shared_ptr<OgrFeatureProvider> result(
new OgrFeatureProvider(dataSource->GetLayer(0)));
result->_dataSource = dataSource;
return result;
}
