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; }