int OGRCCreate(const char *pszFname)
{
OGRSFDriverH driver;
int i, numDrivers;
OGRDataSourceH datasource;
OGRLayerH layer;
OGRFeatureDefnH layerDefn;
OGRFieldDefnH fieldDefn;
OGRFeatureH feature;
OGRGeometryH geometry, ring;
/* Register all OGR drivers */
OGRRegisterAll();
/* Fetch MITAB driver - we want to create a TAB file */
numDrivers = OGRGetDriverCount();
for(i=0; i<numDrivers; i++)
{
driver = OGRGetDriver(i);
if (EQUAL("MapInfo File", OGR_Dr_GetName(driver)))
break; /* Found it! */
driver = NULL;
}
if (!driver)
{
printf("Driver not found!\n");
return -1;
}
/* Create new file using this driver */
datasource = OGR_Dr_CreateDataSource(driver, pszFname, NULL);
if (datasource == NULL)
{
printf("Unable to create %s\n", pszFname);
return -1;
}
/* MapInfo data sources are created with one empty layer.
Fetch the layer handle */
layer = OGR_DS_GetLayer(datasource, 0);
if (layer == NULL)
{
printf("Unable to create new layer in %s\n", pszFname);
return -1;
}
/* Add a few fields to the layer defn */
fieldDefn = OGR_Fld_Create( "id", OFTInteger );
OGR_L_CreateField(layer, fieldDefn, 0);
fieldDefn = OGR_Fld_Create( "area", OFTReal );
OGR_L_CreateField(layer, fieldDefn, 0);
fieldDefn = OGR_Fld_Create( "name", OFTString );
OGR_L_CreateField(layer, fieldDefn, 0);
/* We'll need the layerDefn handle to create new features in this layer */
layerDefn = OGR_L_GetLayerDefn( layer );
/* Create a new point */
feature = OGR_F_Create( layerDefn );
OGR_F_SetFieldInteger( feature, 0, 1);
OGR_F_SetFieldDouble( feature, 1, 123.45);
OGR_F_SetFieldString( feature, 2, "Feature #1");
geometry = OGR_G_CreateGeometry( wkbPoint );
OGR_G_SetPoint(geometry, 0, 123.45, 456.78, 0);
OGR_F_SetGeometryDirectly(feature, geometry);
OGR_L_CreateFeature( layer, feature );
/* Create a new line */
feature = OGR_F_Create( layerDefn );
OGR_F_SetFieldInteger( feature, 0, 2);
OGR_F_SetFieldDouble( feature, 1, 42.45);
OGR_F_SetFieldString( feature, 2, "Feature #2");
geometry = OGR_G_CreateGeometry( wkbLineString );
OGR_G_AddPoint(geometry, 123.45, 456.78, 0);
OGR_G_AddPoint(geometry, 12.34, 45.67, 0);
OGR_F_SetGeometryDirectly(feature, geometry);
OGR_L_CreateFeature( layer, feature );
/* Create a new polygon (square) */
feature = OGR_F_Create( layerDefn );
OGR_F_SetFieldInteger( feature, 0, 3);
OGR_F_SetFieldDouble( feature, 1, 49.71);
OGR_F_SetFieldString( feature, 2, "Feature #3");
geometry = OGR_G_CreateGeometry( wkbPolygon );
ring = OGR_G_CreateGeometry( wkbLinearRing );
OGR_G_AddPoint(ring, 123.45, 456.78, 0);
OGR_G_AddPoint(ring, 12.34, 456.78, 0);
OGR_G_AddPoint(ring, 12.34, 45.67, 0);
OGR_G_AddPoint(ring, 123.45, 45.67, 0);
OGR_G_AddPoint(ring, 123.45, 456.78, 0);
OGR_G_AddGeometryDirectly(geometry, ring);
OGR_F_SetGeometryDirectly(feature, geometry);
OGR_L_CreateFeature( layer, feature );
/* Close data source */
OGR_DS_Destroy( datasource );
return 0;
}
static CPLErr OGRPolygonContourWriter( double dfLevelMin, double dfLevelMax,
const OGRMultiPolygon& multipoly,
void *pInfo )
{
OGRContourWriterInfo *poInfo = static_cast<OGRContourWriterInfo *>(pInfo);
OGRFeatureDefnH hFDefn =
OGR_L_GetLayerDefn( static_cast<OGRLayerH>(poInfo->hLayer) );
OGRFeatureH hFeat = OGR_F_Create( hFDefn );
if( poInfo->nIDField != -1 )
OGR_F_SetFieldInteger( hFeat, poInfo->nIDField, poInfo->nNextID++ );
if( poInfo->nElevFieldMin != -1 )
OGR_F_SetFieldDouble( hFeat, poInfo->nElevFieldMin, dfLevelMin );
if( poInfo->nElevFieldMax != -1 )
OGR_F_SetFieldDouble( hFeat, poInfo->nElevFieldMax, dfLevelMax );
const bool bHasZ = wkbHasZ(OGR_FD_GetGeomType(hFDefn));
OGRGeometryH hGeom = OGR_G_CreateGeometry(
bHasZ ? wkbMultiPolygon25D : wkbMultiPolygon );
for ( int iPart = 0; iPart < multipoly.getNumGeometries(); iPart++ )
{
OGRPolygon* poNewPoly = new OGRPolygon();
const OGRPolygon* poPolygon = static_cast<const OGRPolygon*>(multipoly.getGeometryRef(iPart));
for ( int iRing = 0; iRing < poPolygon->getNumInteriorRings() + 1; iRing++ )
{
const OGRLinearRing* poRing = iRing == 0 ?
poPolygon->getExteriorRing()
: poPolygon->getInteriorRing(iRing - 1);
OGRLinearRing* poNewRing = new OGRLinearRing();
for ( int iPoint = 0; iPoint < poRing->getNumPoints(); iPoint++ )
{
const double dfX = poInfo->adfGeoTransform[0]
+ poInfo->adfGeoTransform[1] * poRing->getX(iPoint)
+ poInfo->adfGeoTransform[2] * poRing->getY(iPoint);
const double dfY = poInfo->adfGeoTransform[3]
+ poInfo->adfGeoTransform[4] * poRing->getX(iPoint)
+ poInfo->adfGeoTransform[5] * poRing->getY(iPoint);
if( bHasZ )
OGR_G_SetPoint( OGRGeometry::ToHandle( poNewRing ), iPoint, dfX, dfY, dfLevelMax );
else
OGR_G_SetPoint_2D( OGRGeometry::ToHandle( poNewRing ), iPoint, dfX, dfY );
}
poNewPoly->addRingDirectly( poNewRing );
}
OGR_G_AddGeometryDirectly( hGeom, OGRGeometry::ToHandle( poNewPoly ) );
}
OGR_F_SetGeometryDirectly( hFeat, hGeom );
const OGRErr eErr =
OGR_L_CreateFeature(static_cast<OGRLayerH>(poInfo->hLayer), hFeat);
OGR_F_Destroy( hFeat );
return eErr == OGRERR_NONE ? CE_None : CE_Failure;
}
int main(int argc, char* argv[])
{
int rc = 0;
#ifdef HAVE_GDAL
try
{
::OGRRegisterAll();
// Parse command-line options
std::string in_file;
std::string out_file;
std::string out_frmt;
{
int on_arg = 1;
while (on_arg < argc)
{
std::string arg(argv[on_arg]);
if (arg == "-h")
{
usage();
return 0;
}
else if (arg == "-formats")
{
report_ogr_formats(std::cout);
return 0;
}
else if (arg == "-i" && (on_arg + 1 < argc))
{
++on_arg;
assert(on_arg < argc);
in_file = argv[on_arg];
}
else if (arg == "-o" && (on_arg + 1 < argc))
{
++on_arg;
assert(on_arg < argc);
out_file = argv[on_arg];
out_frmt = "ESRI Shapefile"; // default output format
}
else if (arg == "-f" && (on_arg + 1 < argc))
{
++on_arg;
assert(on_arg < argc);
out_frmt = argv[on_arg];
}
else
{
throw std::runtime_error(std::string("unrecognized parameter: ") + arg);
}
++on_arg;
}
if (in_file.empty() || out_file.empty() || out_frmt.empty())
{
throw std::runtime_error("missing input paremeters");
}
}
//
// Source
//
std::cout << "Source:" << "\n - dataset: " << in_file << std::endl;
std::ifstream ifs;
if (!liblas::Open(ifs, in_file.c_str()))
{
throw std::runtime_error(std::string("Can not open \'") + in_file + "\'");
}
liblas::Reader reader(ifs);
//
// Target
//
std::string const lyrname(out_file.substr(0, out_file.find_last_of('.')));
std::cout << "Target:"
<< "\n - format: " << out_frmt
<< "\n - dataset: " << out_file
<< "\n - layer: " << lyrname
<< std::endl;
OGRSFDriverH drv = OGRGetDriverByName(out_frmt.c_str());
if (0 == drv)
{
throw std::runtime_error(out_frmt + " driver not available");
}
ogr_wrapper<OGRDataSourceH> ds(OGR_Dr_CreateDataSource(drv, out_file.c_str(), 0), OGR_DS_Destroy);
if (0 == ds.get())
{
throw std::runtime_error(out_file + " datasource creation failed");
}
OGRLayerH lyr = OGR_DS_CreateLayer(ds, lyrname.c_str(), 0, wkbPoint25D, 0);
if (0 == lyr)
{
throw std::runtime_error(out_file + " layer creation failed");
}
// Prepare layer schema
create_layer_def(lyr);
//
// Translation of points cloud to features set
//
boost::uint32_t i = 0;
boost::uint32_t const size = reader.GetHeader().GetPointRecordsCount();
std::cout << "Translating " << size << " points:\n";
ogr_wrapper<OGRFeatureH> feat(OGR_F_Create(OGR_L_GetLayerDefn(lyr)), OGR_F_Destroy);
while (reader.ReadNextPoint())
{
liblas::Point const& p = reader.GetPoint();
OGR_F_SetFieldInteger(feat, 0, p.GetReturnNumber());
OGR_F_SetFieldInteger(feat, 1, p.GetScanAngleRank());
OGR_F_SetFieldInteger(feat, 2, p.GetIntensity());
std::ostringstream os;
os << p.GetClassification();
OGR_F_SetFieldString(feat, 3, os.str().c_str());
OGR_F_SetFieldInteger(feat, 4, p.GetNumberOfReturns());
OGR_F_SetFieldDouble(feat, 5, p.GetTime());
ogr_wrapper<OGRGeometryH> geom(OGR_G_CreateGeometry(wkbPoint25D), OGR_G_DestroyGeometry);
OGR_G_SetPoint(geom, 0, p.GetX(), p.GetY(), p.GetZ());
if (OGRERR_NONE != OGR_F_SetGeometry(feat, geom))
{
throw std::runtime_error("geometry creation failed");
}
if (OGRERR_NONE != OGR_L_CreateFeature(lyr, feat))
{
throw std::runtime_error("feature creation failed");
}
term_progress(std::cout, (i + 1) / static_cast<double>(size));
i++;
}
std::cout << std::endl;
}
catch (std::exception const& e)
{
std::cerr << "Error: " << e.what() << std::endl;
rc = -1;
}
catch (...)
{
std::cerr << "Unknown error\n";
rc = -1;
}
#else
std::cout << "Missing GDAL/OGR support built-in las2ogr. Aborted." << std::endl;
#endif // #ifdef HAVE_GDAL
::OGRCleanupAll();
return rc;
}
int main(int argc, char* argv[])
{
const char *pszFormat = "ESRI Shapefile";
char *pszLayerName = NULL;
const char *pszSrcFilename = NULL, *pszDstFilename = NULL;
int iBand = 1;
GDALDatasetH hDS;
GDALRasterBandH hBand;
int nXSize, nYSize;
int i, j;
FILE *fOut = NULL;
double *padfBuffer;
double adfGeotransform[6];
OGRSFDriverH hOGRDriver;
OGRDataSourceH hOGRDS;
OGRLayerH hOGRLayer;
OGRwkbGeometryType eType = wkbPoint25D;
int xStep = 1, yStep = 1;
OGRRegisterAll();
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Parse arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if ( EQUAL(argv[i], "-b") && i < argc - 1)
iBand = atoi(argv[++i]);
else if ( EQUAL(argv[i], "-f") && i < argc - 1)
pszFormat = argv[++i];
else if ( EQUAL(argv[i], "-l") && i < argc - 1)
pszLayerName = CPLStrdup(argv[++i]);
else if ( EQUAL(argv[i], "-t") && i < argc - 1)
{
i++;
if (EQUAL(argv[i], "POLYGON"))
eType = wkbPolygon;
else if (EQUAL(argv[i], "POINT"))
eType = wkbPoint;
else if (EQUAL(argv[i], "POINT25D"))
eType = wkbPoint25D;
else
{
fprintf(stderr, "unhandled geometry type : %s\n", argv[i]);
}
}
else if ( EQUAL(argv[i], "-step") && i < argc - 1)
xStep = yStep = atoi(argv[++i]);
else if ( argv[i][0] == '-')
Usage();
else if( pszSrcFilename == NULL )
pszSrcFilename = argv[i];
else if( pszDstFilename == NULL )
pszDstFilename = argv[i];
else
Usage();
}
if( pszSrcFilename == NULL || pszDstFilename == NULL)
Usage();
/* -------------------------------------------------------------------- */
/* Open GDAL source dataset */
/* -------------------------------------------------------------------- */
hDS = GDALOpen(pszSrcFilename, GA_ReadOnly);
if (hDS == NULL)
{
fprintf(stderr, "Can't open %s\n", pszSrcFilename);
exit(1);
}
hBand = GDALGetRasterBand(hDS, iBand);
if (hBand == NULL)
{
fprintf(stderr, "Can't get band %d\n", iBand);
exit(1);
}
if (GDALGetGeoTransform(hDS, adfGeotransform) != CE_None)
{
fprintf(stderr, "Can't get geotransform\n");
exit(1);
}
nXSize = GDALGetRasterXSize(hDS);
nYSize = GDALGetRasterYSize(hDS);
/* -------------------------------------------------------------------- */
/* Create OGR destination dataset */
/* -------------------------------------------------------------------- */
/* Special case for CSV : we generate the appropriate VRT file in the same time */
if (EQUAL(pszFormat, "CSV") && EQUAL(CPLGetExtension(pszDstFilename), "CSV"))
{
FILE* fOutCSVT;
FILE* fOutVRT;
char* pszDstFilenameCSVT;
char* pszDstFilenameVRT;
fOut = fopen(pszDstFilename, "wt");
if (fOut == NULL)
{
fprintf(stderr, "Can't open %s for writing\n", pszDstFilename);
exit(1);
}
fprintf(fOut, "x,y,z\n");
pszDstFilenameCSVT = CPLMalloc(strlen(pszDstFilename) + 2);
strcpy(pszDstFilenameCSVT, pszDstFilename);
strcat(pszDstFilenameCSVT, "t");
fOutCSVT = fopen(pszDstFilenameCSVT, "wt");
if (fOutCSVT == NULL)
{
fprintf(stderr, "Can't open %s for writing\n", pszDstFilenameCSVT);
exit(1);
}
CPLFree(pszDstFilenameCSVT);
fprintf(fOutCSVT, "Real,Real,Real\n");
fclose(fOutCSVT);
fOutCSVT = NULL;
pszDstFilenameVRT = CPLStrdup(pszDstFilename);
strcpy(pszDstFilenameVRT + strlen(pszDstFilename) - 3, "vrt");
fOutVRT = fopen(pszDstFilenameVRT, "wt");
if (fOutVRT == NULL)
{
fprintf(stderr, "Can't open %s for writing\n", pszDstFilenameVRT);
exit(1);
}
CPLFree(pszDstFilenameVRT);
fprintf(fOutVRT, "<OGRVRTDataSource>\n");
fprintf(fOutVRT, " <OGRVRTLayer name=\"%s\">\n", CPLGetBasename(pszDstFilename));
fprintf(fOutVRT, " <SrcDataSource>%s</SrcDataSource> \n", pszDstFilename);
fprintf(fOutVRT, " <GeometryType>wkbPoint</GeometryType>\n");
fprintf(fOutVRT, " <GeometryField encoding=\"PointFromColumns\" x=\"x\" y=\"y\" z=\"z\"/>\n");
fprintf(fOutVRT, " </OGRVRTLayer>\n");
fprintf(fOutVRT, "</OGRVRTDataSource>\n");
fclose(fOutVRT);
fOutVRT = NULL;
}
else
{
OGRSpatialReferenceH hSRS = NULL;
const char* pszWkt;
hOGRDriver = OGRGetDriverByName(pszFormat);
if (hOGRDriver == NULL)
{
fprintf(stderr, "Can't find OGR driver %s\n", pszFormat);
exit(1);
}
hOGRDS = OGR_Dr_CreateDataSource(hOGRDriver, pszDstFilename, NULL);
if (hOGRDS == NULL)
{
fprintf(stderr, "Can't create OGR datasource %s\n", pszDstFilename);
exit(1);
}
pszWkt = GDALGetProjectionRef(hDS);
if (pszWkt && pszWkt[0])
{
hSRS = OSRNewSpatialReference(pszWkt);
}
if (pszLayerName == NULL)
pszLayerName = CPLStrdup(CPLGetBasename(pszDstFilename));
hOGRLayer = OGR_DS_CreateLayer( hOGRDS, pszLayerName,
hSRS, eType, NULL);
if (hSRS)
OSRDestroySpatialReference(hSRS);
if (hOGRLayer == NULL)
{
fprintf(stderr, "Can't create layer %s\n", pszLayerName);
exit(1);
}
if (eType != wkbPoint25D)
{
OGRFieldDefnH hFieldDefn = OGR_Fld_Create( "z", OFTReal );
OGR_L_CreateField(hOGRLayer, hFieldDefn, 0);
OGR_Fld_Destroy( hFieldDefn );
}
}
padfBuffer = (double*)CPLMalloc(nXSize * sizeof(double));
#define GET_X(j, i) adfGeotransform[0] + (j) * adfGeotransform[1] + (i) * adfGeotransform[2]
#define GET_Y(j, i) adfGeotransform[3] + (j) * adfGeotransform[4] + (i) * adfGeotransform[5]
#define GET_XY(j, i) GET_X(j, i), GET_Y(j, i)
/* -------------------------------------------------------------------- */
/* "Translate" the source dataset */
/* -------------------------------------------------------------------- */
for(i=0;i<nYSize;i+=yStep)
{
GDALRasterIO( hBand, GF_Read, 0, i, nXSize, 1,
padfBuffer, nXSize, 1, GDT_Float64, 0, 0);
for(j=0;j<nXSize;j+=xStep)
{
if (fOut)
{
fprintf(fOut, "%f,%f,%f\n",
GET_XY(j + .5, i + .5), padfBuffer[j]);
}
else
{
OGRFeatureH hFeature = OGR_F_Create(OGR_L_GetLayerDefn(hOGRLayer));
OGRGeometryH hGeometry = OGR_G_CreateGeometry(eType);
if (eType == wkbPoint25D)
{
OGR_G_SetPoint(hGeometry, 0, GET_XY(j + .5, i + .5),
padfBuffer[j]);
}
else if (eType == wkbPoint)
{
OGR_G_SetPoint_2D(hGeometry, 0, GET_XY(j + .5, i + .5));
OGR_F_SetFieldDouble(hFeature, 0, padfBuffer[j]);
}
else
{
OGRGeometryH hLinearRing = OGR_G_CreateGeometry(wkbLinearRing);
OGR_G_SetPoint_2D(hLinearRing, 0, GET_XY(j + 0, i + 0));
OGR_G_SetPoint_2D(hLinearRing, 1, GET_XY(j + 1, i + 0));
OGR_G_SetPoint_2D(hLinearRing, 2, GET_XY(j + 1, i + 1));
OGR_G_SetPoint_2D(hLinearRing, 3, GET_XY(j + 0, i + 1));
OGR_G_SetPoint_2D(hLinearRing, 4, GET_XY(j + 0, i + 0));
OGR_G_AddGeometryDirectly(hGeometry, hLinearRing);
OGR_F_SetFieldDouble(hFeature, 0, padfBuffer[j]);
}
OGR_F_SetGeometryDirectly(hFeature, hGeometry);
OGR_L_CreateFeature(hOGRLayer, hFeature);
OGR_F_Destroy(hFeature);
}
}
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
if (fOut)
fclose(fOut);
else
OGR_DS_Destroy(hOGRDS);
GDALClose(hDS);
CPLFree(padfBuffer);
CPLFree(pszLayerName);
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
OGRCleanupAll();
CSLDestroy( argv );
return 0;
}