void print_wkt(int esristyle, int dontprettify)
{
char *outwkt;
if (check_xy(FALSE))
return;
outwkt = GPJ_grass_to_wkt(projinfo, projunits, esristyle,
!(dontprettify));
if (outwkt != NULL) {
fprintf(stdout, "%s\n", outwkt);
G_free(outwkt);
}
else
G_warning(_("%s: Unable to convert to WKT"), G_program_name());
return;
}
QgsCoordinateReferenceSystem GRASS_EXPORT QgsGrass::crsDirect( QString gisdbase, QString location )
{
QString Wkt;
struct Cell_head cellhd;
QgsGrass::resetError();
QgsGrass::setLocation( gisdbase, location );
const char *oldlocale = setlocale( LC_NUMERIC, NULL );
setlocale( LC_NUMERIC, "C" );
try
{
G_get_default_window( &cellhd );
}
catch ( QgsGrass::Exception &e )
{
Q_UNUSED( e );
setlocale( LC_NUMERIC, oldlocale );
QgsDebugMsg( QString( "Cannot get default window: %1" ).arg( e.what() ) );
return QgsCoordinateReferenceSystem();
}
if ( cellhd.proj != PROJECTION_XY )
{
struct Key_Value *projinfo = G_get_projinfo();
struct Key_Value *projunits = G_get_projunits();
char *wkt = GPJ_grass_to_wkt( projinfo, projunits, 0, 0 );
Wkt = QString( wkt );
G_free( wkt );
}
setlocale( LC_NUMERIC, oldlocale );
QgsCoordinateReferenceSystem srs;
srs.createFromWkt( Wkt );
return srs;
}
int main( int argc, char **argv )
{
struct GModule *module;
struct Option *info_opt, *rast_opt, *vect_opt, *coor_opt;
struct Cell_head window;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->description = ( "Get info about locations,mapsets,maps" );
info_opt = G_define_option();
info_opt->key = "info";
info_opt->type = TYPE_STRING;
info_opt->description = "info key";
info_opt->options = "proj,window,query";
rast_opt = G_define_standard_option( G_OPT_R_INPUT );
rast_opt->key = "rast";
rast_opt->required = NO;
vect_opt = G_define_standard_option( G_OPT_V_INPUT );
vect_opt->key = "vect";
vect_opt->required = NO;
coor_opt = G_define_option();
coor_opt->key = "coor";
coor_opt->type = TYPE_DOUBLE;
coor_opt->multiple = YES;
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
if ( strcmp( "proj", info_opt->answer ) == 0 )
{
G_get_window( &window );
/* code from g.proj */
if ( window.proj != PROJECTION_XY )
{
struct Key_Value *projinfo, *projunits;
char *wkt;
projinfo = G_get_projinfo();
projunits = G_get_projunits();
wkt = GPJ_grass_to_wkt( projinfo, projunits, 0, 0 );
fprintf( stdout, "%s", wkt );
}
}
else if ( strcmp( "window", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%f,%f,%f,%f", window.west, window.south, window.east, window.north );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
else if ( strcmp( "query", info_opt->answer ) == 0 )
{
double x, y;
int row, col;
x = atof( coor_opt->answers[0] );
y = atof( coor_opt->answers[1] );
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
G_get_cellhd( rast_opt->answer, "", &window );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
col = ( int ) G_easting_to_col( x, &window );
row = ( int ) G_northing_to_row( y, &window );
if ( col == window.cols ) col--;
if ( row == window.rows ) row--;
if ( col < 0 || col > window.cols || row < 0 || row > window.rows )
{
fprintf( stdout, "value:null\n" );
}
else
{
void *ptr;
double val;
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = cell[col];
ptr = &( cell[col] );
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = dcell[col];
ptr = &( dcell[col] );
}
if ( G_is_null_value( ptr, rast_type ) )
{
fprintf( stdout, "value:null\n" );
}
else
{
fprintf( stdout, "value:%f\n", val );
}
}
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
exit( EXIT_SUCCESS );
}
GDALDataset *GRASSDataset::Open( GDALOpenInfo * poOpenInfo )
{
char *pszGisdb = NULL, *pszLoc = NULL;
char *pszMapset = NULL, *pszElem = NULL, *pszName = NULL;
char **papszCells = NULL;
char **papszMapsets = NULL;
/* -------------------------------------------------------------------- */
/* Does this even look like a grass file path? */
/* -------------------------------------------------------------------- */
if( strstr(poOpenInfo->pszFilename,"/cellhd/") == NULL
&& strstr(poOpenInfo->pszFilename,"/group/") == NULL )
return NULL;
/* Always init, if no rasters are opened G_no_gisinit resets the projection and
* rasters in different projection may be then opened */
// Don't use GISRC file and read/write GRASS variables (from location G_VAR_GISRC) to memory only.
G_set_gisrc_mode ( G_GISRC_MODE_MEMORY );
// Init GRASS libraries (required)
G_no_gisinit(); // Doesn't check write permissions for mapset compare to G_gisinit
// Set error function
G_set_error_routine ( (GrassErrorHandler) Grass2CPLErrorHook );
// GISBASE is path to the directory where GRASS is installed,
if ( !getenv( "GISBASE" ) ) {
static char* gisbaseEnv = NULL;
const char *gisbase = GRASS_GISBASE;
CPLError( CE_Warning, CPLE_AppDefined, "GRASS warning: GISBASE "
"enviroment variable was not set, using:\n%s", gisbase );
char buf[2000];
snprintf ( buf, sizeof(buf), "GISBASE=%s", gisbase );
buf[sizeof(buf)-1] = '\0';
CPLFree(gisbaseEnv);
gisbaseEnv = CPLStrdup ( buf );
putenv( gisbaseEnv );
}
if ( !SplitPath( poOpenInfo->pszFilename, &pszGisdb, &pszLoc, &pszMapset,
&pszElem, &pszName) ) {
return NULL;
}
/* -------------------------------------------------------------------- */
/* Check element name */
/* -------------------------------------------------------------------- */
if ( strcmp(pszElem,"cellhd") != 0 && strcmp(pszElem,"group") != 0 ) {
G_free(pszGisdb);
G_free(pszLoc);
G_free(pszMapset);
G_free(pszElem);
G_free(pszName);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Set GRASS variables */
/* -------------------------------------------------------------------- */
G__setenv( "GISDBASE", pszGisdb );
G__setenv( "LOCATION_NAME", pszLoc );
G__setenv( "MAPSET", pszMapset); // group is searched only in current mapset
G_reset_mapsets();
G_add_mapset_to_search_path ( pszMapset );
/* -------------------------------------------------------------------- */
/* Check if this is a valid grass cell. */
/* -------------------------------------------------------------------- */
if ( strcmp(pszElem,"cellhd") == 0 ) {
if ( G_find_file2("cell", pszName, pszMapset) == NULL ) {
G_free(pszGisdb); G_free(pszLoc); G_free(pszMapset); G_free(pszElem); G_free(pszName);
return NULL;
}
papszMapsets = CSLAddString( papszMapsets, pszMapset );
papszCells = CSLAddString( papszCells, pszName );
}
/* -------------------------------------------------------------------- */
/* Check if this is a valid GRASS imagery group. */
/* -------------------------------------------------------------------- */
else {
struct Ref ref;
I_init_group_ref( &ref );
if ( I_get_group_ref( pszName, &ref ) == 0 ) {
G_free(pszGisdb); G_free(pszLoc); G_free(pszMapset); G_free(pszElem); G_free(pszName);
return NULL;
}
for( int iRef = 0; iRef < ref.nfiles; iRef++ )
{
papszCells = CSLAddString( papszCells, ref.file[iRef].name );
papszMapsets = CSLAddString( papszMapsets, ref.file[iRef].mapset );
G_add_mapset_to_search_path ( ref.file[iRef].mapset );
}
I_free_group_ref( &ref );
}
G_free( pszMapset );
G_free( pszName );
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
GRASSDataset *poDS;
poDS = new GRASSDataset();
/* notdef: should only allow read access to an existing cell, right? */
poDS->eAccess = poOpenInfo->eAccess;
poDS->pszGisdbase = pszGisdb;
poDS->pszLocation = pszLoc;
poDS->pszElement = pszElem;
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
#if GRASS_VERSION_MAJOR >= 7
Rast_get_cellhd( papszCells[0], papszMapsets[0], &(poDS->sCellInfo) );
#else
if( G_get_cellhd( papszCells[0], papszMapsets[0], &(poDS->sCellInfo) ) != 0 ) {
CPLError( CE_Warning, CPLE_AppDefined, "GRASS: Cannot open raster header");
delete poDS;
return NULL;
}
#endif
poDS->nRasterXSize = poDS->sCellInfo.cols;
poDS->nRasterYSize = poDS->sCellInfo.rows;
poDS->adfGeoTransform[0] = poDS->sCellInfo.west;
poDS->adfGeoTransform[1] = poDS->sCellInfo.ew_res;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = poDS->sCellInfo.north;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = -1 * poDS->sCellInfo.ns_res;
/* -------------------------------------------------------------------- */
/* Try to get a projection definition. */
/* -------------------------------------------------------------------- */
struct Key_Value *projinfo, *projunits;
projinfo = G_get_projinfo();
projunits = G_get_projunits();
poDS->pszProjection = GPJ_grass_to_wkt ( projinfo, projunits, 0, 0);
if (projinfo) G_free_key_value(projinfo);
if (projunits) G_free_key_value(projunits);
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
for( int iBand = 0; papszCells[iBand] != NULL; iBand++ )
{
GRASSRasterBand *rb = new GRASSRasterBand( poDS, iBand+1, papszMapsets[iBand],
papszCells[iBand] );
if ( !rb->valid ) {
CPLError( CE_Warning, CPLE_AppDefined, "GRASS: Cannot open raster band %d", iBand);
delete rb;
delete poDS;
return NULL;
}
poDS->SetBand( iBand+1, rb );
}
CSLDestroy(papszCells);
CSLDestroy(papszMapsets);
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
delete poDS;
CPLError( CE_Failure, CPLE_NotSupported,
"The GRASS driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
return poDS;
}
int main( int argc, char **argv )
{
struct GModule *module;
struct Option *info_opt, *rast_opt, *vect_opt, *coor_opt, *north_opt, *south_opt, *east_opt, *west_opt, *rows_opt, *cols_opt;
struct Cell_head window;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->description = ( "Get info about locations,mapsets,maps" );
info_opt = G_define_option();
info_opt->key = "info";
info_opt->type = TYPE_STRING;
info_opt->description = "info key";
info_opt->options = "proj,window,size,query,info,colors,stats";
rast_opt = G_define_standard_option( G_OPT_R_INPUT );
rast_opt->key = "rast";
rast_opt->required = NO;
vect_opt = G_define_standard_option( G_OPT_V_INPUT );
vect_opt->key = "vect";
vect_opt->required = NO;
coor_opt = G_define_option();
coor_opt->key = "coor";
coor_opt->type = TYPE_DOUBLE;
coor_opt->multiple = YES;
north_opt = G_define_option();
north_opt->key = "north";
north_opt->type = TYPE_STRING;
south_opt = G_define_option();
south_opt->key = "south";
south_opt->type = TYPE_STRING;
east_opt = G_define_option();
east_opt->key = "east";
east_opt->type = TYPE_STRING;
west_opt = G_define_option();
west_opt->key = "west";
west_opt->type = TYPE_STRING;
rows_opt = G_define_option();
rows_opt->key = "rows";
rows_opt->type = TYPE_INTEGER;
cols_opt = G_define_option();
cols_opt->key = "cols";
cols_opt->type = TYPE_INTEGER;
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
if ( strcmp( "proj", info_opt->answer ) == 0 )
{
G_get_window( &window );
/* code from g.proj */
if ( window.proj != PROJECTION_XY )
{
struct Key_Value *projinfo, *projunits;
char *wkt;
projinfo = G_get_projinfo();
projunits = G_get_projunits();
wkt = GPJ_grass_to_wkt( projinfo, projunits, 0, 0 );
fprintf( stdout, "%s", wkt );
}
}
else if ( strcmp( "window", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%f,%f,%f,%f", window.west, window.south, window.east, window.north );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
// raster width and height
else if ( strcmp( "size", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%d,%d", window.cols, window.rows );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
// raster informations
else if ( strcmp( "info", info_opt->answer ) == 0 )
{
struct FPRange range;
double zmin, zmax;
// Data type
RASTER_MAP_TYPE raster_type = G_raster_map_type( rast_opt->answer, "" );
fprintf( stdout, "TYPE:%d\n", raster_type );
// Statistics
if ( G_read_fp_range( rast_opt->answer, "", &range ) < 0 )
{
G_fatal_error(( "Unable to read range file" ) );
}
G_get_fp_range_min_max( &range, &zmin, &zmax );
fprintf( stdout, "MIN_VALUE:%.17e\n", zmin );
fprintf( stdout, "MAX_VALUE:%.17e\n", zmax );
}
else if ( strcmp( "colors", info_opt->answer ) == 0 )
{
// Color table
struct Colors colors;
int i, ccount;
if ( G_read_colors( rast_opt->answer, "", &colors ) == 1 )
{
//int maxcolor;
//CELL min, max;
//G_get_color_range ( &min, &max, &colors);
ccount = G_colors_count( &colors );
for ( i = ccount - 1; i >= 0; i-- )
{
DCELL val1, val2;
unsigned char r1, g1, b1, r2, g2, b2;
G_get_f_color_rule( &val1, &r1, &g1, &b1, &val2, &r2, &g2, &b2, &colors, i );
fprintf( stdout, "%.17e %.17e %d %d %d %d %d %d\n", val1, val2, r1, g1, b1, r2, g2, b2 );
}
}
}
else if ( strcmp( "query", info_opt->answer ) == 0 )
{
double x, y;
int row, col;
//x = atof( coor_opt->answers[0] );
//y = atof( coor_opt->answers[1] );
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
char buff[101];
G_get_cellhd( rast_opt->answer, "", &window );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
// wait for coors from stdin
while ( fgets( buff, 100, stdin ) != 0 )
{
if ( sscanf( buff, "%lf%lf", &x, &y ) != 2 )
{
fprintf( stdout, "value:error\n" );
}
else
{
col = ( int ) G_easting_to_col( x, &window );
row = ( int ) G_northing_to_row( y, &window );
if ( col == window.cols )
col--;
if ( row == window.rows )
row--;
if ( col < 0 || col > window.cols || row < 0 || row > window.rows )
{
fprintf( stdout, "value:out\n" );
}
else
{
void *ptr;
double val;
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = cell[col];
ptr = &( cell[col] );
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = dcell[col];
ptr = &( dcell[col] );
}
if ( G_is_null_value( ptr, rast_type ) )
{
fprintf( stdout, "value:null\n" );
}
else
{
fprintf( stdout, "value:%f\n", val );
}
}
}
fflush( stdout );
}
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
else if ( strcmp( "stats", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
int ncols, nrows;
int row, col;
void *ptr;
double val;
double min = DBL_MAX;
double max = -DBL_MAX;
double sum = 0; // sum of values
int count = 0; // count of non null values
double mean = 0;
double squares_sum = 0; // sum of squares
double stdev = 0; // standard deviation
G_get_cellhd( rast_opt->answer, "", &window );
window.north = atof( north_opt->answer );
window.south = atof( south_opt->answer );
window.east = atof( east_opt->answer );
window.west = atof( west_opt->answer );
window.rows = ( int ) atoi( rows_opt->answer );
window.cols = ( int ) atoi( cols_opt->answer );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
ncols = G_window_cols();
nrows = G_window_rows();
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
// Calc stats is very slow for large rasters -> prefer optimization for speed over
// code length and readability (which is not currently true)
for ( row = 0; row < nrows; row++ )
{
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
}
for ( col = 0; col < ncols; col++ )
{
if ( rast_type == CELL_TYPE )
{
val = cell[col];
ptr = &( cell[col] );
}
else
{
val = dcell[col];
ptr = &( dcell[col] );
}
if ( ! G_is_null_value( ptr, rast_type ) )
{
if ( val < min ) min = val;
if ( val > max ) max = val;
sum += val;
count++;
squares_sum += pow( val, 2 );
}
}
}
mean = sum / count;
squares_sum -= count * pow( mean, 2 );
stdev = sqrt( squares_sum / ( count - 1 ) );
fprintf( stdout, "MIN:%.17e\n", min );
fprintf( stdout, "MAX:%.17e\n", max );
fprintf( stdout, "SUM:%.17e\n", sum );
fprintf( stdout, "MEAN:%.17e\n", mean );
fprintf( stdout, "COUNT:%d\n", count );
fprintf( stdout, "STDEV:%.17e\n", stdev );
fprintf( stdout, "SQSUM:%.17e\n", squares_sum );
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
exit( EXIT_SUCCESS );
}
OGRGRASSLayer::OGRGRASSLayer( int layerIndex, struct Map_info * map )
{
CPLDebug ( "GRASS", "OGRGRASSLayer::OGRGRASSLayer layerIndex = %d", layerIndex );
iLayerIndex = layerIndex;
poMap = map;
poSRS = NULL;
iNextId = 0;
poPoints = Vect_new_line_struct();
poCats = Vect_new_cats_struct();
pszQuery = NULL;
paQueryMatch = NULL;
paSpatialMatch = NULL;
iLayer = Vect_cidx_get_field_number ( poMap, iLayerIndex);
CPLDebug ( "GRASS", "iLayer = %d", iLayer );
poLink = Vect_get_field ( poMap, iLayer ); // May be NULL if not defined
// Layer name
if ( poLink && poLink->name )
{
pszName = CPLStrdup( poLink->name );
}
else
{
char buf[20];
sprintf ( buf, "%d", iLayer );
pszName = CPLStrdup( buf );
}
// Because we don't represent centroids as any simple feature, we have to scan
// category index and create index of feature IDs pointing to category index
nTotalCount = Vect_cidx_get_type_count(poMap,iLayer, GV_POINT|GV_LINES|GV_AREA);
CPLDebug ( "GRASS", "nTotalCount = %d", nTotalCount );
paFeatureIndex = (int *) CPLMalloc ( nTotalCount * sizeof(int) );
int n = Vect_cidx_get_type_count(poMap,iLayer, GV_POINTS|GV_LINES|GV_AREA);
int cnt = 0;
for ( int i = 0; i < n; i++ )
{
int cat,type, id;
Vect_cidx_get_cat_by_index ( poMap, iLayerIndex, i, &cat, &type, &id );
if ( !( type & (GV_POINT|GV_LINES|GV_AREA) ) ) continue;
paFeatureIndex[cnt++] = i;
}
poFeatureDefn = new OGRFeatureDefn( pszName );
poFeatureDefn->Reference();
// Get type definition
int nTypes = Vect_cidx_get_num_types_by_index ( poMap, iLayerIndex );
int types = 0;
for ( int i = 0; i < nTypes; i++ ) {
int type, count;
Vect_cidx_get_type_count_by_index ( poMap, iLayerIndex, i, &type, &count);
if ( !(type & (GV_POINT|GV_LINES|GV_AREA) ) ) continue;
types |= type;
CPLDebug ( "GRASS", "type = %d types = %d", type, types );
}
OGRwkbGeometryType eGeomType = wkbUnknown;
if ( types == GV_LINE || types == GV_BOUNDARY || types == GV_LINES )
{
eGeomType = wkbLineString;
}
else if ( types == GV_POINT )
{
eGeomType = wkbPoint;
}
else if ( types == GV_AREA )
{
CPLDebug ( "GRASS", "set wkbPolygon" );
eGeomType = wkbPolygon;
}
if (Vect_is_3d(poMap))
poFeatureDefn->SetGeomType ( (OGRwkbGeometryType)(eGeomType | wkb25DBit) );
else
poFeatureDefn->SetGeomType ( eGeomType );
// Get attributes definition
poDbString = (dbString*) CPLMalloc ( sizeof(dbString) );
poCursor = (dbCursor*) CPLMalloc ( sizeof(dbCursor) );
bCursorOpened = FALSE;
poDriver = NULL;
bHaveAttributes = false;
db_init_string ( poDbString );
if ( poLink )
{
if ( StartDbDriver() )
{
db_set_string ( poDbString, poLink->table );
dbTable *table;
if ( db_describe_table ( poDriver, poDbString, &table) == DB_OK )
{
nFields = db_get_table_number_of_columns ( table );
iCatField = -1;
for ( int i = 0; i < nFields; i++)
{
dbColumn *column = db_get_table_column ( table, i );
int ctype = db_sqltype_to_Ctype ( db_get_column_sqltype(column) );
OGRFieldType ogrFtype = OFTInteger;
switch ( ctype ) {
case DB_C_TYPE_INT:
ogrFtype = OFTInteger;
break;
case DB_C_TYPE_DOUBLE:
ogrFtype = OFTReal;
break;
case DB_C_TYPE_STRING:
ogrFtype = OFTString;
break;
case DB_C_TYPE_DATETIME:
ogrFtype = OFTDateTime;
break;
}
CPLDebug ( "GRASS", "column = %s type = %d",
db_get_column_name(column), ctype );
OGRFieldDefn oField ( db_get_column_name(column), ogrFtype );
poFeatureDefn->AddFieldDefn( &oField );
if ( G_strcasecmp(db_get_column_name(column),poLink->key) == 0 )
{
iCatField = i;
}
}
if ( iCatField >= 0 )
{
bHaveAttributes = true;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined, "Cannot find key field" );
db_close_database_shutdown_driver ( poDriver );
poDriver = NULL;
}
}
else
{
CPLError( CE_Failure, CPLE_AppDefined, "Cannot describe table %s",
poLink->table );
}
db_close_database_shutdown_driver ( poDriver );
poDriver = NULL;
}
}
if ( !bHaveAttributes && iLayer > 0 ) // Because features in layer 0 have no cats
{
OGRFieldDefn oField("cat", OFTInteger);
poFeatureDefn->AddFieldDefn( &oField );
}
if ( getenv("GISBASE") ) // We have some projection info in GISBASE
{
struct Key_Value *projinfo, *projunits;
// Note: we dont have to reset GISDBASE and LOCATION_NAME because
// OGRGRASSLayer constructor is called from OGRGRASSDataSource::Open
// where those variables are set
projinfo = G_get_projinfo();
projunits = G_get_projunits();
char *srsWkt = GPJ_grass_to_wkt ( projinfo, projunits, 0, 0);
if ( srsWkt )
{
poSRS = new OGRSpatialReference ( srsWkt );
CPLFree ( srsWkt );
}
G_free_key_value(projinfo);
G_free_key_value(projunits);
}
}
/*!
\brief Create GDAL settings for given raster map
\param name map name
\param map_type map type (CELL, FCELL, DCELL)
\return pointer to allocated GDAL_link structure
\return NULL on error
*/
struct GDAL_link *Rast_create_gdal_link(const char *name,
RASTER_MAP_TYPE map_type)
{
#ifdef GDAL_LINK
char path[GPATH_MAX];
GDALDriverH driver;
double transform[6];
struct GDAL_link *gdal;
FILE *fp;
struct Key_Value *key_val;
char buf[32];
Rast__init_window();
Rast_init_gdal();
if (!G_is_initialized(&st->initialized)) {
read_gdal_options();
st->projinfo = G_get_projinfo();
st->projunits = G_get_projunits();
#if 0
/* We cannot use GPJ_grass_to_wkt() here because that would create a
circular dependency between libgis and libgproj */
if (st->projinfo && st->projunits)
st->srswkt = GPJ_grass_to_wkt(st->projinfo, st->projunits);
#endif
G_initialize_done(&st->initialized);
}
gdal = G_calloc(1, sizeof(struct GDAL_link));
sprintf(path, "%s/%s%s", st->opts.dir, name, st->opts.ext);
gdal->filename = G_store(path);
gdal->band_num = 1;
gdal->hflip = 0;
gdal->vflip = 0;
switch (map_type) {
case CELL_TYPE:
switch (R__.nbytes) {
case 1:
gdal->type = GDT_Byte;
gdal->null_val = (DCELL) 0xFF;
break;
case 2:
gdal->type = GDT_UInt16;
gdal->null_val = (DCELL) 0xFFFF;
break;
case 3:
case 4:
gdal->type = GDT_Int32;
gdal->null_val = (DCELL) 0x80000000U;
break;
}
break;
case FCELL_TYPE:
gdal->type = GDT_Float32;
Rast_set_d_null_value(&gdal->null_val, 1);
break;
case DCELL_TYPE:
gdal->type = GDT_Float64;
Rast_set_d_null_value(&gdal->null_val, 1);
break;
default:
G_fatal_error(_("Invalid map type <%d>"), map_type);
break;
}
driver = (*pGDALGetDriverByName) (st->opts.format);
if (!driver)
G_fatal_error(_("Unable to get <%s> driver"), st->opts.format);
/* Does driver support GDALCreate ? */
if ((*pGDALGetMetadataItem) (driver, GDAL_DCAP_CREATE, NULL)) {
gdal->data =
(*pGDALCreate)(driver, gdal->filename,
R__.wr_window.cols, R__.wr_window.rows,
1, gdal->type, st->opts.options);
if (!gdal->data)
G_fatal_error(_("Unable to create <%s> dataset using <%s> driver"),
name, st->opts.format);
}
/* If not - create MEM driver for intermediate dataset.
* Check if raster can be created at all (with GDALCreateCopy) */
else if ((*pGDALGetMetadataItem) (driver, GDAL_DCAP_CREATECOPY, NULL)) {
GDALDriverH mem_driver;
G_message(_("Driver <%s> does not support direct writing. "
"Using MEM driver for intermediate dataset."),
st->opts.format);
mem_driver = (*pGDALGetDriverByName) ("MEM");
if (!mem_driver)
G_fatal_error(_("Unable to get in-memory raster driver"));
gdal->data =
(*pGDALCreate)(mem_driver, "",
R__.wr_window.cols, R__.wr_window.rows,
1, gdal->type, st->opts.options);
if (!gdal->data)
G_fatal_error(_("Unable to create <%s> dataset using memory driver"),
name);
}
else
G_fatal_error(_("Driver <%s> does not support creating rasters"),
st->opts.format);
gdal->band = (*pGDALGetRasterBand) (gdal->data, gdal->band_num);
(*pGDALSetRasterNoDataValue) (gdal->band, gdal->null_val);
/* Set Geo Transform */
transform[0] = R__.wr_window.west;
transform[1] = R__.wr_window.ew_res;
transform[2] = 0.0;
transform[3] = R__.wr_window.north;
transform[4] = 0.0;
transform[5] = -R__.wr_window.ns_res;
if ((*pGDALSetGeoTransform) (gdal->data, transform) >= CE_Failure)
G_warning(_("Unable to set geo transform"));
if (st->srswkt)
if ((*pGDALSetProjection) (gdal->data, st->srswkt) == CE_Failure)
G_warning(_("Unable to set projection"));
fp = G_fopen_new_misc("cell_misc", "gdal", name);
if (!fp)
G_fatal_error(_("Unable to create cell_misc/%s/gdal file"), name);
key_val = G_create_key_value();
G_set_key_value("file", gdal->filename, key_val);
sprintf(buf, "%d", gdal->band_num);
G_set_key_value("band", buf, key_val);
sprintf(buf, "%.22g", gdal->null_val);
G_set_key_value("null", buf, key_val);
sprintf(buf, "%d", gdal->type);
G_set_key_value("type", buf, key_val);
if (G_fwrite_key_value(fp, key_val) < 0)
G_fatal_error(_("Error writing cell_misc/%s/gdal file"), name);
G_free_key_value(key_val);
fclose(fp);
return gdal;
#else
return NULL;
#endif
}