/* ---------------------------------------------------------------------- */
void
setFlowAccuColorTable(char* cellname) {
struct Colors colors;
const char *mapset;
struct Range r;
mapset = G_find_raster(cellname, "");
if (mapset == NULL) {
G_fatal_error (_("Raster map <%s> not found"), cellname);
}
if (Rast_read_range(cellname, mapset, &r) == -1) {
G_fatal_error(_("cannot read range"));
}
/*fprintf(stderr, "%s range is: min=%d, max=%d\n", cellname, r.min, r.max);*/
int v[6];
v[0] = r.min;
v[1] = 5;
v[2] = 30;
v[3] = 100;
v[4] = 1000;
v[5] = r.max;
Rast_init_colors(&colors);
Rast_add_c_color_rule(&v[0], 255,255,255, &v[1], 255,255,0, &colors);
Rast_add_c_color_rule(&v[1], 255,255,0, &v[2], 0,255,255, &colors);
Rast_add_c_color_rule(&v[2], 0,255,255, &v[3], 0,127,255, &colors);
Rast_add_c_color_rule(&v[3], 0,127,255, &v[4], 0,0,255, &colors);
Rast_add_c_color_rule(&v[4], 0,0,255, &v[5], 0,0,0, &colors);
Rast_write_colors(cellname, mapset, &colors);
Rast_free_colors(&colors);
}
/* check compatibility of map header and region header */
void check_header(char* cellname) {
const char *mapset;
mapset = G_find_raster(cellname, "");
if (mapset == NULL) {
G_fatal_error(_("Raster map <%s> not found"), cellname);
}
/* read cell header */
struct Cell_head cell_hd;
Rast_get_cellhd (cellname, mapset, &cell_hd);
/* check compatibility with module region */
if (!((region->ew_res == cell_hd.ew_res)
&& (region->ns_res == cell_hd.ns_res))) {
G_fatal_error(_("cell file %s resolution differs from current region"),
cellname);
} else {
if (opt->verbose) {
G_message(_("cell %s header compatible with region header"),
cellname);
fflush(stderr);
}
}
/* check type of input elevation raster and check if precision is lost */
RASTER_MAP_TYPE data_type;
data_type = Rast_map_type(opt->elev_grid, mapset);
#ifdef ELEV_SHORT
G_verbose_message(_("Elevation stored as SHORT (%dB)"),
sizeof(elevation_type));
if (data_type == FCELL_TYPE) {
G_warning(_("raster %s is of type FCELL_TYPE "
"--precision may be lost."), opt->elev_grid);
}
if (data_type == DCELL_TYPE) {
G_warning(_("raster %s is of type DCELL_TYPE "
"--precision may be lost."), opt->elev_grid);
}
#endif
#ifdef ELEV_FLOAT
G_verbose_message( _("Elevation stored as FLOAT (%dB)"),
sizeof(elevation_type));
if (data_type == CELL_TYPE) {
G_warning(_("raster %s is of type CELL_TYPE "
"--you should use r.terraflow.short"), opt->elev_grid);
}
if (data_type == DCELL_TYPE) {
G_warning(_("raster %s is of type DCELL_TYPE "
"--precision may be lost."), opt->elev_grid);
}
#endif
}
int parse(int argc, char *argv[], struct parms *parms)
{
struct Option *group, *subgroup, *sigfile, *trainingmap, *maxsig;
trainingmap = G_define_standard_option(G_OPT_R_MAP);
trainingmap->key = "trainingmap";
trainingmap->description = _("Ground truth training map");
group = G_define_standard_option(G_OPT_I_GROUP);
subgroup = G_define_standard_option(G_OPT_I_SUBGROUP);
sigfile = G_define_option();
sigfile->key = "signaturefile";
sigfile->description = _("Name for output file containing result signatures");
sigfile->required = YES;
sigfile->type = TYPE_STRING;
maxsig = G_define_option();
maxsig->key = "maxsig";
maxsig->description = _("Maximum number of sub-signatures in any class");
maxsig->required = NO;
maxsig->type = TYPE_INTEGER;
maxsig->answer = "10";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
parms->training_map = trainingmap->answer;
parms->group = group->answer;
parms->subgroup = subgroup->answer;
parms->sigfile = sigfile->answer;
/* check all the inputs */
if (G_find_raster(parms->training_map, "") == NULL) {
G_fatal_error(_("Raster map <%s> not found"), parms->training_map);
}
if (!I_find_group(parms->group)) {
G_fatal_error(_("Group <%s> not found"), parms->group);
}
if (!I_find_subgroup(parms->group, parms->subgroup)) {
G_fatal_error(_("Subgroup <%s> not found"), parms->subgroup);
}
if (sscanf(maxsig->answer, "%d", &parms->maxsubclasses) != 1 ||
parms->maxsubclasses <= 0) {
G_fatal_error(_("Illegal number of sub-signatures (%s)"),
maxsig->answer);
}
return 0;
}
/* ---------------------------------------------------------------------- */
void
setSinkWatershedColorTable(char* cellname) {
struct Colors colors;
const char *mapset;
struct Range r;
mapset = G_find_raster(cellname, "");
if (mapset == NULL) {
G_fatal_error (_("Raster map <%s> not found"), cellname);
}
if (Rast_read_range(cellname, mapset, &r) == -1) {
G_fatal_error(_("cannot read range"));
}
Rast_init_colors(&colors);
Rast_make_random_colors(&colors, 1, r.max);
Rast_write_colors(cellname, mapset, &colors);
Rast_free_colors(&colors);
}
/*!
\brief Read the raster header
The raster header for the raster map <i>name</i> in the specified
<i>mapset</i> is read into the <i>cellhd</i> structure. If there is
an error reading the raster header file, a diagnostic message is
printed and -1 is returned. Otherwise, 0 is returned.
<b>Note</b>:a warning message for errors encountered.
Cell header files may contain either grid cell header information or
reclass information. If it is a reclass file, it will specify the
map and mapset names of the actual grid cell file being
reclassed. Rast_get_cellhd(), upon reading reclass information will go
read the cell header information for the referenced file. Only one
reference is allowed.
\param name name of map
\param mapset mapset that map belongs to
\param[out] cellhd structure to hold cell header info
\return void
*/
void Rast_get_cellhd(const char *name, const char *mapset,
struct Cell_head *cellhd)
{
FILE *fp;
int is_reclass;
char real_name[GNAME_MAX], real_mapset[GMAPSET_MAX];
/*
is_reclass = Rast_is_reclass (name, mapset, real_name, real_mapset);
if (is_reclass < 0)
{
sprintf (buf,"Can't read header file for [%s in %s]\n", name, mapset);
tail = buf + strlen(buf);
strcpy (tail, "It is a reclass file, but with an invalid format");
G_warning(buf);
return -1;
}
*/
is_reclass = (Rast_is_reclass(name, mapset, real_name, real_mapset) > 0);
if (is_reclass) {
fp = G_fopen_old("cellhd", real_name, real_mapset);
if (!fp)
G_fatal_error(_("Unable to read header file for raster map <%s@%s>. "
"It is a reclass of raster map <%s@%s> %s"),
name, mapset, real_name, real_mapset,
!G_find_raster(real_name, real_mapset)
? _("which is missing.")
: _("whose header file can't be opened."));
}
else {
fp = G_fopen_old("cellhd", name, mapset);
if (!fp)
G_fatal_error(_("Unable to open header file for raster map <%s@%s>"),
name, mapset);
}
G__read_Cell_head(fp, cellhd, 1);
fclose(fp);
}
int main(int argc, char **argv)
{
char *mapname, /* ptr to name of output layer */
*setname, /* ptr to name of input mapset */
*ipolname; /* name of interpolation method */
int fdi, /* input map file descriptor */
fdo, /* output map file descriptor */
method, /* position of method in table */
permissions, /* mapset permissions */
cell_type, /* output celltype */
cell_size, /* size of a cell in bytes */
row, col, /* counters */
irows, icols, /* original rows, cols */
orows, ocols, have_colors, /* Input map has a colour table */
overwrite, /* Overwrite */
curr_proj; /* output projection (see gis.h) */
void *obuffer, /* buffer that holds one output row */
*obufptr; /* column ptr in output buffer */
struct cache *ibuffer; /* buffer that holds the input map */
func interpolate; /* interpolation routine */
double xcoord1, xcoord2, /* temporary x coordinates */
ycoord1, ycoord2, /* temporary y coordinates */
col_idx, /* column index in input matrix */
row_idx, /* row index in input matrix */
onorth, osouth, /* save original border coords */
oeast, owest, inorth, isouth, ieast, iwest;
char north_str[30], south_str[30], east_str[30], west_str[30];
struct Colors colr; /* Input map colour table */
struct History history;
struct pj_info iproj, /* input map proj parameters */
oproj; /* output map proj parameters */
struct Key_Value *in_proj_info, /* projection information of */
*in_unit_info, /* input and output mapsets */
*out_proj_info, *out_unit_info;
struct GModule *module;
struct Flag *list, /* list files in source location */
*nocrop, /* don't crop output map */
*print_bounds, /* print output bounds and exit */
*gprint_bounds; /* same but print shell style */
struct Option *imapset, /* name of input mapset */
*inmap, /* name of input layer */
*inlocation, /* name of input location */
*outmap, /* name of output layer */
*indbase, /* name of input database */
*interpol, /* interpolation method:
nearest neighbor, bilinear, cubic */
*memory, /* amount of memory for cache */
*res; /* resolution of target map */
struct Cell_head incellhd, /* cell header of input map */
outcellhd; /* and output map */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("projection"));
G_add_keyword(_("transformation"));
module->description =
_("Re-projects a raster map from given location to the current location.");
inmap = G_define_standard_option(G_OPT_R_INPUT);
inmap->description = _("Name of input raster map to re-project");
inmap->required = NO;
inmap->guisection = _("Source");
inlocation = G_define_option();
inlocation->key = "location";
inlocation->type = TYPE_STRING;
inlocation->required = YES;
inlocation->description = _("Location containing input raster map");
inlocation->gisprompt = "old,location,location";
inlocation->key_desc = "name";
imapset = G_define_standard_option(G_OPT_M_MAPSET);
imapset->label = _("Mapset containing input raster map");
imapset->description = _("default: name of current mapset");
imapset->guisection = _("Source");
indbase = G_define_option();
indbase->key = "dbase";
indbase->type = TYPE_STRING;
indbase->required = NO;
indbase->description = _("Path to GRASS database of input location");
indbase->gisprompt = "old,dbase,dbase";
indbase->key_desc = "path";
indbase->guisection = _("Source");
outmap = G_define_standard_option(G_OPT_R_OUTPUT);
outmap->required = NO;
outmap->description = _("Name for output raster map (default: same as 'input')");
outmap->guisection = _("Target");
ipolname = make_ipol_list();
interpol = G_define_option();
interpol->key = "method";
interpol->type = TYPE_STRING;
interpol->required = NO;
interpol->answer = "nearest";
interpol->options = ipolname;
interpol->description = _("Interpolation method to use");
interpol->guisection = _("Target");
interpol->descriptions = make_ipol_desc();
memory = G_define_option();
memory->key = "memory";
memory->type = TYPE_INTEGER;
memory->required = NO;
memory->description = _("Cache size (MiB)");
res = G_define_option();
res->key = "resolution";
res->type = TYPE_DOUBLE;
res->required = NO;
res->description = _("Resolution of output raster map");
res->guisection = _("Target");
list = G_define_flag();
list->key = 'l';
list->description = _("List raster maps in input location and exit");
nocrop = G_define_flag();
nocrop->key = 'n';
nocrop->description = _("Do not perform region cropping optimization");
print_bounds = G_define_flag();
print_bounds->key = 'p';
print_bounds->description =
_("Print input map's bounds in the current projection and exit");
print_bounds->guisection = _("Target");
gprint_bounds = G_define_flag();
gprint_bounds->key = 'g';
gprint_bounds->description =
_("Print input map's bounds in the current projection and exit (shell style)");
gprint_bounds->guisection = _("Target");
/* The parser checks if the map already exists in current mapset,
we switch out the check and do it
in the module after the parser */
overwrite = G_check_overwrite(argc, argv);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* get the method */
for (method = 0; (ipolname = menu[method].name); method++)
if (strcmp(ipolname, interpol->answer) == 0)
break;
if (!ipolname)
G_fatal_error(_("<%s=%s> unknown %s"),
interpol->key, interpol->answer, interpol->key);
interpolate = menu[method].method;
mapname = outmap->answer ? outmap->answer : inmap->answer;
if (mapname && !list->answer && !overwrite &&
G_find_raster(mapname, G_mapset()))
G_fatal_error(_("option <%s>: <%s> exists."), "output", mapname);
setname = imapset->answer ? imapset->answer : G_store(G_mapset());
if (strcmp(inlocation->answer, G_location()) == 0 &&
(!indbase->answer || strcmp(indbase->answer, G_gisdbase()) == 0))
#if 0
G_fatal_error(_("Input and output locations can not be the same"));
#else
G_warning(_("Input and output locations are the same"));
#endif
G_get_window(&outcellhd);
if(gprint_bounds->answer && !print_bounds->answer)
print_bounds->answer = gprint_bounds->answer;
curr_proj = G_projection();
/* Get projection info for output mapset */
if ((out_proj_info = G_get_projinfo()) == NULL)
G_fatal_error(_("Unable to get projection info of output raster map"));
if ((out_unit_info = G_get_projunits()) == NULL)
G_fatal_error(_("Unable to get projection units of output raster map"));
if (pj_get_kv(&oproj, out_proj_info, out_unit_info) < 0)
G_fatal_error(_("Unable to get projection key values of output raster map"));
/* Change the location */
G__create_alt_env();
G__setenv("GISDBASE", indbase->answer ? indbase->answer : G_gisdbase());
G__setenv("LOCATION_NAME", inlocation->answer);
permissions = G__mapset_permissions(setname);
if (permissions < 0) /* can't access mapset */
G_fatal_error(_("Mapset <%s> in input location <%s> - %s"),
setname, inlocation->answer,
permissions == 0 ? _("permission denied")
: _("not found"));
/* if requested, list the raster maps in source location - MN 5/2001 */
if (list->answer) {
int i;
char **list;
G_verbose_message(_("Checking location <%s> mapset <%s>"),
inlocation->answer, setname);
list = G_list(G_ELEMENT_RASTER, G__getenv("GISDBASE"),
G__getenv("LOCATION_NAME"), setname);
for (i = 0; list[i]; i++) {
fprintf(stdout, "%s\n", list[i]);
}
fflush(stdout);
exit(EXIT_SUCCESS); /* leave r.proj after listing */
}
if (!inmap->answer)
G_fatal_error(_("Required parameter <%s> not set"), inmap->key);
if (!G_find_raster(inmap->answer, setname))
G_fatal_error(_("Raster map <%s> in location <%s> in mapset <%s> not found"),
inmap->answer, inlocation->answer, setname);
/* Read input map colour table */
have_colors = Rast_read_colors(inmap->answer, setname, &colr);
/* Get projection info for input mapset */
if ((in_proj_info = G_get_projinfo()) == NULL)
G_fatal_error(_("Unable to get projection info of input map"));
if ((in_unit_info = G_get_projunits()) == NULL)
G_fatal_error(_("Unable to get projection units of input map"));
if (pj_get_kv(&iproj, in_proj_info, in_unit_info) < 0)
G_fatal_error(_("Unable to get projection key values of input map"));
G_free_key_value(in_proj_info);
G_free_key_value(in_unit_info);
G_free_key_value(out_proj_info);
G_free_key_value(out_unit_info);
if (G_verbose() > G_verbose_std())
pj_print_proj_params(&iproj, &oproj);
/* this call causes r.proj to read the entire map into memeory */
Rast_get_cellhd(inmap->answer, setname, &incellhd);
Rast_set_input_window(&incellhd);
if (G_projection() == PROJECTION_XY)
G_fatal_error(_("Unable to work with unprojected data (xy location)"));
/* Save default borders so we can show them later */
inorth = incellhd.north;
isouth = incellhd.south;
ieast = incellhd.east;
iwest = incellhd.west;
irows = incellhd.rows;
icols = incellhd.cols;
onorth = outcellhd.north;
osouth = outcellhd.south;
oeast = outcellhd.east;
owest = outcellhd.west;
orows = outcellhd.rows;
ocols = outcellhd.cols;
if (print_bounds->answer) {
G_message(_("Input map <%s@%s> in location <%s>:"),
inmap->answer, setname, inlocation->answer);
if (pj_do_proj(&iwest, &isouth, &iproj, &oproj) < 0)
G_fatal_error(_("Error in pj_do_proj (projection of input coordinate pair)"));
if (pj_do_proj(&ieast, &inorth, &iproj, &oproj) < 0)
G_fatal_error(_("Error in pj_do_proj (projection of input coordinate pair)"));
G_format_northing(inorth, north_str, curr_proj);
G_format_northing(isouth, south_str, curr_proj);
G_format_easting(ieast, east_str, curr_proj);
G_format_easting(iwest, west_str, curr_proj);
if(gprint_bounds->answer) {
fprintf(stdout, "n=%s s=%s w=%s e=%s rows=%d cols=%d\n",
north_str, south_str, west_str, east_str, irows, icols);
}
else {
fprintf(stdout, "Source cols: %d\n", icols);
fprintf(stdout, "Source rows: %d\n", irows);
fprintf(stdout, "Local north: %s\n", north_str);
fprintf(stdout, "Local south: %s\n", south_str);
fprintf(stdout, "Local west: %s\n", west_str);
fprintf(stdout, "Local east: %s\n", east_str);
}
/* somehow approximate local ewres, nsres ?? (use 'g.region -m' on lat/lon side) */
exit(EXIT_SUCCESS);
}
/* Cut non-overlapping parts of input map */
if (!nocrop->answer)
bordwalk(&outcellhd, &incellhd, &oproj, &iproj);
/* Add 2 cells on each side for bilinear/cubic & future interpolation methods */
/* (should probably be a factor based on input and output resolution) */
incellhd.north += 2 * incellhd.ns_res;
incellhd.east += 2 * incellhd.ew_res;
incellhd.south -= 2 * incellhd.ns_res;
incellhd.west -= 2 * incellhd.ew_res;
if (incellhd.north > inorth)
incellhd.north = inorth;
if (incellhd.east > ieast)
incellhd.east = ieast;
if (incellhd.south < isouth)
incellhd.south = isouth;
if (incellhd.west < iwest)
incellhd.west = iwest;
Rast_set_input_window(&incellhd);
/* And switch back to original location */
G__switch_env();
/* Adjust borders of output map */
if (!nocrop->answer)
bordwalk(&incellhd, &outcellhd, &iproj, &oproj);
#if 0
outcellhd.west = outcellhd.south = HUGE_VAL;
outcellhd.east = outcellhd.north = -HUGE_VAL;
for (row = 0; row < incellhd.rows; row++) {
ycoord1 = Rast_row_to_northing((double)(row + 0.5), &incellhd);
for (col = 0; col < incellhd.cols; col++) {
xcoord1 = Rast_col_to_easting((double)(col + 0.5), &incellhd);
pj_do_proj(&xcoord1, &ycoord1, &iproj, &oproj);
if (xcoord1 > outcellhd.east)
outcellhd.east = xcoord1;
if (ycoord1 > outcellhd.north)
outcellhd.north = ycoord1;
if (xcoord1 < outcellhd.west)
outcellhd.west = xcoord1;
if (ycoord1 < outcellhd.south)
outcellhd.south = ycoord1;
}
}
#endif
if (res->answer != NULL) /* set user defined resolution */
outcellhd.ns_res = outcellhd.ew_res = atof(res->answer);
G_adjust_Cell_head(&outcellhd, 0, 0);
Rast_set_output_window(&outcellhd);
G_message(" ");
G_message(_("Input:"));
G_message(_("Cols: %d (%d)"), incellhd.cols, icols);
G_message(_("Rows: %d (%d)"), incellhd.rows, irows);
G_message(_("North: %f (%f)"), incellhd.north, inorth);
G_message(_("South: %f (%f)"), incellhd.south, isouth);
G_message(_("West: %f (%f)"), incellhd.west, iwest);
G_message(_("East: %f (%f)"), incellhd.east, ieast);
G_message(_("EW-res: %f"), incellhd.ew_res);
G_message(_("NS-res: %f"), incellhd.ns_res);
G_message(" ");
G_message(_("Output:"));
G_message(_("Cols: %d (%d)"), outcellhd.cols, ocols);
G_message(_("Rows: %d (%d)"), outcellhd.rows, orows);
G_message(_("North: %f (%f)"), outcellhd.north, onorth);
G_message(_("South: %f (%f)"), outcellhd.south, osouth);
G_message(_("West: %f (%f)"), outcellhd.west, owest);
G_message(_("East: %f (%f)"), outcellhd.east, oeast);
G_message(_("EW-res: %f"), outcellhd.ew_res);
G_message(_("NS-res: %f"), outcellhd.ns_res);
G_message(" ");
/* open and read the relevant parts of the input map and close it */
G__switch_env();
Rast_set_input_window(&incellhd);
fdi = Rast_open_old(inmap->answer, setname);
cell_type = Rast_get_map_type(fdi);
ibuffer = readcell(fdi, memory->answer);
Rast_close(fdi);
G__switch_env();
Rast_set_output_window(&outcellhd);
if (strcmp(interpol->answer, "nearest") == 0) {
fdo = Rast_open_new(mapname, cell_type);
obuffer = (CELL *) Rast_allocate_output_buf(cell_type);
}
else {
fdo = Rast_open_fp_new(mapname);
cell_type = FCELL_TYPE;
obuffer = (FCELL *) Rast_allocate_output_buf(cell_type);
}
cell_size = Rast_cell_size(cell_type);
xcoord1 = xcoord2 = outcellhd.west + (outcellhd.ew_res / 2);
/**/ ycoord1 = ycoord2 = outcellhd.north - (outcellhd.ns_res / 2);
/**/ G_important_message(_("Projecting..."));
G_percent(0, outcellhd.rows, 2);
for (row = 0; row < outcellhd.rows; row++) {
obufptr = obuffer;
for (col = 0; col < outcellhd.cols; col++) {
/* project coordinates in output matrix to */
/* coordinates in input matrix */
if (pj_do_proj(&xcoord1, &ycoord1, &oproj, &iproj) < 0)
Rast_set_null_value(obufptr, 1, cell_type);
else {
/* convert to row/column indices of input matrix */
col_idx = (xcoord1 - incellhd.west) / incellhd.ew_res;
row_idx = (incellhd.north - ycoord1) / incellhd.ns_res;
/* and resample data point */
interpolate(ibuffer, obufptr, cell_type,
&col_idx, &row_idx, &incellhd);
}
obufptr = G_incr_void_ptr(obufptr, cell_size);
xcoord2 += outcellhd.ew_res;
xcoord1 = xcoord2;
ycoord1 = ycoord2;
}
Rast_put_row(fdo, obuffer, cell_type);
xcoord1 = xcoord2 = outcellhd.west + (outcellhd.ew_res / 2);
ycoord2 -= outcellhd.ns_res;
ycoord1 = ycoord2;
G_percent(row, outcellhd.rows - 1, 2);
}
Rast_close(fdo);
if (have_colors > 0) {
Rast_write_colors(mapname, G_mapset(), &colr);
Rast_free_colors(&colr);
}
Rast_short_history(mapname, "raster", &history);
Rast_command_history(&history);
Rast_write_history(mapname, &history);
G_done_msg(NULL);
exit(EXIT_SUCCESS);
}
int parse_args(int argc, char *argv[], struct globals *globals)
{
struct Option *group, *seeds, *bounds, *output,
*method, *similarity, *threshold, *min_segment_size,
#ifdef _OR_SHAPE_
*shape_weight, *smooth_weight,
#endif
*mem;
struct Flag *diagonal, *weighted;
struct Option *outband, *endt;
/* required parameters */
group = G_define_standard_option(G_OPT_I_GROUP);
output = G_define_standard_option(G_OPT_R_OUTPUT);
threshold = G_define_option();
threshold->key = "threshold";
threshold->type = TYPE_DOUBLE;
threshold->required = YES;
threshold->label = _("Difference threshold between 0 and 1");
threshold->description = _("Threshold = 0 merges only identical segments; threshold = 1 merges all");
/* optional parameters */
method = G_define_option();
method->key = "method";
method->type = TYPE_STRING;
method->required = NO;
method->answer = "region_growing";
method->options = "region_growing,mean_shift,watershed";
method->description = _("Segmentation method");
method->guisection = _("Settings");
similarity = G_define_option();
similarity->key = "similarity";
similarity->type = TYPE_STRING;
similarity->required = NO;
similarity->answer = "euclidean";
similarity->options = "euclidean,manhattan";
similarity->description = _("Similarity calculation method");
similarity->guisection = _("Settings");
min_segment_size = G_define_option();
min_segment_size->key = "minsize";
min_segment_size->type = TYPE_INTEGER;
min_segment_size->required = NO;
min_segment_size->answer = "1";
min_segment_size->options = "1-100000";
min_segment_size->label = _("Minimum number of cells in a segment");
min_segment_size->description =
_("The final step will merge small segments with their best neighbor");
min_segment_size->guisection = _("Settings");
#ifdef _OR_SHAPE_
radio_weight = G_define_option();
radio_weight->key = "radio_weight";
radio_weight->type = TYPE_DOUBLE;
radio_weight->required = NO;
radio_weight->answer = "1";
radio_weight->options = "0-1";
radio_weight->label =
_("Importance of radiometric (input raster) values relative to shape");
radio_weight->guisection = _("Settings");
smooth_weight = G_define_option();
smooth_weight->key = "smooth_weight";
smooth_weight->type = TYPE_DOUBLE;
smooth_weight->required = NO;
smooth_weight->answer = "0.5";
smooth_weight->options = "0-1";
smooth_weight->label =
_("Importance of smoothness relative to compactness");
smooth_weight->guisection = _("Settings");
#endif
mem = G_define_option();
mem->key = "memory";
mem->type = TYPE_INTEGER;
mem->required = NO;
mem->answer = "300";
mem->description = _("Memory in MB");
/* TODO input for distance function */
/* debug parameters */
endt = G_define_option();
endt->key = "iterations";
endt->type = TYPE_INTEGER;
endt->required = NO;
endt->answer = "20";
endt->description = _("Maximum number of iterations");
endt->guisection = _("Settings");
/* Using raster for seeds
* Low priority TODO: allow vector points/centroids seed input. */
seeds = G_define_standard_option(G_OPT_R_INPUT);
seeds->key = "seeds";
seeds->required = NO;
seeds->description = _("Name for input raster map with starting seeds");
/* Polygon constraints. */
bounds = G_define_standard_option(G_OPT_R_INPUT);
bounds->key = "bounds";
bounds->required = NO;
bounds->label = _("Name of input bounding/constraining raster map");
bounds->description =
_("Must be integer values, each area will be segmented independent of the others");
outband = G_define_standard_option(G_OPT_R_OUTPUT);
outband->key = "goodness";
outband->required = NO;
outband->description =
_("Name for output goodness of fit estimate map");
diagonal = G_define_flag();
diagonal->key = 'd';
diagonal->description =
_("Use 8 neighbors (3x3 neighborhood) instead of the default 4 neighbors for each pixel");
diagonal->guisection = _("Settings");
weighted = G_define_flag();
weighted->key = 'w';
weighted->description =
_("Weighted input, do not perform the default scaling of input raster maps");
weighted->guisection = _("Settings");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* Check and save parameters */
globals->image_group = group->answer;
if (G_legal_filename(output->answer) == TRUE)
globals->out_name = output->answer;
else
G_fatal_error("Invalid output raster name");
/* Note: this threshold is scaled after we know more at the beginning of create_isegs() */
globals->alpha = atof(threshold->answer);
if (globals->alpha <= 0 || globals->alpha >= 1)
G_fatal_error(_("Threshold should be > 0 and < 1"));
/* segmentation methods */
if (strcmp(method->answer, "region_growing") == 0) {
globals->method = ORM_RG;
globals->method_fn = region_growing;
}
else if (strcmp(method->answer, "mean_shift") == 0) {
globals->method = ORM_MS;
globals->method_fn = mean_shift;
}
else if (strcmp(method->answer, "watershed") == 0) {
globals->method = ORM_WS;
globals->method_fn = watershed;
}
else
G_fatal_error(_("Unable to assign segmentation method"));
G_debug(1, "segmentation method: %s", method->answer);
/* distance methods for similarity measurement */
if (strcmp(similarity->answer, "euclidean") == 0)
globals->calculate_similarity = calculate_euclidean_similarity;
else if (strcmp(similarity->answer, "manhattan") == 0)
globals->calculate_similarity = calculate_manhattan_similarity;
else
G_fatal_error(_("Invalid similarity method"));
#ifdef _OR_SHAPE_
/* consider shape */
globals->radio_weight = atof(radio_weight->answer);
if (globals->radio_weight <= 0)
G_fatal_error(_("Option '%s' must be > 0"), radio_weight->key);
if (globals->radio_weight > 1)
G_fatal_error(_("Option '%s' must be <= 1"), radio_weight->key);
globals->smooth_weight = atof(smooth_weight->answer);
if (globals->smooth_weight < 0)
G_fatal_error(_("Option '%s' must be >= 0"), smooth_weight->key);
if (globals->smooth_weight > 1)
G_fatal_error(_("Option '%s' must be <= 1"), smooth_weight->key);
#else
globals->radio_weight = 1;
globals->smooth_weight = 0.5;
#endif
globals->min_segment_size = atoi(min_segment_size->answer);
if (diagonal->answer == FALSE) {
globals->find_neighbors = find_four_neighbors;
globals->nn = 4;
G_debug(1, "four pixel neighborhood");
}
else if (diagonal->answer == TRUE) {
globals->find_neighbors = find_eight_neighbors;
globals->nn = 8;
G_debug(1, "eight (3x3) pixel neighborhood");
}
/* default/0 for performing the scaling
* selected/1 if scaling should be skipped. */
globals->weighted = weighted->answer;
globals->seeds = seeds->answer;
if (globals->seeds) {
if (G_find_raster(globals->seeds, "") == NULL) {
G_fatal_error(_("Seeds raster map not found"));
}
if (Rast_map_type(globals->seeds, "") !=
CELL_TYPE) {
G_fatal_error(_("Seeeds raster map must be CELL type (integers)"));
}
}
if (bounds->answer == NULL) {
globals->bounds_map = NULL;
}
else {
globals->bounds_map = bounds->answer;
if ((globals->bounds_mapset = G_find_raster(globals->bounds_map, "")) == NULL) {
G_fatal_error(_("Segmentation constraint/boundary raster map not found"));
}
if (Rast_map_type(globals->bounds_map, globals->bounds_mapset) !=
CELL_TYPE) {
G_fatal_error(_("Segmentation constraint raster map must be CELL type (integers)"));
}
}
/* other data */
globals->nrows = Rast_window_rows();
globals->ncols = Rast_window_cols();
/* debug help */
if (outband->answer == NULL)
globals->out_band = NULL;
else {
if (G_legal_filename(outband->answer) == TRUE)
globals->out_band = outband->answer;
else
G_fatal_error(_("Invalid output raster name for goodness of fit"));
}
if (endt->answer) {
if (atoi(endt->answer) > 0)
globals->end_t = atoi(endt->answer);
else {
globals->end_t = 100;
G_warning(_("Invalid number of iterations, 100 will be used"));
}
}
else
globals->end_t = 1000;
if (mem->answer && atoi(mem->answer) > 10)
globals->mb = atoi(mem->answer);
else {
globals->mb = 300;
G_warning(_("Invalid number of MB, 300 will be used"));
}
return TRUE;
}
void* raster2array(const char* name, struct Cell_head* header, int* rows,
int* cols, RASTER_MAP_TYPE out_type) {
// Open the raster map and load the dem
// for simplicity sake, the dem will be an array of
// doubles, converted from any possible GRASS CELL type.
//ORG char* mapset = G_find_cell2(name, "");
char* mapset = G_find_raster(name, "");
if (mapset == NULL)
G_fatal_error("Raster map <%s> not found", name);
// Find out the cell type of the DEM
//ORG RASTER_MAP_TYPE type = G_raster_map_type(name, mapset);
RASTER_MAP_TYPE type = Rast_map_type(name, mapset);
// Get a file descriptor for the DEM raster map
int infd;
//ORG if ((infd = G_open_cell_old(name, mapset)) < 0)
if ((infd = Rast_open_old(name, mapset)) < 0)
G_fatal_error("Unable to open raster map <%s>", name);
// Get header info for the DEM raster map
struct Cell_head cellhd;
//ORG if (G_get_cellhd(name, mapset, &cellhd) < 0)
//ORG G_fatal_error("Unable to open raster map <%s>", name);
Rast_get_cellhd(name, mapset, &cellhd);
// Create a GRASS buffer for the DEM raster
//ORG void* inrast = G_allocate_raster_buf(type);
void* inrast = Rast_allocate_buf(type);
// Get the max rows and max cols from the window information, since the
// header gives the values for the full raster
//ORG const int maxr = G_window_rows();
//ORG const int maxc = G_window_cols();
const int maxr = Rast_window_rows();
const int maxc = Rast_window_cols();
// Read in the raster line by line, copying it into the double array
// rast for return.
void* rast;
switch (out_type) {
case CELL_TYPE:
rast = (int*) calloc(maxr * maxc, sizeof(int));
break;
case FCELL_TYPE:
rast = (float*) calloc(maxr * maxc, sizeof(float));
break;
case DCELL_TYPE:
rast = (double*) calloc(maxr * maxc, sizeof(double));
break;
}
if (rast == NULL) {
G_fatal_error("Unable to allocate memory for raster map <%s>", name);
}
int row, col;
for (row = 0; row < maxr; ++row) {
//ORG if (G_get_raster_row(infd, inrast, row, type) < 0)
//ORG G_fatal_error("Unable to read raster map <%s> row %d", name, row);
Rast_get_row(infd, inrast, row, type);
for (col = 0; col < maxc; ++col) {
int index = col + row * maxc;
if (out_type == CELL_TYPE) {
switch (type) {
case CELL_TYPE:
((int*) rast)[index] = ((int *) inrast)[col];
break;
case FCELL_TYPE:
((int*) rast)[index] = (int) ((float *) inrast)[col];
break;
case DCELL_TYPE:
((int*) rast)[index] = (int) ((double *) inrast)[col];
break;
default:
G_fatal_error("Unknown cell type");
break;
}
}
if (out_type == FCELL_TYPE) {
switch (type) {
case CELL_TYPE:
((float*) rast)[index] = (float) ((int *) inrast)[col];
break;
case FCELL_TYPE:
((float*) rast)[index] = ((float *) inrast)[col];
break;
case DCELL_TYPE:
((float*) rast)[index] = (float) ((double *) inrast)[col];
break;
default:
G_fatal_error("Unknown cell type");
break;
}
}
if (out_type == DCELL_TYPE) {
switch (type) {
case CELL_TYPE:
((double*) rast)[index] = (double) ((int *) inrast)[col];
break;
case FCELL_TYPE:
((double*) rast)[index] = (double) ((float *) inrast)[col];
break;
case DCELL_TYPE:
((double*) rast)[index] = ((double *) inrast)[col];
break;
default:
G_fatal_error("Unknown cell type");
break;
}
}
}
}
// Return cellhd, maxr, and maxc by pointer
if (header != NULL)
*header = cellhd;
if (rows != NULL)
*rows = maxr;
if (cols != NULL)
*cols = maxc;
return rast;
}
int main(int argc, char **argv)
{
int n, verbose = 1,
backrow, backcol,
col, row,
len, flag,
srows, scols,
backrow_fd, backcol_fd, path_fd, in_row_fd, in_col_fd, out_fd;
const char *current_mapset,
*search_mapset,
*path_mapset,
*backrow_mapset,
*backcol_mapset, *in_row_file, *in_col_file, *out_file;
CELL *cell;
POINT *PRES_PT, *PRESENT_PT, *OLD_PT;
struct Cell_head window;
double east, north;
struct Option *opt1, *opt2, *opt3, *opt4;
struct Flag *flag1;
struct GModule *module;
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("fire"));
G_add_keyword(_("cumulative costs"));
module->description =
_("Recursively traces the least cost path backwards to "
"cells from which the cumulative cost was determined.");
opt1 = G_define_option();
opt1->key = "x_input";
opt1->type = TYPE_STRING;
opt1->required = YES;
opt1->gisprompt = "old,cell,raster";
opt1->description =
_("Name of raster map containing back-path easting information");
opt2 = G_define_option();
opt2->key = "y_input";
opt2->type = TYPE_STRING;
opt2->required = YES;
opt2->gisprompt = "old,cell,raster";
opt2->description =
_("Name of raster map containing back-path northing information");
opt3 = G_define_option();
opt3->key = "coordinate";
opt3->type = TYPE_STRING;
opt3->multiple = YES;
opt3->key_desc = "x,y";
opt3->description =
_("The map E and N grid coordinates of starting points");
opt4 = G_define_option();
opt4->key = "output";
opt4->type = TYPE_STRING;
opt4->required = YES;
opt4->gisprompt = "new,cell,raster";
opt4->description = _("Name of spread path raster map");
flag1 = G_define_flag();
flag1->key = 'v';
flag1->description = _("Run verbosely");
/* Do command line parsing */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
current_mapset = G_mapset();
in_row_file = G_tempfile();
in_col_file = G_tempfile();
out_file = G_tempfile();
/* Get database window parameters */
G_get_window(&window);
verbose = flag1->answer;
/* Check if backrow layer exists in data base */
search_mapset = "";
strcpy(backrow_layer, opt2->answer);
strcpy(backcol_layer, opt1->answer);
backrow_mapset = G_find_raster(backrow_layer, search_mapset);
backcol_mapset = G_find_raster(backcol_layer, search_mapset);
if (backrow_mapset == NULL)
G_fatal_error("%s - not found", backrow_layer);
if (backcol_mapset == NULL)
G_fatal_error("%s - not found", backcol_layer);
search_mapset = "";
strcpy(path_layer, opt4->answer);
path_mapset = G_find_raster(path_layer, search_mapset);
/* find number of rows and cols in window */
nrows = Rast_window_rows();
ncols = Rast_window_cols();
cell = Rast_allocate_c_buf();
/* Open back cell layers for reading */
backrow_fd = Rast_open_old(backrow_layer, backrow_mapset);
backcol_fd = Rast_open_old(backcol_layer, backcol_mapset);
/* Parameters for map submatrices */
len = sizeof(CELL);
srows = nrows / 4 + 1;
scols = ncols / 4 + 1;
if (verbose)
G_message
("\nReading the input map -%s- and -%s- and creating some temporary files...",
backrow_layer, backcol_layer);
/* Create segmented files for back cell and output layers */
in_row_fd = creat(in_row_file, 0666);
segment_format(in_row_fd, nrows, ncols, srows, scols, len);
close(in_row_fd);
in_col_fd = creat(in_col_file, 0666);
segment_format(in_col_fd, nrows, ncols, srows, scols, len);
close(in_col_fd);
out_fd = creat(out_file, 0666);
segment_format(out_fd, nrows, ncols, srows, scols, len);
close(out_fd);
/* Open initialize and segment all files */
in_row_fd = open(in_row_file, 2);
segment_init(&in_row_seg, in_row_fd, 4);
in_col_fd = open(in_col_file, 2);
segment_init(&in_col_seg, in_col_fd, 4);
out_fd = open(out_file, 2);
segment_init(&out_seg, out_fd, 4);
/* Write the back cell layers in the segmented files, and
* Change UTM coordinates to ROWs and COLUMNs */
for (row = 0; row < nrows; row++) {
Rast_get_c_row(backrow_fd, cell, row);
for (col = 0; col < ncols; col++)
if (cell[col] > 0)
cell[col] =
(window.north - cell[col]) / window.ns_res /* - 0.5 */ ;
else
cell[col] = -1;
segment_put_row(&in_row_seg, cell, row);
Rast_get_c_row(backcol_fd, cell, row);
for (col = 0; col < ncols; col++)
if (cell[col] > 0)
cell[col] =
(cell[col] - window.west) / window.ew_res /* - 0.5 */ ;
segment_put_row(&in_col_seg, cell, row);
}
/* Convert easting and northing from the command line to row and col */
if (opt3->answer) {
for (n = 0; opt3->answers[n] != NULL; n += 2) {
G_scan_easting(opt3->answers[n], &east, G_projection());
G_scan_northing(opt3->answers[n + 1], &north, G_projection());
row = (window.north - north) / window.ns_res;
col = (east - window.west) / window.ew_res;
/* ignore pt outside window */
if (east < window.west || east > window.east ||
north < window.south || north > window.north) {
G_warning("Ignoring point outside window: ");
G_warning(" %.4f,%.4f", east, north);
continue;
}
value = (char *)&backrow;
segment_get(&in_row_seg, value, row, col);
/* ignore pt in no-data area */
if (backrow < 0) {
G_warning("Ignoring point in NO-DATA area :");
G_warning(" %.4f,%.4f", east, north);
continue;
}
value = (char *)&backcol;
segment_get(&in_col_seg, value, row, col);
insert(&PRESENT_PT, row, col, backrow, backcol);
}
}
/* Set flag according to input */
if (path_mapset != NULL) {
if (head_start_pt == NULL)
/*output layer exists and start pts are not given on cmd line */
flag = 1;
/* output layer exists and starting pts are given on cmd line */
else
flag = 2;
}
else
flag = 3; /* output layer does not previously exist */
/* If the output layer containing the starting positions */
/* create a linked list of of them */
if (flag == 1) {
path_fd = Rast_open_old(path_layer, path_mapset);
/* Search for the marked starting pts and make list */
for (row = 0; row < nrows; row++) {
Rast_get_c_row(path_fd, cell, row);
for (col = 0; col < ncols; col++) {
if (cell[col] > 0) {
value = (char *)&backrow;
segment_get(&in_row_seg, value, row, col);
/* ignore pt in no-data area */
if (backrow < 0) {
G_warning("Ignoring point in NO-DATA area:");
G_warning(" %.4f,%.4f\n",
window.west + window.ew_res * (col + 0.5),
window.north - window.ns_res * (row + 0.5));
continue;
}
value = (char *)&backcol;
segment_get(&in_col_seg, value, row, col);
insert(&PRESENT_PT, row, col, backrow, backcol);
}
} /* loop over cols */
} /* loop over rows */
Rast_close(path_fd);
}
/* loop over the starting points to find the least cost paths */
if (verbose)
G_message("\nFinding the least cost paths ...");
PRES_PT = head_start_pt;
while (PRES_PT != NULL) {
path_finder(PRES_PT->row, PRES_PT->col, PRES_PT->backrow,
PRES_PT->backcol);
OLD_PT = PRES_PT;
PRES_PT = NEXT_PT;
G_free(OLD_PT);
}
/* Write pending updates by segment_put() to outputmap */
segment_flush(&out_seg);
if (verbose)
G_message("\nWriting the output map -%s-...", path_layer);
path_fd = Rast_open_c_new(path_layer);
for (row = 0; row < nrows; row++) {
segment_get_row(&out_seg, cell, row);
Rast_put_row(path_fd, cell, CELL_TYPE);
}
if (verbose)
G_message("finished.");
segment_release(&in_row_seg); /* release memory */
segment_release(&in_col_seg);
segment_release(&out_seg);
close(in_row_fd); /* close all files */
close(in_col_fd);
close(out_fd);
Rast_close(path_fd);
Rast_close(backrow_fd);
Rast_close(backcol_fd);
unlink(in_row_file); /* remove submatrix files */
unlink(in_col_file);
unlink(out_file);
exit(EXIT_SUCCESS);
}
