void readHeaderString(FILE * fp, char *valueString, double *value)
{
static char format[100];
char line_buff[1024];
/* to avoid buffer overflows we use G_snprintf */
G_snprintf(format, 100, "%s %%lf", valueString);
G_getl2(line_buff, 1024, fp);
if (sscanf(line_buff, format, value) != 1) {
G_debug(3, "bad value for [%s]", valueString);
fatalError("readHeaderString: header value invalid");
}
}
/*!
\brief Get color rules description for Option->descriptions
\return allocated buffer with descriptions
*/
char *G_color_rules_descriptions(void)
{
char path[GPATH_MAX];
struct Key_Value *kv;
int result_len, result_max;
char *result, **rules;
const char *name, *desc;
int i, len, nrules;
result_len = 0;
result_max = 2000;
result = G_malloc(result_max);
G_snprintf(path, GPATH_MAX, "%s/etc/colors.desc", G_gisbase());
kv = G_read_key_value_file(path);
if (!kv)
return NULL;
rules = scan_rules(&nrules);
for (i = 0; i < nrules; i++) {
name = rules[i];
desc = G_find_key_value(name, kv);
if (!desc)
desc = _("no description");
/* desc = _(desc); */
len = strlen(name) + strlen(desc) + 2;
if (result_len + len >= result_max) {
result_max = result_len + len + 1000;
result = G_realloc(result, result_max);
}
sprintf(result + result_len, "%s;%s;", name, desc);
result_len += len;
}
G_free_key_value(kv);
G_free(rules);
return result;
}
static void wps_print_literal_input_output(int inout_type, int min, int max, const char *identifier,
const char *title, const char *abstract, const char *datatype, int unitofmesure,
const char **choices, int num_choices, const char *default_value, int type)
{
int i;
char range[2][24];
char *str;
if(inout_type == WPS_INPUT)
fprintf(stdout,"\t\t\t<Input minOccurs=\"%i\" maxOccurs=\"%i\">\n", min, max);
else if(inout_type == WPS_OUTPUT)
fprintf(stdout,"\t\t\t<Output>\n");
wps_print_ident_title_abstract(identifier, title, abstract);
fprintf(stdout,"\t\t\t\t<LiteralData>\n");
if(datatype)
fprintf(stdout,"\t\t\t\t\t<ows:DataType ows:reference=\"xs:%s\">%s</ows:DataType>\n", datatype, datatype);
if(unitofmesure)
{
fprintf(stdout,"\t\t\t\t\t<UOMs>\n");
fprintf(stdout,"\t\t\t\t\t\t<Default>\n");
fprintf(stdout,"\t\t\t\t\t\t\t<ows:UOM>meters</ows:UOM>\n");
fprintf(stdout,"\t\t\t\t\t\t</Default>\n");
fprintf(stdout,"\t\t\t\t\t\t<Supported>\n");
fprintf(stdout,"\t\t\t\t\t\t\t<ows:UOM>meters</ows:UOM>\n");
fprintf(stdout,"\t\t\t\t\t\t\t<ows:UOM>degrees</ows:UOM>\n");
fprintf(stdout,"\t\t\t\t\t\t</Supported>\n");
fprintf(stdout,"\t\t\t\t\t</UOMs>\n");
}
if(num_choices == 0 || choices == NULL)
fprintf(stdout,"\t\t\t\t\t<ows:AnyValue/>\n");
else
{
/* Check for range values */
if(strcmp(datatype, "integer") == 0 || strcmp(datatype, "float") == 0) {
str = strtok((char*)choices[0], "-");
if(str != NULL) {
G_snprintf(range[0], 24, "%s", str);
str = strtok(NULL, "-");
if(str != NULL) {
G_snprintf(range[1], 24, "%s", str);
type = TYPE_RANGE;
}
}
}
fprintf(stdout,"\t\t\t\t\t<ows:AllowedValues>\n");
if(type == TYPE_RANGE)
{
fprintf(stdout,"\t\t\t\t\t\t<ows:Range ows:rangeClosure=\"closed\">\n");
fprintf(stdout,"\t\t\t\t\t\t\t<ows:MinimumValue>%s</ows:MinimumValue>\n", range[0]);
fprintf(stdout,"\t\t\t\t\t\t\t<ows:MaximumValue>%s</ows:MaximumValue>\n", range[1]);
fprintf(stdout,"\t\t\t\t\t\t</ows:Range>\n");
}
else
{
for(i = 0; i < num_choices; i++)
{
fprintf(stdout,"\t\t\t\t\t\t<ows:Value>");
print_escaped_for_xml(stdout, choices[i]);
fprintf(stdout,"</ows:Value>\n");
}
}
fprintf(stdout,"\t\t\t\t\t</ows:AllowedValues>\n");
}
if(default_value)
{
fprintf(stdout,"\t\t\t\t\t<DefaultValue>");
print_escaped_for_xml(stdout, default_value);
fprintf(stdout,"</DefaultValue>\n");
}
fprintf(stdout,"\t\t\t\t</LiteralData>\n");
if(inout_type == WPS_INPUT)
fprintf(stdout,"\t\t\t</Input>\n");
else if(inout_type == WPS_OUTPUT)
fprintf(stdout,"\t\t\t</Output>\n");
}
/*!
\brief Select array of ordered integers from table/column
\param driver DB driver
\param tab table name
\param col column name
\param where where statement
\param[out] pval array of ordered integer values
\return number of selected values
\return -1 on error
*/
int db_select_int(dbDriver * driver, const char *tab, const char *col,
const char *where, int **pval)
{
int type, more, alloc, count;
int *val;
char buf[1024];
const char *sval;
dbString stmt;
dbCursor cursor;
dbColumn *column;
dbValue *value;
dbTable *table;
G_debug(3, "db_select_int()");
if (col == NULL || strlen(col) == 0) {
G_warning(_("Missing column name"));
return -1;
}
/* allocate */
alloc = 1000;
val = (int *)G_malloc(alloc * sizeof(int));
if (where == NULL || strlen(where) == 0)
G_snprintf(buf, 1023, "SELECT %s FROM %s", col, tab);
else
G_snprintf(buf, 1023, "SELECT %s FROM %s WHERE %s", col, tab, where);
G_debug(3, " SQL: %s", buf);
db_init_string(&stmt);
db_append_string(&stmt, buf);
if (db_open_select_cursor(driver, &stmt, &cursor, DB_SEQUENTIAL) != DB_OK)
return (-1);
table = db_get_cursor_table(&cursor);
column = db_get_table_column(table, 0); /* first column */
if (column == NULL) {
return -1;
}
value = db_get_column_value(column);
type = db_get_column_sqltype(column);
type = db_sqltype_to_Ctype(type);
/* fetch the data */
count = 0;
while (1) {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
return (-1);
if (!more)
break;
if (count == alloc) {
alloc += 1000;
val = (int *)G_realloc(val, alloc * sizeof(int));
}
switch (type) {
case (DB_C_TYPE_INT):
val[count] = db_get_value_int(value);
break;
case (DB_C_TYPE_STRING):
sval = db_get_value_string(value);
val[count] = atoi(sval);
break;
case (DB_C_TYPE_DOUBLE):
val[count] = (int)db_get_value_double(value);
break;
default:
return (-1);
}
count++;
}
db_close_cursor(&cursor);
db_free_string(&stmt);
qsort((void *)val, count, sizeof(int), cmp);
*pval = val;
return (count);
}
int main(int argc, char *argv[])
{
const char *input, *source, *output;
char *title;
struct Cell_head cellhd;
GDALDatasetH hDS;
GDALRasterBandH hBand;
struct GModule *module;
struct {
struct Option *input, *source, *output, *band, *title;
} parm;
struct {
struct Flag *o, *f, *e, *h, *v, *t;
} flag;
int min_band, max_band, band;
struct band_info info;
int flip;
struct Ref reference;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("import"));
G_add_keyword(_("external"));
module->description =
_("Links GDAL supported raster data as a pseudo GRASS raster map.");
parm.input = G_define_standard_option(G_OPT_F_INPUT);
parm.input->description = _("Name of raster file to be linked");
parm.input->required = NO;
parm.input->guisection = _("Input");
parm.source = G_define_option();
parm.source->key = "source";
parm.source->description = _("Name of non-file GDAL data source");
parm.source->required = NO;
parm.source->type = TYPE_STRING;
parm.source->key_desc = "name";
parm.source->guisection = _("Input");
parm.output = G_define_standard_option(G_OPT_R_OUTPUT);
parm.band = G_define_option();
parm.band->key = "band";
parm.band->type = TYPE_INTEGER;
parm.band->required = NO;
parm.band->description = _("Band to select (default is all bands)");
parm.band->guisection = _("Input");
parm.title = G_define_option();
parm.title->key = "title";
parm.title->key_desc = "phrase";
parm.title->type = TYPE_STRING;
parm.title->required = NO;
parm.title->description = _("Title for resultant raster map");
parm.title->guisection = _("Metadata");
flag.f = G_define_flag();
flag.f->key = 'f';
flag.f->description = _("List supported formats and exit");
flag.f->guisection = _("Print");
flag.f->suppress_required = YES;
flag.o = G_define_flag();
flag.o->key = 'o';
flag.o->label =
_("Override projection check (use current location's projection)");
flag.o->description =
_("Assume that the dataset has same projection as the current location");
flag.e = G_define_flag();
flag.e->key = 'e';
flag.e->label = _("Extend region extents based on new dataset");
flag.e->description = _("Also updates the default region if in the PERMANENT mapset");
flag.h = G_define_flag();
flag.h->key = 'h';
flag.h->description = _("Flip horizontally");
flag.v = G_define_flag();
flag.v->key = 'v';
flag.v->description = _("Flip vertically");
flag.t = G_define_flag();
flag.t->key = 't';
flag.t->label =
_("List available bands including band type in dataset and exit");
flag.t->description = _("Format: band number,type,projection check");
flag.t->guisection = _("Print");
flag.t->suppress_required = YES;
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
GDALAllRegister();
if (flag.f->answer) {
list_formats();
exit(EXIT_SUCCESS);
}
input = parm.input->answer;
source = parm.source->answer;
output = parm.output->answer;
flip = 0;
if (flag.h->answer)
flip |= FLIP_H;
if (flag.v->answer)
flip |= FLIP_V;
if (parm.title->answer) {
title = G_store(parm.title->answer);
G_strip(title);
}
else
title = NULL;
if (!input && !source)
G_fatal_error(_("%s= or %s= must be given"),
parm.input->key, parm.source->key);
if (input && source)
G_fatal_error(_("%s= and %s= are mutually exclusive"),
parm.input->key, parm.source->key);
if (input && !G_is_absolute_path(input)) {
char path[GPATH_MAX], *cwd;
cwd = CPLGetCurrentDir();
if (!cwd)
G_fatal_error(_("Unable to get current working directory"));
G_snprintf(path, GPATH_MAX, "%s%c%s", cwd, HOST_DIRSEP, input);
input = G_store(path);
CPLFree(cwd);
}
if (!input)
input = source;
hDS = GDALOpen(input, GA_ReadOnly);
if (hDS == NULL)
return 1;
setup_window(&cellhd, hDS, &flip);
if (flag.t->answer) {
list_bands(&cellhd, hDS);
/* close the GDALDataset to avoid segfault in libgdal */
GDALClose(hDS);
exit(EXIT_SUCCESS);
}
check_projection(&cellhd, hDS, flag.o->answer);
Rast_set_window(&cellhd);
if (parm.band->answer)
min_band = max_band = atoi(parm.band->answer);
else
min_band = 1, max_band = GDALGetRasterCount(hDS);
G_verbose_message(_("Proceeding with import..."));
if (max_band > min_band) {
if (I_find_group(output) == 1)
G_warning(_("Imagery group <%s> already exists and will be overwritten."), output);
I_init_group_ref(&reference);
}
for (band = min_band; band <= max_band; band++) {
char *output2, *title2 = NULL;
G_message(_("Reading band %d of %d..."),
band, GDALGetRasterCount( hDS ));
hBand = GDALGetRasterBand(hDS, band);
if (!hBand)
G_fatal_error(_("Selected band (%d) does not exist"), band);
if (max_band > min_band) {
G_asprintf(&output2, "%s.%d", output, band);
if (title)
G_asprintf(&title2, "%s (band %d)", title, band);
G_debug(1, "Adding raster map <%s> to group <%s>", output2, output);
I_add_file_to_group_ref(output2, G_mapset(), &reference);
}
else {
output2 = G_store(output);
if (title)
title2 = G_store(title);
}
query_band(hBand, output2, &cellhd, &info);
create_map(input, band, output2, &cellhd, &info, title, flip);
G_free(output2);
G_free(title2);
}
/* close the GDALDataset to avoid segfault in libgdal */
GDALClose(hDS);
if (flag.e->answer)
update_default_window(&cellhd);
/* Create the imagery group if multiple bands are imported */
if (max_band > min_band) {
I_put_group_ref(output, &reference);
I_put_group(output);
G_message(_("Imagery group <%s> created"), output);
}
exit(EXIT_SUCCESS);
}