int do_vpoints(int after_masking)
{
int n;
struct Map_info Map;
n = vector.count;
while (n-- > 0) {
if (vector.layer[n].type != VPOINTS)
continue;
if (after_masking && vector.layer[n].masked)
continue;
if (!after_masking && !vector.layer[n].masked)
continue;
G_message(_("Reading vector points file <%s in %s> ..."),
vector.layer[n].name, vector.layer[n].mapset);
Vect_set_open_level(2);
Vect_set_fatal_error(GV_FATAL_PRINT);
if (2 >
Vect_open_old(&Map, vector.layer[n].name,
vector.layer[n].mapset)) {
char name[100];
sprintf(name, "%s in %s", vector.layer[n].name,
vector.layer[n].mapset);
error("vector map", name, "can't open");
continue;
}
PS_vpoints_plot(&Map, n, LINE_DRAW_LINE);
Vect_close(&Map);
fprintf(PS.fp, "[] 0 setdash\n");
}
return 0;
}
int read_vpoints(char *name, char *mapset)
{
char fullname[100];
char buf[1024];
char *key, *data;
double width, size, scale, rotate;
int itmp, vec;
int r, g, b;
int ret;
struct Map_info Map;
vector_alloc(); /* allocate space */
sprintf(fullname, "%s in %s", name, mapset);
Vect_set_open_level(2);
Vect_set_fatal_error(GV_FATAL_PRINT);
if (2 > Vect_open_old(&Map, name, mapset)) {
error(fullname, "", "can't open vector map");
gobble_input();
return 0;
}
Vect_close(&Map);
vec = vector.count;
vector.layer[vec].type = VPOINTS;
vector.layer[vec].name = G_store(name);
vector.layer[vec].mapset = G_store(mapset);
vector.layer[vec].ltype = GV_POINT;
vector.layer[vec].masked = 0;
vector.layer[vec].field = 1;
vector.layer[vec].cats = NULL;
vector.layer[vec].where = NULL;
vector.layer[vec].width = 1.;
set_color(&(vector.layer[vec].color), 0, 0, 0);
set_color(&(vector.layer[vec].fcolor), 255, 0, 0);
vector.layer[vec].rgbcol = NULL;
vector.layer[vec].label = NULL;
vector.layer[vec].lpos = -1;
vector.layer[vec].symbol = G_store("basic/diamond");
vector.layer[vec].size = 6.0;
vector.layer[vec].sizecol = NULL;
vector.layer[vec].scale = 1.0;
vector.layer[vec].rotate = 0.0;
vector.layer[vec].rotcol = NULL;
vector.layer[vec].epstype = 0;
while (input(2, buf, help)) {
if (!key_data(buf, &key, &data))
continue;
if (KEY("masked")) {
vector.layer[vec].masked = yesno(key, data);
if (vector.layer[vec].masked)
PS.mask_needed = 1;
continue;
}
if (KEY("type")) {
G_strip(data);
vector.layer[vec].ltype = 0;
if (strstr(data, "point"))
vector.layer[vec].ltype |= GV_POINT;
if (strstr(data, "centroid"))
vector.layer[vec].ltype |= GV_CENTROID;
continue;
}
if (KEY("layer")) {
G_strip(data);
vector.layer[vec].field = atoi(data);
continue;
}
if (KEY("cats")) {
G_strip(data);
vector.layer[vec].cats = G_store(data);
continue;
}
if (KEY("where")) {
G_strip(data);
vector.layer[vec].where = G_store(data);
continue;
}
if (KEY("width")) {
width = -1.;
*mapset = 0;
if (sscanf(data, "%lf%s", &width, mapset) < 1 || width < 0.) {
width = 1.;
error(key, data, "illegal width (vpoints)");
continue;
}
if (mapset[0] == 'i')
width = width / 72.;
vector.layer[vec].width = width;
continue;
}
if (KEY("color")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&(vector.layer[vec].color), r, g, b);
else if (ret == 2)
unset_color(&(vector.layer[vec].color));
else
error(key, data, "illegal color request");
continue;
}
if (KEY("fcolor")) { /* fill color */
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&(vector.layer[vec].fcolor), r, g, b);
else if (ret == 2)
unset_color(&(vector.layer[vec].fcolor));
else
error(key, data, "illegal color request (vpoints)");
continue;
}
if (KEY("rgbcolumn")) {
G_strip(data);
vector.layer[vec].rgbcol = G_store(data);
continue;
}
if (KEY("label")) { /* map legend label */
G_strip(data);
vector.layer[vec].label = G_store(data);
continue;
}
if (KEY("lpos")) {
if (sscanf(data, "%d", &itmp) < 1 || itmp < 0) {
itmp = -1;
error(key, data, "illegal lpos");
continue;
}
vector.layer[vec].lpos = itmp;
continue;
}
if (KEY("symbol")) {
/* TODO: test here if isymbol exists */
vector.layer[vec].symbol = G_store(data);
continue;
}
if (KEY("eps")) {
char *cc;
G_chop(data);
vector.layer[vec].epspre = G_store(data);
/* epstype: 0 - no eps, 1 - common eps, 2 - eps for each category */
vector.layer[vec].epstype = 1;
/* find dynamic filename by cat number character */
/* pre is filename before the $, suf is filename after the $ */
cc = (char *)strchr(vector.layer[vec].epspre, '$');
if (cc != NULL) {
*cc = '\0';
vector.layer[vec].epssuf = G_store(cc + sizeof(char));
vector.layer[vec].epstype = 2;
G_debug(2, "epstype=%d, pre=[%s], suf=[%s]",
vector.layer[vec].epstype, vector.layer[vec].epspre,
vector.layer[vec].epssuf);
}
else {
G_debug(2, "epstype=%d, eps file=[%s]",
vector.layer[vec].epstype, vector.layer[vec].epspre);
}
continue;
}
if (KEY("size")) {
if (sscanf(data, "%lf", &size) != 1 || size <= 0.0) {
size = 1.0;
error(key, data, "illegal size request (vpoints)");
}
vector.layer[vec].size = size;
continue;
}
/*
GRASS 6.3: sizecol renamed to sizecolumn
remove sizecol test and the warning in GRASS7
*/
if (KEY("sizecol")) {
G_warning(_("The mapping instruction <%s> will be renamed to <%s> "
"in future versions of GRASS. Please use <%s> instead."),
"sizecol", "sizecolumn", "sizecolumn");
}
if (KEY("sizecol") || KEY("sizecolumn")) {
G_strip(data);
vector.layer[vec].sizecol = G_store(data);
continue;
}
if (KEY("scale")) {
if (sscanf(data, "%lf", &scale) != 1 || scale <= 0.0) {
scale = 1.0;
error(key, data, "illegal scale request (vpoints)");
}
vector.layer[vec].scale = scale;
continue;
}
if (KEY("rotate")) {
if (sscanf(data, "%lf", &rotate) != 1) {
rotate = 0.0;
error(key, data, "illegal rotation request (vpoints)");
}
vector.layer[vec].rotate = rotate;
continue;
}
if (KEY("rotatecolumn")) {
G_strip(data);
vector.layer[vec].rotcol = G_store(data);
continue;
}
error(key, "", "illegal request (vpoints)");
}
vector.count++;
return 1;
}
int OGRGRASSDataSource::Open( const char * pszNewName, int /*bUpdate*/,
int bTestOpen, int /*bSingleNewFileIn*/ )
{
VSIStatBuf stat;
CPLAssert( nLayers == 0 );
pszName = CPLStrdup( pszNewName ); // Released by destructor
/* -------------------------------------------------------------------- */
/* Do the given path contains 'vector' and 'head'? */
/* -------------------------------------------------------------------- */
if ( strstr(pszName,"vector") == NULL || strstr(pszName,"head") == NULL )
{
if( !bTestOpen )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s is not GRASS vector, access failed.\n", pszName );
}
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Is the given a regular file? */
/* -------------------------------------------------------------------- */
if( CPLStat( pszName, &stat ) != 0 || !VSI_ISREG(stat.st_mode) )
{
if( !bTestOpen )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s is not GRASS vector, access failed.\n", pszName );
}
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Parse datasource name */
/* -------------------------------------------------------------------- */
if ( !SplitPath(pszName, &pszGisdbase, &pszLocation,
&pszMapset, &pszMap) )
{
if( !bTestOpen )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s is not GRASS datasource name, access failed.\n",
pszName );
}
return FALSE;
}
CPLDebug ( "GRASS", "Gisdbase: %s", pszGisdbase );
CPLDebug ( "GRASS", "Location: %s", pszLocation );
CPLDebug ( "GRASS", "Mapset: %s", pszMapset );
CPLDebug ( "GRASS", "Map: %s", pszMap );
/* -------------------------------------------------------------------- */
/* Init GRASS library */
/* -------------------------------------------------------------------- */
// GISBASE is path to the directory where GRASS is installed,
// it is necessary because there are database drivers.
if ( !getenv( "GISBASE" ) ) {
static char* gisbaseEnv = NULL;
const char *gisbase = GRASS_GISBASE;
CPLError( CE_Warning, CPLE_AppDefined, "GRASS warning: GISBASE "
"environment 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 );
}
// 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()
G_no_gisinit();
// Set error function
G_set_error_routine ( (GrassErrorHandler) Grass2OGRErrorHook );
/* -------------------------------------------------------------------- */
/* Set GRASS variables */
/* -------------------------------------------------------------------- */
G__setenv( "GISDBASE", pszGisdbase );
G__setenv( "LOCATION_NAME", pszLocation );
G__setenv( "MAPSET", pszMapset);
G_reset_mapsets();
G_add_mapset_to_search_path ( pszMapset );
/* -------------------------------------------------------------------- */
/* Open GRASS vector map */
/* -------------------------------------------------------------------- */
#if GRASS_VERSION_MAJOR < 7
Vect_set_fatal_error ( GV_FATAL_PRINT ); // Print error and continue
#endif
Vect_set_open_level (2);
int level = Vect_open_old ( &map, pszMap, pszMapset);
if ( level < 2 ) {
CPLError( CE_Failure, CPLE_AppDefined,
"Cannot open GRASS vector %s on level 2.\n", pszName );
return FALSE;
}
CPLDebug ( "GRASS", "Num lines = %d", Vect_get_num_lines(&map) );
/* -------------------------------------------------------------------- */
/* Build a list of layers. */
/* -------------------------------------------------------------------- */
int ncidx = Vect_cidx_get_num_fields ( &map );
CPLDebug ( "GRASS", "Num layers = %d", ncidx );
for ( int i = 0; i < ncidx; i++ ) {
// Create the layer object
OGRGRASSLayer *poLayer = new OGRGRASSLayer( i, &map );
// Add layer to data source layer list
papoLayers = (OGRGRASSLayer **)
CPLRealloc( papoLayers, sizeof(OGRGRASSLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
}
bOpened = TRUE;
return TRUE;
}
int read_vlines(char *name, char *mapset)
{
char fullname[GNAME_MAX];
char buf[1024];
char *key, *data, *dp;
double width;
int itmp, vec;
int r, g, b;
int ret;
struct Map_info Map;
vector_alloc(); /* allocate space */
sprintf(fullname, "%s in %s", name, mapset);
Vect_set_open_level(2);
Vect_set_fatal_error(GV_FATAL_PRINT);
if (2 > Vect_open_old(&Map, name, mapset)) {
error(fullname, "", "can't open vector map");
gobble_input();
return 0;
}
Vect_close(&Map);
vec = vector.count;
vector.layer[vec].type = VLINES;
vector.layer[vec].name = G_store(name);
vector.layer[vec].mapset = G_store(mapset);
vector.layer[vec].ltype = GV_LINE;
vector.layer[vec].masked = 0;
vector.layer[vec].field = 1;
vector.layer[vec].cats = NULL;
vector.layer[vec].where = NULL;
vector.layer[vec].width = 1.;
vector.layer[vec].cwidth = 0.;
vector.layer[vec].offset = 0.;
vector.layer[vec].coffset = 0.;
set_color(&(vector.layer[vec].color), 0, 0, 0);
vector.layer[vec].rgbcol = NULL;
vector.layer[vec].linestyle = NULL;
vector.layer[vec].linecap = LINECAP_BUTT;
vector.layer[vec].ref = LINE_REF_CENTER;
vector.layer[vec].hwidth = 0.;
unset_color(&(vector.layer[vec].hcolor));
vector.layer[vec].label = NULL;
vector.layer[vec].lpos = -1;
vector.layer[vec].pwidth = 1.;
while (input(2, buf, help)) {
if (!key_data(buf, &key, &data))
continue;
if (KEY("masked")) {
vector.layer[vec].masked = yesno(key, data);
if (vector.layer[vec].masked)
PS.mask_needed = 1;
continue;
}
if (KEY("type")) {
G_strip(data);
vector.layer[vec].ltype = 0;
if (strstr(data, "line"))
vector.layer[vec].ltype |= GV_LINE;
if (strstr(data, "boundary"))
vector.layer[vec].ltype |= GV_BOUNDARY;
continue;
}
if (KEY("layer")) {
G_strip(data);
vector.layer[vec].field = atoi(data);
continue;
}
if (KEY("cats")) {
G_strip(data);
vector.layer[vec].cats = G_store(data);
continue;
}
if (KEY("where")) {
G_strip(data);
vector.layer[vec].where = G_store(data);
continue;
}
if (KEY("style")) {
G_strip(data);
if (strcmp(data, "solid") == 0) {
vector.layer[vec].linestyle = NULL;
continue;
}
else if (strcmp(data, "dashed") == 0) {
vector.layer[vec].linestyle = G_store("000000111");
continue;
}
else if (strcmp(data, "dotted") == 0) {
vector.layer[vec].linestyle = G_store("100000");
continue;
}
else if (strcmp(data, "dashdotted") == 0) {
vector.layer[vec].linestyle = G_store("000000111011111");
continue;
}
for (dp = data; *dp; dp++)
if (*dp < '0' || *dp > '9')
break;
if (*dp != 0 || dp == data) {
error(key, data, "illegal line style (vlines)");
continue;
}
vector.layer[vec].linestyle = G_store(data);
continue;
}
if (KEY("linecap")) {
G_strip(data);
if (strcmp(data, "butt") == 0) {
vector.layer[vec].linecap = LINECAP_BUTT;
continue;
}
else if (strcmp(data, "round") == 0) {
vector.layer[vec].linecap = LINECAP_ROUND;
continue;
}
else if (strcmp(data, "extended_butt") == 0) {
vector.layer[vec].linecap = LINECAP_EXTBUTT;
continue;
}
else
error(key, data, "illegal line cap (vlines)");
continue;
}
if (KEY("width")) {
width = -1.;
*mapset = 0;
if (sscanf(data, "%lf%s", &width, mapset) < 1 || width < 0.) {
width = 1.;
error(key, data, "illegal width (vlines)");
continue;
}
if (mapset[0] == 'i')
width = width / 72.;
vector.layer[vec].width = width;
continue;
}
if (KEY("cwidth")) {
width = -1.;
*mapset = 0;
if (sscanf(data, "%lf%s", &width, mapset) < 1 || width < 0.) {
width = 1.;
error(key, data, "illegal cwidth (vlines)");
continue;
}
if (mapset[0] == 'i')
width = width / 72.;
vector.layer[vec].cwidth = width;
continue;
}
if (KEY("offset")) {
*mapset = 0;
if (sscanf(data, "%lf%s", &width, mapset) < 1) {
width = 0.;
error(key, data, "illegal offset (vlines)");
continue;
}
if (mapset[0] == 'i')
width = width / 72.;
vector.layer[vec].offset = width;
continue;
}
if (KEY("coffset")) {
*mapset = 0;
if (sscanf(data, "%lf%s", &width, mapset) < 1) {
width = 0.;
error(key, data, "illegal coffset (vlines)");
continue;
}
if (mapset[0] == 'i')
width = width / 72.;
vector.layer[vec].coffset = width;
continue;
}
if (KEY("hwidth")) {
width = -1.;
if (sscanf(data, "%lf%s", &width, mapset) < 1 || width < 0.) {
width = 0.;
error(key, data, "illegal hwidth (vlines)");
continue;
}
if (mapset[0] == 'i')
width = width / 72.;
vector.layer[vec].hwidth = width;
continue;
}
if (KEY("color")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&(vector.layer[vec].color), r, g, b);
else if (ret == 2)
unset_color(&(vector.layer[vec].color));
else
error(key, data, "illegal color request (vlines)");
continue;
}
if (KEY("rgbcolumn")) {
G_strip(data);
vector.layer[vec].rgbcol = G_store(data);
continue;
}
if (KEY("hcolor")) {
ret = G_str_to_color(data, &r, &g, &b);
if (ret == 1)
set_color(&(vector.layer[vec].hcolor), r, g, b);
else if (ret == 2)
unset_color(&(vector.layer[vec].hcolor));
else
error(key, data, "illegal hcolor request (vlines)");
continue;
}
if (KEY("label")) { /* map legend label */
G_strip(data);
vector.layer[vec].label = G_store(data);
continue;
}
if (KEY("lpos")) {
if (sscanf(data, "%d", &itmp) < 1 || itmp < 0) {
itmp = -1;
error(key, data, "illegal lpos (vlines)");
continue;
}
vector.layer[vec].lpos = itmp;
continue;
}
if (KEY("ref")) {
G_strip(data);
if (strcmp(data, "left") == 0) {
vector.layer[vec].ref = LINE_REF_LEFT;
continue;
}
if (strcmp(data, "right") == 0) {
vector.layer[vec].ref = LINE_REF_RIGHT;
continue;
}
error(key, data, "illegal ref request (vlines)");
continue;
}
if (KEY("scale")) {
G_strip(data);
vector.layer[vec].scale = atof(data);
continue;
}
error(key, "", "illegal request (vlines)");
}
vector.count++;
return 1;
}
int do_vectors(int after_masking)
{
int n, z, lz, dig;
struct Map_info Map;
char dashes[100], buf[20], *ptr;
n = vector.count;
while (n-- > 0) {
if (vector.layer[n].type == VPOINTS)
continue;
if (after_masking && vector.layer[n].masked)
continue;
if (!after_masking && !vector.layer[n].masked)
continue;
G_message(_("Reading vector map <%s in %s> ..."),
vector.layer[n].name, vector.layer[n].mapset);
Vect_set_open_level(2);
Vect_set_fatal_error(GV_FATAL_PRINT);
if (2 >
Vect_open_old(&Map, vector.layer[n].name,
vector.layer[n].mapset)) {
char name[100];
sprintf(name, "%s in %s", vector.layer[n].name,
vector.layer[n].mapset);
error("vector map", name, "can't open");
continue;
}
if (vector.layer[n].type == VAREAS) {
PS_vareas_plot(&Map, n);
}
else if (vector.layer[n].type == VLINES) {
fprintf(PS.fp, "[] 0 setdash\n");
if (vector.layer[n].hwidth &&
vector.layer[n].ref == LINE_REF_CENTER) {
set_ps_color(&(vector.layer[n].hcolor));
fprintf(PS.fp, "%.8f W\n",
vector.layer[n].width + 2. * vector.layer[n].hwidth);
PS_vlines_plot(&Map, n, LINE_DRAW_HIGHLITE);
Vect_rewind(&Map);
}
fprintf(PS.fp, "%.8f W\n", vector.layer[n].width);
set_ps_color(&(vector.layer[n].color));
if (vector.layer[n].linecap >= 0) {
G_debug(1, "Line cap: '%d'", vector.layer[n].linecap);
fprintf(PS.fp, "%d setlinecap\n",vector.layer[n].linecap);
}
dashes[0] = '[';
dashes[1] = 0;
lz = 0;
if (vector.layer[n].linestyle != NULL) {
G_debug(1, "Line style: '%s'", vector.layer[n].linestyle);
G_strip(vector.layer[n].linestyle);
ptr = vector.layer[n].linestyle;
while (*ptr && (*ptr < '1' || *ptr > '9')) {
lz++;
ptr++;
}
if (lz) {
sprintf(buf, "%d ", lz);
strcat(dashes, buf);
}
while (*ptr) {
dig = 0;
while (*ptr >= '1' && *ptr <= '9') {
dig++;
ptr++;
}
if (dig) {
sprintf(buf, "%d ", dig);
strcat(dashes, buf);
}
z = 0;
while (*ptr && (*ptr < '1' || *ptr > '9')) {
z++;
ptr++;
}
if (z) {
sprintf(buf, "%d ", z);
strcat(dashes, buf);
}
}
}
sprintf(buf, "] %d", lz);
strcat(dashes, buf);
fprintf(PS.fp, "%s setdash\n", dashes);
vector.layer[n].setdash = G_store(dashes);
if (vector.layer[n].linestyle != NULL)
G_debug(1, "Dash style: '%s setdash'", dashes);
PS_vlines_plot(&Map, n, LINE_DRAW_LINE);
}
Vect_close(&Map);
fprintf(PS.fp, "[] 0 setdash\n");
}
return 0;
}