void color_rules_to_cats(dbCatValArray *cvarr, int is_fp,
struct Colors *vcolors, struct Colors *colors)
{
int i, cat;
dbCatVal *cv;
int red, grn, blu;
/* color table for categories */
G_message(_("Converting color rules into categories..."));
for (i = 0; i < cvarr->n_values; i++) {
cv = &(cvarr->value[i]);
cat = cv->cat;
if (is_fp) {
if (Rast_get_d_color((const DCELL *) &(cv->val.d), &red, &grn, &blu,
vcolors) == 0) {
/* G_warning(_("No color rule defined for value %f"), cv->val.d); */
G_debug(3, "scan_attr(): cat=%d, val=%f -> no color rule", cat, cv->val.d);
continue;
}
}
else {
if (Rast_get_c_color((const CELL *) &(cv->val.i), &red, &grn, &blu,
vcolors) == 0) {
/* G_warning(_("No color rule defined for value %d"), cv->val.i); */
G_debug(3, "scan_attr(): cat=%d, val=%d -> no color rule", cat, cv->val.i);
continue;
}
}
G_debug(3, "scan_attr(): cat=%d, val=%f, r=%d, g=%d, b=%d",
cat, is_fp ? cv->val.d : cv->val.i, red, grn, blu);
Rast_add_c_color_rule((const CELL*) &cat, red, grn, blu,
(const CELL*) &cat, red, grn, blu, colors);
}
}
int support(char **names,
struct Cell_stats *statf, int nfiles,
struct Categories *cats,
int *cats_ok,
struct Colors *colr, int *colr_ok, RASTER_MAP_TYPE out_type)
{
int i;
struct Categories pcats;
struct Colors pcolr;
CELL n;
long count;
int red, grn, blu;
int do_cats, do_colr;
*cats_ok = 1;
*colr_ok = 1;
if (Rast_read_cats(names[0], "", cats) < 0)
*cats_ok = 0;
G_suppress_warnings(1);
if (Rast_read_colors(names[0], "", colr) < 0)
*colr_ok = 0;
G_suppress_warnings(0);
if (*cats_ok == 0 && *colr_ok == 0)
return 0;
for (i = 1; i < nfiles; i++) {
do_cats = *cats_ok && (Rast_read_cats(names[i], "", &pcats) >= 0);
G_suppress_warnings(1);
do_colr = *colr_ok && (Rast_read_colors(names[i], "", &pcolr) >= 0);
G_suppress_warnings(0);
if (!do_cats && !do_colr)
continue;
if (out_type == CELL_TYPE) {
Rast_rewind_cell_stats(statf + i);
while (Rast_next_cell_stat(&n, &count, statf + i))
if (n && !Rast_find_cell_stat(n, &count, statf)) {
if (do_cats) {
Rast_update_cell_stats(&n, 1, statf);
Rast_set_c_cat(&n, &n, Rast_get_c_cat((CELL *) &n, &pcats), cats);
}
if (do_colr) {
Rast_get_c_color(&n, &red, &grn, &blu, &pcolr);
Rast_set_c_color(n, red, grn, blu, colr);
}
}
}
/* else the color will be the color of the first map */
if (do_cats)
Rast_free_cats(&pcats);
if (do_colr)
/* otherwise this memory is used in colr pointer */
Rast_free_colors(&pcolr);
}
return 1;
}
static void forced_write_old_colors(FILE * fd, struct Colors *colors)
{
int red, grn, blu;
CELL cat;
fprintf(fd, "#%ld first color\n", (long)colors->cmin);
cat = 0;
Rast_get_c_color(&cat, &red, &grn, &blu, colors);
fprintf(fd, "%d %d %d\n", red, grn, blu);
for (cat = colors->cmin; cat <= colors->cmax; cat++) {
Rast_get_c_color(&cat, &red, &grn, &blu, colors);
fprintf(fd, "%d", red);
if (red != grn || red != blu)
fprintf(fd, " %d %d", grn, blu);
fprintf(fd, "\n");
}
}
int get_table_color(int cat, int line,
struct Colors *colors, dbCatValArray *cvarr,
int *red, int *grn, int *blu)
{
int custom_rgb;
char colorstring[12]; /* RRR:GGG:BBB */
dbCatVal *cv;
custom_rgb = FALSE;
cv = NULL;
if (cat < 0)
return custom_rgb;
if (colors) {
/* read color table */
if (Rast_get_c_color(&cat, red, grn, blu, colors) == 1) {
custom_rgb = TRUE;
G_debug(3, "\tb: %d, g: %d, r: %d", *blu, *grn, *red);
}
}
/* read RGB colors from db for current area # */
if (cvarr && db_CatValArray_get_value(cvarr, cat, &cv) == DB_OK) {
sprintf(colorstring, "%s", db_get_string(cv->val.s));
if (*colorstring != '\0') {
G_debug(3, "element %d: colorstring: %s", line,
colorstring);
if (G_str_to_color(colorstring, red, grn, blu) == 1) {
custom_rgb = TRUE;
G_debug(3, "element:%d cat %d r:%d g:%d b:%d",
line, cat, *red, *grn, *blu);
}
else {
G_debug(3, "Invalid color definition '%s' ignored", colorstring);
ncolor_rules_skipped++;
}
}
else {
G_debug(3, "Invalid color definition '%s' ignored", colorstring);
ncolor_rules_skipped++;
}
}
return custom_rgb;
}
GRASSRasterBand::GRASSRasterBand( GRASSDataset *poDS, int nBand,
const char * pszMapset,
const char * pszCellName )
{
struct Cell_head sCellInfo;
// Note: GISDBASE, LOCATION_NAME ans MAPSET was set in GRASSDataset::Open
this->poDS = poDS;
this->nBand = nBand;
this->valid = false;
this->pszCellName = G_store ( (char *) pszCellName );
this->pszMapset = G_store ( (char *) pszMapset );
G_get_cellhd( (char *) pszCellName, (char *) pszMapset, &sCellInfo );
nGRSType = G_raster_map_type( (char *) pszCellName, (char *) pszMapset );
/* -------------------------------------------------------------------- */
/* Get min/max values. */
/* -------------------------------------------------------------------- */
struct FPRange sRange;
if( G_read_fp_range( (char *) pszCellName, (char *) pszMapset,
&sRange ) == -1 )
{
bHaveMinMax = FALSE;
}
else
{
bHaveMinMax = TRUE;
G_get_fp_range_min_max( &sRange, &dfCellMin, &dfCellMax );
}
/* -------------------------------------------------------------------- */
/* Setup band type, and preferred nodata value. */
/* -------------------------------------------------------------------- */
// Negative values are also (?) stored as 4 bytes (format = 3)
// => raster with format < 3 has only positive values
// GRASS modules usually do not waste space and only the format necessary to keep
// full raster values range is used -> no checks if shorter type could be used
if( nGRSType == CELL_TYPE ) {
if ( sCellInfo.format == 0 ) { // 1 byte / cell -> possible range 0,255
if ( bHaveMinMax && dfCellMin > 0 ) {
this->eDataType = GDT_Byte;
dfNoData = 0.0;
} else if ( bHaveMinMax && dfCellMax < 255 ) {
this->eDataType = GDT_Byte;
dfNoData = 255.0;
} else { // maximum is not known or full range is used
this->eDataType = GDT_UInt16;
dfNoData = 256.0;
}
nativeNulls = false;
} else if ( sCellInfo.format == 1 ) { // 2 bytes / cell -> possible range 0,65535
if ( bHaveMinMax && dfCellMin > 0 ) {
this->eDataType = GDT_UInt16;
dfNoData = 0.0;
} else if ( bHaveMinMax && dfCellMax < 65535 ) {
this->eDataType = GDT_UInt16;
dfNoData = 65535;
} else { // maximum is not known or full range is used
CELL cval;
this->eDataType = GDT_Int32;
G_set_c_null_value ( &cval, 1);
dfNoData = (double) cval;
nativeNulls = true;
}
nativeNulls = false;
} else { // 3-4 bytes
CELL cval;
this->eDataType = GDT_Int32;
G_set_c_null_value ( &cval, 1);
dfNoData = (double) cval;
nativeNulls = true;
}
}
else if( nGRSType == FCELL_TYPE ) {
FCELL fval;
this->eDataType = GDT_Float32;
G_set_f_null_value ( &fval, 1);
dfNoData = (double) fval;
nativeNulls = true;
}
else if( nGRSType == DCELL_TYPE )
{
DCELL dval;
this->eDataType = GDT_Float64;
G_set_d_null_value ( &dval, 1);
dfNoData = (double) dval;
nativeNulls = true;
}
nBlockXSize = poDS->nRasterXSize;;
nBlockYSize = 1;
G_set_window( &(((GRASSDataset *)poDS)->sCellInfo) );
if ( (hCell = G_open_cell_old((char *) pszCellName, (char *) pszMapset)) < 0 ) {
CPLError( CE_Warning, CPLE_AppDefined, "GRASS: Cannot open raster '%s'", pszCellName );
return;
}
G_copy((void *) &sOpenWindow, (void *) &(((GRASSDataset *)poDS)->sCellInfo), sizeof(struct Cell_head));
/* -------------------------------------------------------------------- */
/* Do we have a color table? */
/* -------------------------------------------------------------------- */
poCT = NULL;
if( G_read_colors( (char *) pszCellName, (char *) pszMapset, &sGrassColors ) == 1 )
{
int maxcolor;
CELL min, max;
G_get_color_range ( &min, &max, &sGrassColors);
if ( bHaveMinMax ) {
if ( max < dfCellMax ) {
maxcolor = max;
} else {
maxcolor = (int) ceil ( dfCellMax );
}
if ( maxcolor > GRASS_MAX_COLORS ) {
maxcolor = GRASS_MAX_COLORS;
CPLDebug( "GRASS", "Too many values, color table cut to %d entries.", maxcolor );
}
} else {
if ( max < GRASS_MAX_COLORS ) {
maxcolor = max;
} else {
maxcolor = GRASS_MAX_COLORS;
CPLDebug( "GRASS", "Too many values, color table set to %d entries.", maxcolor );
}
}
poCT = new GDALColorTable();
for( int iColor = 0; iColor <= maxcolor; iColor++ )
{
int nRed, nGreen, nBlue;
GDALColorEntry sColor;
#if GRASS_VERSION_MAJOR >= 7
if( Rast_get_c_color( &iColor, &nRed, &nGreen, &nBlue, &sGrassColors ) )
#else
if( G_get_color( iColor, &nRed, &nGreen, &nBlue, &sGrassColors ) )
#endif
{
sColor.c1 = nRed;
sColor.c2 = nGreen;
sColor.c3 = nBlue;
sColor.c4 = 255;
poCT->SetColorEntry( iColor, &sColor );
}
else
{
sColor.c1 = 0;
sColor.c2 = 0;
sColor.c3 = 0;
sColor.c4 = 0;
poCT->SetColorEntry( iColor, &sColor );
}
}
/* Create metadata enries for color table rules */
char key[200], value[200];
int rcount = G_colors_count ( &sGrassColors );
sprintf ( value, "%d", rcount );
this->SetMetadataItem( "COLOR_TABLE_RULES_COUNT", value );
/* Add the rules in reverse order */
for ( int i = rcount-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, &sGrassColors, i );
sprintf ( key, "COLOR_TABLE_RULE_RGB_%d", rcount-i-1 );
sprintf ( value, "%e %e %d %d %d %d %d %d", val1, val2, r1, g1, b1, r2, g2, b2 );
this->SetMetadataItem( key, value );
}
} else {
this->SetMetadataItem( "COLOR_TABLE_RULES_COUNT", "0" );
}
this->valid = true;
}
void write_rgb_values(const struct Map_info *Map, int layer, const char *column_name,
struct Colors *colors)
{
int ctype, nrec, i;
int red, grn, blu;
int *pval;
char buf[1024];
struct field_info *fi;
dbDriver *driver;
dbString stmt;
fi = Vect_get_field(Map, layer);
if (!fi)
G_fatal_error(_("Database connection not defined for layer %d"),
layer);
driver = db_start_driver_open_database(fi->driver, fi->database);
if (!driver)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
fi->database, fi->driver);
db_set_error_handler_driver(driver);
db_init_string(&stmt);
ctype = db_column_Ctype(driver, fi->table, column_name);
if (ctype == -1) {
sprintf(buf, "ALTER TABLE %s ADD COLUMN %s VARCHAR(11)",
fi->table, column_name);
db_set_string(&stmt, buf);
if (db_execute_immediate(driver, &stmt) != DB_OK)
G_fatal_error(_("Unable to add column <%s> to table <%s>"),
column_name, fi->table);
/*
db_add_column needs to be implemented for DB drivers first...
dbString table;
dbColumn column;
db_init_column(&column);
db_set_column_name(&column, column_name);
db_set_column_sqltype(&column, DB_SQL_TYPE_CHARACTER);
db_set_column_null_allowed(&column);
db_set_column_length(&column, 11);
db_init_string(&table);
db_set_string(&table, fi->table);
if (db_add_column(driver, &table, &column) != DB_OK)
G_fatal_error(_("Unable to add column <%s> to table <%s>"),
column_name, fi->table);
db_free_column(&column);
*/
G_important_message(_("Column <%s> added to table <%s>"),
column_name, fi->table);
}
else if (ctype != DB_C_TYPE_STRING)
G_fatal_error(_("Data type of column <%s> must be char"), column_name);
nrec = db_select_int(driver, fi->table, fi->key, NULL, &pval);
if (nrec < 1) {
G_warning(_("No categories found"));
return;
}
db_begin_transaction(driver);
for (i = 0; i < nrec; i++) {
G_percent(i, nrec, 2);
if (Rast_get_c_color((const CELL *) &(pval[i]), &red, &grn, &blu,
colors) == 0)
G_warning(_("No color value defined for category %d"), pval[i]);
sprintf(buf, "UPDATE %s SET %s='%d:%d:%d' WHERE %s=%d", fi->table,
column_name, red, grn, blu, fi->key, pval[i]);
G_debug(3, "\tSQL: %s", buf);
db_set_string(&stmt, buf);
if (db_execute_immediate(driver, &stmt) != DB_OK)
G_fatal_error(_("Unable to update RGB values"));
}
G_percent(1, 1, 1);
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
/* actual raster band export
* returns 0 on success
* -1 on raster data read/write error
* */
int export_band(GDALDatasetH hMEMDS, int band,
const char *name, const char *mapset,
struct Cell_head *cellhead, RASTER_MAP_TYPE maptype,
double nodataval, int suppress_main_colortable)
{
struct Colors sGrassColors;
GDALColorTableH hCT;
int iColor;
int bHaveMinMax;
double dfCellMin;
double dfCellMax;
struct FPRange sRange;
int fd;
int cols = cellhead->cols;
int rows = cellhead->rows;
int ret = 0;
char value[200];
/* Open GRASS raster */
fd = Rast_open_old(name, mapset);
/* Get raster band */
GDALRasterBandH hBand = GDALGetRasterBand(hMEMDS, band);
if (hBand == NULL) {
G_warning(_("Unable to get raster band"));
return -1;
}
/* Get min/max values. */
if (Rast_read_fp_range(name, mapset, &sRange) == -1) {
bHaveMinMax = FALSE;
}
else {
bHaveMinMax = TRUE;
Rast_get_fp_range_min_max(&sRange, &dfCellMin, &dfCellMax);
}
sprintf(value, "GRASS GIS %s", GRASS_VERSION_NUMBER);
GDALSetMetadataItem(hBand, "Generated_with", value, NULL);
/* use default color rules if no color rules are given */
if (Rast_read_colors(name, mapset, &sGrassColors) >= 0) {
int maxcolor, i;
CELL min, max;
char key[200];
int rcount;
Rast_get_c_color_range(&min, &max, &sGrassColors);
if (bHaveMinMax) {
if (max < dfCellMax) {
maxcolor = max;
}
else {
maxcolor = (int)ceil(dfCellMax);
}
if (maxcolor > GRASS_MAX_COLORS) {
maxcolor = GRASS_MAX_COLORS;
G_warning("Too many values, color table cut to %d entries",
maxcolor);
}
}
else {
if (max < GRASS_MAX_COLORS) {
maxcolor = max;
}
else {
maxcolor = GRASS_MAX_COLORS;
G_warning("Too many values, color table set to %d entries",
maxcolor);
}
}
rcount = Rast_colors_count(&sGrassColors);
G_debug(3, "dfCellMin: %f, dfCellMax: %f, maxcolor: %d", dfCellMin,
dfCellMax, maxcolor);
if (!suppress_main_colortable) {
hCT = GDALCreateColorTable(GPI_RGB);
for (iColor = 0; iColor <= maxcolor; iColor++) {
int nRed, nGreen, nBlue;
GDALColorEntry sColor;
if (Rast_get_c_color(&iColor, &nRed, &nGreen, &nBlue,
&sGrassColors)) {
sColor.c1 = nRed;
sColor.c2 = nGreen;
sColor.c3 = nBlue;
sColor.c4 = 255;
G_debug(3,
"Rast_get_c_color: Y, rcount %d, nRed %d, nGreen %d, nBlue %d",
rcount, nRed, nGreen, nBlue);
GDALSetColorEntry(hCT, iColor, &sColor);
}
else {
sColor.c1 = 0;
sColor.c2 = 0;
sColor.c3 = 0;
sColor.c4 = 0;
G_debug(3,
"Rast_get_c_color: N, rcount %d, nRed %d, nGreen %d, nBlue %d",
rcount, nRed, nGreen, nBlue);
GDALSetColorEntry(hCT, iColor, &sColor);
}
}
GDALSetRasterColorTable(hBand, hCT);
}
if (rcount > 0) {
/* Create metadata entries for color table rules */
sprintf(value, "%d", rcount);
GDALSetMetadataItem(hBand, "COLOR_TABLE_RULES_COUNT", value,
NULL);
}
/* Add the rules in reverse order */
/* This can cause a GDAL warning with many rules, something like
* Warning 1: Lost metadata writing to GeoTIFF ... too large to fit in tag. */
for (i = rcount - 1; i >= 0; i--) {
DCELL val1, val2;
unsigned char r1, g1, b1, r2, g2, b2;
Rast_get_fp_color_rule(&val1, &r1, &g1, &b1, &val2, &r2, &g2, &b2,
&sGrassColors, i);
sprintf(key, "COLOR_TABLE_RULE_RGB_%d", rcount - i - 1);
sprintf(value, "%e %e %d %d %d %d %d %d", val1, val2, r1, g1, b1,
r2, g2, b2);
GDALSetMetadataItem(hBand, key, value, NULL);
}
}
/* Create GRASS raster buffer */
void *bufer = Rast_allocate_buf(maptype);
if (bufer == NULL) {
G_warning(_("Unable to allocate buffer for reading raster map"));
return -1;
}
/* the following routine must be kept identical to exact_checks */
/* Copy data form GRASS raster to GDAL raster */
int row, col;
int n_nulls = 0;
/* Better use selected GDAL datatype instead of
* the best match with GRASS raster map types ? */
if (maptype == FCELL_TYPE) {
/* Source datatype understandable by GDAL */
GDALDataType datatype = GDT_Float32;
FCELL fnullval = (FCELL) nodataval;
G_debug(1, "FCELL nodata val: %f", fnullval);
for (row = 0; row < rows; row++) {
Rast_get_row(fd, bufer, row, maptype);
for (col = 0; col < cols; col++) {
if (Rast_is_f_null_value(&((FCELL *) bufer)[col])) {
((FCELL *) bufer)[col] = fnullval;
if (n_nulls == 0) {
GDALSetRasterNoDataValue(hBand, nodataval);
}
n_nulls++;
}
}
if (GDALRasterIO
(hBand, GF_Write, 0, row, cols, 1, bufer, cols, 1, datatype,
0, 0) >= CE_Failure) {
G_warning(_("Unable to write GDAL raster file"));
return -1;
}
G_percent(row + 1, rows, 2);
}
}
else if (maptype == DCELL_TYPE) {
GDALDataType datatype = GDT_Float64;
DCELL dnullval = (DCELL) nodataval;
G_debug(1, "DCELL nodata val: %f", dnullval);
for (row = 0; row < rows; row++) {
Rast_get_row(fd, bufer, row, maptype);
for (col = 0; col < cols; col++) {
if (Rast_is_d_null_value(&((DCELL *) bufer)[col])) {
((DCELL *) bufer)[col] = dnullval;
if (n_nulls == 0) {
GDALSetRasterNoDataValue(hBand, nodataval);
}
n_nulls++;
}
}
if (GDALRasterIO
(hBand, GF_Write, 0, row, cols, 1, bufer, cols, 1, datatype,
0, 0) >= CE_Failure) {
G_warning(_("Unable to write GDAL raster file"));
return -1;
}
G_percent(row + 1, rows, 2);
}
}
else {
GDALDataType datatype = GDT_Int32;
CELL inullval = (CELL) nodataval;
G_debug(1, "CELL nodata val: %d", inullval);
for (row = 0; row < rows; row++) {
Rast_get_row(fd, bufer, row, maptype);
for (col = 0; col < cols; col++) {
if (Rast_is_c_null_value(&((CELL *) bufer)[col])) {
((CELL *) bufer)[col] = inullval;
if (n_nulls == 0) {
GDALSetRasterNoDataValue(hBand, nodataval);
}
n_nulls++;
}
}
if (GDALRasterIO
(hBand, GF_Write, 0, row, cols, 1, bufer, cols, 1, datatype,
0, 0) >= CE_Failure) {
G_warning(_("Unable to write GDAL raster file"));
return -1;
}
G_percent(row + 1, rows, 2);
}
}
Rast_close(fd);
G_free(bufer);
return ret;
}
int close_array_seg(void)
{
struct Colors colors;
int incr, max, red, green, blue, rd, gr, bl, flag;
int c, r, map_fd;
CELL *cellrow, value;
CELL *theseg;
RAMSEG thesegseg;
cellrow = Rast_allocate_c_buf();
if (seg_flag || bas_flag || haf_flag) {
if (seg_flag) {
theseg = bas;
thesegseg = bas_seg;
}
else if (bas_flag) {
theseg = bas;
thesegseg = bas_seg;
}
else {
theseg = haf;
thesegseg = haf_seg;
}
max = n_basins;
G_debug(1, "%d basins created", max);
Rast_init_colors(&colors);
if (max > 0)
Rast_make_random_colors(&colors, 1, max);
else {
G_warning(_("No basins were created. Verify threshold and region settings."));
Rast_make_random_colors(&colors, 1, 2);
}
if (max < 1000 && max > 0) {
Rast_set_c_color((CELL) 0, 0, 0, 0, &colors);
r = 1;
incr = 0;
while (incr >= 0) {
G_percent(r, max, 2);
for (gr = 130 + incr; gr <= 255; gr += 20) {
for (rd = 90 + incr; rd <= 255; rd += 30) {
for (bl = 90 + incr; bl <= 255; bl += 40) {
flag = 1;
while (flag) {
Rast_get_c_color(&r, &red, &green, &blue, &colors);
/* if existing rule is too dark then append a new
rule to override it */
if ((blue * .11 + red * .30 + green * .59) <
100) {
Rast_set_c_color(r, rd, gr, bl, &colors);
flag = 0;
}
if (++r > max) {
gr = rd = bl = 300;
flag = 0;
incr = -1;
}
}
}
}
}
if (incr >= 0) {
incr += 15;
if (incr > 120)
incr = 7;
}
}
G_percent(r - 1, max, 3); /* finish it */
}
else
G_debug(1,
"Too many subbasins to reasonably check for color brightness");
/* using the existing stack of while/for/for/for/while loops ... */
}
/* stream segments map */
if (seg_flag) {
map_fd = Rast_open_c_new(seg_name);
for (r = 0; r < nrows; r++) {
Rast_set_c_null_value(cellrow, ncols); /* reset row to all NULL */
for (c = 0; c < ncols; c++) {
value = FLAG_GET(swale, r, c);
if (value)
cellrow[c] = bas[SEG_INDEX(bas_seg, r, c)];
}
Rast_put_row(map_fd, cellrow, CELL_TYPE);
}
Rast_close(map_fd);
Rast_write_colors(seg_name, this_mapset, &colors);
}
/* basins map */
if (bas_flag) {
map_fd = Rast_open_c_new(bas_name);
for (r = 0; r < nrows; r++) {
for (c = 0; c < ncols; c++) {
cellrow[c] = bas[SEG_INDEX(bas_seg, r, c)];
if (cellrow[c] == 0)
Rast_set_c_null_value(cellrow + c, 1);
}
Rast_put_row(map_fd, cellrow, CELL_TYPE);
}
Rast_close(map_fd);
Rast_write_colors(bas_name, this_mapset, &colors);
}
/* half_basins map */
if (haf_flag) {
map_fd = Rast_open_c_new(haf_name);
for (r = 0; r < nrows; r++) {
for (c = 0; c < ncols; c++) {
cellrow[c] = haf[SEG_INDEX(haf_seg, r, c)];
if (cellrow[c] == 0)
Rast_set_c_null_value(cellrow + c, 1);
}
Rast_put_row(map_fd, cellrow, CELL_TYPE);
}
Rast_close(map_fd);
Rast_write_colors(haf_name, this_mapset, &colors);
}
if (seg_flag || bas_flag || haf_flag)
Rast_free_colors(&colors);
G_free(haf);
G_free(bas);
G_free(cellrow);
if (arm_flag)
fclose(fp);
close_maps();
return 0;
}
/*!
\brief Load styles for geolines based on thematic mapping
\param gv pointer to geovect structure
\param colors pointer to Colors structure or NULL
\return number of features defined by thematic mapping
\return -1 on error
*/
int Gv_load_vect_thematic(geovect *gv, struct Colors *colors)
{
geoline *gvt;
struct Map_info Map;
struct field_info *Fi;
int nvals, cat, nlines, nskipped;
int red, blu, grn;
const char *str;
const char *mapset;
dbDriver *driver;
dbValue value;
if(!gv || !gv->tstyle || !gv->filename)
return -1;
mapset = G_find_vector2(gv->filename, "");
if (!mapset) {
G_fatal_error(_("Vector map <%s> not found"), gv->filename);
}
Vect_set_open_level(1);
if (Vect_open_old(&Map, gv->filename, "") == -1) {
G_fatal_error(_("Unable to open vector map <%s>"),
G_fully_qualified_name(gv->filename, mapset));
}
Fi = Vect_get_field(&Map, gv->tstyle->layer);
if (!Fi) {
G_warning(_("Database connection not defined for layer %d"),
gv->tstyle->layer);
}
else {
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (!driver)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
}
G_message(_("Loading thematic vector layer <%s>..."),
G_fully_qualified_name(gv->filename, mapset));
nlines = nskipped = 0;
for(gvt = gv->lines; gvt; gvt = gvt->next) {
gvt->style = (gvstyle *) G_malloc(sizeof(gvstyle));
G_zero(gvt->style, sizeof(gvstyle));
/* use default style */
gvt->style->color = gv->style->color;
gvt->style->symbol = gv->style->symbol;
gvt->style->size = gv->style->size;
gvt->style->width = gv->style->width;
cat = -1;
if (gvt->cats)
Vect_cat_get(gvt->cats, gv->tstyle->layer, &cat);
if (cat < 0) {
nskipped++;
continue;
}
/* color */
if (colors) {
if (!Rast_get_c_color((const CELL *) &cat, &red, &grn, &blu, colors)) {
G_warning(_("No color rule defined for category %d"), cat);
gvt->style->color = gv->style->color;
}
gvt->style->color = (red & RED_MASK) + ((int)((grn) << 8) & GRN_MASK) +
((int)((blu) << 16) & BLU_MASK);
}
if (gv->tstyle->color_column) {
nvals = db_select_value(driver, Fi->table, Fi->key, cat, gv->tstyle->color_column, &value);
if (nvals < 1)
continue;
str = db_get_value_string(&value);
if (!str)
continue;
if (G_str_to_color(str, &red, &grn, &blu) != 1) {
G_warning(_("Invalid color definition (%s)"),
str);
gvt->style->color = gv->style->color;
}
else {
gvt->style->color = (red & RED_MASK) + ((int)((grn) << 8) & GRN_MASK) +
((int)((blu) << 16) & BLU_MASK);
}
}
/* width */
if (gv->tstyle->width_column) {
nvals = db_select_value(driver, Fi->table, Fi->key, cat, gv->tstyle->width_column, &value);
if (nvals < 1)
continue;
gvt->style->width = db_get_value_int(&value);
}
nlines++;
}
if (nskipped > 0)
G_warning(_("%d features without category. "
"Unable to determine color rules for features without category."),
nskipped);
return nlines;
}
/* *************************************************************** */
int main(int argc, char *argv[])
{
int i, j;
int nfiles;
int fd[NFILES];
struct Categories cats[NFILES];
struct Cell_head window;
struct Colors ncolor[NFILES];
struct Colors colors;
RASTER_MAP_TYPE out_type[NFILES];
CELL *cell[NFILES];
DCELL *dcell[NFILES];
/* int row, col; */
double drow, dcol;
int row_in_window, in_window;
double east, north;
int line;
char buffer[1024];
char **ptr;
struct Option *opt1, *opt2, *opt3, *opt4, *opt_fs;
struct Flag *label_flag, *cache_flag, *int_flag, *color_flag, *header_flag;
char fs;
int Cache_size;
int done = FALSE;
int point, point_cnt;
struct order *cache;
int cur_row;
int projection;
int cache_hit = 0, cache_miss = 0;
int cache_hit_tot = 0, cache_miss_tot = 0;
int pass = 0;
int cache_report = FALSE;
char tmp_buf[500], *null_str;
int red, green, blue;
struct GModule *module;
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("position"));
G_add_keyword(_("querying"));
module->description =
_("Queries raster map layers on their category values and category labels.");
opt1 = G_define_option();
opt1->key = "input";
opt1->type = TYPE_STRING;
opt1->required = YES;
opt1->multiple = YES;
opt1->gisprompt = "old,cell,raster";
opt1->description = _("Name of existing raster map(s) to query");
opt2 = G_define_option();
opt2->key = "cache";
opt2->type = TYPE_INTEGER;
opt2->required = NO;
opt2->multiple = NO;
opt2->description = _("Size of point cache");
opt2->answer = "500";
opt2->guisection = _("Advanced");
opt3 = G_define_option();
opt3->key = "null";
opt3->type = TYPE_STRING;
opt3->required = NO;
opt3->answer = "*";
opt3->description = _("Char string to represent no data cell");
opt_fs = G_define_standard_option(G_OPT_F_SEP);
opt4 = G_define_option();
opt4->key = "east_north";
opt4->type = TYPE_DOUBLE;
opt4->key_desc = "east,north";
opt4->required = NO;
opt4->multiple = YES;
opt4->description = _("Coordinates for query");
header_flag = G_define_flag();
header_flag->key = 'n';
header_flag->description = _("Output header row");
label_flag = G_define_flag();
label_flag->key = 'f';
label_flag->description = _("Show the category labels of the grid cell(s)");
color_flag = G_define_flag();
color_flag->key = 'r';
color_flag->description = _("Output color values as RRR:GGG:BBB");
int_flag = G_define_flag();
int_flag->key = 'i';
int_flag->description = _("Output integer category values, not cell values");
cache_flag = G_define_flag();
cache_flag->key = 'c';
cache_flag->description = _("Turn on cache reporting");
cache_flag->guisection = _("Advanced");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
tty = isatty(0);
projection = G_projection();
/* see v.in.ascii for a better solution */
if (opt_fs->answer != NULL) {
if (strcmp(opt_fs->answer, "space") == 0)
fs = ' ';
else if (strcmp(opt_fs->answer, "tab") == 0)
fs = '\t';
else if (strcmp(opt_fs->answer, "\\t") == 0)
fs = '\t';
else
fs = opt_fs->answer[0];
}
null_str = opt3->answer;
if (tty)
Cache_size = 1;
else
Cache_size = atoi(opt2->answer);
if (Cache_size < 1)
Cache_size = 1;
cache = (struct order *)G_malloc(sizeof(struct order) * Cache_size);
/*enable cache report */
if (cache_flag->answer)
cache_report = TRUE;
ptr = opt1->answers;
nfiles = 0;
for (; *ptr != NULL; ptr++) {
char name[GNAME_MAX];
if (nfiles >= NFILES)
G_fatal_error(_("can only do up to %d raster maps"),
NFILES);
strcpy(name, *ptr);
fd[nfiles] = Rast_open_old(name, "");
out_type[nfiles] = Rast_get_map_type(fd[nfiles]);
if (int_flag->answer)
out_type[nfiles] = CELL_TYPE;
if (color_flag->answer) {
Rast_read_colors(name, "", &colors);
ncolor[nfiles] = colors;
}
if (label_flag->answer && Rast_read_cats(name, "", &cats[nfiles]) < 0)
G_fatal_error(_("Unable to read category file for <%s>"), name);
nfiles++;
}
for (i = 0; i < nfiles; i++) {
if (int_flag->answer)
out_type[i] = CELL_TYPE;
cell[i] = Rast_allocate_c_buf();
if (out_type[i] != CELL_TYPE)
dcell[i] = Rast_allocate_d_buf();
}
G_get_window(&window);
if(header_flag->answer) {
fprintf(stdout, "easting%cnorthing%csite_name", fs, fs);
ptr = opt1->answers;
for (; *ptr != NULL; ptr++) {
char name[GNAME_MAX];
strcpy(name, *ptr);
fprintf(stdout, "%c%s", fs, name);
if (label_flag->answer)
fprintf(stdout, "%c%s_label", fs, name);
if (color_flag->answer)
fprintf(stdout, "%c%s_color", fs, name);
}
fprintf(stdout, "\n");
}
line = 0;
if (!opt4->answers && tty)
fprintf(stderr, "enter points, \"end\" to quit\n");
j = 0;
done = FALSE;
while (!done) {
pass++;
if (cache_report & !tty)
fprintf(stderr, "Pass %3d Line %6d - ", pass, line);
cache_hit = cache_miss = 0;
if (!opt4->answers && tty) {
fprintf(stderr, "\neast north [label] > ");
Cache_size = 1;
}
{
point_cnt = 0;
for (i = 0; i < Cache_size; i++) {
if (!opt4->answers && fgets(buffer, 1000, stdin) == NULL)
done = TRUE;
else {
line++;
if ((!opt4->answers &&
(strncmp(buffer, "end\n", 4) == 0 ||
strncmp(buffer, "exit\n", 5) == 0)) ||
(opt4->answers && !opt4->answers[j]))
done = TRUE;
else {
*(cache[point_cnt].lab_buf) =
*(cache[point_cnt].east_buf) =
*(cache[point_cnt].north_buf) = 0;
if (!opt4->answers)
sscanf(buffer, "%s %s %[^\n]",
cache[point_cnt].east_buf,
cache[point_cnt].north_buf,
cache[point_cnt].lab_buf);
else {
strcpy(cache[point_cnt].east_buf,
opt4->answers[j++]);
strcpy(cache[point_cnt].north_buf,
opt4->answers[j++]);
}
if (*(cache[point_cnt].east_buf) == 0)
continue; /* skip blank lines */
if (*(cache[point_cnt].north_buf) == 0) {
oops(line, buffer,
"two coordinates (east north) required");
continue;
}
if (!G_scan_northing
(cache[point_cnt].north_buf, &north, window.proj)
|| !G_scan_easting(cache[point_cnt].east_buf,
&east, window.proj)) {
oops(line, buffer, "invalid coordinate(s)");
continue;
}
/* convert north, east to row and col */
drow = Rast_northing_to_row(north, &window);
dcol = Rast_easting_to_col(east, &window);
/* a special case.
* if north falls at southern edge, or east falls on eastern edge,
* the point will appear outside the window.
* So, for these edges, bring the point inside the window
*/
if (drow == window.rows)
drow--;
if (dcol == window.cols)
dcol--;
cache[point_cnt].row = (int)drow;
cache[point_cnt].col = (int)dcol;
cache[point_cnt].point = point_cnt;
point_cnt++;
}
}
}
}
if (Cache_size > 1)
qsort(cache, point_cnt, sizeof(struct order), by_row);
/* extract data from files and store in cache */
cur_row = -99;
for (point = 0; point < point_cnt; point++) {
row_in_window = 1;
in_window = 1;
if (cache[point].row < 0 || cache[point].row >= window.rows)
row_in_window = in_window = 0;
if (cache[point].col < 0 || cache[point].col >= window.cols)
in_window = 0;
if (!in_window) {
if (tty)
fprintf(stderr,
"** note ** %s %s is outside your current window\n",
cache[point].east_buf, cache[point].north_buf);
}
if (cur_row != cache[point].row) {
cache_miss++;
if (row_in_window)
for (i = 0; i < nfiles; i++) {
Rast_get_c_row(fd[i], cell[i], cache[point].row);
if (out_type[i] != CELL_TYPE)
Rast_get_d_row(fd[i], dcell[i], cache[point].row);
}
cur_row = cache[point].row;
}
else
cache_hit++;
for (i = 0; i < nfiles; i++) {
if (in_window)
cache[point].value[i] = cell[i][cache[point].col];
else
Rast_set_c_null_value(&(cache[point].value[i]), 1);
if (out_type[i] != CELL_TYPE) {
if (in_window)
cache[point].dvalue[i] = dcell[i][cache[point].col];
else
Rast_set_d_null_value(&(cache[point].dvalue[i]), 1);
}
if (color_flag->answer) {
if (out_type[i] == CELL_TYPE)
Rast_get_c_color(&cell[i][cache[point].col],
&red, &green, &blue, &ncolor[i]);
else
Rast_get_d_color(&dcell[i][cache[point].col],
&red, &green, &blue, &ncolor[i]);
sprintf(cache[point].clr_buf[i], "%03d:%03d:%03d", red,
green, blue);
}
}
} /* point loop */
if (Cache_size > 1)
qsort(cache, point_cnt, sizeof(struct order), by_point);
/* report data from re-ordered cache */
for (point = 0; point < point_cnt; point++) {
G_debug(1, "%s|%s at col %d, row %d\n",
cache[point].east_buf, cache[point].north_buf,
cache[point].col, cache[point].row);
fprintf(stdout, "%s%c%s%c%s", cache[point].east_buf, fs,
cache[point].north_buf, fs, cache[point].lab_buf);
for (i = 0; i < nfiles; i++) {
if (out_type[i] == CELL_TYPE) {
if (Rast_is_c_null_value(&cache[point].value[i])) {
fprintf(stdout, "%c%s", fs, null_str);
if (label_flag->answer)
fprintf(stdout, "%c", fs);
if (color_flag->answer)
fprintf(stdout, "%c", fs);
continue;
}
fprintf(stdout, "%c%ld", fs, (long)cache[point].value[i]);
}
else { /* FCELL or DCELL */
if (Rast_is_d_null_value(&cache[point].dvalue[i])) {
fprintf(stdout, "%c%s", fs, null_str);
if (label_flag->answer)
fprintf(stdout, "%c", fs);
if (color_flag->answer)
fprintf(stdout, "%c", fs);
continue;
}
if (out_type[i] == FCELL_TYPE)
sprintf(tmp_buf, "%.7g", cache[point].dvalue[i]);
else /* DCELL */
sprintf(tmp_buf, "%.15g", cache[point].dvalue[i]);
G_trim_decimal(tmp_buf); /* not needed with %g? */
fprintf(stdout, "%c%s", fs, tmp_buf);
}
if (label_flag->answer)
fprintf(stdout, "%c%s", fs,
Rast_get_c_cat(&(cache[point].value[i]), &cats[i]));
if (color_flag->answer)
fprintf(stdout, "%c%s", fs, cache[point].clr_buf[i]);
}
fprintf(stdout, "\n");
}
if (cache_report & !tty)
fprintf(stderr, "Cache Hit: %6d Miss: %6d\n",
cache_hit, cache_miss);
cache_hit_tot += cache_hit;
cache_miss_tot += cache_miss;
cache_hit = cache_miss = 0;
}
if (!opt4->answers && tty)
fprintf(stderr, "\n");
if (cache_report & !tty)
fprintf(stderr, "Total: Cache Hit: %6d Miss: %6d\n",
cache_hit_tot, cache_miss_tot);
exit(EXIT_SUCCESS);
}
