int main(int argc, char *argv[])
{
char *terrainmap, *seedmap, *lakemap, *mapset;
int rows, cols, in_terran_fd, out_fd, lake_fd, row, col, pases, pass;
int lastcount, curcount, start_col = 0, start_row = 0;
double east, north, area = 0, volume = 0;
FCELL **in_terran, **out_water, water_level, max_depth = 0, min_depth = 0;
FCELL water_window[3][3];
struct Option *tmap_opt, *smap_opt, *wlvl_opt, *lake_opt, *sdxy_opt;
struct Flag *negative_flag, *overwrite_flag;
struct GModule *module;
struct Colors colr;
struct Cell_head window;
struct History history;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, hydrology");
module->description = _("Fills lake at given point to given level.");
tmap_opt = G_define_option();
tmap_opt->key = "dem";
tmap_opt->key_desc = "name";
tmap_opt->description = _("Name of terrain raster map (DEM)");
tmap_opt->type = TYPE_STRING;
tmap_opt->gisprompt = "old,cell,raster";
tmap_opt->required = YES;
wlvl_opt = G_define_option();
wlvl_opt->key = "wl";
wlvl_opt->description = _("Water level");
wlvl_opt->type = TYPE_DOUBLE;
wlvl_opt->required = YES;
lake_opt = G_define_option();
lake_opt->key = "lake";
lake_opt->key_desc = "name";
lake_opt->description = _("Name for output raster map with lake");
lake_opt->type = TYPE_STRING;
lake_opt->gisprompt = "new,cell,raster";
lake_opt->required = NO;
sdxy_opt = G_define_option();
sdxy_opt->key = "xy";
sdxy_opt->description = _("Seed point coordinates");
sdxy_opt->type = TYPE_DOUBLE;
sdxy_opt->key_desc = "east,north";
sdxy_opt->required = NO;
sdxy_opt->multiple = NO;
smap_opt = G_define_option();
smap_opt->key = "seed";
smap_opt->key_desc = "name";
smap_opt->description =
_("Name of raster map with given starting point(s) (at least 1 cell > 0)");
smap_opt->type = TYPE_STRING;
smap_opt->gisprompt = "old,cell,raster";
smap_opt->required = NO;
negative_flag = G_define_flag();
negative_flag->key = 'n';
negative_flag->description =
_("Use negative depth values for lake raster map");
overwrite_flag = G_define_flag();
overwrite_flag->key = 'o';
overwrite_flag->description =
_("Overwrite seed map with result (lake) map");
if (G_parser(argc, argv)) /* Returns 0 if successful, non-zero otherwise */
exit(EXIT_FAILURE);
if (smap_opt->answer && sdxy_opt->answer)
G_fatal_error(_("Both seed map and coordinates cannot be specified"));
if (!smap_opt->answer && !sdxy_opt->answer)
G_fatal_error(_("Seed map or seed coordinates must be set!"));
if (sdxy_opt->answer && !lake_opt->answer)
G_fatal_error(_("Seed coordinates and output map lake= must be set!"));
if (lake_opt->answer && overwrite_flag->answer)
G_fatal_error(_("Both lake and overwrite cannot be specified"));
if (!lake_opt->answer && !overwrite_flag->answer)
G_fatal_error(_("Output lake map or overwrite flag must be set!"));
terrainmap = tmap_opt->answer;
seedmap = smap_opt->answer;
sscanf(wlvl_opt->answer, "%f", &water_level);
lakemap = lake_opt->answer;
/* If lakemap is set, write to it, else is set overwrite flag and we should write to seedmap. */
if (lakemap) {
lake_fd = G_open_raster_new(lakemap, 1);
if (lake_fd < 0)
G_fatal_error(_("Unable to create raster map <%s>"), lakemap);
}
rows = G_window_rows();
cols = G_window_cols();
/* If we use x,y as seed... */
if (sdxy_opt->answer) {
G_get_window(&window);
east = window.east;
north = window.north;
G_scan_easting(sdxy_opt->answers[0], &east, G_projection());
G_scan_northing(sdxy_opt->answers[1], &north, G_projection());
start_col = (int)G_easting_to_col(east, &window);
start_row = (int)G_northing_to_row(north, &window);
if (start_row < 0 || start_row > rows ||
start_col < 0 || start_col > cols)
G_fatal_error(_("Seed point outside the current region"));
}
/* Open terran map */
mapset = G_find_cell2(terrainmap, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), terrainmap);
in_terran_fd = G_open_cell_old(terrainmap, mapset);
if (in_terran_fd < 0)
G_fatal_error(_("Unable to open raster map <%s>"),
G_fully_qualified_name(terrainmap, mapset));
/* Open seed map */
if (smap_opt->answer) {
mapset = G_find_cell2(seedmap, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), seedmap);
out_fd = G_open_cell_old(seedmap, mapset);
if (out_fd < 0)
G_fatal_error(_("Unable to open raster map <%s>"),
G_fully_qualified_name(seedmap, mapset));
}
/* Pointers to rows. Row = ptr to 'col' size array. */
in_terran = (FCELL **) G_malloc(rows * sizeof(FCELL *));
out_water = (FCELL **) G_malloc(rows * sizeof(FCELL *));
if (in_terran == NULL || out_water == NULL)
G_fatal_error(_("G_malloc: out of memory"));
G_debug(1, "Loading maps...");
/* foo_rows[row] == array with data (2d array). */
for (row = 0; row < rows; row++) {
in_terran[row] = (FCELL *) G_malloc(cols * sizeof(FCELL));
out_water[row] = (FCELL *) G_calloc(cols, sizeof(FCELL));
/* In newly created space load data from file. */
if (G_get_f_raster_row(in_terran_fd, in_terran[row], row) != 1)
G_fatal_error(_("Unable to read raster map <%s> row %d"),
terrainmap, row);
if (smap_opt->answer)
if (G_get_f_raster_row(out_fd, out_water[row], row) != 1)
G_fatal_error(_("Unable to read raster map <%s> row %d"),
seedmap, row);
G_percent(row + 1, rows, 5);
}
/* Set seed point */
if (sdxy_opt->answer)
/* Check is water level higher than seed point */
if (in_terran[start_row][start_col] >= water_level)
G_fatal_error(_("Given water level at seed point is below earth surface. "
"Increase water level or move seed point."));
out_water[start_row][start_col] = 1;
/* Close seed map for reading. */
if (smap_opt->answer)
G_close_cell(out_fd);
/* Open output map for writing. */
if (lakemap) {
out_fd = lake_fd;
}
else {
out_fd = G_open_raster_new(seedmap, 1);
if (out_fd < 0)
G_fatal_error(_("Unable to create raster map <%s>"), seedmap);
}
/* More pases are renudant. Real pases count is controled by altered cell count. */
pases = (int)(rows * cols) / 2;
G_debug(1,
"Starting lake filling at level of %8.4f in %d passes. Percent done:",
water_level, pases);
lastcount = 0;
for (pass = 0; pass < pases; pass++) {
G_debug(3, "Pass: %d", pass);
curcount = 0;
/* Move from left upper corner to right lower corner. */
for (row = 0; row < rows; row++) {
for (col = 0; col < cols; col++) {
/* Loading water data into window. */
load_window_values(out_water, water_window, rows, cols, row,
col);
/* Cheking presence of water. */
if (is_near_water(water_window) == 1) {
if (in_terran[row][col] < water_level) {
out_water[row][col] =
water_level - in_terran[row][col];
curcount++;
}
else {
out_water[row][col] = 0; /* Cell is higher than water level -> NULL. */
}
}
}
}
if (curcount == lastcount)
break; /* We done. */
lastcount = curcount;
curcount = 0;
/* Move backwards - from lower right corner to upper left corner. */
for (row = rows - 1; row >= 0; row--) {
for (col = cols - 1; col >= 0; col--) {
load_window_values(out_water, water_window, rows, cols, row,
col);
if (is_near_water(water_window) == 1) {
if (in_terran[row][col] < water_level) {
out_water[row][col] =
water_level - in_terran[row][col];
curcount++;
}
else {
out_water[row][col] = 0;
}
}
}
}
G_percent(pass + 1, pases, 10);
if (curcount == lastcount)
break; /* We done. */
lastcount = curcount;
} /*pases */
G_percent(pases, pases, 10); /* Show 100%. */
save_map(out_water, out_fd, rows, cols, negative_flag->answer, &min_depth,
&max_depth, &area, &volume);
G_message(_("Lake depth from %f to %f"), min_depth, max_depth);
G_message(_("Lake area %f square meters"), area);
G_message(_("Lake volume %f cubic meters"), volume);
G_warning(_("Volume is correct only if lake depth (terrain raster map) is in meters"));
/* Close all files. Lake map gets written only now. */
G_close_cell(in_terran_fd);
G_close_cell(out_fd);
/* Add blue color gradient from light bank to dark depth */
G_init_colors(&colr);
if (negative_flag->answer == 1) {
G_add_f_raster_color_rule(&max_depth, 0, 240, 255,
&min_depth, 0, 50, 170, &colr);
}
else {
G_add_f_raster_color_rule(&min_depth, 0, 240, 255,
&max_depth, 0, 50, 170, &colr);
}
if (G_write_colors(lakemap, G_mapset(), &colr) != 1)
G_fatal_error(_("Unable to read color file of raster map <%s>"),
lakemap);
G_short_history(lakemap, "raster", &history);
G_command_history(&history);
G_write_history(lakemap, &history);
return EXIT_SUCCESS;
}
void wtrshed(int fm, int fd, int nl, int ns, int mxbuf)
{
int pass, repeat, flag, i, j, half, bufsz;
int sline, nline, rdline;
struct whereandwhat hold;
struct whereandwhat *dir;
struct whereandwhat *bas;
dir = G_malloc(mxbuf * sizeof(struct whereandwhat));
bas = G_malloc(mxbuf * sizeof(struct whereandwhat));
bufsz = ns * sizeof(CELL);
/* adjust maxbuf to an even number */
half = mxbuf / 2;
mxbuf = 2 * half;
/* allocate buffers for drainage directions and basin areas */
for (i = 0; i < mxbuf; i += 1)
bas[i].p = (CELL *) G_calloc(ns, sizeof(CELL));
for (i = 0; i < mxbuf; i += 1)
dir[i].p = (CELL *) G_calloc(ns, sizeof(CELL));
pass = 0;
/* complete a downward pass */
do {
G_message(_("wtrshed pass %d"), ++pass);
repeat = 0;
/* fill the buffer */
nline = mxbuf;
sline = 0;
rdline = 1;
for (i = 0; i < mxbuf; i++) {
bas[i].offset = dir[i].offset = (off_t) rdline *bufsz;
lseek(fm, bas[i].offset, SEEK_SET);
read(fm, bas[i].p, bufsz);
lseek(fd, dir[i].offset, SEEK_SET);
read(fd, dir[i].p, bufsz);
rdline++;
}
/* repeat for all subsequent rows except the first and last */
for (i = 1; i < nl - 1; i += 1) {
/* analyse one line */
for (j = 1; j < ns - 1; j += 1) {
flag = bas[sline].p[j];
if (flag > 0)
if (recurse_cell(flag, sline, j, nline, ns, bas, dir) > 0)
repeat = 1;
}
/* write one line */
lseek(fm, bas[sline].offset, SEEK_SET);
write(fm, bas[sline].p, bufsz);
/* If the bottom end of the buffers reach the bottom of the file,
* rotate the buffers and read new lines */
if (rdline < nl - 1) {
hold = bas[0];
for (j = 1; j < mxbuf; j += 1)
bas[j - 1] = bas[j];
bas[mxbuf - 1] = hold;
hold = dir[0];
for (j = 1; j < mxbuf; j += 1)
dir[j - 1] = dir[j];
dir[mxbuf - 1] = hold;
bas[mxbuf - 1].offset = dir[mxbuf - 1].offset =
(off_t) rdline *bufsz;
lseek(fm, bas[mxbuf - 1].offset, SEEK_SET);
read(fm, bas[mxbuf - 1].p, bufsz);
lseek(fd, dir[mxbuf - 1].offset, SEEK_SET);
read(fd, dir[mxbuf - 1].p, bufsz);
rdline++;
}
/* After the buffer reaches the bottom of the file, stop reading file,
* just advance the pointers */
else {
nline -= 1;
sline += 1;
}
}
/* fill the buffer */
nline = mxbuf;
rdline = nl - 2;
for (i = mxbuf - 1; i >= 0; i -= 1) {
bas[i].offset = dir[i].offset = (off_t) rdline *bufsz;
lseek(fm, bas[i].offset, SEEK_SET);
read(fm, bas[i].p, bufsz);
lseek(fd, dir[i].offset, SEEK_SET);
read(fd, dir[i].p, bufsz);
rdline--;
}
/* repeat */
for (i = nl - 2; i >= 1; i -= 1) {
/* analyse one line */
for (j = 1; j < ns - 1; j += 1) {
flag = bas[nline - 1].p[j];
if (flag > 0)
if (recurse_cell(flag, nline - 1, j, nline, ns, bas, dir)
> 0)
repeat = 1;
}
/* write one line */
lseek(fm, bas[nline - 1].offset, SEEK_SET);
write(fm, bas[nline - 1].p, bufsz);
/* Until the top of the buffers reach the top of the file,
* rotate the buffers and read new lines */
if (rdline >= 1) {
hold = bas[nline - 1];
for (j = nline - 1; j > 0; j -= 1)
bas[j] = bas[j - 1];
bas[0] = hold;
hold = dir[nline - 1];
for (j = nline - 1; j > 0; j -= 1)
dir[j] = dir[j - 1];
dir[0] = hold;
bas[0].offset = dir[0].offset = (off_t) rdline *bufsz;
lseek(fm, bas[0].offset, SEEK_SET);
read(fm, bas[0].p, bufsz);
lseek(fd, dir[0].offset, SEEK_SET);
read(fd, dir[0].p, bufsz);
rdline--;
}
/* after the buffer reaches the top of the file, just decrease the
* line count */
else
nline -= 1;
}
} while (repeat);
/* allocate buffers for drainage directions and basin areas */
for (i = 0; i < mxbuf; i += 1)
G_free(bas[i].p);
for (i = 0; i < mxbuf; i += 1)
G_free(dir[i].p);
G_free(dir);
G_free(bas);
}
int main(int argc, char **argv)
{
static DCELL *count, *sum, *mean, *sumu, *sum2, *sum3, *sum4, *min, *max;
DCELL *result;
struct GModule *module;
struct {
struct Option *method, *basemap, *covermap, *output;
} opt;
struct {
struct Flag *c, *r;
} flag;
char methods[2048];
const char *basemap, *covermap, *output;
int usecats;
int reclass;
int base_fd, cover_fd;
struct Categories cats;
CELL *base_buf;
DCELL *cover_buf;
struct Range range;
CELL mincat, ncats;
int method;
int rows, cols;
int row, col, i;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("statistics"));
module->description =
_("Calculates category or object oriented statistics (accumulator-based statistics).");
opt.basemap = G_define_standard_option(G_OPT_R_BASE);
opt.covermap = G_define_standard_option(G_OPT_R_COVER);
opt.method = G_define_option();
opt.method->key = "method";
opt.method->type = TYPE_STRING;
opt.method->required = YES;
opt.method->description = _("Method of object-based statistic");
for (i = 0; menu[i].name; i++) {
if (i)
strcat(methods, ",");
else
*(methods) = 0;
strcat(methods, menu[i].name);
}
opt.method->options = G_store(methods);
for (i = 0; menu[i].name; i++) {
if (i)
strcat(methods, ";");
else
*(methods) = 0;
strcat(methods, menu[i].name);
strcat(methods, ";");
strcat(methods, menu[i].text);
}
opt.method->descriptions = G_store(methods);
opt.output = G_define_standard_option(G_OPT_R_OUTPUT);
opt.output->description = _("Resultant raster map");
opt.output->required = YES;
flag.c = G_define_flag();
flag.c->key = 'c';
flag.c->description =
_("Cover values extracted from the category labels of the cover map");
flag.r = G_define_flag();
flag.r->key = 'r';
flag.r->description =
_("Create reclass map with statistics as category labels");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
basemap = opt.basemap->answer;
covermap = opt.covermap->answer;
output = opt.output->answer;
usecats = flag.c->answer;
reclass = flag.r->answer;
for (i = 0; menu[i].name; i++)
if (strcmp(menu[i].name, opt.method->answer) == 0)
break;
if (!menu[i].name) {
G_warning(_("<%s=%s> unknown %s"), opt.method->key, opt.method->answer,
opt.method->key);
G_usage();
exit(EXIT_FAILURE);
}
method = menu[i].val;
base_fd = Rast_open_old(basemap, "");
cover_fd = Rast_open_old(covermap, "");
if (usecats && Rast_read_cats(covermap, "", &cats) < 0)
G_fatal_error(_("Unable to read category file of cover map <%s>"), covermap);
if (Rast_map_is_fp(basemap, "") != 0)
G_fatal_error(_("The base map must be an integer (CELL) map"));
if (Rast_read_range(basemap, "", &range) < 0)
G_fatal_error(_("Unable to read range of base map <%s>"), basemap);
mincat = range.min;
ncats = range.max - range.min + 1;
rows = Rast_window_rows();
cols = Rast_window_cols();
switch (method) {
case COUNT:
count = G_calloc(ncats, sizeof(DCELL));
break;
case SUM:
sum = G_calloc(ncats, sizeof(DCELL));
break;
case MIN:
min = G_malloc(ncats * sizeof(DCELL));
break;
case MAX:
max = G_malloc(ncats * sizeof(DCELL));
break;
case RANGE:
min = G_malloc(ncats * sizeof(DCELL));
max = G_malloc(ncats * sizeof(DCELL));
break;
case AVERAGE:
case ADEV:
case VARIANCE2:
case STDDEV2:
case SKEWNESS2:
case KURTOSIS2:
count = G_calloc(ncats, sizeof(DCELL));
sum = G_calloc(ncats, sizeof(DCELL));
break;
case VARIANCE1:
case STDDEV1:
count = G_calloc(ncats, sizeof(DCELL));
sum = G_calloc(ncats, sizeof(DCELL));
sum2 = G_calloc(ncats, sizeof(DCELL));
break;
case SKEWNESS1:
count = G_calloc(ncats, sizeof(DCELL));
sum = G_calloc(ncats, sizeof(DCELL));
sum2 = G_calloc(ncats, sizeof(DCELL));
sum3 = G_calloc(ncats, sizeof(DCELL));
break;
case KURTOSIS1:
count = G_calloc(ncats, sizeof(DCELL));
sum = G_calloc(ncats, sizeof(DCELL));
sum2 = G_calloc(ncats, sizeof(DCELL));
sum4 = G_calloc(ncats, sizeof(DCELL));
break;
}
if (min)
for (i = 0; i < ncats; i++)
min[i] = 1e300;
if (max)
for (i = 0; i < ncats; i++)
max[i] = -1e300;
base_buf = Rast_allocate_c_buf();
cover_buf = Rast_allocate_d_buf();
G_message(_("First pass"));
for (row = 0; row < rows; row++) {
Rast_get_c_row(base_fd, base_buf, row);
Rast_get_d_row(cover_fd, cover_buf, row);
for (col = 0; col < cols; col++) {
int n;
DCELL v;
if (Rast_is_c_null_value(&base_buf[col]))
continue;
if (Rast_is_d_null_value(&cover_buf[col]))
continue;
n = base_buf[col] - mincat;
if (n < 0 || n >= ncats)
continue;
v = cover_buf[col];
if (usecats)
sscanf(Rast_get_c_cat((CELL *) &v, &cats), "%lf", &v);
if (count)
count[n]++;
if (sum)
sum[n] += v;
if (sum2)
sum2[n] += v * v;
if (sum3)
sum3[n] += v * v * v;
if (sum4)
sum4[n] += v * v * v * v;
if (min && min[n] > v)
min[n] = v;
if (max && max[n] < v)
max[n] = v;
}
G_percent(row, rows, 2);
}
G_percent(row, rows, 2);
result = G_calloc(ncats, sizeof(DCELL));
switch (method) {
case ADEV:
case VARIANCE2:
case STDDEV2:
case SKEWNESS2:
case KURTOSIS2:
mean = G_calloc(ncats, sizeof(DCELL));
for (i = 0; i < ncats; i++)
mean[i] = sum[i] / count[i];
G_free(sum);
break;
}
switch (method) {
case ADEV:
sumu = G_calloc(ncats, sizeof(DCELL));
break;
case VARIANCE2:
case STDDEV2:
sum2 = G_calloc(ncats, sizeof(DCELL));
break;
case SKEWNESS2:
sum2 = G_calloc(ncats, sizeof(DCELL));
sum3 = G_calloc(ncats, sizeof(DCELL));
break;
case KURTOSIS2:
sum2 = G_calloc(ncats, sizeof(DCELL));
sum4 = G_calloc(ncats, sizeof(DCELL));
break;
}
if (mean) {
G_message(_("Second pass"));
for (row = 0; row < rows; row++) {
Rast_get_c_row(base_fd, base_buf, row);
Rast_get_d_row(cover_fd, cover_buf, row);
for (col = 0; col < cols; col++) {
int n;
DCELL v, d;
if (Rast_is_c_null_value(&base_buf[col]))
continue;
if (Rast_is_d_null_value(&cover_buf[col]))
continue;
n = base_buf[col] - mincat;
if (n < 0 || n >= ncats)
continue;
v = cover_buf[col];
if (usecats)
sscanf(Rast_get_c_cat((CELL *) &v, &cats), "%lf", &v);
d = v - mean[n];
if (sumu)
sumu[n] += fabs(d);
if (sum2)
sum2[n] += d * d;
if (sum3)
sum3[n] += d * d * d;
if (sum4)
sum4[n] += d * d * d * d;
}
G_percent(row, rows, 2);
}
G_percent(row, rows, 2);
G_free(mean);
G_free(cover_buf);
}
switch (method) {
case COUNT:
for (i = 0; i < ncats; i++)
result[i] = count[i];
break;
case SUM:
for (i = 0; i < ncats; i++)
result[i] = sum[i];
break;
case AVERAGE:
for (i = 0; i < ncats; i++)
result[i] = sum[i] / count[i];
break;
case MIN:
for (i = 0; i < ncats; i++)
result[i] = min[i];
break;
case MAX:
for (i = 0; i < ncats; i++)
result[i] = max[i];
break;
case RANGE:
for (i = 0; i < ncats; i++)
result[i] = max[i] - min[i];
break;
case VARIANCE1:
for (i = 0; i < ncats; i++) {
double n = count[i];
double var = (sum2[i] - sum[i] * sum[i] / n) / (n - 1);
result[i] = var;
}
break;
case STDDEV1:
for (i = 0; i < ncats; i++) {
double n = count[i];
double var = (sum2[i] - sum[i] * sum[i] / n) / (n - 1);
result[i] = sqrt(var);
}
break;
case SKEWNESS1:
for (i = 0; i < ncats; i++) {
double n = count[i];
double var = (sum2[i] - sum[i] * sum[i] / n) / (n - 1);
double skew = (sum3[i] / n
- 3 * sum[i] * sum2[i] / (n * n)
+ 2 * sum[i] * sum[i] * sum[i] / (n * n * n))
/ (pow(var, 1.5));
result[i] = skew;
}
break;
case KURTOSIS1:
for (i = 0; i < ncats; i++) {
double n = count[i];
double var = (sum2[i] - sum[i] * sum[i] / n) / (n - 1);
double kurt = (sum4[i] / n
- 4 * sum[i] * sum3[i] / (n * n)
+ 6 * sum[i] * sum[i] * sum2[i] / (n * n * n)
- 3 * sum[i] * sum[i] * sum[i] * sum[i] / (n * n * n * n))
/ (var * var) - 3;
result[i] = kurt;
}
break;
case ADEV:
for (i = 0; i < ncats; i++)
result[i] = sumu[i] / count[i];
break;
case VARIANCE2:
for (i = 0; i < ncats; i++)
result[i] = sum2[i] / (count[i] - 1);
break;
case STDDEV2:
for (i = 0; i < ncats; i++)
result[i] = sqrt(sum2[i] / (count[i] - 1));
break;
case SKEWNESS2:
for (i = 0; i < ncats; i++) {
double n = count[i];
double var = sum2[i] / (n - 1);
double sdev = sqrt(var);
result[i] = sum3[i] / (sdev * sdev * sdev) / n;
}
G_free(count);
G_free(sum2);
G_free(sum3);
break;
case KURTOSIS2:
for (i = 0; i < ncats; i++) {
double n = count[i];
double var = sum2[i] / (n - 1);
result[i] = sum4[i] / (var * var) / n - 3;
}
G_free(count);
G_free(sum2);
G_free(sum4);
break;
}
if (reclass) {
const char *tempfile = G_tempfile();
char *input_arg = G_malloc(strlen(basemap) + 7);
char *output_arg = G_malloc(strlen(output) + 8);
char *rules_arg = G_malloc(strlen(tempfile) + 7);
FILE *fp;
G_message(_("Generating reclass map"));
sprintf(input_arg, "input=%s", basemap);
sprintf(output_arg, "output=%s", output);
sprintf(rules_arg, "rules=%s", tempfile);
fp = fopen(tempfile, "w");
if (!fp)
G_fatal_error(_("Unable to open temporary file"));
for (i = 0; i < ncats; i++)
fprintf(fp, "%d = %d %f\n", mincat + i, mincat + i, result[i]);
fclose(fp);
G_spawn("r.reclass", "r.reclass", input_arg, output_arg, rules_arg, NULL);
}
else {
int out_fd;
DCELL *out_buf;
struct Colors colors;
G_message(_("Writing output map"));
out_fd = Rast_open_fp_new(output);
out_buf = Rast_allocate_d_buf();
for (row = 0; row < rows; row++) {
Rast_get_c_row(base_fd, base_buf, row);
for (col = 0; col < cols; col++)
if (Rast_is_c_null_value(&base_buf[col]))
Rast_set_d_null_value(&out_buf[col], 1);
else
out_buf[col] = result[base_buf[col] - mincat];
Rast_put_d_row(out_fd, out_buf);
G_percent(row, rows, 2);
}
G_percent(row, rows, 2);
Rast_close(out_fd);
if (Rast_read_colors(covermap, "", &colors) > 0)
Rast_write_colors(output, G_mapset(), &colors);
}
return 0;
}
int execute_random(struct rr_state *theState)
{
long nt;
long nc;
struct Cell_head window;
int nrows, ncols, row, col;
int infd, cinfd, outfd;
struct Map_info Out;
struct field_info *fi;
dbTable *table;
dbColumn *column;
dbString sql;
dbDriver *driver;
struct line_pnts *Points;
struct line_cats *Cats;
int cat;
RASTER_MAP_TYPE type;
int do_check;
G_get_window(&window);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* open the data files, input raster should be set-up already */
if ((infd = theState->fd_old) < 0)
G_fatal_error(_("Unable to open raster map <%s>"),
theState->inraster);
if (theState->docover == TRUE) {
if ((cinfd = theState->fd_cold) < 0)
G_fatal_error(_("Unable to open raster map <%s>"),
theState->inrcover);
}
if (theState->outraster != NULL) {
if (theState->docover == TRUE)
type = theState->cover.type;
else
type = theState->buf.type;
outfd = Rast_open_new(theState->outraster, type);
theState->fd_new = outfd;
}
if (theState->outvector) {
if (Vect_open_new(&Out, theState->outvector, theState->z_geometry) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
theState->outvector);
Vect_hist_command(&Out);
fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
driver =
db_start_driver_open_database(fi->driver,
Vect_subst_var(fi->database, &Out));
if (!driver)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Vect_subst_var(fi->database, &Out), fi->driver);
db_set_error_handler_driver(driver);
Vect_map_add_dblink(&Out, 1, NULL, fi->table, GV_KEY_COLUMN, fi->database,
fi->driver);
if (theState->docover == TRUE)
table = db_alloc_table(3);
else
table = db_alloc_table(2);
db_set_table_name(table, fi->table);
column = db_get_table_column(table, 0);
db_set_column_name(column, GV_KEY_COLUMN);
db_set_column_sqltype(column, DB_SQL_TYPE_INTEGER);
column = db_get_table_column(table, 1);
db_set_column_name(column, "value");
db_set_column_sqltype(column, DB_SQL_TYPE_DOUBLE_PRECISION);
if (theState->docover == TRUE) {
column = db_get_table_column(table, 2);
db_set_column_name(column, "covervalue");
db_set_column_sqltype(column, DB_SQL_TYPE_DOUBLE_PRECISION);
}
if (db_create_table(driver, table) != DB_OK)
G_warning(_("Cannot create new table"));
db_begin_transaction(driver);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_init_string(&sql);
}
if (theState->outvector && theState->outraster)
G_message(_("Writing raster map <%s> and vector map <%s> ..."),
theState->outraster, theState->outvector);
else if (theState->outraster)
G_message(_("Writing raster map <%s> ..."), theState->outraster);
else if (theState->outvector)
G_message(_("Writing vector map <%s> ..."), theState->outvector);
G_percent(0, theState->nRand, 2);
init_rand();
nc = (theState->use_nulls) ? theState->nCells :
theState->nCells - theState->nNulls;
nt = theState->nRand; /* Number of points to generate */
cat = 1;
/* Execute for loop for every row if nt>1 */
for (row = 0; row < nrows && nt; row++) {
Rast_get_row(infd, theState->buf.data.v, row, theState->buf.type);
if (theState->docover == TRUE) {
Rast_get_row(cinfd, theState->cover.data.v, row,
theState->cover.type);
}
for (col = 0; col < ncols && nt; col++) {
do_check = 0;
if (theState->use_nulls || !is_null_value(theState->buf, col))
do_check = 1;
if (do_check && theState->docover == TRUE) { /* skip no data cover points */
if (!theState->use_nulls &&
is_null_value(theState->cover, col))
do_check = 0;
}
if (do_check && make_rand() % nc < nt) {
nt--;
if (is_null_value(theState->buf, col))
cpvalue(&theState->nulls, 0, &theState->buf, col);
if (theState->docover == TRUE) {
if (is_null_value(theState->cover, col))
cpvalue(&theState->cnulls, 0, &theState->cover, col);
}
if (theState->outvector) {
double x, y, val, coverval;
char buf[500];
Vect_reset_line(Points);
Vect_reset_cats(Cats);
x = window.west + (col + .5) * window.ew_res;
y = window.north - (row + .5) * window.ns_res;
val = cell_as_dbl(&theState->buf, col);
if (theState->docover == 1)
coverval = cell_as_dbl(&theState->cover, col);
if (theState->z_geometry)
Vect_append_point(Points, x, y, val);
else
Vect_append_point(Points, x, y, 0.0);
Vect_cat_set(Cats, 1, cat);
Vect_write_line(&Out, GV_POINT, Points, Cats);
if (theState->docover == 1)
if (is_null_value(theState->cover, col))
sprintf(buf,
"insert into %s values ( %d, %f, NULL )",
fi->table, cat, val);
else
sprintf(buf,
"insert into %s values ( %d, %f, %f )",
fi->table, cat, val, coverval);
else
sprintf(buf, "insert into %s values ( %d, %f )",
fi->table, cat, val);
db_set_string(&sql, buf);
if (db_execute_immediate(driver, &sql) != DB_OK)
G_fatal_error(_("Cannot insert new record: %s"),
db_get_string(&sql));
cat++;
}
G_percent((theState->nRand - nt), theState->nRand, 2);
}
else {
set_to_null(&theState->buf, col);
if (theState->docover == 1)
set_to_null(&theState->cover, col);
}
if (do_check)
nc--;
}
while (col < ncols) {
set_to_null(&theState->buf, col);
if (theState->docover == 1)
set_to_null(&theState->cover, col);
col++;
}
if (theState->outraster) {
if (theState->docover == 1)
Rast_put_row(outfd, theState->cover.data.v,
theState->cover.type);
else
Rast_put_row(outfd, theState->buf.data.v,
theState->buf.type);
}
}
/* Catch any remaining rows in the window */
if (theState->outraster && row < nrows) {
for (col = 0; col < ncols; col++) {
if (theState->docover == 1)
set_to_null(&theState->cover, col);
else
set_to_null(&theState->buf, col);
}
for (; row < nrows; row++) {
if (theState->docover == 1)
Rast_put_row(outfd, theState->cover.data.v,
theState->cover.type);
else
Rast_put_row(outfd, theState->buf.data.v,
theState->buf.type);
}
}
if (nt > 0)
G_warning(_("Only [%ld] random points created"),
theState->nRand - nt);
/* close files */
Rast_close(infd);
if (theState->docover == TRUE)
Rast_close(cinfd);
if (theState->outvector) {
db_commit_transaction(driver);
if (db_create_index2(driver, fi->table, GV_KEY_COLUMN) != DB_OK)
G_warning(_("Unable to create index"));
if (db_grant_on_table
(driver, fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK) {
G_fatal_error(_("Unable to grant privileges on table <%s>"),
fi->table);
}
db_close_database_shutdown_driver(driver);
if (theState->notopol != 1)
Vect_build(&Out);
Vect_close(&Out);
}
if (theState->outraster)
Rast_close(outfd);
return 0;
} /* execute_random() */
int main(int argc, char *argv[])
{
struct GModule *module;
struct _param {
struct Option *dsn, *out, *layer, *spat, *where,
*min_area;
struct Option *snap, *type, *outloc, *cnames;
} param;
struct _flag {
struct Flag *list, *tlist, *no_clean, *z, *notab,
*region;
struct Flag *over, *extend, *formats, *tolower, *no_import;
} flag;
int i, j, layer, arg_s_num, nogeom, ncnames;
float xmin, ymin, xmax, ymax;
int ncols = 0, type;
double min_area, snap;
char buf[2000], namebuf[2000], tempvect[GNAME_MAX];
char *separator;
struct Key_Value *loc_proj_info, *loc_proj_units;
struct Key_Value *proj_info, *proj_units;
struct Cell_head cellhd, loc_wind, cur_wind;
char error_msg[8192];
/* Vector */
struct Map_info Map, Tmp, *Out;
int cat;
/* Attributes */
struct field_info *Fi;
dbDriver *driver;
dbString sql, strval;
int dim, with_z;
/* OGR */
OGRDataSourceH Ogr_ds;
OGRLayerH Ogr_layer;
OGRFieldDefnH Ogr_field;
char *Ogr_fieldname;
OGRFieldType Ogr_ftype;
OGRFeatureH Ogr_feature;
OGRFeatureDefnH Ogr_featuredefn;
OGRGeometryH Ogr_geometry, Ogr_oRing, poSpatialFilter;
OGRSpatialReferenceH Ogr_projection;
OGREnvelope oExt;
OGRwkbGeometryType Ogr_geom_type;
int OFTIntegerListlength;
char *output;
char **layer_names; /* names of layers to be imported */
int *layers; /* layer indexes */
int nlayers; /* number of layers to import */
char **available_layer_names; /* names of layers to be imported */
int navailable_layers;
int layer_id;
unsigned int n_features, feature_count;
int overwrite;
double area_size;
int use_tmp_vect;
xmin = ymin = xmax = ymax = 0.0;
loc_proj_info = loc_proj_units = NULL;
Ogr_ds = Ogr_oRing = poSpatialFilter = NULL;
OFTIntegerListlength = 40; /* hack due to limitation in OGR */
area_size = 0.0;
use_tmp_vect = FALSE;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("import"));
module->description = _("Converts vector data into a GRASS vector map using OGR library.");
param.dsn = G_define_option();
param.dsn->key = "dsn";
param.dsn->type = TYPE_STRING;
param.dsn->required =YES;
param.dsn->label = _("OGR datasource name");
param.dsn->description = _("Examples:\n"
"\t\tESRI Shapefile: directory containing shapefiles\n"
"\t\tMapInfo File: directory containing mapinfo files");
param.layer = G_define_option();
param.layer->key = "layer";
param.layer->type = TYPE_STRING;
param.layer->required = NO;
param.layer->multiple = YES;
param.layer->label =
_("OGR layer name. If not given, all available layers are imported");
param.layer->description =
_("Examples:\n" "\t\tESRI Shapefile: shapefile name\n"
"\t\tMapInfo File: mapinfo file name");
param.layer->guisection = _("Selection");
param.out = G_define_standard_option(G_OPT_V_OUTPUT);
param.out->required = NO;
param.out->guisection = _("Output");
param.spat = G_define_option();
param.spat->key = "spatial";
param.spat->type = TYPE_DOUBLE;
param.spat->multiple = YES;
param.spat->required = NO;
param.spat->key_desc = "xmin,ymin,xmax,ymax";
param.spat->label = _("Import subregion only");
param.spat->guisection = _("Selection");
param.spat->description =
_("Format: xmin,ymin,xmax,ymax - usually W,S,E,N");
param.where = G_define_standard_option(G_OPT_DB_WHERE);
param.where->guisection = _("Selection");
param.min_area = G_define_option();
param.min_area->key = "min_area";
param.min_area->type = TYPE_DOUBLE;
param.min_area->required = NO;
param.min_area->answer = "0.0001";
param.min_area->label =
_("Minimum size of area to be imported (square units)");
param.min_area->guisection = _("Selection");
param.min_area->description = _("Smaller areas and "
"islands are ignored. Should be greater than snap^2");
param.type = G_define_standard_option(G_OPT_V_TYPE);
param.type->options = "point,line,boundary,centroid";
param.type->answer = "";
param.type->description = _("Optionally change default input type");
param.type->descriptions =
_("point;import area centroids as points;"
"line;import area boundaries as lines;"
"boundary;import lines as area boundaries;"
"centroid;import points as centroids");
param.type->guisection = _("Selection");
param.snap = G_define_option();
param.snap->key = "snap";
param.snap->type = TYPE_DOUBLE;
param.snap->required = NO;
param.snap->answer = "-1";
param.snap->label = _("Snapping threshold for boundaries");
param.snap->description = _("'-1' for no snap");
param.outloc = G_define_option();
param.outloc->key = "location";
param.outloc->type = TYPE_STRING;
param.outloc->required = NO;
param.outloc->description = _("Name for new location to create");
param.outloc->key_desc = "name";
param.cnames = G_define_option();
param.cnames->key = "cnames";
param.cnames->type = TYPE_STRING;
param.cnames->required = NO;
param.cnames->multiple = YES;
param.cnames->description =
_("List of column names to be used instead of original names, "
"first is used for category column");
param.cnames->guisection = _("Attributes");
flag.list = G_define_flag();
flag.list->key = 'l';
flag.list->description = _("List available OGR layers in data source and exit");
flag.list->suppress_required = YES;
flag.list->guisection = _("Print");
flag.tlist = G_define_flag();
flag.tlist->key = 'a';
flag.tlist->description = _("List available OGR layers including feature types "
"in data source and exit");
flag.tlist->suppress_required = YES;
flag.tlist->guisection = _("Print");
flag.formats = G_define_flag();
flag.formats->key = 'f';
flag.formats->description = _("List supported formats and exit");
flag.formats->suppress_required = YES;
flag.formats->guisection = _("Print");
/* if using -c, you lose topological information ! */
flag.no_clean = G_define_flag();
flag.no_clean->key = 'c';
flag.no_clean->description = _("Do not clean polygons (not recommended)");
flag.no_clean->guisection = _("Output");
flag.z = G_define_flag();
flag.z->key = 'z';
flag.z->description = _("Create 3D output");
flag.z->guisection = _("Output");
flag.notab = G_define_flag();
flag.notab->key = 't';
flag.notab->description = _("Do not create attribute table");
flag.notab->guisection = _("Attributes");
flag.over = G_define_flag();
flag.over->key = 'o';
flag.over->description =
_("Override dataset projection (use location's projection)");
flag.region = G_define_flag();
flag.region->key = 'r';
flag.region->guisection = _("Selection");
flag.region->description = _("Limit import to the current region");
flag.extend = G_define_flag();
flag.extend->key = 'e';
flag.extend->description =
_("Extend location extents based on new dataset");
flag.tolower = G_define_flag();
flag.tolower->key = 'w';
flag.tolower->description =
_("Change column names to lowercase characters");
flag.tolower->guisection = _("Attributes");
flag.no_import = G_define_flag();
flag.no_import->key = 'i';
flag.no_import->description =
_("Create the location specified by the \"location\" parameter and exit."
" Do not import the vector data.");
/* The parser checks if the map already exists in current mapset, this is
* wrong if location options is used, so 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);
G_begin_polygon_area_calculations(); /* Used in geom() */
OGRRegisterAll();
/* list supported formats */
if (flag.formats->answer) {
int iDriver;
G_message(_("Available OGR Drivers:"));
for (iDriver = 0; iDriver < OGRGetDriverCount(); iDriver++) {
OGRSFDriverH poDriver = OGRGetDriver(iDriver);
const char *pszRWFlag;
if (OGR_Dr_TestCapability(poDriver, ODrCCreateDataSource))
pszRWFlag = "rw";
else
pszRWFlag = "ro";
fprintf(stdout, " %s (%s): %s\n",
OGR_Dr_GetName(poDriver),
pszRWFlag, OGR_Dr_GetName(poDriver));
}
exit(EXIT_SUCCESS);
}
if (param.dsn->answer == NULL) {
G_fatal_error(_("Required parameter <%s> not set"), param.dsn->key);
}
min_area = atof(param.min_area->answer);
snap = atof(param.snap->answer);
type = Vect_option_to_types(param.type);
ncnames = 0;
if (param.cnames->answers) {
i = 0;
while (param.cnames->answers[i++]) {
ncnames++;
}
}
/* Open OGR DSN */
Ogr_ds = NULL;
if (strlen(param.dsn->answer) > 0)
Ogr_ds = OGROpen(param.dsn->answer, FALSE, NULL);
if (Ogr_ds == NULL)
G_fatal_error(_("Unable to open data source <%s>"), param.dsn->answer);
/* Make a list of available layers */
navailable_layers = OGR_DS_GetLayerCount(Ogr_ds);
available_layer_names =
(char **)G_malloc(navailable_layers * sizeof(char *));
if (flag.list->answer || flag.tlist->answer)
G_message(_("Data source <%s> (format '%s') contains %d layers:"),
param.dsn->answer,
OGR_Dr_GetName(OGR_DS_GetDriver(Ogr_ds)), navailable_layers);
for (i = 0; i < navailable_layers; i++) {
Ogr_layer = OGR_DS_GetLayer(Ogr_ds, i);
Ogr_featuredefn = OGR_L_GetLayerDefn(Ogr_layer);
Ogr_geom_type = OGR_FD_GetGeomType(Ogr_featuredefn);
available_layer_names[i] =
G_store((char *)OGR_FD_GetName(Ogr_featuredefn));
if (flag.tlist->answer)
fprintf(stdout, "%s (%s)\n", available_layer_names[i],
OGRGeometryTypeToName(Ogr_geom_type));
else if (flag.list->answer)
fprintf(stdout, "%s\n", available_layer_names[i]);
}
if (flag.list->answer || flag.tlist->answer) {
fflush(stdout);
exit(EXIT_SUCCESS);
}
/* Make a list of layers to be imported */
if (param.layer->answer) { /* From option */
nlayers = 0;
while (param.layer->answers[nlayers])
nlayers++;
layer_names = (char **)G_malloc(nlayers * sizeof(char *));
layers = (int *)G_malloc(nlayers * sizeof(int));
for (i = 0; i < nlayers; i++) {
layer_names[i] = G_store(param.layer->answers[i]);
/* Find it in the source */
layers[i] = -1;
for (j = 0; j < navailable_layers; j++) {
if (strcmp(available_layer_names[j], layer_names[i]) == 0) {
layers[i] = j;
break;
}
}
if (layers[i] == -1)
G_fatal_error(_("Layer <%s> not available"), layer_names[i]);
}
}
else { /* use list of all layers */
nlayers = navailable_layers;
layer_names = available_layer_names;
layers = (int *)G_malloc(nlayers * sizeof(int));
for (i = 0; i < nlayers; i++)
layers[i] = i;
}
if (param.out->answer) {
output = G_store(param.out->answer);
}
else {
if (nlayers < 1)
G_fatal_error(_("No OGR layers available"));
output = G_store(layer_names[0]);
G_message(_("All available OGR layers will be imported into vector map <%s>"), output);
}
if (!param.outloc->answer) { /* Check if the map exists */
if (G_find_vector2(output, G_mapset()) && !overwrite)
G_fatal_error(_("Vector map <%s> already exists"),
output);
}
/* Get first imported layer to use for extents and projection check */
Ogr_layer = OGR_DS_GetLayer(Ogr_ds, layers[0]);
if (flag.region->answer) {
if (param.spat->answer)
G_fatal_error(_("Select either the current region flag or the spatial option, not both"));
G_get_window(&cur_wind);
xmin = cur_wind.west;
xmax = cur_wind.east;
ymin = cur_wind.south;
ymax = cur_wind.north;
}
if (param.spat->answer) {
/* See as reference: gdal/ogr/ogr_capi_test.c */
/* cut out a piece of the map */
/* order: xmin,ymin,xmax,ymax */
arg_s_num = 0;
i = 0;
while (param.spat->answers[i]) {
if (i == 0)
xmin = atof(param.spat->answers[i]);
if (i == 1)
ymin = atof(param.spat->answers[i]);
if (i == 2)
xmax = atof(param.spat->answers[i]);
if (i == 3)
ymax = atof(param.spat->answers[i]);
arg_s_num++;
i++;
}
if (arg_s_num != 4)
G_fatal_error(_("4 parameters required for 'spatial' parameter"));
}
if (param.spat->answer || flag.region->answer) {
G_debug(2, "cut out with boundaries: xmin:%f ymin:%f xmax:%f ymax:%f",
xmin, ymin, xmax, ymax);
/* in theory this could be an irregular polygon */
poSpatialFilter = OGR_G_CreateGeometry(wkbPolygon);
Ogr_oRing = OGR_G_CreateGeometry(wkbLinearRing);
OGR_G_AddPoint(Ogr_oRing, xmin, ymin, 0.0);
OGR_G_AddPoint(Ogr_oRing, xmin, ymax, 0.0);
OGR_G_AddPoint(Ogr_oRing, xmax, ymax, 0.0);
OGR_G_AddPoint(Ogr_oRing, xmax, ymin, 0.0);
OGR_G_AddPoint(Ogr_oRing, xmin, ymin, 0.0);
OGR_G_AddGeometryDirectly(poSpatialFilter, Ogr_oRing);
OGR_L_SetSpatialFilter(Ogr_layer, poSpatialFilter);
}
if (param.where->answer) {
/* select by attribute */
OGR_L_SetAttributeFilter(Ogr_layer, param.where->answer);
}
/* fetch boundaries */
if ((OGR_L_GetExtent(Ogr_layer, &oExt, 1)) == OGRERR_NONE) {
G_get_window(&cellhd);
cellhd.north = oExt.MaxY;
cellhd.south = oExt.MinY;
cellhd.west = oExt.MinX;
cellhd.east = oExt.MaxX;
cellhd.rows = 20; /* TODO - calculate useful values */
cellhd.cols = 20;
cellhd.ns_res = (cellhd.north - cellhd.south) / cellhd.rows;
cellhd.ew_res = (cellhd.east - cellhd.west) / cellhd.cols;
}
else {
cellhd.north = 1.;
cellhd.south = 0.;
cellhd.west = 0.;
cellhd.east = 1.;
cellhd.top = 1.;
cellhd.bottom = 1.;
cellhd.rows = 1;
cellhd.rows3 = 1;
cellhd.cols = 1;
cellhd.cols3 = 1;
cellhd.depths = 1;
cellhd.ns_res = 1.;
cellhd.ns_res3 = 1.;
cellhd.ew_res = 1.;
cellhd.ew_res3 = 1.;
cellhd.tb_res = 1.;
}
/* suppress boundary splitting ? */
if (flag.no_clean->answer) {
split_distance = -1.;
}
else {
split_distance = 0.;
area_size =
sqrt((cellhd.east - cellhd.west) * (cellhd.north - cellhd.south));
}
/* Fetch input map projection in GRASS form. */
proj_info = NULL;
proj_units = NULL;
Ogr_projection = OGR_L_GetSpatialRef(Ogr_layer); /* should not be freed later */
/* Do we need to create a new location? */
if (param.outloc->answer != NULL) {
/* Convert projection information non-interactively as we can't
* assume the user has a terminal open */
if (GPJ_osr_to_grass(&cellhd, &proj_info,
&proj_units, Ogr_projection, 0) < 0) {
G_fatal_error(_("Unable to convert input map projection to GRASS "
"format; cannot create new location."));
}
else {
G_make_location(param.outloc->answer, &cellhd,
proj_info, proj_units, NULL);
G_message(_("Location <%s> created"), param.outloc->answer);
}
/* If the i flag is set, clean up? and exit here */
if(flag.no_import->answer)
{
exit(EXIT_SUCCESS);
}
}
else {
int err = 0;
/* Projection only required for checking so convert non-interactively */
if (GPJ_osr_to_grass(&cellhd, &proj_info,
&proj_units, Ogr_projection, 0) < 0)
G_warning(_("Unable to convert input map projection information to "
"GRASS format for checking"));
/* Does the projection of the current location match the dataset? */
/* G_get_window seems to be unreliable if the location has been changed */
G__get_window(&loc_wind, "", "DEFAULT_WIND", "PERMANENT");
/* fetch LOCATION PROJ info */
if (loc_wind.proj != PROJECTION_XY) {
loc_proj_info = G_get_projinfo();
loc_proj_units = G_get_projunits();
}
if (flag.over->answer) {
cellhd.proj = loc_wind.proj;
cellhd.zone = loc_wind.zone;
G_message(_("Over-riding projection check"));
}
else if (loc_wind.proj != cellhd.proj
|| (err =
G_compare_projections(loc_proj_info, loc_proj_units,
proj_info, proj_units)) != TRUE) {
int i_value;
strcpy(error_msg,
_("Projection of dataset does not"
" appear to match current location.\n\n"));
/* TODO: output this info sorted by key: */
if (loc_wind.proj != cellhd.proj || err != -2) {
if (loc_proj_info != NULL) {
strcat(error_msg, _("GRASS LOCATION PROJ_INFO is:\n"));
for (i_value = 0; i_value < loc_proj_info->nitems;
i_value++)
sprintf(error_msg + strlen(error_msg), "%s: %s\n",
loc_proj_info->key[i_value],
loc_proj_info->value[i_value]);
strcat(error_msg, "\n");
}
if (proj_info != NULL) {
strcat(error_msg, _("Import dataset PROJ_INFO is:\n"));
for (i_value = 0; i_value < proj_info->nitems; i_value++)
sprintf(error_msg + strlen(error_msg), "%s: %s\n",
proj_info->key[i_value],
proj_info->value[i_value]);
}
else {
strcat(error_msg, _("Import dataset PROJ_INFO is:\n"));
if (cellhd.proj == PROJECTION_XY)
sprintf(error_msg + strlen(error_msg),
"Dataset proj = %d (unreferenced/unknown)\n",
cellhd.proj);
else if (cellhd.proj == PROJECTION_LL)
sprintf(error_msg + strlen(error_msg),
"Dataset proj = %d (lat/long)\n",
cellhd.proj);
else if (cellhd.proj == PROJECTION_UTM)
sprintf(error_msg + strlen(error_msg),
"Dataset proj = %d (UTM), zone = %d\n",
cellhd.proj, cellhd.zone);
else if (cellhd.proj == PROJECTION_SP)
sprintf(error_msg + strlen(error_msg),
"Dataset proj = %d (State Plane), zone = %d\n",
cellhd.proj, cellhd.zone);
else
sprintf(error_msg + strlen(error_msg),
"Dataset proj = %d (unknown), zone = %d\n",
cellhd.proj, cellhd.zone);
}
}
else {
if (loc_proj_units != NULL) {
strcat(error_msg, "GRASS LOCATION PROJ_UNITS is:\n");
for (i_value = 0; i_value < loc_proj_units->nitems;
i_value++)
sprintf(error_msg + strlen(error_msg), "%s: %s\n",
loc_proj_units->key[i_value],
loc_proj_units->value[i_value]);
strcat(error_msg, "\n");
}
if (proj_units != NULL) {
strcat(error_msg, "Import dataset PROJ_UNITS is:\n");
for (i_value = 0; i_value < proj_units->nitems; i_value++)
sprintf(error_msg + strlen(error_msg), "%s: %s\n",
proj_units->key[i_value],
proj_units->value[i_value]);
}
}
sprintf(error_msg + strlen(error_msg),
_("\nYou can use the -o flag to %s to override this projection check.\n"),
G_program_name());
strcat(error_msg,
_("Consider generating a new location with 'location' parameter"
" from input data set.\n"));
G_fatal_error(error_msg);
}
else {
G_message(_("Projection of input dataset and current location "
"appear to match"));
}
}
db_init_string(&sql);
db_init_string(&strval);
/* open output vector */
/* strip any @mapset from vector output name */
G_find_vector(output, G_mapset());
Vect_open_new(&Map, output, flag.z->answer != 0);
Out = ⤅
n_polygon_boundaries = 0;
if (!flag.no_clean->answer) {
/* check if we need a tmp vector */
/* estimate distance for boundary splitting --> */
for (layer = 0; layer < nlayers; layer++) {
layer_id = layers[layer];
Ogr_layer = OGR_DS_GetLayer(Ogr_ds, layer_id);
Ogr_featuredefn = OGR_L_GetLayerDefn(Ogr_layer);
n_features = feature_count = 0;
n_features = OGR_L_GetFeatureCount(Ogr_layer, 1);
OGR_L_ResetReading(Ogr_layer);
/* count polygons and isles */
G_message(_("Counting polygons for %d features (OGR layer <%s>)..."),
n_features, layer_names[layer]);
while ((Ogr_feature = OGR_L_GetNextFeature(Ogr_layer)) != NULL) {
G_percent(feature_count++, n_features, 1); /* show something happens */
/* Geometry */
Ogr_geometry = OGR_F_GetGeometryRef(Ogr_feature);
if (Ogr_geometry != NULL) {
poly_count(Ogr_geometry, (type & GV_BOUNDARY));
}
OGR_F_Destroy(Ogr_feature);
}
}
G_debug(1, "n polygon boundaries: %d", n_polygon_boundaries);
if (n_polygon_boundaries > 50) {
split_distance =
area_size / log(n_polygon_boundaries);
/* divisor is the handle: increase divisor to decrease split_distance */
split_distance = split_distance / 5.;
G_debug(1, "root of area size: %f", area_size);
G_verbose_message(_("Boundary splitting distance in map units: %G"),
split_distance);
}
/* <-- estimate distance for boundary splitting */
use_tmp_vect = n_polygon_boundaries > 0;
if (use_tmp_vect) {
/* open temporary vector, do the work in the temporary vector
* at the end copy alive lines to output vector
* in case of polygons this reduces the coor file size by a factor of 2 to 5
* only needed when cleaning polygons */
sprintf(tempvect, "%s_tmp", output);
G_verbose_message(_("Using temporary vector <%s>"), tempvect);
Vect_open_new(&Tmp, tempvect, flag.z->answer != 0);
Out = &Tmp;
}
}
Vect_hist_command(&Map);
/* Points and lines are written immediately with categories. Boundaries of polygons are
* written to the vector then cleaned and centroids are calculated for all areas in cleaan vector.
* Then second pass through finds all centroids in each polygon feature and adds its category
* to the centroid. The result is that one centroids may have 0, 1 ore more categories
* of one ore more (more input layers) fields. */
with_z = 0;
for (layer = 0; layer < nlayers; layer++) {
layer_id = layers[layer];
Ogr_layer = OGR_DS_GetLayer(Ogr_ds, layer_id);
Ogr_featuredefn = OGR_L_GetLayerDefn(Ogr_layer);
/* Add DB link */
if (!flag.notab->answer) {
char *cat_col_name = GV_KEY_COLUMN;
if (nlayers == 1) { /* one layer only */
Fi = Vect_default_field_info(&Map, layer + 1, NULL,
GV_1TABLE);
}
else {
Fi = Vect_default_field_info(&Map, layer + 1, NULL,
GV_MTABLE);
}
if (ncnames > 0) {
cat_col_name = param.cnames->answers[0];
}
Vect_map_add_dblink(&Map, layer + 1, layer_names[layer], Fi->table,
cat_col_name, Fi->database, Fi->driver);
ncols = OGR_FD_GetFieldCount(Ogr_featuredefn);
G_debug(2, "%d columns", ncols);
/* Create table */
sprintf(buf, "create table %s (%s integer", Fi->table,
cat_col_name);
db_set_string(&sql, buf);
for (i = 0; i < ncols; i++) {
Ogr_field = OGR_FD_GetFieldDefn(Ogr_featuredefn, i);
Ogr_ftype = OGR_Fld_GetType(Ogr_field);
G_debug(3, "Ogr_ftype: %i", Ogr_ftype); /* look up below */
if (i < ncnames - 1) {
Ogr_fieldname = G_store(param.cnames->answers[i + 1]);
}
else {
/* Change column names to [A-Za-z][A-Za-z0-9_]* */
Ogr_fieldname = G_store(OGR_Fld_GetNameRef(Ogr_field));
G_debug(3, "Ogr_fieldname: '%s'", Ogr_fieldname);
G_str_to_sql(Ogr_fieldname);
G_debug(3, "Ogr_fieldname: '%s'", Ogr_fieldname);
}
/* avoid that we get the 'cat' column twice */
if (strcmp(Ogr_fieldname, GV_KEY_COLUMN) == 0) {
sprintf(namebuf, "%s_", Ogr_fieldname);
Ogr_fieldname = G_store(namebuf);
}
/* captial column names are a pain in SQL */
if (flag.tolower->answer)
G_str_to_lower(Ogr_fieldname);
if (strcmp(OGR_Fld_GetNameRef(Ogr_field), Ogr_fieldname) != 0) {
G_warning(_("Column name changed: '%s' -> '%s'"),
OGR_Fld_GetNameRef(Ogr_field), Ogr_fieldname);
}
/** Simple 32bit integer OFTInteger = 0 **/
/** List of 32bit integers OFTIntegerList = 1 **/
/** Double Precision floating point OFTReal = 2 **/
/** List of doubles OFTRealList = 3 **/
/** String of ASCII chars OFTString = 4 **/
/** Array of strings OFTStringList = 5 **/
/** Double byte string (unsupported) OFTWideString = 6 **/
/** List of wide strings (unsupported) OFTWideStringList = 7 **/
/** Raw Binary data (unsupported) OFTBinary = 8 **/
/** OFTDate = 9 **/
/** OFTTime = 10 **/
/** OFTDateTime = 11 **/
if (Ogr_ftype == OFTInteger) {
sprintf(buf, ", %s integer", Ogr_fieldname);
}
else if (Ogr_ftype == OFTIntegerList) {
/* hack: treat as string */
sprintf(buf, ", %s varchar ( %d )", Ogr_fieldname,
OFTIntegerListlength);
G_warning(_("Writing column <%s> with fixed length %d chars (may be truncated)"),
Ogr_fieldname, OFTIntegerListlength);
}
else if (Ogr_ftype == OFTReal) {
sprintf(buf, ", %s double precision", Ogr_fieldname);
#if GDAL_VERSION_NUM >= 1320
}
else if (Ogr_ftype == OFTDate) {
sprintf(buf, ", %s date", Ogr_fieldname);
}
else if (Ogr_ftype == OFTTime) {
sprintf(buf, ", %s time", Ogr_fieldname);
}
else if (Ogr_ftype == OFTDateTime) {
sprintf(buf, ", %s datetime", Ogr_fieldname);
#endif
}
else if (Ogr_ftype == OFTString) {
int fwidth;
fwidth = OGR_Fld_GetWidth(Ogr_field);
/* TODO: read all records first and find the longest string length */
if (fwidth == 0) {
G_warning(_("Width for column %s set to 255 (was not specified by OGR), "
"some strings may be truncated!"),
Ogr_fieldname);
fwidth = 255;
}
sprintf(buf, ", %s varchar ( %d )", Ogr_fieldname,
fwidth);
}
else if (Ogr_ftype == OFTStringList) {
/* hack: treat as string */
sprintf(buf, ", %s varchar ( %d )", Ogr_fieldname,
OFTIntegerListlength);
G_warning(_("Writing column %s with fixed length %d chars (may be truncated)"),
Ogr_fieldname, OFTIntegerListlength);
}
else {
G_warning(_("Column type not supported (%s)"),
Ogr_fieldname);
buf[0] = 0;
}
db_append_string(&sql, buf);
G_free(Ogr_fieldname);
}
db_append_string(&sql, ")");
G_debug(3, db_get_string(&sql));
driver =
db_start_driver_open_database(Fi->driver,
Vect_subst_var(Fi->database,
&Map));
if (driver == NULL) {
G_fatal_error(_("Unable open database <%s> by driver <%s>"),
Vect_subst_var(Fi->database, &Map), Fi->driver);
}
if (db_execute_immediate(driver, &sql) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Unable to create table: '%s'"),
db_get_string(&sql));
}
if (db_create_index2(driver, Fi->table, cat_col_name) != DB_OK)
G_warning(_("Unable to create index for table <%s>, key <%s>"),
Fi->table, cat_col_name);
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Unable to grant privileges on table <%s>"),
Fi->table);
db_begin_transaction(driver);
}
/* Import feature */
cat = 1;
nogeom = 0;
OGR_L_ResetReading(Ogr_layer);
n_features = feature_count = 0;
n_features = OGR_L_GetFeatureCount(Ogr_layer, 1);
G_important_message(_("Importing %d features (OGR layer <%s>)..."),
n_features, layer_names[layer]);
while ((Ogr_feature = OGR_L_GetNextFeature(Ogr_layer)) != NULL) {
G_percent(feature_count++, n_features, 1); /* show something happens */
/* Geometry */
Ogr_geometry = OGR_F_GetGeometryRef(Ogr_feature);
if (Ogr_geometry == NULL) {
nogeom++;
}
else {
dim = OGR_G_GetCoordinateDimension(Ogr_geometry);
if (dim > 2)
with_z = 1;
geom(Ogr_geometry, Out, layer + 1, cat, min_area, type,
flag.no_clean->answer);
}
/* Attributes */
if (!flag.notab->answer) {
sprintf(buf, "insert into %s values ( %d", Fi->table, cat);
db_set_string(&sql, buf);
for (i = 0; i < ncols; i++) {
Ogr_field = OGR_FD_GetFieldDefn(Ogr_featuredefn, i);
Ogr_ftype = OGR_Fld_GetType(Ogr_field);
if (OGR_F_IsFieldSet(Ogr_feature, i)) {
if (Ogr_ftype == OFTInteger || Ogr_ftype == OFTReal) {
sprintf(buf, ", %s",
OGR_F_GetFieldAsString(Ogr_feature, i));
#if GDAL_VERSION_NUM >= 1320
/* should we use OGR_F_GetFieldAsDateTime() here ? */
}
else if (Ogr_ftype == OFTDate || Ogr_ftype == OFTTime
|| Ogr_ftype == OFTDateTime) {
char *newbuf;
db_set_string(&strval, (char *)
OGR_F_GetFieldAsString(Ogr_feature,
i));
db_double_quote_string(&strval);
sprintf(buf, ", '%s'", db_get_string(&strval));
newbuf = G_str_replace(buf, "/", "-"); /* fix 2001/10/21 to 2001-10-21 */
sprintf(buf, "%s", newbuf);
#endif
}
else if (Ogr_ftype == OFTString ||
Ogr_ftype == OFTIntegerList) {
db_set_string(&strval, (char *)
OGR_F_GetFieldAsString(Ogr_feature,
i));
db_double_quote_string(&strval);
sprintf(buf, ", '%s'", db_get_string(&strval));
}
}
else {
/* G_warning (_("Column value not set" )); */
if (Ogr_ftype == OFTInteger || Ogr_ftype == OFTReal) {
sprintf(buf, ", NULL");
#if GDAL_VERSION_NUM >= 1320
}
else if (Ogr_ftype == OFTString ||
Ogr_ftype == OFTIntegerList ||
Ogr_ftype == OFTDate) {
#else
}
else if (Ogr_ftype == OFTString ||
Ogr_ftype == OFTIntegerList) {
#endif
sprintf(buf, ", ''");
}
}
db_append_string(&sql, buf);
}
db_append_string(&sql, " )");
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Cannot insert new row: %s"),
db_get_string(&sql));
}
}
OGR_F_Destroy(Ogr_feature);
cat++;
}
G_percent(1, 1, 1); /* finish it */
if (!flag.notab->answer) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
if (nogeom > 0)
G_warning(_("%d %s without geometry"), nogeom,
nogeom == 1 ? "feature" : "features");
}
separator = "-----------------------------------------------------";
G_message("%s", separator);
if (use_tmp_vect) {
/* TODO: is it necessary to build here? probably not, consumes time */
/* GV_BUILD_BASE is sufficient to toggle boundary cleaning */
Vect_build_partial(&Tmp, GV_BUILD_BASE);
}
if (use_tmp_vect && !flag.no_clean->answer &&
Vect_get_num_primitives(Out, GV_BOUNDARY) > 0) {
int ret, centr, ncentr, otype, n_overlaps, n_nocat;
CENTR *Centr;
struct spatial_index si;
double x, y, total_area, overlap_area, nocat_area;
struct bound_box box;
struct line_pnts *Points;
int nmodif;
Points = Vect_new_line_struct();
G_message("%s", separator);
G_warning(_("Cleaning polygons, result is not guaranteed!"));
if (snap >= 0) {
G_message("%s", separator);
G_message(_("Snapping boundaries (threshold = %.3e)..."), snap);
Vect_snap_lines(&Tmp, GV_BOUNDARY, snap, NULL);
}
/* It is not to clean to snap centroids, but I have seen data with 2 duplicate polygons
* (as far as decimal places were printed) and centroids were not identical */
/* Disabled, because overlapping polygons result in many duplicate centroids anyway */
/*
fprintf ( stderr, separator );
fprintf ( stderr, "Snap centroids (threshold 0.000001):\n" );
Vect_snap_lines ( &Map, GV_CENTROID, 0.000001, NULL, stderr );
*/
G_message("%s", separator);
G_message(_("Breaking polygons..."));
Vect_break_polygons(&Tmp, GV_BOUNDARY, NULL);
/* It is important to remove also duplicate centroids in case of duplicate input polygons */
G_message("%s", separator);
G_message(_("Removing duplicates..."));
Vect_remove_duplicates(&Tmp, GV_BOUNDARY | GV_CENTROID, NULL);
/* in non-pathological cases, the bulk of the cleaning is now done */
/* Vect_clean_small_angles_at_nodes() can change the geometry so that new intersections
* are created. We must call Vect_break_lines(), Vect_remove_duplicates()
* and Vect_clean_small_angles_at_nodes() until no more small angles are found */
do {
G_message("%s", separator);
G_message(_("Breaking boundaries..."));
Vect_break_lines(&Tmp, GV_BOUNDARY, NULL);
G_message("%s", separator);
G_message(_("Removing duplicates..."));
Vect_remove_duplicates(&Tmp, GV_BOUNDARY, NULL);
G_message("%s", separator);
G_message(_("Cleaning boundaries at nodes..."));
nmodif =
Vect_clean_small_angles_at_nodes(&Tmp, GV_BOUNDARY, NULL);
} while (nmodif > 0);
/* merge boundaries */
G_message("%s", separator);
G_message(_("Merging boundaries..."));
Vect_merge_lines(&Tmp, GV_BOUNDARY, NULL, NULL);
G_message("%s", separator);
if (type & GV_BOUNDARY) { /* that means lines were converted to boundaries */
G_message(_("Changing boundary dangles to lines..."));
Vect_chtype_dangles(&Tmp, -1.0, NULL);
}
else {
G_message(_("Removing dangles..."));
Vect_remove_dangles(&Tmp, GV_BOUNDARY, -1.0, NULL);
}
G_message("%s", separator);
if (type & GV_BOUNDARY) {
G_message(_("Changing boundary bridges to lines..."));
Vect_chtype_bridges(&Tmp, NULL);
}
else {
G_message(_("Removing bridges..."));
Vect_remove_bridges(&Tmp, NULL);
}
/* Boundaries are hopefully clean, build areas */
G_message("%s", separator);
Vect_build_partial(&Tmp, GV_BUILD_ATTACH_ISLES);
/* Calculate new centroids for all areas, centroids have the same id as area */
ncentr = Vect_get_num_areas(&Tmp);
G_debug(3, "%d centroids/areas", ncentr);
Centr = (CENTR *) G_calloc(ncentr + 1, sizeof(CENTR));
Vect_spatial_index_init(&si, 0);
for (centr = 1; centr <= ncentr; centr++) {
Centr[centr].valid = 0;
Centr[centr].cats = Vect_new_cats_struct();
ret = Vect_get_point_in_area(&Tmp, centr, &x, &y);
if (ret < 0) {
G_warning(_("Unable to calculate area centroid"));
continue;
}
Centr[centr].x = x;
Centr[centr].y = y;
Centr[centr].valid = 1;
box.N = box.S = y;
box.E = box.W = x;
box.T = box.B = 0;
Vect_spatial_index_add_item(&si, centr, &box);
}
/* Go through all layers and find centroids for each polygon */
for (layer = 0; layer < nlayers; layer++) {
G_message("%s", separator);
G_message(_("Finding centroids for OGR layer <%s>..."), layer_names[layer]);
layer_id = layers[layer];
Ogr_layer = OGR_DS_GetLayer(Ogr_ds, layer_id);
n_features = OGR_L_GetFeatureCount(Ogr_layer, 1);
OGR_L_ResetReading(Ogr_layer);
cat = 0; /* field = layer + 1 */
G_percent(cat, n_features, 2);
while ((Ogr_feature = OGR_L_GetNextFeature(Ogr_layer)) != NULL) {
cat++;
G_percent(cat, n_features, 2);
/* Geometry */
Ogr_geometry = OGR_F_GetGeometryRef(Ogr_feature);
if (Ogr_geometry != NULL) {
centroid(Ogr_geometry, Centr, &si, layer + 1, cat,
min_area, type);
}
OGR_F_Destroy(Ogr_feature);
}
}
/* Write centroids */
G_message("%s", separator);
G_message(_("Writing centroids..."));
n_overlaps = n_nocat = 0;
total_area = overlap_area = nocat_area = 0.0;
for (centr = 1; centr <= ncentr; centr++) {
double area;
G_percent(centr, ncentr, 2);
area = Vect_get_area_area(&Tmp, centr);
total_area += area;
if (!(Centr[centr].valid)) {
continue;
}
if (Centr[centr].cats->n_cats == 0) {
nocat_area += area;
n_nocat++;
continue;
}
if (Centr[centr].cats->n_cats > 1) {
Vect_cat_set(Centr[centr].cats, nlayers + 1,
Centr[centr].cats->n_cats);
overlap_area += area;
n_overlaps++;
}
Vect_reset_line(Points);
Vect_append_point(Points, Centr[centr].x, Centr[centr].y, 0.0);
if (type & GV_POINT)
otype = GV_POINT;
else
otype = GV_CENTROID;
Vect_write_line(&Tmp, otype, Points, Centr[centr].cats);
}
if (Centr)
G_free(Centr);
Vect_spatial_index_destroy(&si);
if (n_overlaps > 0) {
G_warning(_("%d areas represent more (overlapping) features, because polygons overlap "
"in input layer(s). Such areas are linked to more than 1 row in attribute table. "
"The number of features for those areas is stored as category in layer %d"),
n_overlaps, nlayers + 1);
}
G_message("%s", separator);
Vect_hist_write(&Map, separator);
Vect_hist_write(&Map, "\n");
sprintf(buf, _("%d input polygons\n"), n_polygons);
G_message(_("%d input polygons"), n_polygons);
Vect_hist_write(&Map, buf);
sprintf(buf, _("Total area: %G (%d areas)\n"), total_area, ncentr);
G_message(_("Total area: %G (%d areas)"), total_area, ncentr);
Vect_hist_write(&Map, buf);
sprintf(buf, _("Overlapping area: %G (%d areas)\n"), overlap_area,
n_overlaps);
G_message(_("Overlapping area: %G (%d areas)"), overlap_area,
n_overlaps);
Vect_hist_write(&Map, buf);
sprintf(buf, _("Area without category: %G (%d areas)\n"), nocat_area,
n_nocat);
G_message(_("Area without category: %G (%d areas)"), nocat_area,
n_nocat);
Vect_hist_write(&Map, buf);
G_message("%s", separator);
}
/* needed?
* OGR_DS_Destroy( Ogr_ds );
*/
if (use_tmp_vect) {
/* Copy temporary vector to output vector */
Vect_copy_map_lines(&Tmp, &Map);
/* release memory occupied by topo, we may need that memory for main output */
Vect_set_release_support(&Tmp);
Vect_close(&Tmp);
Vect_delete(tempvect);
}
Vect_build(&Map);
Vect_close(&Map);
/* -------------------------------------------------------------------- */
/* Extend current window based on dataset. */
/* -------------------------------------------------------------------- */
if (flag.extend->answer) {
G_get_default_window(&loc_wind);
loc_wind.north = MAX(loc_wind.north, cellhd.north);
loc_wind.south = MIN(loc_wind.south, cellhd.south);
loc_wind.west = MIN(loc_wind.west, cellhd.west);
loc_wind.east = MAX(loc_wind.east, cellhd.east);
loc_wind.rows = (int)ceil((loc_wind.north - loc_wind.south)
/ loc_wind.ns_res);
loc_wind.south = loc_wind.north - loc_wind.rows * loc_wind.ns_res;
loc_wind.cols = (int)ceil((loc_wind.east - loc_wind.west)
/ loc_wind.ew_res);
loc_wind.east = loc_wind.west + loc_wind.cols * loc_wind.ew_res;
G__put_window(&loc_wind, "../PERMANENT", "DEFAULT_WIND");
}
if (with_z && !flag.z->answer)
G_warning(_("Input data contains 3D features. Created vector is 2D only, "
"use -z flag to import 3D vector."));
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int fe, fd, fm;
int i, j, type;
int new_id;
int nrows, ncols, nbasins;
int map_id, dir_id, bas_id;
char map_name[GNAME_MAX], new_map_name[GNAME_MAX];
const char *tempfile1, *tempfile2, *tempfile3;
char dir_name[GNAME_MAX];
char bas_name[GNAME_MAX];
struct Cell_head window;
struct GModule *module;
struct Option *opt1, *opt2, *opt3, *opt4, *opt5;
struct Flag *flag1;
int in_type, bufsz;
void *in_buf;
CELL *out_buf;
struct band3 bnd, bndC;
/* Initialize the GRASS environment variables */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("hydrology"));
module->description =
_("Filters and generates a depressionless elevation map and a "
"flow direction map from a given elevation raster map.");
opt1 = G_define_standard_option(G_OPT_R_ELEV);
opt2 = G_define_standard_option(G_OPT_R_OUTPUT);
opt2->key = "depressionless";
opt2->description = _("Name for output depressionless elevation raster map");
opt4 = G_define_standard_option(G_OPT_R_OUTPUT);
opt4->key = "direction";
opt4->description = _("Name for output flow direction map for depressionless elevation raster map");
opt5 = G_define_standard_option(G_OPT_R_OUTPUT);
opt5->key = "areas";
opt5->required = NO;
opt5->description = _("Name for output raster map of problem areas");
opt3 = G_define_option();
opt3->key = "type";
opt3->type = TYPE_STRING;
opt3->required = NO;
opt3->description =
_("Aspect direction format");
opt3->options = "agnps,answers,grass";
opt3->answer = "grass";
flag1 = G_define_flag();
flag1->key = 'f';
flag1->description = _("Find unresolved areas only");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (flag1->answer && opt5->answer == NULL) {
G_fatal_error(_("The '%c' flag requires '%s'to be specified"),
flag1->key, opt5->key);
}
type = 0;
strcpy(map_name, opt1->answer);
strcpy(new_map_name, opt2->answer);
strcpy(dir_name, opt4->answer);
if (opt5->answer != NULL)
strcpy(bas_name, opt5->answer);
if (strcmp(opt3->answer, "agnps") == 0)
type = 1;
else if (strcmp(opt3->answer, "answers") == 0)
type = 2;
else if (strcmp(opt3->answer, "grass") == 0)
type = 3;
G_debug(1, "output type (1=AGNPS, 2=ANSWERS, 3=GRASS): %d", type);
if (type == 3)
G_verbose_message(_("Direction map is D8 resolution, i.e. 45 degrees"));
/* open the maps and get their file id */
map_id = Rast_open_old(map_name, "");
/* allocate cell buf for the map layer */
in_type = Rast_get_map_type(map_id);
/* set the pointers for multi-typed functions */
set_func_pointers(in_type);
/* get the window information */
G_get_window(&window);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* buffers for internal use */
bndC.ns = ncols;
bndC.sz = sizeof(CELL) * ncols;
bndC.b[0] = G_calloc(ncols, sizeof(CELL));
bndC.b[1] = G_calloc(ncols, sizeof(CELL));
bndC.b[2] = G_calloc(ncols, sizeof(CELL));
/* buffers for external use */
bnd.ns = ncols;
bnd.sz = ncols * bpe();
bnd.b[0] = G_calloc(ncols, bpe());
bnd.b[1] = G_calloc(ncols, bpe());
bnd.b[2] = G_calloc(ncols, bpe());
in_buf = get_buf();
tempfile1 = G_tempfile();
tempfile2 = G_tempfile();
tempfile3 = G_tempfile();
fe = open(tempfile1, O_RDWR | O_CREAT, 0666); /* elev */
fd = open(tempfile2, O_RDWR | O_CREAT, 0666); /* dirn */
fm = open(tempfile3, O_RDWR | O_CREAT, 0666); /* problems */
G_message(_("Reading elevation map..."));
for (i = 0; i < nrows; i++) {
G_percent(i, nrows, 2);
get_row(map_id, in_buf, i);
write(fe, in_buf, bnd.sz);
}
G_percent(1, 1, 1);
Rast_close(map_id);
/* fill single-cell holes and take a first stab at flow directions */
G_message(_("Filling sinks..."));
filldir(fe, fd, nrows, &bnd);
/* determine flow directions for ambiguous cases */
G_message(_("Determining flow directions for ambiguous cases..."));
resolve(fd, nrows, &bndC);
/* mark and count the sinks in each internally drained basin */
nbasins = dopolys(fd, fm, nrows, ncols);
if (flag1->answer) {
/* determine the watershed for each sink */
wtrshed(fm, fd, nrows, ncols, 4);
/* fill all of the watersheds up to the elevation necessary for drainage */
ppupdate(fe, fm, nrows, nbasins, &bnd, &bndC);
/* repeat the first three steps to get the final directions */
G_message(_("Repeat to get the final directions..."));
filldir(fe, fd, nrows, &bnd);
resolve(fd, nrows, &bndC);
nbasins = dopolys(fd, fm, nrows, ncols);
}
G_free(bndC.b[0]);
G_free(bndC.b[1]);
G_free(bndC.b[2]);
G_free(bnd.b[0]);
G_free(bnd.b[1]);
G_free(bnd.b[2]);
out_buf = Rast_allocate_c_buf();
bufsz = ncols * sizeof(CELL);
lseek(fe, 0, SEEK_SET);
new_id = Rast_open_new(new_map_name, in_type);
lseek(fd, 0, SEEK_SET);
dir_id = Rast_open_new(dir_name, CELL_TYPE);
if (opt5->answer != NULL) {
lseek(fm, 0, SEEK_SET);
bas_id = Rast_open_new(bas_name, CELL_TYPE);
for (i = 0; i < nrows; i++) {
read(fm, out_buf, bufsz);
Rast_put_row(bas_id, out_buf, CELL_TYPE);
}
Rast_close(bas_id);
close(fm);
}
for (i = 0; i < nrows; i++) {
read(fe, in_buf, bnd.sz);
put_row(new_id, in_buf);
read(fd, out_buf, bufsz);
for (j = 0; j < ncols; j += 1)
out_buf[j] = dir_type(type, out_buf[j]);
Rast_put_row(dir_id, out_buf, CELL_TYPE);
}
Rast_close(new_id);
close(fe);
Rast_close(dir_id);
close(fd);
G_free(in_buf);
G_free(out_buf);
exit(EXIT_SUCCESS);
}
/* *************************************************************** */
int test_array_3d(void)
{
int sum = 0, res = 0;
char buff[1024];
RASTER3D_Region region;
N_array_3d *data1;
N_array_3d *data11;
N_array_3d *data2;
N_array_3d *data22;
N_array_3d *tmp;
double min, max, ssum;
int nonzero;
/*Alloacte memory for all arrays */
data1 =
N_alloc_array_3d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, TEST_N_NUM_DEPTHS, 2,
FCELL_TYPE);
N_print_array_3d_info(data1);
data11 =
N_alloc_array_3d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, TEST_N_NUM_DEPTHS, 2,
FCELL_TYPE);
data2 =
N_alloc_array_3d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, TEST_N_NUM_DEPTHS, 2,
DCELL_TYPE);
N_print_array_3d_info(data2);
data22 =
N_alloc_array_3d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, TEST_N_NUM_DEPTHS, 2,
DCELL_TYPE);
/*Fill the first arrays with data */
res = fill_array_3d(data1);
if (res != 0)
G_warning("test_array_3d: error while filling array with values");
sum += res;
res = fill_array_3d(data2);
if (res != 0)
G_warning("test_array_3d: error while filling array with values");
sum += res;
/*Copy the data */
N_copy_array_3d(data1, data11);
N_copy_array_3d(data2, data22);
/*Compare the data */
res = compare_array_3d(data1, data11);
if (res != 0)
G_warning("test_array_3d: error in N_copy_array_2d");
sum += res;
res = compare_array_3d(data1, data11);
if (res != 0)
G_warning("test_array_3d: error in N_copy_array_2d");
sum += res;
/*compute statistics */
N_calc_array_3d_stats(data1, &min, &max, &ssum, &nonzero, 0);
G_message("FELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 729 || ssum != 91125 || nonzero != 1000) {
G_warning("test_array_3d: error in N_calc_array_3d_stats");
sum++;
}
N_calc_array_3d_stats(data1, &min, &max, &ssum, &nonzero, 1);
G_message("FELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 729 || ssum != 91125 || nonzero != 2744) {
G_warning("test_array_3d: error in N_calc_array_3d_stats");
sum++;
}
N_calc_array_3d_stats(data2, &min, &max, &ssum, &nonzero, 0);
G_message("DCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 729 || ssum != 91125 || nonzero != 1000) {
G_warning("test_array_3d: error in N_calc_array_3d_stats");
sum++;
}
N_calc_array_3d_stats(data2, &min, &max, &ssum, &nonzero, 1);
G_message("DCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 729 || ssum != 91125 || nonzero != 2744) {
G_warning("test_array_3d: error in N_calc_array_3d_stats");
sum++;
}
/*test the array math functions */
tmp = N_math_array_3d(data1, data2, NULL, N_ARRAY_SUM);
N_math_array_3d(data2, data2, tmp, N_ARRAY_SUM);
res = N_convert_array_3d_null_to_zero(tmp);
if (res != 0)
G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
sum = res;
N_free_array_3d(tmp);
tmp = N_math_array_3d(data2, data1, NULL, N_ARRAY_DIF);
N_math_array_3d(data1, data2, tmp, N_ARRAY_DIF);
res = N_convert_array_3d_null_to_zero(tmp);
if (res != 0)
G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
sum = res;
N_free_array_3d(tmp);
tmp = N_math_array_3d(data1, data1, NULL, N_ARRAY_MUL);
N_math_array_3d(data1, data1, tmp, N_ARRAY_MUL);
res = N_convert_array_3d_null_to_zero(tmp);
if (res != 0)
G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
sum = res;
N_free_array_3d(tmp);
tmp = N_math_array_3d(data2, data1, NULL, N_ARRAY_DIV);
N_math_array_3d(data1, data2, tmp, N_ARRAY_DIV);
res = N_convert_array_3d_null_to_zero(tmp);
if (res == 0) { /* if a division with zero is detected, the value is set to null, not to nan */
G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
sum++;
}
N_free_array_3d(tmp);
/*check for correct norm calculation */
if (N_norm_array_3d(data1, data11, N_EUKLID_NORM) != 0.0) {
G_warning("test_array_3d: error in N_norm_array_3d");
sum++;
}
if (N_norm_array_3d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
G_warning("test_array_3d: error in N_norm_array_3d");
sum++;
}
if (N_norm_array_3d(data1, data2, N_EUKLID_NORM) != 0.0) {
G_warning("test_array_3d: error in N_norm_array_3d");
sum++;
}
if (N_norm_array_3d(data1, data2, N_MAXIMUM_NORM) != 0.0) {
G_warning("test_array_3d: error in N_norm_array_3d");
sum++;
}
/*fill arrays with null values */
res = fill_array_3d_null(data1);
if (res != 0)
G_warning
("test_array_3d: error while filling array with float null values");
sum += res;
res = fill_array_3d_null(data2);
if (res != 0)
G_warning
("test_array_3d: error while filling array with double null values");
sum += res;
/*Copy the data */
N_copy_array_3d(data1, data11);
N_copy_array_3d(data2, data22);
/*Compare the data */
compare_array_3d(data1, data11);
compare_array_3d(data2, data22);
/*test the array math functions */
tmp = N_math_array_3d(data1, data2, NULL, N_ARRAY_SUM);
N_math_array_3d(data2, data2, tmp, N_ARRAY_SUM);
res = N_convert_array_3d_null_to_zero(tmp);
if (res == 0) {
G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
sum++;
}
N_free_array_3d(tmp);
tmp = N_math_array_3d(data2, data1, NULL, N_ARRAY_DIF);
N_math_array_3d(data1, data2, tmp, N_ARRAY_DIF);
res = N_convert_array_3d_null_to_zero(tmp);
if (res == 0) {
G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
sum++;
}
N_free_array_3d(tmp);
tmp = N_math_array_3d(data1, data1, NULL, N_ARRAY_MUL);
N_math_array_3d(data1, data1, tmp, N_ARRAY_MUL);
res = N_convert_array_3d_null_to_zero(tmp);
if (res == 0) {
G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
sum++;
}
N_free_array_3d(tmp);
tmp = N_math_array_3d(data2, data1, NULL, N_ARRAY_DIV);
N_math_array_3d(data1, data2, tmp, N_ARRAY_DIV);
res = N_convert_array_3d_null_to_zero(tmp);
if (res == 0) {
G_warning("test_array_3d: error in N_convert_array_3d_null_to_zero");
sum++;
}
N_free_array_3d(tmp);
/*check for correct norm calculation in case of null values */
if (N_norm_array_3d(data1, data11, N_EUKLID_NORM) != 0.0) {
G_warning("test_array_3d: error in N_norm_array_3d");
sum++;
}
if (N_norm_array_3d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
G_warning("test_array_3d: error in N_norm_array_3d");
sum++;
}
if (N_norm_array_3d(data1, data2, N_EUKLID_NORM) != 0.0) {
G_warning("test_array_3d: error in N_norm_array_3d");
sum++;
}
if (N_norm_array_3d(data1, data2, N_MAXIMUM_NORM) != 0.0) {
G_warning("test_array_3d: error in N_norm_array_3d");
sum++;
}
N_free_array_3d(data1);
N_free_array_3d(data2);
/*Set the defaults */
Rast3d_init_defaults();
Rast3d_get_window(®ion);
data1 =
N_alloc_array_3d(region.cols, region.rows, region.depths, 0,
FCELL_TYPE);
data2 =
N_alloc_array_3d(region.cols, region.rows, region.depths, 0,
DCELL_TYPE);
fill_array_3d(data1);
fill_array_3d(data2);
/*Volume IO methods */
N_write_array_3d_to_rast3d(data1, "gpde_lib_test_volume_1", 1);
N_write_array_3d_to_rast3d(data2, "gpde_lib_test_volume_2", 1);
tmp = N_read_rast3d_to_array_3d("gpde_lib_test_volume_1", NULL, 1);
N_read_rast3d_to_array_3d("gpde_lib_test_volume_1", tmp, 1);
N_free_array_3d(tmp);
tmp = N_read_rast3d_to_array_3d("gpde_lib_test_volume_2", NULL, 1);
N_read_rast3d_to_array_3d("gpde_lib_test_volume_2", tmp, 1);
N_free_array_3d(tmp);
sprintf(buff,
"g.remove rast3d=gpde_lib_test_volume_1,gpde_lib_test_volume_2");
system(buff);
N_free_array_3d(data1);
N_free_array_3d(data11);
N_free_array_3d(data2);
N_free_array_3d(data22);
return sum;
}
int main(int argc, char *argv[])
{
struct Map_info In, Out, Error;
struct line_pnts *Points;
struct line_cats *Cats;
int i, type, iter;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out, *error_out, *thresh_opt, *method_opt,
*look_ahead_opt;
struct Option *iterations_opt, *cat_opt, *alpha_opt, *beta_opt, *type_opt;
struct Option *field_opt, *where_opt, *reduction_opt, *slide_opt;
struct Option *angle_thresh_opt, *degree_thresh_opt,
*closeness_thresh_opt;
struct Option *betweeness_thresh_opt;
struct Flag *notab_flag, *loop_support_flag;
int with_z;
int total_input, total_output; /* Number of points in the input/output map respectively */
double thresh, alpha, beta, reduction, slide, angle_thresh;
double degree_thresh, closeness_thresh, betweeness_thresh;
int method;
int look_ahead, iterations;
int loop_support;
int layer;
int n_lines;
int simplification, mask_type;
struct cat_list *cat_list = NULL;
char *s, *descriptions;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("generalization"));
G_add_keyword(_("simplification"));
G_add_keyword(_("smoothing"));
G_add_keyword(_("displacement"));
G_add_keyword(_("network generalization"));
module->description = _("Performs vector based generalization.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->options = "line,boundary,area";
type_opt->answer = "line,boundary,area";
type_opt->guisection = _("Selection");
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
error_out = G_define_standard_option(G_OPT_V_OUTPUT);
error_out->key = "error";
error_out->required = NO;
error_out->description =
_("Error map of all lines and boundaries not being generalized due to topology issues or over-simplification");
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->multiple = NO;
method_opt->options =
"douglas,douglas_reduction,lang,reduction,reumann,boyle,sliding_averaging,distance_weighting,chaiken,hermite,snakes,network,displacement";
descriptions = NULL;
G_asprintf(&descriptions,
"douglas;%s;"
"douglas_reduction;%s;"
"lang;%s;"
"reduction;%s;"
"reumann;%s;"
"boyle;%s;"
"sliding_averaging;%s;"
"distance_weighting;%s;"
"chaiken;%s;"
"hermite;%s;"
"snakes;%s;"
"network;%s;"
"displacement;%s;",
_("Douglas-Peucker Algorithm"),
_("Douglas-Peucker Algorithm with reduction parameter"),
_("Lang Simplification Algorithm"),
_("Vertex Reduction Algorithm eliminates points close to each other"),
_("Reumann-Witkam Algorithm"),
_("Boyle's Forward-Looking Algorithm"),
_("McMaster's Sliding Averaging Algorithm"),
_("McMaster's Distance-Weighting Algorithm"),
_("Chaiken's Algorithm"),
_("Interpolation by Cubic Hermite Splines"),
_("Snakes method for line smoothing"),
_("Network generalization"),
_("Displacement of lines close to each other"));
method_opt->descriptions = G_store(descriptions);
method_opt->description = _("Generalization algorithm");
thresh_opt = G_define_option();
thresh_opt->key = "threshold";
thresh_opt->type = TYPE_DOUBLE;
thresh_opt->required = YES;
thresh_opt->options = "0-1000000000";
thresh_opt->description = _("Maximal tolerance value");
look_ahead_opt = G_define_option();
look_ahead_opt->key = "look_ahead";
look_ahead_opt->type = TYPE_INTEGER;
look_ahead_opt->required = NO;
look_ahead_opt->answer = "7";
look_ahead_opt->description = _("Look-ahead parameter");
reduction_opt = G_define_option();
reduction_opt->key = "reduction";
reduction_opt->type = TYPE_DOUBLE;
reduction_opt->required = NO;
reduction_opt->answer = "50";
reduction_opt->options = "0-100";
reduction_opt->description =
_("Percentage of the points in the output of 'douglas_reduction' algorithm");
slide_opt = G_define_option();
slide_opt->key = "slide";
slide_opt->type = TYPE_DOUBLE;
slide_opt->required = NO;
slide_opt->answer = "0.5";
slide_opt->options = "0-1";
slide_opt->description =
_("Slide of computed point toward the original point");
angle_thresh_opt = G_define_option();
angle_thresh_opt->key = "angle_thresh";
angle_thresh_opt->type = TYPE_DOUBLE;
angle_thresh_opt->required = NO;
angle_thresh_opt->answer = "3";
angle_thresh_opt->options = "0-180";
angle_thresh_opt->description =
_("Minimum angle between two consecutive segments in Hermite method");
degree_thresh_opt = G_define_option();
degree_thresh_opt->key = "degree_thresh";
degree_thresh_opt->type = TYPE_INTEGER;
degree_thresh_opt->required = NO;
degree_thresh_opt->answer = "0";
degree_thresh_opt->description =
_("Degree threshold in network generalization");
closeness_thresh_opt = G_define_option();
closeness_thresh_opt->key = "closeness_thresh";
closeness_thresh_opt->type = TYPE_DOUBLE;
closeness_thresh_opt->required = NO;
closeness_thresh_opt->answer = "0";
closeness_thresh_opt->options = "0-1";
closeness_thresh_opt->description =
_("Closeness threshold in network generalization");
betweeness_thresh_opt = G_define_option();
betweeness_thresh_opt->key = "betweeness_thresh";
betweeness_thresh_opt->type = TYPE_DOUBLE;
betweeness_thresh_opt->required = NO;
betweeness_thresh_opt->answer = "0";
betweeness_thresh_opt->description =
_("Betweeness threshold in network generalization");
alpha_opt = G_define_option();
alpha_opt->key = "alpha";
alpha_opt->type = TYPE_DOUBLE;
alpha_opt->required = NO;
alpha_opt->answer = "1.0";
alpha_opt->description = _("Snakes alpha parameter");
beta_opt = G_define_option();
beta_opt->key = "beta";
beta_opt->type = TYPE_DOUBLE;
beta_opt->required = NO;
beta_opt->answer = "1.0";
beta_opt->description = _("Snakes beta parameter");
iterations_opt = G_define_option();
iterations_opt->key = "iterations";
iterations_opt->type = TYPE_INTEGER;
iterations_opt->required = NO;
iterations_opt->answer = "1";
iterations_opt->description = _("Number of iterations");
cat_opt = G_define_standard_option(G_OPT_V_CATS);
cat_opt->guisection = _("Selection");
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
where_opt->guisection = _("Selection");
loop_support_flag = G_define_flag();
loop_support_flag->key = 'l';
loop_support_flag->label = _("Disable loop support");
loop_support_flag->description = _("Do not modify end points of lines forming a closed loop");
notab_flag = G_define_standard_flag(G_FLG_V_TABLE);
notab_flag->description = _("Do not copy attributes");
notab_flag->guisection = _("Attributes");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
thresh = atof(thresh_opt->answer);
look_ahead = atoi(look_ahead_opt->answer);
alpha = atof(alpha_opt->answer);
beta = atof(beta_opt->answer);
reduction = atof(reduction_opt->answer);
iterations = atoi(iterations_opt->answer);
slide = atof(slide_opt->answer);
angle_thresh = atof(angle_thresh_opt->answer);
degree_thresh = atof(degree_thresh_opt->answer);
closeness_thresh = atof(closeness_thresh_opt->answer);
betweeness_thresh = atof(betweeness_thresh_opt->answer);
mask_type = type_mask(type_opt);
G_debug(3, "Method: %s", method_opt->answer);
s = method_opt->answer;
if (strcmp(s, "douglas") == 0)
method = DOUGLAS;
else if (strcmp(s, "lang") == 0)
method = LANG;
else if (strcmp(s, "reduction") == 0)
method = VERTEX_REDUCTION;
else if (strcmp(s, "reumann") == 0)
method = REUMANN;
else if (strcmp(s, "boyle") == 0)
method = BOYLE;
else if (strcmp(s, "distance_weighting") == 0)
method = DISTANCE_WEIGHTING;
else if (strcmp(s, "chaiken") == 0)
method = CHAIKEN;
else if (strcmp(s, "hermite") == 0)
method = HERMITE;
else if (strcmp(s, "snakes") == 0)
method = SNAKES;
else if (strcmp(s, "douglas_reduction") == 0)
method = DOUGLAS_REDUCTION;
else if (strcmp(s, "sliding_averaging") == 0)
method = SLIDING_AVERAGING;
else if (strcmp(s, "network") == 0)
method = NETWORK;
else if (strcmp(s, "displacement") == 0) {
method = DISPLACEMENT;
/* we can displace only the lines */
mask_type = GV_LINE;
}
else {
G_fatal_error(_("Unknown method"));
exit(EXIT_FAILURE);
}
/* simplification or smoothing? */
switch (method) {
case DOUGLAS:
case DOUGLAS_REDUCTION:
case LANG:
case VERTEX_REDUCTION:
case REUMANN:
simplification = 1;
break;
default:
simplification = 0;
break;
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_check_input_output_name(map_in->answer, map_out->answer,
G_FATAL_EXIT);
Vect_set_open_level(2);
if (Vect_open_old2(&In, map_in->answer, "", field_opt->answer) < 1)
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
if (Vect_get_num_primitives(&In, mask_type) == 0) {
G_warning(_("No lines found in input map <%s>"), map_in->answer);
Vect_close(&In);
exit(EXIT_SUCCESS);
}
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, map_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), map_out->answer);
}
if (error_out->answer) {
if (0 > Vect_open_new(&Error, error_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create error vector map <%s>"), error_out->answer);
}
}
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
total_input = total_output = 0;
layer = Vect_get_field_number(&In, field_opt->answer);
/* parse filter options */
if (layer > 0)
cat_list = Vect_cats_set_constraint(&In, layer,
where_opt->answer, cat_opt->answer);
if (method == DISPLACEMENT) {
/* modifies only lines, all other features including boundaries are preserved */
/* options where, cats, and layer are respected */
G_message(_("Displacement..."));
snakes_displacement(&In, &Out, thresh, alpha, beta, 1.0, 10.0,
iterations, cat_list, layer);
}
/* TODO: rearrange code below. It's really messy */
if (method == NETWORK) {
/* extracts lines of selected type, all other features are discarded */
/* options where, cats, and layer are ignored */
G_message(_("Network generalization..."));
total_output =
graph_generalization(&In, &Out, mask_type, degree_thresh,
closeness_thresh, betweeness_thresh);
}
/* copy tables here because method == NETWORK is complete and
* tables for Out may be needed for parse_filter_options() below */
if (!notab_flag->answer) {
if (method == NETWORK)
copy_tables_by_cats(&In, &Out);
else
Vect_copy_tables(&In, &Out, -1);
}
else if (where_opt->answer && method < NETWORK) {
G_warning(_("Attributes are needed for 'where' option, copying table"));
Vect_copy_tables(&In, &Out, -1);
}
/* smoothing/simplification */
if (method < NETWORK) {
/* modifies only lines of selected type, all other features are preserved */
int not_modified_boundaries = 0, n_oversimplified = 0;
struct line_pnts *APoints; /* original Points */
set_topo_debug();
Vect_copy_map_lines(&In, &Out);
Vect_build_partial(&Out, GV_BUILD_CENTROIDS);
G_message("-----------------------------------------------------");
G_message(_("Generalization (%s)..."), method_opt->answer);
G_message(_("Using threshold: %g %s"), thresh, G_database_unit_name(1));
G_percent_reset();
APoints = Vect_new_line_struct();
n_lines = Vect_get_num_lines(&Out);
for (i = 1; i <= n_lines; i++) {
int after = 0;
G_percent(i, n_lines, 1);
type = Vect_read_line(&Out, APoints, Cats, i);
if (!(type & GV_LINES) || !(mask_type & type))
continue;
if (layer > 0) {
if ((type & GV_LINE) &&
!Vect_cats_in_constraint(Cats, layer, cat_list))
continue;
else if ((type & GV_BOUNDARY)) {
int do_line = 0;
int left, right;
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
if (!do_line) {
/* check if any of the centroids is selected */
Vect_get_line_areas(&Out, i, &left, &right);
if (left < 0)
left = Vect_get_isle_area(&Out, abs(left));
if (right < 0)
right = Vect_get_isle_area(&Out, abs(right));
if (left > 0) {
Vect_get_area_cats(&Out, left, Cats);
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
}
if (!do_line && right > 0) {
Vect_get_area_cats(&Out, right, Cats);
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
}
}
if (!do_line)
continue;
}
}
Vect_line_prune(APoints);
if (APoints->n_points < 2)
/* Line of length zero, delete if boundary ? */
continue;
total_input += APoints->n_points;
/* copy points */
Vect_reset_line(Points);
Vect_append_points(Points, APoints, GV_FORWARD);
loop_support = 0;
if (!loop_support_flag->answer) {
int n1, n2;
Vect_get_line_nodes(&Out, i, &n1, &n2);
if (n1 == n2) {
if (Vect_get_node_n_lines(&Out, n1) == 2) {
if (abs(Vect_get_node_line(&Out, n1, 0)) == i &&
abs(Vect_get_node_line(&Out, n1, 1)) == i)
loop_support = 1;
}
}
}
for (iter = 0; iter < iterations; iter++) {
switch (method) {
case DOUGLAS:
douglas_peucker(Points, thresh, with_z);
break;
case DOUGLAS_REDUCTION:
douglas_peucker_reduction(Points, thresh, reduction,
with_z);
break;
case LANG:
lang(Points, thresh, look_ahead, with_z);
break;
case VERTEX_REDUCTION:
vertex_reduction(Points, thresh, with_z);
break;
case REUMANN:
reumann_witkam(Points, thresh, with_z);
break;
case BOYLE:
boyle(Points, look_ahead, loop_support, with_z);
break;
case SLIDING_AVERAGING:
sliding_averaging(Points, slide, look_ahead, loop_support, with_z);
break;
case DISTANCE_WEIGHTING:
distance_weighting(Points, slide, look_ahead, loop_support, with_z);
break;
case CHAIKEN:
chaiken(Points, thresh, loop_support, with_z);
break;
case HERMITE:
hermite(Points, thresh, angle_thresh, loop_support, with_z);
break;
case SNAKES:
snakes(Points, alpha, beta, loop_support, with_z);
break;
}
}
if (loop_support == 0) {
/* safety check, BUG in method if not passed */
if (APoints->x[0] != Points->x[0] ||
APoints->y[0] != Points->y[0] ||
APoints->z[0] != Points->z[0])
G_fatal_error(_("Method '%s' did not preserve first point"), method_opt->answer);
if (APoints->x[APoints->n_points - 1] != Points->x[Points->n_points - 1] ||
APoints->y[APoints->n_points - 1] != Points->y[Points->n_points - 1] ||
APoints->z[APoints->n_points - 1] != Points->z[Points->n_points - 1])
G_fatal_error(_("Method '%s' did not preserve last point"), method_opt->answer);
}
else {
/* safety check, BUG in method if not passed */
if (Points->x[0] != Points->x[Points->n_points - 1] ||
Points->y[0] != Points->y[Points->n_points - 1] ||
Points->z[0] != Points->z[Points->n_points - 1])
G_fatal_error(_("Method '%s' did not preserve loop"), method_opt->answer);
}
Vect_line_prune(Points);
/* oversimplified line */
if (Points->n_points < 2) {
after = APoints->n_points;
n_oversimplified++;
if (error_out->answer)
Vect_write_line(&Error, type, APoints, Cats);
}
/* check for topology corruption */
else if (type == GV_BOUNDARY) {
if (!check_topo(&Out, i, APoints, Points, Cats)) {
after = APoints->n_points;
not_modified_boundaries++;
if (error_out->answer)
Vect_write_line(&Error, type, APoints, Cats);
}
else
after = Points->n_points;
}
else {
/* type == GV_LINE */
Vect_rewrite_line(&Out, i, type, Points, Cats);
after = Points->n_points;
}
total_output += after;
}
if (not_modified_boundaries > 0)
G_warning(_("%d boundaries were not modified because modification would damage topology"),
not_modified_boundaries);
if (n_oversimplified > 0)
G_warning(_("%d lines/boundaries were not modified due to over-simplification"),
n_oversimplified);
G_message("-----------------------------------------------------");
/* make sure that clean topo is built at the end */
Vect_build_partial(&Out, GV_BUILD_NONE);
if (error_out->answer)
Vect_build_partial(&Error, GV_BUILD_NONE);
}
Vect_build(&Out);
if (error_out->answer)
Vect_build(&Error);
Vect_close(&In);
Vect_close(&Out);
if (error_out->answer)
Vect_close(&Error);
G_message("-----------------------------------------------------");
if (total_input != 0 && total_input != total_output)
G_done_msg(_("Number of vertices for selected features %s from %d to %d (%d%% remaining)"),
simplification ? _("reduced") : _("changed"),
total_input, total_output,
(total_output * 100) / total_input);
else
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
/*--------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
/* Variable declarations */
int nsply, nsplx, nrows, ncols, nsplx_adj, nsply_adj;
int nsubregion_col, nsubregion_row, subregion_row, subregion_col;
int subregion = 0, nsubregions = 0;
int last_row, last_column, grid, bilin, ext, flag_auxiliar, cross; /* booleans */
double stepN, stepE, lambda, mean;
double N_extension, E_extension, edgeE, edgeN;
const char *mapset, *drv, *db, *vector, *map;
char table_name[GNAME_MAX], title[64];
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
int dim_vect, nparameters, BW;
int *lineVect; /* Vector restoring primitive's ID */
double *TN, *Q, *parVect; /* Interpolating and least-square vectors */
double **N, **obsVect; /* Interpolation and least-square matrix */
SEGMENT out_seg, mask_seg;
const char *out_file, *mask_file;
int out_fd, mask_fd;
double seg_size;
int seg_mb, segments_in_memory;
int have_mask;
/* Structs declarations */
int raster;
struct Map_info In, In_ext, Out;
struct History history;
struct GModule *module;
struct Option *in_opt, *in_ext_opt, *out_opt, *out_map_opt, *stepE_opt,
*stepN_opt, *lambda_f_opt, *type_opt, *dfield_opt, *col_opt, *mask_opt,
*memory_opt, *solver, *error, *iter;
struct Flag *cross_corr_flag, *spline_step_flag;
struct Reg_dimens dims;
struct Cell_head elaboration_reg, original_reg;
struct bound_box general_box, overlap_box, original_box;
struct Point *observ;
struct line_cats *Cats;
dbCatValArray cvarr;
int with_z;
int nrec, ctype = 0;
struct field_info *Fi;
dbDriver *driver, *driver_cats;
/*----------------------------------------------------------------*/
/* Options declarations */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("surface"));
G_add_keyword(_("interpolation"));
G_add_keyword(_("LIDAR"));
module->description =
_("Performs bicubic or bilinear spline interpolation with Tykhonov regularization.");
cross_corr_flag = G_define_flag();
cross_corr_flag->key = 'c';
cross_corr_flag->description =
_("Find the best Tykhonov regularizing parameter using a \"leave-one-out\" cross validation method");
spline_step_flag = G_define_flag();
spline_step_flag->key = 'e';
spline_step_flag->label = _("Estimate point density and distance");
spline_step_flag->description =
_("Estimate point density and distance for the input vector points within the current region extends and quit");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
in_opt->label = _("Name of input vector point map");
dfield_opt = G_define_standard_option(G_OPT_V_FIELD);
dfield_opt->guisection = _("Settings");
col_opt = G_define_standard_option(G_OPT_DB_COLUMN);
col_opt->required = NO;
col_opt->label =
_("Name of the attribute column with values to be used for approximation");
col_opt->description = _("If not given and input is 3D vector map then z-coordinates are used.");
col_opt->guisection = _("Settings");
in_ext_opt = G_define_standard_option(G_OPT_V_INPUT);
in_ext_opt->key = "sparse_input";
in_ext_opt->required = NO;
in_ext_opt->label =
_("Name of input vector map with sparse points");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->required = NO;
out_opt->guisection = _("Outputs");
out_map_opt = G_define_standard_option(G_OPT_R_OUTPUT);
out_map_opt->key = "raster_output";
out_map_opt->required = NO;
out_map_opt->guisection = _("Outputs");
mask_opt = G_define_standard_option(G_OPT_R_INPUT);
mask_opt->key = "mask";
mask_opt->label = _("Raster map to use for masking (applies to raster output only)");
mask_opt->description = _("Only cells that are not NULL and not zero are interpolated");
mask_opt->required = NO;
stepE_opt = G_define_option();
stepE_opt->key = "ew_step";
stepE_opt->type = TYPE_DOUBLE;
stepE_opt->required = NO;
stepE_opt->answer = "4";
stepE_opt->description =
_("Length of each spline step in the east-west direction");
stepE_opt->guisection = _("Settings");
stepN_opt = G_define_option();
stepN_opt->key = "ns_step";
stepN_opt->type = TYPE_DOUBLE;
stepN_opt->required = NO;
stepN_opt->answer = "4";
stepN_opt->description =
_("Length of each spline step in the north-south direction");
stepN_opt->guisection = _("Settings");
type_opt = G_define_option();
type_opt->key = "method";
type_opt->description = _("Spline interpolation algorithm");
type_opt->type = TYPE_STRING;
type_opt->options = "bilinear,bicubic";
type_opt->answer = "bilinear";
type_opt->guisection = _("Settings");
G_asprintf((char **) &(type_opt->descriptions),
"bilinear;%s;bicubic;%s",
_("Bilinear interpolation"),
_("Bicubic interpolation"));
lambda_f_opt = G_define_option();
lambda_f_opt->key = "lambda_i";
lambda_f_opt->type = TYPE_DOUBLE;
lambda_f_opt->required = NO;
lambda_f_opt->description = _("Tykhonov regularization parameter (affects smoothing)");
lambda_f_opt->answer = "0.01";
lambda_f_opt->guisection = _("Settings");
solver = N_define_standard_option(N_OPT_SOLVER_SYMM);
solver->options = "cholesky,cg";
solver->answer = "cholesky";
iter = N_define_standard_option(N_OPT_MAX_ITERATIONS);
error = N_define_standard_option(N_OPT_ITERATION_ERROR);
memory_opt = G_define_option();
memory_opt->key = "memory";
memory_opt->type = TYPE_INTEGER;
memory_opt->required = NO;
memory_opt->answer = "300";
memory_opt->label = _("Maximum memory to be used (in MB)");
memory_opt->description = _("Cache size for raster rows");
/*----------------------------------------------------------------*/
/* Parsing */
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
vector = out_opt->answer;
map = out_map_opt->answer;
if (vector && map)
G_fatal_error(_("Choose either vector or raster output, not both"));
if (!vector && !map && !cross_corr_flag->answer)
G_fatal_error(_("No raster or vector or cross-validation output"));
if (!strcmp(type_opt->answer, "linear"))
bilin = P_BILINEAR;
else
bilin = P_BICUBIC;
stepN = atof(stepN_opt->answer);
stepE = atof(stepE_opt->answer);
lambda = atof(lambda_f_opt->answer);
flag_auxiliar = FALSE;
drv = db_get_default_driver_name();
if (!drv) {
if (db_set_default_connection() != DB_OK)
G_fatal_error(_("Unable to set default DB connection"));
drv = db_get_default_driver_name();
}
db = db_get_default_database_name();
if (!db)
G_fatal_error(_("No default DB defined"));
/* Set auxiliary table's name */
if (vector) {
if (G_name_is_fully_qualified(out_opt->answer, xname, xmapset)) {
sprintf(table_name, "%s_aux", xname);
}
else
sprintf(table_name, "%s_aux", out_opt->answer);
}
/* Something went wrong in a previous v.surf.bspline execution */
if (db_table_exists(drv, db, table_name)) {
/* Start driver and open db */
driver = db_start_driver_open_database(drv, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
drv);
db_set_error_handler_driver(driver);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Old auxiliary table could not be dropped"));
db_close_database_shutdown_driver(driver);
}
/* Open input vector */
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
Vect_set_open_level(1); /* WITHOUT TOPOLOGY */
if (1 > Vect_open_old(&In, in_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s> at the topological level"),
in_opt->answer);
bspline_field = 0; /* assume 3D input */
bspline_column = col_opt->answer;
with_z = !bspline_column && Vect_is_3d(&In);
if (Vect_is_3d(&In)) {
if (!with_z)
G_verbose_message(_("Input is 3D: using attribute values instead of z-coordinates for approximation"));
else
G_verbose_message(_("Input is 3D: using z-coordinates for approximation"));
}
else { /* 2D */
if (!bspline_column)
G_fatal_error(_("Input vector map is 2D. Parameter <%s> required."), col_opt->key);
}
if (!with_z) {
bspline_field = Vect_get_field_number(&In, dfield_opt->answer);
}
/* Estimate point density and mean distance for current region */
if (spline_step_flag->answer) {
double dens, dist;
if (P_estimate_splinestep(&In, &dens, &dist) == 0) {
fprintf(stdout, _("Estimated point density: %.4g"), dens);
fprintf(stdout, _("Estimated mean distance between points: %.4g"), dist);
}
else {
fprintf(stdout, _("No points in current region"));
}
Vect_close(&In);
exit(EXIT_SUCCESS);
}
/*----------------------------------------------------------------*/
/* Cross-correlation begins */
if (cross_corr_flag->answer) {
G_debug(1, "CrossCorrelation()");
cross = cross_correlation(&In, stepE, stepN);
if (cross != TRUE)
G_fatal_error(_("Cross validation didn't finish correctly"));
else {
G_debug(1, "Cross validation finished correctly");
Vect_close(&In);
G_done_msg(_("Cross validation finished for ew_step = %f and ns_step = %f"), stepE, stepN);
exit(EXIT_SUCCESS);
}
}
/* Open input ext vector */
ext = FALSE;
if (in_ext_opt->answer) {
ext = TRUE;
G_message(_("Vector map <%s> of sparse points will be interpolated"),
in_ext_opt->answer);
if ((mapset = G_find_vector2(in_ext_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), in_ext_opt->answer);
Vect_set_open_level(1); /* WITHOUT TOPOLOGY */
if (1 > Vect_open_old(&In_ext, in_ext_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s> at the topological level"),
in_opt->answer);
}
/* Open output map */
/* vector output */
if (vector && !map) {
if (strcmp(drv, "dbf") == 0)
G_fatal_error(_("Sorry, the <%s> driver is not compatible with "
"the vector output of this module. "
"Try with raster output or another driver."), drv);
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
G_FATAL_EXIT);
grid = FALSE;
if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z))
G_fatal_error(_("Unable to create vector map <%s>"),
out_opt->answer);
/* Copy vector Head File */
if (ext == FALSE) {
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
}
else {
Vect_copy_head_data(&In_ext, &Out);
Vect_hist_copy(&In_ext, &Out);
}
Vect_hist_command(&Out);
G_verbose_message(_("Points in input vector map <%s> will be interpolated"),
vector);
}
/* read z values from attribute table */
if (bspline_field > 0) {
G_message(_("Reading values from attribute table..."));
db_CatValArray_init(&cvarr);
Fi = Vect_get_field(&In, bspline_field);
if (Fi == NULL)
G_fatal_error(_("Cannot read layer info"));
driver_cats = db_start_driver_open_database(Fi->driver, Fi->database);
/*G_debug (0, _("driver=%s db=%s"), Fi->driver, Fi->database); */
if (driver_cats == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
db_set_error_handler_driver(driver_cats);
nrec =
db_select_CatValArray(driver_cats, Fi->table, Fi->key,
col_opt->answer, NULL, &cvarr);
G_debug(3, "nrec = %d", nrec);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type not supported"));
if (nrec < 0)
G_fatal_error(_("Unable to select data from table"));
G_verbose_message(_("%d records selected from table"), nrec);
db_close_database_shutdown_driver(driver_cats);
}
/*----------------------------------------------------------------*/
/* Interpolation begins */
G_debug(1, "Interpolation()");
/* Open driver and database */
driver = db_start_driver_open_database(drv, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. "
"Run db.connect."), drv);
db_set_error_handler_driver(driver);
/* Create auxiliary table */
if (vector) {
if ((flag_auxiliar = P_Create_Aux4_Table(driver, table_name)) == FALSE) {
P_Drop_Aux_Table(driver, table_name);
G_fatal_error(_("Interpolation: Creating table: "
"It was impossible to create table <%s>."),
table_name);
}
/* db_create_index2(driver, table_name, "ID"); */
/* sqlite likes that ??? */
db_close_database_shutdown_driver(driver);
driver = db_start_driver_open_database(drv, db);
}
/* raster output */
raster = -1;
Rast_set_fp_type(DCELL_TYPE);
if (!vector && map) {
grid = TRUE;
raster = Rast_open_fp_new(out_map_opt->answer);
G_verbose_message(_("Cells for raster map <%s> will be interpolated"),
map);
}
/* Setting regions and boxes */
G_debug(1, "Interpolation: Setting regions and boxes");
G_get_window(&original_reg);
G_get_window(&elaboration_reg);
Vect_region_box(&original_reg, &original_box);
Vect_region_box(&elaboration_reg, &overlap_box);
Vect_region_box(&elaboration_reg, &general_box);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* Alloc raster matrix */
have_mask = 0;
out_file = mask_file = NULL;
out_fd = mask_fd = -1;
if (grid == TRUE) {
int row;
DCELL *drastbuf;
seg_mb = atoi(memory_opt->answer);
if (seg_mb < 3)
G_fatal_error(_("Memory in MB must be >= 3"));
if (mask_opt->answer)
seg_size = sizeof(double) + sizeof(char);
else
seg_size = sizeof(double);
seg_size = (seg_size * SEGSIZE * SEGSIZE) / (1 << 20);
segments_in_memory = seg_mb / seg_size + 0.5;
G_debug(1, "%d %dx%d segments held in memory", segments_in_memory, SEGSIZE, SEGSIZE);
out_file = G_tempfile();
out_fd = creat(out_file, 0666);
if (Segment_format(out_fd, nrows, ncols, SEGSIZE, SEGSIZE, sizeof(double)) != 1)
G_fatal_error(_("Can not create temporary file"));
close(out_fd);
out_fd = open(out_file, 2);
if (Segment_init(&out_seg, out_fd, segments_in_memory) != 1)
G_fatal_error(_("Can not initialize temporary file"));
/* initialize output */
G_message(_("Initializing output..."));
drastbuf = Rast_allocate_buf(DCELL_TYPE);
Rast_set_d_null_value(drastbuf, ncols);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Segment_put_row(&out_seg, drastbuf, row);
}
G_percent(row, nrows, 2);
if (mask_opt->answer) {
int row, col, maskfd;
DCELL dval, *drastbuf;
char mask_val;
G_message(_("Load masking map"));
mask_file = G_tempfile();
mask_fd = creat(mask_file, 0666);
if (Segment_format(mask_fd, nrows, ncols, SEGSIZE, SEGSIZE, sizeof(char)) != 1)
G_fatal_error(_("Can not create temporary file"));
close(mask_fd);
mask_fd = open(mask_file, 2);
if (Segment_init(&mask_seg, mask_fd, segments_in_memory) != 1)
G_fatal_error(_("Can not initialize temporary file"));
maskfd = Rast_open_old(mask_opt->answer, "");
drastbuf = Rast_allocate_buf(DCELL_TYPE);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Rast_get_d_row(maskfd, drastbuf, row);
for (col = 0; col < ncols; col++) {
dval = drastbuf[col];
if (Rast_is_d_null_value(&dval) || dval == 0)
mask_val = 0;
else
mask_val = 1;
Segment_put(&mask_seg, &mask_val, row, col);
}
}
G_percent(row, nrows, 2);
G_free(drastbuf);
Rast_close(maskfd);
have_mask = 1;
}
}
/*------------------------------------------------------------------
| Subdividing and working with tiles:
| Each original region will be divided into several subregions.
| Each one will be overlaped by its neighbouring subregions.
| The overlapping is calculated as a fixed OVERLAP_SIZE times
| the largest spline step plus 2 * edge
----------------------------------------------------------------*/
/* Fixing parameters of the elaboration region */
P_zero_dim(&dims); /* Set dim struct to zero */
nsplx_adj = NSPLX_MAX;
nsply_adj = NSPLY_MAX;
if (stepN > stepE)
dims.overlap = OVERLAP_SIZE * stepN;
else
dims.overlap = OVERLAP_SIZE * stepE;
P_get_edge(bilin, &dims, stepE, stepN);
P_set_dim(&dims, stepE, stepN, &nsplx_adj, &nsply_adj);
G_verbose_message(_("Adjusted EW splines %d"), nsplx_adj);
G_verbose_message(_("Adjusted NS splines %d"), nsply_adj);
/* calculate number of subregions */
edgeE = dims.ew_size - dims.overlap - 2 * dims.edge_v;
edgeN = dims.sn_size - dims.overlap - 2 * dims.edge_h;
N_extension = original_reg.north - original_reg.south;
E_extension = original_reg.east - original_reg.west;
nsubregion_col = ceil(E_extension / edgeE) + 0.5;
nsubregion_row = ceil(N_extension / edgeN) + 0.5;
if (nsubregion_col < 0)
nsubregion_col = 0;
if (nsubregion_row < 0)
nsubregion_row = 0;
nsubregions = nsubregion_row * nsubregion_col;
/* Creating line and categories structs */
Cats = Vect_new_cats_struct();
Vect_cat_set(Cats, 1, 0);
subregion_row = 0;
elaboration_reg.south = original_reg.north;
last_row = FALSE;
while (last_row == FALSE) { /* For each subregion row */
subregion_row++;
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_ROW);
if (elaboration_reg.north > original_reg.north) { /* First row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
FIRST_ROW);
}
if (elaboration_reg.south <= original_reg.south) { /* Last row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
LAST_ROW);
last_row = TRUE;
}
nsply =
ceil((elaboration_reg.north -
elaboration_reg.south) / stepN) + 0.5;
G_debug(1, "Interpolation: nsply = %d", nsply);
/*
if (nsply > NSPLY_MAX)
nsply = NSPLY_MAX;
*/
elaboration_reg.east = original_reg.west;
last_column = FALSE;
subregion_col = 0;
/* TODO: process each subregion using its own thread (via OpenMP or pthreads) */
/* I'm not sure about pthreads, but you can tell OpenMP to start all at the
same time and it will keep num_workers supplied with the next job as free
cpus become available */
while (last_column == FALSE) { /* For each subregion column */
int npoints = 0;
/* needed for sparse points interpolation */
int npoints_ext, *lineVect_ext = NULL;
double **obsVect_ext; /*, mean_ext = .0; */
struct Point *observ_ext;
subregion_col++;
subregion++;
if (nsubregions > 1)
G_message(_("Processing subregion %d of %d..."), subregion, nsubregions);
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_COLUMN);
if (elaboration_reg.west < original_reg.west) { /* First column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, FIRST_COLUMN);
}
if (elaboration_reg.east >= original_reg.east) { /* Last column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, LAST_COLUMN);
last_column = TRUE;
}
nsplx =
ceil((elaboration_reg.east -
elaboration_reg.west) / stepE) + 0.5;
G_debug(1, "Interpolation: nsplx = %d", nsplx);
/*
if (nsplx > NSPLX_MAX)
nsplx = NSPLX_MAX;
*/
G_debug(1, "Interpolation: (%d,%d): subregion bounds",
subregion_row, subregion_col);
G_debug(1, "Interpolation: \t\tNORTH:%.2f\t",
elaboration_reg.north);
G_debug(1, "Interpolation: WEST:%.2f\t\tEAST:%.2f",
elaboration_reg.west, elaboration_reg.east);
G_debug(1, "Interpolation: \t\tSOUTH:%.2f",
elaboration_reg.south);
#ifdef DEBUG_SUBREGIONS
fprintf(stdout, "B 5\n");
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.east, elaboration_reg.north);
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.west, elaboration_reg.north);
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.west, elaboration_reg.south);
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.east, elaboration_reg.south);
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.east, elaboration_reg.north);
fprintf(stdout, "C 1 1\n");
fprintf(stdout, " %.11g %.11g\n", (elaboration_reg.west + elaboration_reg.east) / 2,
(elaboration_reg.south + elaboration_reg.north) / 2);
fprintf(stdout, " 1 %d\n", subregion);
#endif
/* reading points in interpolation region */
dim_vect = nsplx * nsply;
observ_ext = NULL;
if (grid == FALSE && ext == TRUE) {
observ_ext =
P_Read_Vector_Region_Map(&In_ext,
&elaboration_reg,
&npoints_ext, dim_vect,
1);
}
else
npoints_ext = 1;
if (grid == TRUE && have_mask) {
/* any unmasked cells in general region ? */
mean = 0;
observ_ext =
P_Read_Raster_Region_masked(&mask_seg, &original_reg,
original_box, general_box,
&npoints_ext, dim_vect, mean);
}
observ = NULL;
if (npoints_ext > 0) {
observ =
P_Read_Vector_Region_Map(&In, &elaboration_reg, &npoints,
dim_vect, bspline_field);
}
else
npoints = 1;
G_debug(1,
"Interpolation: (%d,%d): Number of points in <elaboration_box> is %d",
subregion_row, subregion_col, npoints);
if (npoints > 0)
G_verbose_message(_("%d points found in this subregion"), npoints);
/* only interpolate if there are any points in current subregion */
if (npoints > 0 && npoints_ext > 0) {
int i;
nparameters = nsplx * nsply;
BW = P_get_BandWidth(bilin, nsply);
/* Least Squares system */
N = G_alloc_matrix(nparameters, BW); /* Normal matrix */
TN = G_alloc_vector(nparameters); /* vector */
parVect = G_alloc_vector(nparameters); /* Parameters vector */
obsVect = G_alloc_matrix(npoints, 3); /* Observation vector */
Q = G_alloc_vector(npoints); /* "a priori" var-cov matrix */
lineVect = G_alloc_ivector(npoints); /* */
for (i = 0; i < npoints; i++) { /* Setting obsVect vector & Q matrix */
double dval;
Q[i] = 1; /* Q=I */
lineVect[i] = observ[i].lineID;
obsVect[i][0] = observ[i].coordX;
obsVect[i][1] = observ[i].coordY;
/* read z coordinates from attribute table */
if (bspline_field > 0) {
int cat, ival, ret;
cat = observ[i].cat;
if (cat < 0)
continue;
if (ctype == DB_C_TYPE_INT) {
ret =
db_CatValArray_get_value_int(&cvarr, cat,
&ival);
obsVect[i][2] = ival;
observ[i].coordZ = ival;
}
else { /* DB_C_TYPE_DOUBLE */
ret =
db_CatValArray_get_value_double(&cvarr, cat,
&dval);
obsVect[i][2] = dval;
observ[i].coordZ = dval;
}
if (ret != DB_OK) {
G_warning(_("Interpolation: (%d,%d): No record for point (cat = %d)"),
subregion_row, subregion_col, cat);
continue;
}
}
/* use z coordinates of 3D vector */
else {
obsVect[i][2] = observ[i].coordZ;
}
}
/* Mean calculation for every point */
mean = P_Mean_Calc(&elaboration_reg, observ, npoints);
G_debug(1, "Interpolation: (%d,%d): mean=%lf",
subregion_row, subregion_col, mean);
G_free(observ);
for (i = 0; i < npoints; i++)
obsVect[i][2] -= mean;
/* Bilinear interpolation */
if (bilin) {
G_debug(1,
"Interpolation: (%d,%d): Bilinear interpolation...",
subregion_row, subregion_col);
normalDefBilin(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, npoints,
nparameters, BW);
nCorrectGrad(N, lambda, nsplx, nsply, stepE, stepN);
}
/* Bicubic interpolation */
else {
G_debug(1,
"Interpolation: (%d,%d): Bicubic interpolation...",
subregion_row, subregion_col);
normalDefBicubic(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, npoints,
nparameters, BW);
nCorrectGrad(N, lambda, nsplx, nsply, stepE, stepN);
}
if(G_strncasecmp(solver->answer, "cg", 2) == 0)
G_math_solver_cg_sband(N, parVect, TN, nparameters, BW, atoi(iter->answer), atof(error->answer));
else
G_math_solver_cholesky_sband(N, parVect, TN, nparameters, BW);
G_free_matrix(N);
G_free_vector(TN);
G_free_vector(Q);
if (grid == TRUE) { /* GRID INTERPOLATION ==> INTERPOLATION INTO A RASTER */
G_debug(1, "Interpolation: (%d,%d): Regular_Points...",
subregion_row, subregion_col);
if (!have_mask) {
P_Regular_Points(&elaboration_reg, &original_reg, general_box,
overlap_box, &out_seg, parVect,
stepN, stepE, dims.overlap, mean,
nsplx, nsply, nrows, ncols, bilin);
}
else {
P_Sparse_Raster_Points(&out_seg,
&elaboration_reg, &original_reg,
general_box, overlap_box,
observ_ext, parVect,
stepE, stepN,
dims.overlap, nsplx, nsply,
npoints_ext, bilin, mean);
}
}
else { /* OBSERVATION POINTS INTERPOLATION */
if (ext == FALSE) {
G_debug(1, "Interpolation: (%d,%d): Sparse_Points...",
subregion_row, subregion_col);
P_Sparse_Points(&Out, &elaboration_reg, general_box,
overlap_box, obsVect, parVect,
lineVect, stepE, stepN,
dims.overlap, nsplx, nsply, npoints,
bilin, Cats, driver, mean,
table_name);
}
else { /* FLAG_EXT == TRUE */
/* done that earlier */
/*
int npoints_ext, *lineVect_ext = NULL;
double **obsVect_ext;
struct Point *observ_ext;
observ_ext =
P_Read_Vector_Region_Map(&In_ext,
&elaboration_reg,
&npoints_ext, dim_vect,
1);
*/
obsVect_ext = G_alloc_matrix(npoints_ext, 3); /* Observation vector_ext */
lineVect_ext = G_alloc_ivector(npoints_ext);
for (i = 0; i < npoints_ext; i++) { /* Setting obsVect_ext vector & Q matrix */
obsVect_ext[i][0] = observ_ext[i].coordX;
obsVect_ext[i][1] = observ_ext[i].coordY;
obsVect_ext[i][2] = observ_ext[i].coordZ - mean;
lineVect_ext[i] = observ_ext[i].lineID;
}
G_free(observ_ext);
G_debug(1, "Interpolation: (%d,%d): Sparse_Points...",
subregion_row, subregion_col);
P_Sparse_Points(&Out, &elaboration_reg, general_box,
overlap_box, obsVect_ext, parVect,
lineVect_ext, stepE, stepN,
dims.overlap, nsplx, nsply,
npoints_ext, bilin, Cats, driver,
mean, table_name);
G_free_matrix(obsVect_ext);
G_free_ivector(lineVect_ext);
} /* END FLAG_EXT == TRUE */
} /* END GRID == FALSE */
G_free_vector(parVect);
G_free_matrix(obsVect);
G_free_ivector(lineVect);
}
else {
if (observ)
G_free(observ);
if (observ_ext)
G_free(observ_ext);
if (npoints == 0)
G_warning(_("No data within this subregion. "
"Consider increasing spline step values."));
}
} /*! END WHILE; last_column = TRUE */
} /*! END WHILE; last_row = TRUE */
G_verbose_message(_("Writing output..."));
/* Writing the output raster map */
if (grid == TRUE) {
int row, col;
DCELL *drastbuf, dval;
if (have_mask) {
Segment_release(&mask_seg); /* release memory */
close(mask_fd);
unlink(mask_file);
}
drastbuf = Rast_allocate_buf(DCELL_TYPE);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
for (col = 0; col < ncols; col++) {
Segment_get(&out_seg, &dval, row, col);
drastbuf[col] = dval;
}
Rast_put_d_row(raster, drastbuf);
}
Rast_close(raster);
Segment_release(&out_seg); /* release memory */
close(out_fd);
unlink(out_file);
/* set map title */
sprintf(title, "%s interpolation with Tykhonov regularization",
type_opt->answer);
Rast_put_cell_title(out_map_opt->answer, title);
/* write map history */
Rast_short_history(out_map_opt->answer, "raster", &history);
Rast_command_history(&history);
Rast_write_history(out_map_opt->answer, &history);
}
/* Writing to the output vector map the points from the overlapping zones */
else if (flag_auxiliar == TRUE) {
if (ext == FALSE)
P_Aux_to_Vector(&In, &Out, driver, table_name);
else
P_Aux_to_Vector(&In_ext, &Out, driver, table_name);
/* Drop auxiliary table */
G_debug(1, "%s: Dropping <%s>", argv[0], table_name);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Auxiliary table could not be dropped"));
}
db_close_database_shutdown_driver(driver);
Vect_close(&In);
if (ext != FALSE)
Vect_close(&In_ext);
if (vector)
Vect_close(&Out);
G_done_msg(" ");
exit(EXIT_SUCCESS);
} /*END MAIN */
/* data preparations, sigma, shear, etc. */
int grad_check(void)
{
int k, l;
double zx, zy, zd2, zd4, sinsl;
double cc, cmul2;
double sheer;
double vsum = 0.;
double vmax = 0.;
double chsum = 0.;
double zmin = 1.e12;
double zmax = -1.e12;
double zd2min = 1.e12;
double zd2max = -1.e12;
double smin = 1.e12;
double smax = -1.e12;
double infmin = 1.e12;
double infmax = -1.e12;
double sigmax = -1.e12;
double cchezmax = -1.e12;
double rhow = 1000.;
double gacc = 9.81;
double hh = 1.;
double deltaw = 1.e12;
sisum = 0.;
infsum = 0.;
cmul2 = rhow * gacc;
for (k = 0; k < my; k++) {
for (l = 0; l < mx; l++) {
if (zz[k][l] != UNDEF) {
zx = v1[k][l];
zy = v2[k][l];
zd2 = zx * zx + zy * zy;
sinsl = sqrt(zd2) / sqrt(zd2 + 1); /* sin(terrain slope) */
/* Computing MIN */
zd2 = sqrt(zd2);
zd2min = amin1(zd2min, zd2);
/* Computing MAX */
zd2max = amax1(zd2max, zd2);
zd4 = sqrt(zd2); /* ^.25 */
if (cchez[k][l] != 0.) {
cchez[k][l] = 1. / cchez[k][l]; /* 1/n */
}
else {
G_fatal_error(_("Zero value in Mannings n"));
}
if (zd2 == 0.) {
v1[k][l] = 0.;
v2[k][l] = 0.;
slope[k][l] = 0.;
}
else {
if (wdepth)
hh = pow(gama[k][l], 2. / 3.);
/* hh = 1 if there is no water depth input */
v1[k][l] = (double)hh *cchez[k][l] * zx / zd4;
v2[k][l] = (double)hh *cchez[k][l] * zy / zd4;
slope[k][l] =
sqrt(v1[k][l] * v1[k][l] + v2[k][l] * v2[k][l]);
}
if (wdepth) {
sheer = (double)(cmul2 * gama[k][l] * sinsl); /* shear stress */
/* if critical shear stress >= shear then all zero */
if ((sheer <= tau[k][l]) || (ct[k][l] == 0.)) {
si[k][l] = 0.;
sigma[k][l] = 0.;
}
else {
si[k][l] = (double)(dc[k][l] * (sheer - tau[k][l]));
sigma[k][l] = (double)(dc[k][l] / ct[k][l]) * (sheer - tau[k][l]) / (pow(sheer, 1.5)); /* rill erosion=1.5, sheet = 1.1 */
}
}
sisum += si[k][l];
smin = amin1(smin, si[k][l]);
smax = amax1(smax, si[k][l]);
if (inf) {
infsum += inf[k][l];
infmin = amin1(infmin, inf[k][l]);
infmax = amax1(infmax, inf[k][l]);
}
vmax = amax1(vmax, slope[k][l]);
vsum += slope[k][l];
chsum += cchez[k][l];
zmin = amin1(zmin, (double)zz[k][l]);
zmax = amax1(zmax, (double)zz[k][l]); /* not clear were needed */
if (wdepth)
sigmax = amax1(sigmax, sigma[k][l]);
cchezmax = amax1(cchezmax, cchez[k][l]);
/* saved sqrt(sinsl)*cchez to cchez array for output */
cchez[k][l] *= sqrt(sinsl);
} /* DEFined area */
}
}
if (inf != NULL && smax < infmax)
G_warning(_("Infiltration exceeds the rainfall rate everywhere! No overland flow."));
cc = (double)mx *my;
si0 = sisum / cc;
vmean = vsum / cc;
chmean = chsum / cc;
if (inf)
infmean = infsum / cc;
if (wdepth)
deltaw = 0.8 / (sigmax * vmax); /*time step for sediment */
deltap = 0.25 * sqrt(stepx * stepy) / vmean; /*time step for water */
if (deltaw > deltap)
timec = 4.;
else
timec = 1.25;
miter = (int)(timesec / (deltap * timec)); /* number of iterations = number of cells to pass */
iterout = (int)(iterout / (deltap * timec)); /* number of cells to pass for time series output */
fprintf(stderr, "\n");
G_message(_("Min elevation \t= %.2f m\nMax elevation \t= %.2f m\n"), zmin,
zmax);
G_message(_("Mean Source Rate (rainf. excess or sediment) \t= %f m/s or kg/m2s \n"),
si0);
G_message(_("Mean flow velocity \t= %f m/s\n"), vmean);
G_message(_("Mean Mannings \t= %f\n"), 1.0 / chmean);
deltap = amin1(deltap, deltaw);
G_message(_("Number of iterations \t= %d cells\n"), miter);
G_message(_("Time step \t= %.2f s\n"), deltap);
if (wdepth) {
G_message(_("Sigmax \t= %f\nMax velocity \t= %f m/s\n"), sigmax,
vmax);
G_message(_("Time step used \t= %.2f s\n"), deltaw);
}
/* if (wdepth) deltap = 0.1;
* deltap for sediment is ar. average deltap and deltaw */
/* if (wdepth) deltap = (deltaw+deltap)/2.;
* deltap for sediment is ar. average deltap and deltaw */
/*! For each cell (k,l) compute the length s=(v1,v2) of the path
* that the particle will travel per one time step
* \f$ s(k,l)=v(k,l)*dt \f$, [m]=[m/s]*[s]
* give warning if there is a cell that will lead to path longer than 2 cells
*
* if running erosion, compute sediment transport capacity for each cell si(k,l)
* \f$
* T({\bf r})=K_t({\bf r}) \bigl[\tau({\bf r})\bigr]^p
* =K_t({\bf r}) \bigl[\rho_w\, g h({\bf r}) \sin \beta ({\bf r}) \bigr]^p
* \f$
* [kg/ms]=...
*/
for (k = 0; k < my; k++) {
for (l = 0; l < mx; l++) {
if (zz[k][l] != UNDEF) {
v1[k][l] *= deltap;
v2[k][l] *= deltap;
/*if(v1[k][l]*v1[k][l]+v2[k][l]*v2[k][l] > cellsize, warning, napocitaj
*ak viac ako 10%a*/
/* THIS IS CORRECT SOLUTION currently commented out */
if (inf)
inf[k][l] *= timesec;
if (wdepth)
gama[k][l] = 0.;
if (et) {
if (sigma[k][l] == 0. || slope[k][l] == 0.)
si[k][l] = 0.;
else
/* temp for transp. cap. erod */
si[k][l] = si[k][l] / (slope[k][l] * sigma[k][l]);
}
} /* DEFined area */
}
}
/*! compute transport capacity limted erosion/deposition et
* as a divergence of sediment transport capacity
* \f$
D_T({\bf r})= \nabla\cdot {\bf T}({\bf r})
* \f$
*/
if (et) {
erod(si); /* compute divergence of t.capc */
if (output_et() != 1)
G_fatal_error(_("Unable to write et file"));
}
/*! compute the inversion operator and store it in sigma - note that after this
* sigma does not store the first order reaction coefficient but the operator
* WRITE the equation here
*/
if (wdepth) {
for (k = 0; k < my; k++) {
for (l = 0; l < mx; l++) {
if (zz[k][l] != UNDEF) {
/* get back from temp */
if (et)
si[k][l] = si[k][l] * slope[k][l] * sigma[k][l];
if (sigma[k][l] != 0.)
/* rate of weight loss - w=w*sigma ,
* vaha prechadzky po n-krokoch je sigma^n */
/*!!!!! not clear what's here :-\ !!!!!*/
sigma[k][l] =
exp(-sigma[k][l] * deltap * slope[k][l]);
/* if(sigma[k][l]<0.5) warning, napocitaj,
* ak vacsie ako 50% skonci, zmensi deltap)*/
}
} /*DEFined area */
}
}
return 1;
}
/* ************************************************************************* */
int main(int argc, char *argv[]) {
struct GModule *module;
int returnstat = 0, i;
/* Initialize GRASS */
G_gisinit(argv[0]);
module = G_define_module();
module->description
= _("Performs unit and integration tests for the g3d library");
/* Get parameters from user */
set_params();
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* Initiate the defaults for testing */
Rast3d_init_defaults();
/*Run the unit tests */
if (param.testunit->answer || param.full->answer) {
returnstat += unit_test_coordinate_transform();
returnstat += unit_test_put_get_value();
}
/*Run the integration tests */
if (param.testint->answer || param.full->answer) {
;
}
/*Run single tests */
if (!param.full->answer) {
/*unit tests */
if (!param.testunit->answer) {
i = 0;
if (param.unit->answers)
while (param.unit->answers[i]) {
if (strcmp(param.unit->answers[i], "coord") == 0)
returnstat += unit_test_coordinate_transform();
if (strcmp(param.unit->answers[i], "putget") == 0)
returnstat += unit_test_put_get_value();
i++;
}
}
/*integration tests */
if (!param.testint->answer) {
i = 0;
if (param.integration->answers)
while (param.integration->answers[i]) {
;
}
}
}
if (returnstat != 0)
G_warning("Errors detected while testing the g3d lib");
else
G_message("\n-- g3d lib tests finished successfully --");
return (returnstat);
}
int main(int argc, char *argv[])
{
char buf[512];
FILE *fd;
long old_min, old_max;
long new_min, new_max;
long new_delta, old_delta;
long value, first, prev;
long cat;
float divisor;
char *old_name;
char *new_name;
char *mapset;
struct GModule *module;
struct
{
struct Option *input, *from, *output, *to, *title;
} parm;
/* please, remove before GRASS 7 released */
struct
{
struct Flag *quiet;
} flag;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, rescale");
module->description =
_("Rescales the range of category values " "in a raster map layer.");
/* Define the different options */
parm.input = G_define_option();
parm.input->key = "input";
parm.input->type = TYPE_STRING;
parm.input->required = YES;
parm.input->gisprompt = "old,cell,raster";
parm.input->description = _("The name of the raster map to be rescaled");
parm.from = G_define_option();
parm.from->key = "from";
parm.from->key_desc = "min,max";
parm.from->type = TYPE_INTEGER;
parm.from->required = NO;
parm.from->description =
_("The input data range to be rescaled (default: full range of input map)");
parm.output = G_define_option();
parm.output->key = "output";
parm.output->type = TYPE_STRING;
parm.output->required = YES;
parm.output->gisprompt = "new,cell,raster";
parm.output->description = _("The resulting raster map name");
parm.to = G_define_option();
parm.to->key = "to";
parm.to->key_desc = "min,max";
parm.to->type = TYPE_INTEGER;
parm.to->required = YES;
parm.to->description = _("The output data range");
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 new raster map");
/* please, remove before GRASS 7 released */
flag.quiet = G_define_flag();
flag.quiet->key = 'q';
flag.quiet->description = _("Quietly");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* please, remove before GRASS 7 released */
if (flag.quiet->answer) {
putenv("GRASS_VERBOSE=0");
G_warning(_("The '-q' flag is superseded and will be removed "
"in future. Please use '--quiet' instead."));
}
old_name = parm.input->answer;
new_name = parm.output->answer;
mapset = G_find_cell(old_name, "");
if (mapset == NULL) {
sprintf(buf, "%s - not found\n", old_name);
G_fatal_error(buf);
}
if (G_legal_filename(new_name) < 0) {
sprintf(buf, "%s - illegal map name\n", new_name);
G_fatal_error(buf);
}
if (parm.from->answer) {
sscanf(parm.from->answers[0], "%ld", &old_min);
sscanf(parm.from->answers[1], "%ld", &old_max);
}
else
get_range(old_name, mapset, &old_min, &old_max);
if (old_min > old_max) {
value = old_min; /* swap */
old_min = old_max;
old_max = value;
}
sscanf(parm.to->answers[0], "%ld", &new_min);
sscanf(parm.to->answers[1], "%ld", &new_max);
if (new_min > new_max) {
value = new_min; /* swap */
new_min = new_max;
new_max = value;
}
G_message(_("Rescale %s[%ld,%ld] to %s[%ld,%ld]"),
old_name, old_min, old_max, new_name, new_min, new_max);
sprintf(buf, "r.reclass input=\"%s\" output=\"%s\" title=\"", old_name,
new_name);
if (parm.title->answer)
strcat(buf, parm.title->answer);
else {
strcat(buf, "rescale of ");
strcat(buf, old_name);
}
strcat(buf, "\"");
fd = popen(buf, "w");
old_delta = old_max - old_min;
new_delta = new_max - new_min;
divisor = (float)new_delta / (float)old_delta;
prev = new_min;
first = old_min;
for (cat = old_min; cat <= old_max; cat++) {
value = (int)(divisor * (cat - old_min) + new_min + .5);
if (value != prev) {
fprintf(fd, "%ld thru %ld = %ld %ld", first, cat - 1, prev,
first);
if (cat - 1 != first)
fprintf(fd, " thru %ld", cat - 1);
fprintf(fd, "\n");
prev = value;
first = cat;
}
}
fprintf(fd, "%ld thru %ld = %ld %ld", first, cat - 1, prev, first);
if (cat - 1 != first)
fprintf(fd, " thru %ld", cat - 1);
fprintf(fd, "\n");
pclose(fd);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
int Out_proj;
int out_stat;
int old_zone, old_proj;
int i;
int stat;
char cmnd2[500];
char proj_out[20], proj_name[50], set_name[20];
char path[1024], buffa[1024], buffb[1024], answer[200], answer1[200];
char answer2[200], buff[1024];
char tmp_buff[20], *buf;
struct Key_Value *old_proj_keys, *out_proj_keys, *in_unit_keys;
double aa, e2;
double f;
FILE *FPROJ;
int exist = 0;
char spheroid[100];
int j, k, sph_check;
struct Cell_head cellhd;
char datum[100], dat_ellps[100], dat_params[100];
struct proj_parm *proj_parms;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("general"));
G_add_keyword(_("projection"));
module->description =
_("Interactively reset the location's projection settings.");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (strcmp(G_mapset(), "PERMANENT") != 0)
G_fatal_error(_("You must be in the PERMANENT mapset to run g.setproj"));
/***
* no longer necessary, table is a static struct
* init_unit_table();
***/
sprintf(set_name, "PERMANENT");
G_file_name(path, "", PROJECTION_FILE, set_name);
/* get the output projection parameters, if existing */
/* Check for ownership here */
stat = G__mapset_permissions(set_name);
if (stat == 0) {
G_fatal_error(_("PERMANENT: permission denied"));
}
G_get_default_window(&cellhd);
if (-1 == G_set_window(&cellhd))
G_fatal_error(_("Current region cannot be set"));
if (G_get_set_window(&cellhd) == -1)
G_fatal_error(_("Retrieving and setting region failed"));
Out_proj = cellhd.proj;
old_zone = cellhd.zone;
old_proj = cellhd.proj;
if (access(path, 0) == 0) {
exist = 1;
FPROJ = fopen(path, "r");
old_proj_keys = G_fread_key_value(FPROJ);
fclose(FPROJ);
buf = G_find_key_value("name", old_proj_keys);
fprintf(stderr,
"\nWARNING: A projection file already exists for this location\n(Filename '%s')\n",
path);
fprintf(stderr,
"\nThis file contains all the parameters for the location's projection:\n %s\n",
buf);
fprintf(stderr,
"\n Overriding this information implies that the old projection parameters\n"
" were incorrect. If you change the parameters, all existing data will\n"
" be interpreted differently by the projection software.\n%c%c%c",
7, 7, 7);
fprintf(stderr,
" GRASS will not re-project your data automatically.\n\n");
if (!G_yes
(_("Would you still like to change some of the parameters?"),
0)) {
G_message(_("The projection information will not be updated"));
leave(SP_NOCHANGE);
}
}
out_proj_keys = G_create_key_value();
if (exist) {
buf = G_find_key_value("zone", old_proj_keys);
if (buf != NULL)
sscanf(buf, "%d", &zone);
if (zone != old_zone) {
G_warning(_("Zone in default geographic region definition: %d\n"
" is different from zone in PROJ_INFO file: %d"),
old_zone, zone);
old_zone = zone;
}
}
switch (Out_proj) {
case 0: /* No projection/units */
if (!exist) {
/* leap frog over code, and just make sure we remove the file */
G_warning(_("XY-location cannot be projected"));
goto write_file;
break;
}
case PROJECTION_UTM:
if (!exist) {
sprintf(proj_name, "%s", G__projection_name(PROJECTION_UTM));
sprintf(proj_out, "utm");
break;
}
case PROJECTION_SP:
if (!exist) {
sprintf(proj_name, "%s", G__projection_name(PROJECTION_SP));
sprintf(proj_out, "stp");
break;
}
case PROJECTION_LL:
if (!exist) {
sprintf(proj_name, "%s", G__projection_name(PROJECTION_LL));
sprintf(proj_out, "ll");
break;
}
case PROJECTION_OTHER:
if (G_ask_proj_name(proj_out, proj_name) < 0)
leave(SP_NOCHANGE);
if (G_strcasecmp(proj_out, "LL") == 0)
Out_proj = PROJECTION_LL;
else if (G_strcasecmp(proj_out, "UTM") == 0)
Out_proj = PROJECTION_UTM;
else if (G_strcasecmp(proj_out, "STP") == 0)
Out_proj = PROJECTION_SP;
break;
default:
G_fatal_error(_("Unknown projection"));
}
cellhd.proj = Out_proj;
proj_parms = get_proj_parms(proj_out);
if (!proj_parms)
G_fatal_error(_("Projection %s is not specified in the file 'proj-parms.table'"),
proj_out);
G_set_key_value("name", proj_name, out_proj_keys);
sph_check = 0;
if (G_yes
(_("Do you wish to specify a geodetic datum for this location?"),
1)) {
char lbuf[100], lbufa[100];
if (exist &&
(G_get_datumparams_from_projinfo(old_proj_keys, lbuf, lbufa) ==
2)) {
G_strip(lbuf);
if ((i = G_get_datum_by_name(lbuf)) > 0) {
G_message(_("The current datum is %s (%s)"),
G_datum_name(i), G_datum_description(i));
if (G_yes
(_("Do you wish to change the datum (or datum transformation parameters)?"),
0))
sph_check = ask_datum(datum, dat_ellps, dat_params);
else {
sprintf(datum, lbuf);
sprintf(dat_params, lbufa);
sprintf(dat_ellps, G_datum_ellipsoid(i));
sph_check = 1;
G_message(_("The datum information has not been changed"));
}
}
else
sph_check = ask_datum(datum, dat_ellps, dat_params);
}
else
sph_check = ask_datum(datum, dat_ellps, dat_params);
}
if (sph_check > 0) {
char *paramkey, *paramvalue;
/* write out key/value pairs to out_proj_keys */
if (G_strcasecmp(datum, "custom") != 0)
G_set_key_value("datum", datum, out_proj_keys);
/* G_set_key_value("datumparams", dat_params, out_proj_keys); */
paramkey = strtok(dat_params, "=");
paramvalue = dat_params + strlen(paramkey) + 1;
G_set_key_value(paramkey, paramvalue, out_proj_keys);
sprintf(spheroid, "%s", dat_ellps);
}
else {
/***************** GET spheroid **************************/
if (Out_proj != PROJECTION_SP) { /* some projections have
* fixed spheroids */
if (G_strcasecmp(proj_out, "ALSK") == 0 ||
G_strcasecmp(proj_out, "GS48") == 0 ||
G_strcasecmp(proj_out, "GS50") == 0) {
sprintf(spheroid, "%s", "clark66");
G_set_key_value("ellps", spheroid, out_proj_keys);
sph_check = 1;
}
else if (G_strcasecmp(proj_out, "LABRD") == 0 ||
G_strcasecmp(proj_out, "NZMG") == 0) {
sprintf(spheroid, "%s", "international");
G_set_key_value("ellps", spheroid, out_proj_keys);
sph_check = 1;
}
else if (G_strcasecmp(proj_out, "SOMERC") == 0) {
sprintf(spheroid, "%s", "bessel");
G_set_key_value("ellps", spheroid, out_proj_keys);
sph_check = 1;
}
else if (G_strcasecmp(proj_out, "OB_TRAN") == 0) {
/* Hard coded to use "Equidistant Cylincrical"
* until g.setproj has been changed to run
* recurively, to allow input of options for
* a second projection, MHu991010 */
G_set_key_value("o_proj", "eqc", out_proj_keys);
sph_check = 2;
}
else {
if (exist &&
(buf =
G_find_key_value("ellps", old_proj_keys)) != NULL) {
strcpy(spheroid, buf);
G_strip(spheroid);
if (G_get_spheroid_by_name(spheroid, &aa, &e2, &f)) {
/* if legal ellips. exist, ask wether or not to change it */
G_message(_("The current ellipsoid is %s"), spheroid);
if (G_yes
(_("Do you want to change ellipsoid parameter?"),
0))
sph_check = G_ask_ellipse_name(spheroid);
else {
G_message(_("The ellipse information has not been changed"));
sph_check = 1;
}
} /* the val is legal */
else
sph_check = G_ask_ellipse_name(spheroid);
}
else
sph_check = G_ask_ellipse_name(spheroid);
}
}
if (sph_check > 0) {
if (sph_check == 2) { /* ask radius */
if (exist) {
buf = G_find_key_value("a", old_proj_keys);
if ((buf != NULL) && (sscanf(buf, "%lf", &radius) == 1)) {
G_message(_("The radius is currently %f"), radius);
if (G_yes(_("Do you want to change the radius?"), 0))
radius =
prompt_num_double(_("Enter radius for the sphere in meters"),
RADIUS_DEF, 1);
}
}
else
radius =
prompt_num_double(_("Enter radius for the sphere in meters"),
RADIUS_DEF, 1);
} /* end ask radius */
}
}
/*** END get spheroid ***/
/* create the PROJ_INFO & PROJ_UNITS files, if required */
if (G_strcasecmp(proj_out, "LL") == 0) ;
else if (G_strcasecmp(proj_out, "STP") == 0)
get_stp_proj(buffb);
else if (sph_check != 2) {
G_strip(spheroid);
if (G_get_spheroid_by_name(spheroid, &aa, &e2, &f) == 0)
G_fatal_error(_("Invalid input ellipsoid"));
}
write_file:
/*
** NOTE the program will (hopefully) never exit abnormally
** after this point. Thus we know the file will be completely
** written out once it is opened for write
*/
if (exist) {
sprintf(buff, "%s~", path);
G_rename_file(path, buff);
}
if (Out_proj == 0)
goto write_units;
/*
** Include MISC parameters for PROJ_INFO
*/
if (G_strcasecmp(proj_out, "STP") == 0) {
for (i = 0; i < strlen(buffb); i++)
if (buffb[i] == ' ')
buffb[i] = '\t';
sprintf(cmnd2, "%s\t\n", buffb);
for (i = 0; i < strlen(cmnd2); i++) {
j = k = 0;
if (cmnd2[i] == '+') {
while (cmnd2[++i] != '=')
buffa[j++] = cmnd2[i];
buffa[j] = 0;
while (cmnd2[++i] != '\t' && cmnd2[i] != '\n' &&
cmnd2[i] != 0)
buffb[k++] = cmnd2[i];
buffb[k] = 0;
G_set_key_value(buffa, buffb, out_proj_keys);
}
}
}
else if (G_strcasecmp(proj_out, "LL") == 0) {
G_set_key_value("proj", "ll", out_proj_keys);
G_set_key_value("ellps", spheroid, out_proj_keys);
}
else {
if (sph_check != 2) {
G_set_key_value("proj", proj_out, out_proj_keys);
G_set_key_value("ellps", spheroid, out_proj_keys);
sprintf(tmp_buff, "%.10f", aa);
G_set_key_value("a", tmp_buff, out_proj_keys);
sprintf(tmp_buff, "%.10f", e2);
G_set_key_value("es", tmp_buff, out_proj_keys);
sprintf(tmp_buff, "%.10f", f);
G_set_key_value("f", tmp_buff, out_proj_keys);
}
else {
G_set_key_value("proj", proj_out, out_proj_keys);
/* G_set_key_value ("ellps", "sphere", out_proj_keys); */
sprintf(tmp_buff, "%.10f", radius);
G_set_key_value("a", tmp_buff, out_proj_keys);
G_set_key_value("es", "0.0", out_proj_keys);
G_set_key_value("f", "0.0", out_proj_keys);
}
for (i = 0;; i++) {
struct proj_parm *parm = &proj_parms[i];
struct proj_desc *desc;
if (!parm->name)
break;
desc = get_proj_desc(parm->name);
if (!desc)
break;
if (parm->ask) {
if (G_strcasecmp(desc->type, "bool") == 0) {
if (G_yes((char *)desc->desc, 0)) {
G_set_key_value(desc->key, "defined", out_proj_keys);
if (G_strcasecmp(parm->name, "SOUTH") == 0)
cellhd.zone = -abs(cellhd.zone);
}
}
else if (G_strcasecmp(desc->type, "lat") == 0) {
double val;
while (!get_LL_stuff(parm, desc, 1, &val)) ;
sprintf(tmp_buff, "%.10f", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "lon") == 0) {
double val;
while (!get_LL_stuff(parm, desc, 0, &val)) ;
sprintf(tmp_buff, "%.10f", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "float") == 0) {
double val;
while (!get_double(parm, desc, &val)) ;
sprintf(tmp_buff, "%.10f", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "int") == 0) {
int val;
while (!get_int(parm, desc, &val)) ;
sprintf(tmp_buff, "%d", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "zone") == 0) {
if ((Out_proj == PROJECTION_UTM) && (old_zone != 0)) {
G_message(_("The UTM zone is now set to %d"),
old_zone);
if (!G_yes
(_("Do you want to change the UTM zone?"), 0)) {
G_message(_("UTM zone information has not been updated"));
zone = old_zone;
break;
}
else {
G_message(_("But if you change zone, all the existing "
"data will be interpreted by projection software. "
"GRASS will not automatically re-project or even "
"change the headers for existing maps."));
if (!G_yes
(_("Would you still like to change the UTM zone?"),
0)) {
zone = old_zone;
break;
}
}
} /* UTM */
while (!get_zone()) ;
sprintf(tmp_buff, "%d", zone);
G_set_key_value("zone", tmp_buff, out_proj_keys);
cellhd.zone = zone;
}
}
else if (parm->def_exists) {
/* don't ask, use the default */
if (G_strcasecmp(desc->type, "float") == 0 ||
G_strcasecmp(desc->type, "lat") == 0 ||
G_strcasecmp(desc->type, "lon") == 0) {
sprintf(tmp_buff, "%.10f", parm->deflt);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "int") == 0) {
sprintf(tmp_buff, "%d", (int)parm->deflt);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
}
} /* for OPTIONS */
}
/* create the PROJ_INFO & PROJ_UNITS files, if required */
G_write_key_value_file(path, out_proj_keys, &out_stat);
if (out_stat != 0) {
G_fatal_error(_("Error writing PROJ_INFO file <%s>"), path);
}
G_free_key_value(out_proj_keys);
if (exist)
G_free_key_value(old_proj_keys);
write_units:
G_file_name(path, "", UNIT_FILE, set_name);
/* if we got this far, the user
** already affirmed to write over old info
** so if units file is here, remove it.
*/
if (access(path, 0) == 0) {
sprintf(buff, "%s~", path);
G_rename_file(path, buff);
}
if (Out_proj == 0)
leave(0);
{
in_unit_keys = G_create_key_value();
switch (Out_proj) {
case PROJECTION_UTM:
G_set_key_value("unit", "meter", in_unit_keys);
G_set_key_value("units", "meters", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
break;
case PROJECTION_SP:
for (;;) {
do {
fprintf(stderr, "\nSpecify the correct units to use:\n");
fprintf(stderr, "Enter the corresponding number\n");
fprintf(stderr,
"1.\tUS Survey Foot (Default for State Plane 1927)\n");
fprintf(stderr, "2.\tInternational Foot\n");
fprintf(stderr, "3.\tMeter\n");
fprintf(stderr, ">");
} while (!G_gets(answer));
G_strip(answer);
if (strcmp(answer, "1") == 0) {
G_set_key_value("unit", "USfoot", in_unit_keys);
G_set_key_value("units", "USfeet", in_unit_keys);
G_set_key_value("meters", "0.30480060960121920243",
in_unit_keys);
break;
}
else if (strcmp(answer, "2") == 0) {
G_set_key_value("unit", "foot", in_unit_keys);
G_set_key_value("units", "feet", in_unit_keys);
G_set_key_value("meters", "0.3048", in_unit_keys);
break;
}
else if (strcmp(answer, "3") == 0) {
G_set_key_value("unit", "meter", in_unit_keys);
G_set_key_value("units", "meters", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
break;
}
else
fprintf(stderr, "\nInvalid Entry (number 1 - 3)\n");
}
break;
case PROJECTION_LL:
G_set_key_value("unit", "degree", in_unit_keys);
G_set_key_value("units", "degrees", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
break;
default:
if (G_strcasecmp(proj_out, "LL") != 0) {
fprintf(stderr, _("Enter plural form of units [meters]: "));
G_gets(answer);
if (strlen(answer) == 0) {
G_set_key_value("unit", "meter", in_unit_keys);
G_set_key_value("units", "meters", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
}
else {
const struct proj_unit *unit;
G_strip(answer);
unit = get_proj_unit(answer);
if (unit) {
#ifdef FOO
if (G_strcasecmp(proj_out, "STP") == 0 &&
!strcmp(answer, "feet")) {
fprintf(stderr,
"%cPROJECTION 99 State Plane cannot be in FEET.\n",
7);
remove(path); /* remove file */
leave(SP_FATAL);
}
#endif
G_set_key_value("unit", unit->unit, in_unit_keys);
G_set_key_value("units", unit->units, in_unit_keys);
sprintf(buffb, "%.10f", unit->fact);
G_set_key_value("meters", buffb, in_unit_keys);
}
else {
double unit_fact;
while (1) {
fprintf(stderr, _("Enter singular for unit: "));
G_gets(answer1);
G_strip(answer1);
if (strlen(answer1) > 0)
break;
}
while (1) {
fprintf(stderr,
_("Enter conversion factor from %s to meters: "),
answer);
G_gets(answer2);
G_strip(answer2);
if (!
(strlen(answer2) == 0 ||
(1 != sscanf(answer2, "%lf", &unit_fact))))
break;
}
G_set_key_value("unit", answer1, in_unit_keys);
G_set_key_value("units", answer, in_unit_keys);
sprintf(buffb, "%.10f", unit_fact);
G_set_key_value("meters", buffb, in_unit_keys);
}
}
}
else {
G_set_key_value("unit", "degree", in_unit_keys);
G_set_key_value("units", "degrees", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
}
} /* switch */
G_write_key_value_file(path, in_unit_keys, &out_stat);
if (out_stat != 0)
G_fatal_error(_("Error writing into UNITS output file <%s>"),
path);
G_free_key_value(in_unit_keys);
} /* if */
if (G__put_window(&cellhd, "", "DEFAULT_WIND") < 0)
G_fatal_error(_("Unable to write to DEFAULT_WIND region file"));
fprintf(stderr,
_("\nProjection information has been recorded for this location\n\n"));
if ((old_zone != zone) | (old_proj != cellhd.proj)) {
G_message(_("The geographic region information in WIND is now obsolete"));
G_message(_("Run g.region -d to update it"));
}
leave(0);
}
int
interpolate(MELEMENT rowlist[], SHORT nrows, SHORT ncols, SHORT datarows,
int npoints, int out_fd, int maskfd)
{
extern CELL *cell;
MELEMENT *Rptr;
EW *search, *ewptr, *current_row, /* start row for north/south search */
*lastrow; /* last element in search array */
SHORT row, col;
NEIGHBOR *nbr_head, *Nptr;
double sum1, sum2;
/* initialize search array and neighbors array */
current_row = search = (EW *) G_calloc(datarows, sizeof(EW));
lastrow = search + datarows - 1;
nbr_head = (NEIGHBOR *) G_calloc(npoints + 1, sizeof(NEIGHBOR));
#if 0
nbr_head->distance = maxdist;
nbr_head->searchptr = &(nbr_head->Mptr); /* see replace_neighbor */
#endif
G_message(_("Interpolating raster map <%s> (%d rows)..."), output,
nrows);
for (row = 0; row < nrows; row++) { /* loop over rows */
G_percent(row+1, nrows, 2);
/* if mask occurs, read current row of the mask */
if (mask)
Rast_get_c_row(maskfd, mask, row);
/* prepare search array for next row of interpolations */
for (ewptr = search, Rptr = rowlist; ewptr <= lastrow;
Rptr++, ewptr++)
ewptr->start = Rptr->next; /* start at first item in row */
for (col = 0; col < ncols; col++) { /* loop over columns */
/* if (row != 279 && col != 209) continue; */
/* don't interpolate outside of the mask */
if (mask && mask[col] == 0) {
cell[col] = 0;
continue;
}
/* make a list of npoints neighboring data pts */
nbr_head->next = NULL;
if (make_neighbors_list(search, lastrow, current_row, row, col, nbr_head, npoints)) { /* otherwise, known data value assigned */
/* calculate value to be set for the cell from the data values
* of npoints closest neighboring points */
sum1 = sum2 = 0.0;
Nptr = nbr_head->next;
do {
sum1 += Nptr->Mptr->value / Nptr->distance;
sum2 += 1.0 / Nptr->distance;
Nptr = Nptr->next;
} while (Nptr); /* to end of list */
cell[col] = (CELL) (sum1 / sum2 + .5);
/* fprintf (stdout,"%d,%d = %d\n", col, row, cell[col]); */
if (error_flag) /* output interpolation error for this cell */
cell[col] -= mask[col];
}
} /* end of loop over columns */
Rast_put_row(out_fd, cell, CELL_TYPE);
/* advance current row pointer if necessary */
if (current_row->start->y == row && current_row != lastrow)
++current_row;
} /* end of loop over rows */
G_free(search);
return 0;
}
int main(int argc, char **argv)
{
double radius;
double fisher, david, douglas, lloyd, lloydip, morisita;
int i, nquads, *counts;
struct Cell_head window;
struct GModule *module;
struct
{
struct Option *input, *field, *output, *n, *r;
} parm;
struct
{
struct Flag *g;
} flag;
COOR *quads;
struct Map_info Map;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("statistics"));
G_add_keyword(_("point pattern"));
module->description = _("Indices for quadrat counts of vector point lists.");
parm.input = G_define_standard_option(G_OPT_V_INPUT);
parm.field = G_define_standard_option(G_OPT_V_FIELD_ALL);
parm.output = G_define_standard_option(G_OPT_V_OUTPUT);
parm.output->required = NO;
parm.output->description =
_("Name for output quadrat centers map (number of points is written as category)");
parm.n = G_define_option();
parm.n->key = "nquadrats";
parm.n->type = TYPE_INTEGER;
parm.n->required = YES;
parm.n->description = _("Number of quadrats");
parm.r = G_define_option();
parm.r->key = "radius";
parm.r->type = TYPE_DOUBLE;
parm.r->required = YES;
parm.r->description = _("Quadrat radius");
flag.g = G_define_flag();
flag.g->key = 'g';
flag.g->description = _("Print results in shell script style");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
sscanf(parm.n->answer, "%d", &nquads);
sscanf(parm.r->answer, "%lf", &radius);
G_get_window(&window);
/* Open input */
Vect_set_open_level(2);
if (Vect_open_old2(&Map, parm.input->answer, "", parm.field->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), parm.input->answer);
/* Get the quadrats */
G_message(_("Finding quadrats..."));
quads = find_quadrats(nquads, radius, window);
/* Get the counts per quadrat */
G_message(_("Counting points quadrats..."));
counts = (int *)G_malloc(nquads * (sizeof(int)));
count_sites(quads, nquads, counts, radius, &Map,
Vect_get_field_number(&Map, parm.field->answer));
Vect_close(&Map);
/* output if requested */
if (parm.output->answer) {
struct Map_info Out;
struct line_pnts *Points;
struct line_cats *Cats;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
if (Vect_open_new(&Out, parm.output->answer, 0) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
parm.output->answer);
Vect_hist_command(&Out);
for (i = 0; i < nquads; i++) {
Vect_reset_line(Points);
Vect_reset_cats(Cats);
Vect_append_point(Points, quads[i].x, quads[i].y, 0.0);
Vect_cat_set(Cats, 1, counts[i]);
Vect_write_line(&Out, GV_POINT, Points, Cats);
}
Vect_build(&Out);
Vect_close(&Out);
}
/* Indices if requested */
qindices(counts, nquads, &fisher, &david, &douglas, &lloyd, &lloydip,
&morisita);
if (!flag.g->answer) {
fprintf(stdout,
"-----------------------------------------------------------\n");
fprintf(stdout,
"Index Realization\n");
fprintf(stdout,
"-----------------------------------------------------------\n");
fprintf(stdout,
"Fisher el al (1922) Relative Variance %g\n",
fisher);
fprintf(stdout,
"David & Moore (1954) Index of Cluster Size %g\n",
david);
fprintf(stdout,
"Douglas (1975) Index of Cluster Frequency %g\n",
douglas);
fprintf(stdout,
"Lloyd (1967) \"mean crowding\" %g\n",
lloyd);
fprintf(stdout,
"Lloyd (1967) Index of patchiness %g\n",
lloydip);
fprintf(stdout,
"Morisita's (1959) I (variability b/n patches) %g\n",
morisita);
fprintf(stdout,
"-----------------------------------------------------------\n");
}
else {
fprintf(stdout, "fisher=%g\n", fisher);
fprintf(stdout, "david=%g\n", david);
fprintf(stdout, "douglas=%g\n", douglas);
fprintf(stdout, "lloyd=%g\n", lloyd);
fprintf(stdout, "lloydip=%g\n", lloydip);
fprintf(stdout, "morisita=%g\n", morisita);
}
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
/* Global variable & function declarations */
struct GModule *module;
struct {
struct Option *orig, *real, *imag;
} opt;
const char *Cellmap_real, *Cellmap_imag;
const char *Cellmap_orig;
int realfd, imagfd, outputfd, maskfd; /* the input and output file descriptors */
struct Cell_head realhead, imaghead;
DCELL *cell_real, *cell_imag;
CELL *maskbuf;
int i, j; /* Loop control variables */
int rows, cols; /* number of rows & columns */
long totsize; /* Total number of data points */
double (*data)[2]; /* Data structure containing real & complex values of FFT */
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("imagery"));
G_add_keyword(_("transformation"));
G_add_keyword(_("Fast Fourier Transform"));
module->description =
_("Inverse Fast Fourier Transform (IFFT) for image processing.");
/* define options */
opt.real = G_define_standard_option(G_OPT_R_INPUT);
opt.real->key = "real";
opt.real->description = _("Name of input raster map (image fft, real part)");
opt.imag = G_define_standard_option(G_OPT_R_INPUT);
opt.imag->key = "imaginary";
opt.imag->description = _("Name of input raster map (image fft, imaginary part");
opt.orig = G_define_standard_option(G_OPT_R_OUTPUT);
opt.orig->description = _("Name for output raster map");
/*call parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
Cellmap_real = opt.real->answer;
Cellmap_imag = opt.imag->answer;
Cellmap_orig = opt.orig->answer;
/* get and compare the original window data */
Rast_get_cellhd(Cellmap_real, "", &realhead);
Rast_get_cellhd(Cellmap_imag, "", &imaghead);
if (realhead.proj != imaghead.proj ||
realhead.zone != imaghead.zone ||
realhead.north != imaghead.north ||
realhead.south != imaghead.south ||
realhead.east != imaghead.east ||
realhead.west != imaghead.west ||
realhead.ew_res != imaghead.ew_res ||
realhead.ns_res != imaghead.ns_res)
G_fatal_error(_("The real and imaginary original windows did not match"));
Rast_set_window(&realhead); /* set the window to the whole cell map */
/* open input raster map */
realfd = Rast_open_old(Cellmap_real, "");
imagfd = Rast_open_old(Cellmap_imag, "");
/* get the rows and columns in the current window */
rows = Rast_window_rows();
cols = Rast_window_cols();
totsize = rows * cols;
/* Allocate appropriate memory for the structure containing
the real and complex components of the FFT. DATA[0] will
contain the real, and DATA[1] the complex component.
*/
data = G_malloc(rows * cols * 2 * sizeof(double));
/* allocate the space for one row of cell map data */
cell_real = Rast_allocate_d_buf();
cell_imag = Rast_allocate_d_buf();
#define C(i, j) ((i) * cols + (j))
/* Read in cell map values */
G_message(_("Reading raster maps..."));
for (i = 0; i < rows; i++) {
Rast_get_d_row(realfd, cell_real, i);
Rast_get_d_row(imagfd, cell_imag, i);
for (j = 0; j < cols; j++) {
data[C(i, j)][0] = cell_real[j];
data[C(i, j)][1] = cell_imag[j];
}
G_percent(i+1, rows, 2);
}
/* close input cell maps */
Rast_close(realfd);
Rast_close(imagfd);
/* Read in cell map values */
G_message(_("Masking raster maps..."));
maskfd = Rast_maskfd();
if (maskfd >= 0) {
maskbuf = Rast_allocate_c_buf();
for (i = 0; i < rows; i++) {
Rast_get_c_row(maskfd, maskbuf, i);
for (j = 0; j < cols; j++) {
if (maskbuf[j] == 0) {
data[C(i, j)][0] = 0.0;
data[C(i, j)][1] = 0.0;
}
}
G_percent(i+1, rows, 2);
}
Rast_close(maskfd);
G_free(maskbuf);
}
#define SWAP1(a, b) \
do { \
double temp = (a); \
(a) = (b); \
(b) = temp; \
} while (0)
#define SWAP2(a, b) \
do { \
SWAP1(data[(a)][0], data[(b)][0]); \
SWAP1(data[(a)][1], data[(b)][1]); \
} while (0)
/* rotate the data array for standard display */
G_message(_("Rotating data..."));
for (i = 0; i < rows; i++)
for (j = 0; j < cols / 2; j++)
SWAP2(C(i, j), C(i, j + cols / 2));
for (i = 0; i < rows / 2; i++)
for (j = 0; j < cols; j++)
SWAP2(C(i, j), C(i + rows / 2, j));
/* perform inverse FFT */
G_message(_("Starting Inverse FFT..."));
fft2(1, data, totsize, cols, rows);
/* open the output cell map */
outputfd = Rast_open_fp_new(Cellmap_orig);
/* Write out result to a new cell map */
G_message(_("Writing raster map <%s>..."),
Cellmap_orig);
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++)
cell_real[j] = data[C(i, j)][0];
Rast_put_d_row(outputfd, cell_real);
G_percent(i+1, rows, 2);
}
Rast_close(outputfd);
G_free(cell_real);
G_free(cell_imag);
fft_colors(Cellmap_orig);
/* Release memory resources */
G_free(data);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int m1;
struct FPRange range;
DCELL cellmin, cellmax;
FCELL *cellrow, fcellmin;
struct GModule *module;
struct
{
struct Option *input, *elev, *slope, *aspect, *pcurv, *tcurv, *mcurv,
*smooth, *maskmap, *zmult, *fi, *segmax, *npmin, *res_ew, *res_ns,
*overlap, *theta, *scalex;
} parm;
struct
{
struct Flag *deriv, *cprght;
} flag;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("resample"));
module->description =
_("Reinterpolates and optionally computes topographic analysis from "
"input raster map to a new raster map (possibly with "
"different resolution) using regularized spline with "
"tension and smoothing.");
parm.input = G_define_standard_option(G_OPT_R_INPUT);
parm.res_ew = G_define_option();
parm.res_ew->key = "ew_res";
parm.res_ew->type = TYPE_DOUBLE;
parm.res_ew->required = YES;
parm.res_ew->description = _("Desired east-west resolution");
parm.res_ns = G_define_option();
parm.res_ns->key = "ns_res";
parm.res_ns->type = TYPE_DOUBLE;
parm.res_ns->required = YES;
parm.res_ns->description = _("Desired north-south resolution");
parm.elev = G_define_option();
parm.elev->key = "elev";
parm.elev->type = TYPE_STRING;
parm.elev->required = NO;
parm.elev->gisprompt = "new,cell,raster";
parm.elev->description = _("Output z-file (elevation) map");
parm.elev->guisection = _("Output");
parm.slope = G_define_option();
parm.slope->key = "slope";
parm.slope->type = TYPE_STRING;
parm.slope->required = NO;
parm.slope->gisprompt = "new,cell,raster";
parm.slope->description = _("Output slope map (or fx)");
parm.slope->guisection = _("Output");
parm.aspect = G_define_option();
parm.aspect->key = "aspect";
parm.aspect->type = TYPE_STRING;
parm.aspect->required = NO;
parm.aspect->gisprompt = "new,cell,raster";
parm.aspect->description = _("Output aspect map (or fy)");
parm.aspect->guisection = _("Output");
parm.pcurv = G_define_option();
parm.pcurv->key = "pcurv";
parm.pcurv->type = TYPE_STRING;
parm.pcurv->required = NO;
parm.pcurv->gisprompt = "new,cell,raster";
parm.pcurv->description = _("Output profile curvature map (or fxx)");
parm.pcurv->guisection = _("Output");
parm.tcurv = G_define_option();
parm.tcurv->key = "tcurv";
parm.tcurv->type = TYPE_STRING;
parm.tcurv->required = NO;
parm.tcurv->gisprompt = "new,cell,raster";
parm.tcurv->description = _("Output tangential curvature map (or fyy)");
parm.tcurv->guisection = _("Output");
parm.mcurv = G_define_option();
parm.mcurv->key = "mcurv";
parm.mcurv->type = TYPE_STRING;
parm.mcurv->required = NO;
parm.mcurv->gisprompt = "new,cell,raster";
parm.mcurv->description = _("Output mean curvature map (or fxy)");
parm.mcurv->guisection = _("Output");
parm.smooth = G_define_option();
parm.smooth->key = "smooth";
parm.smooth->type = TYPE_STRING;
parm.smooth->required = NO;
parm.smooth->gisprompt = "old,cell,raster";
parm.smooth->description = _("Name of raster map containing smoothing");
parm.smooth->guisection = _("Settings");
parm.maskmap = G_define_option();
parm.maskmap->key = "maskmap";
parm.maskmap->type = TYPE_STRING;
parm.maskmap->required = NO;
parm.maskmap->gisprompt = "old,cell,raster";
parm.maskmap->description = _("Name of raster map to be used as mask");
parm.maskmap->guisection = _("Settings");
parm.overlap = G_define_option();
parm.overlap->key = "overlap";
parm.overlap->type = TYPE_INTEGER;
parm.overlap->required = NO;
parm.overlap->answer = OVERLAP;
parm.overlap->description = _("Rows/columns overlap for segmentation");
parm.overlap->guisection = _("Settings");
parm.zmult = G_define_option();
parm.zmult->key = "zmult";
parm.zmult->type = TYPE_DOUBLE;
parm.zmult->answer = ZMULT;
parm.zmult->required = NO;
parm.zmult->description = _("Multiplier for z-values");
parm.zmult->guisection = _("Settings");
parm.fi = G_define_option();
parm.fi->key = "tension";
parm.fi->type = TYPE_DOUBLE;
parm.fi->answer = TENSION;
parm.fi->required = NO;
parm.fi->description = _("Spline tension value");
parm.fi->guisection = _("Settings");
parm.theta = G_define_option();
parm.theta->key = "theta";
parm.theta->type = TYPE_DOUBLE;
parm.theta->required = NO;
parm.theta->description = _("Anisotropy angle (in degrees)");
parm.theta->guisection = _("Anisotropy");
parm.scalex = G_define_option();
parm.scalex->key = "scalex";
parm.scalex->type = TYPE_DOUBLE;
parm.scalex->required = NO;
parm.scalex->description = _("Anisotropy scaling factor");
parm.scalex->guisection = _("Anisotropy");
flag.cprght = G_define_flag();
flag.cprght->key = 't';
flag.cprght->description = _("Use dnorm independent tension");
flag.deriv = G_define_flag();
flag.deriv->key = 'd';
flag.deriv->description =
_("Output partial derivatives instead of topographic parameters");
flag.deriv->guisection = _("Output");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_get_set_window(&winhd);
inp_ew_res = winhd.ew_res;
inp_ns_res = winhd.ns_res;
inp_cols = winhd.cols;
inp_rows = winhd.rows;
inp_x_orig = winhd.west;
inp_y_orig = winhd.south;
input = parm.input->answer;
smooth = parm.smooth->answer;
maskmap = parm.maskmap->answer;
elev = parm.elev->answer;
slope = parm.slope->answer;
aspect = parm.aspect->answer;
pcurv = parm.pcurv->answer;
tcurv = parm.tcurv->answer;
mcurv = parm.mcurv->answer;
cond2 = ((pcurv != NULL) || (tcurv != NULL) || (mcurv != NULL));
cond1 = ((slope != NULL) || (aspect != NULL) || cond2);
deriv = flag.deriv->answer;
dtens = flag.cprght->answer;
ertre = 0.1;
if (!G_scan_resolution(parm.res_ew->answer, &ew_res, winhd.proj))
G_fatal_error(_("Unable to read ew_res value"));
if (!G_scan_resolution(parm.res_ns->answer, &ns_res, winhd.proj))
G_fatal_error(_("Unable to read ns_res value"));
if (sscanf(parm.fi->answer, "%lf", &fi) != 1)
G_fatal_error(_("Invalid value for tension"));
if (sscanf(parm.zmult->answer, "%lf", &zmult) != 1)
G_fatal_error(_("Invalid value for zmult"));
if (sscanf(parm.overlap->answer, "%d", &overlap) != 1)
G_fatal_error(_("Invalid value for overlap"));
if (parm.theta->answer) {
if (sscanf(parm.theta->answer, "%lf", &theta) != 1)
G_fatal_error(_("Invalid value for theta"));
}
if (parm.scalex->answer) {
if (sscanf(parm.scalex->answer, "%lf", &scalex) != 1)
G_fatal_error(_("Invalid value for scalex"));
if (!parm.theta->answer)
G_fatal_error(_("When using anisotropy both theta and scalex must be specified"));
}
/*
* G_set_embedded_null_value_mode(1);
*/
outhd.ew_res = ew_res;
outhd.ns_res = ns_res;
outhd.east = winhd.east;
outhd.west = winhd.west;
outhd.north = winhd.north;
outhd.south = winhd.south;
outhd.proj = winhd.proj;
outhd.zone = winhd.zone;
G_adjust_Cell_head(&outhd, 0, 0);
ew_res = outhd.ew_res;
ns_res = outhd.ns_res;
nsizc = outhd.cols;
nsizr = outhd.rows;
disk = nsizc * nsizr * sizeof(int);
az = G_alloc_vector(nsizc + 1);
if (cond1) {
adx = G_alloc_vector(nsizc + 1);
ady = G_alloc_vector(nsizc + 1);
if (cond2) {
adxx = G_alloc_vector(nsizc + 1);
adyy = G_alloc_vector(nsizc + 1);
adxy = G_alloc_vector(nsizc + 1);
}
}
if (smooth != NULL) {
fdsmooth = Rast_open_old(smooth, "");
Rast_get_cellhd(smooth, "", &smhd);
if ((winhd.ew_res != smhd.ew_res) || (winhd.ns_res != smhd.ns_res))
G_fatal_error(_("Map <%s> is the wrong resolution"), smooth);
if (Rast_read_fp_range(smooth, "", &range) >= 0)
Rast_get_fp_range_min_max(&range, &cellmin, &cellmax);
fcellmin = (float)cellmin;
if (Rast_is_f_null_value(&fcellmin) || fcellmin < 0.0)
G_fatal_error(_("Smoothing values can not be negative or NULL"));
}
Rast_get_cellhd(input, "", &inphd);
if ((winhd.ew_res != inphd.ew_res) || (winhd.ns_res != inphd.ns_res))
G_fatal_error(_("Input map resolution differs from current region resolution!"));
fdinp = Rast_open_old(input, "");
sdisk = 0;
if (elev != NULL)
sdisk += disk;
if (slope != NULL)
sdisk += disk;
if (aspect != NULL)
sdisk += disk;
if (pcurv != NULL)
sdisk += disk;
if (tcurv != NULL)
sdisk += disk;
if (mcurv != NULL)
sdisk += disk;
G_message(_("Processing all selected output files will require"));
if (sdisk > 1024) {
if (sdisk > 1024 * 1024) {
if (sdisk > 1024 * 1024 * 1024) {
G_message(_("%.2f GB of disk space for temp files."), sdisk / (1024. * 1024. * 1024.));
}
else
G_message(_("%.2f MB of disk space for temp files."), sdisk / (1024. * 1024.));
}
else
G_message(_("%.2f KB of disk space for temp files."), sdisk / 1024.);
}
else
G_message(_("%d bytes of disk space for temp files."), sdisk);
fstar2 = fi * fi / 4.;
tfsta2 = fstar2 + fstar2;
deltx = winhd.east - winhd.west;
delty = winhd.north - winhd.south;
xmin = winhd.west;
xmax = winhd.east;
ymin = winhd.south;
ymax = winhd.north;
if (smooth != NULL)
smc = -9999;
else
smc = 0.01;
if (Rast_read_fp_range(input, "", &range) >= 0) {
Rast_get_fp_range_min_max(&range, &cellmin, &cellmax);
}
else {
cellrow = Rast_allocate_f_buf();
for (m1 = 0; m1 < inp_rows; m1++) {
Rast_get_f_row(fdinp, cellrow, m1);
Rast_row_update_fp_range(cellrow, m1, &range, FCELL_TYPE);
}
Rast_get_fp_range_min_max(&range, &cellmin, &cellmax);
}
fcellmin = (float)cellmin;
if (Rast_is_f_null_value(&fcellmin))
G_fatal_error(_("Maximum value of a raster map is NULL."));
zmin = (double)cellmin *zmult;
zmax = (double)cellmax *zmult;
G_debug(1, "zmin=%f, zmax=%f", zmin, zmax);
if (fd4 != NULL)
fprintf(fd4, "deltx,delty %f %f \n", deltx, delty);
create_temp_files();
IL_init_params_2d(¶ms, NULL, 1, 1, zmult, KMIN, KMAX, maskmap,
outhd.rows, outhd.cols, az, adx, ady, adxx, adyy, adxy,
fi, MAXPOINTS, SCIK1, SCIK2, SCIK3, smc, elev, slope,
aspect, pcurv, tcurv, mcurv, dmin, inp_x_orig,
inp_y_orig, deriv, theta, scalex, Tmp_fd_z, Tmp_fd_dx,
Tmp_fd_dy, Tmp_fd_xx, Tmp_fd_yy, Tmp_fd_xy, NULL, NULL,
0, NULL);
/* In the above line, the penultimate argument is supposed to be a
* deviations file pointer. None is obvious, so I used NULL. */
/* The 3rd and 4th argument are int-s, elatt and smatt (from the function
* definition. The value 1 seemed like a good placeholder... or not. */
IL_init_func_2d(¶ms, IL_grid_calc_2d, IL_matrix_create,
IL_check_at_points_2d,
IL_secpar_loop_2d, IL_crst, IL_crstg, IL_write_temp_2d);
G_message(_("Temporarily changing the region to desired resolution ..."));
Rast_set_window(&outhd);
bitmask = IL_create_bitmask(¶ms);
/* change region to initial region */
G_message(_("Changing back to the original region ..."));
Rast_set_window(&winhd);
ertot = 0.;
cursegm = 0;
G_message(_("Percent complete: "));
NPOINT =
IL_resample_interp_segments_2d(¶ms, bitmask, zmin, zmax, &zminac,
&zmaxac, &gmin, &gmax, &c1min, &c1max,
&c2min, &c2max, &ertot, nsizc, &dnorm,
overlap, inp_rows, inp_cols, fdsmooth,
fdinp, ns_res, ew_res, inp_ns_res,
inp_ew_res, dtens);
G_message(_("dnorm in mainc after grid before out1= %f"), dnorm);
if (NPOINT < 0) {
clean();
G_fatal_error(_("split_and_interpolate() failed"));
}
if (fd4 != NULL)
fprintf(fd4, "max. error found = %f \n", ertot);
G_free_vector(az);
if (cond1) {
G_free_vector(adx);
G_free_vector(ady);
if (cond2) {
G_free_vector(adxx);
G_free_vector(adyy);
G_free_vector(adxy);
}
}
G_message(_("dnorm in mainc after grid before out2= %f"), dnorm);
if (IL_resample_output_2d(¶ms, zmin, zmax, zminac, zmaxac, c1min,
c1max, c2min, c2max, gmin, gmax, ertot, input,
&dnorm, &outhd, &winhd, smooth, NPOINT) < 0) {
clean();
G_fatal_error(_("Unable to write raster maps -- try increasing cell size"));
}
G_free(zero_array_cell);
clean();
if (fd4)
fclose(fd4);
Rast_close(fdinp);
if (smooth != NULL)
Rast_close(fdsmooth);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int ram_calculate_upstream(DCELL ** distance, CELL ** dirs,
DCELL ** elevation, DCELL ** tmp_elevation,
int near)
{
int r, c;
int next_r, next_c;
double easting, northing;
double cell_easting, cell_northing;
int i, j, k, d;
int done;
int counter;
int n_inits = 0;
double cur_dist;
POINT *d_inits;
double tmp_dist = 0;
double target_elev = 0;
size_t elevation_data_size;
struct Cell_head window;
Rast_get_window(&window);
if (elevation) {
elevation_data_size = Rast_cell_size(DCELL_TYPE);
for (r = 0; r < nrows; ++r)
memcpy(tmp_elevation[r], elevation[r],
ncols * elevation_data_size);
}
for (r = 0; r < nrows; ++r)
for (c = 0; c < ncols; ++c) {
for (i = 1; i < 9; ++i) {
if (NOT_IN_REGION(i))
continue; /* out of border */
j = DIAG(i);
next_r = NR(i);
next_c = NC(i);
if (dirs[next_r][next_c] == j && distance[r][c] != 0) { /* is contributing cell */
distance[r][c] = -1;
break;
}
}
if (distance[r][c] == 1 && dirs[r][c] > 0)
n_inits++;
else if (dirs[r][c] > 0)
distance[r][c] = -1;
}
d_inits = (POINT *) G_malloc(n_inits * sizeof(POINT));
k = 0;
for (r = 0; r < nrows; ++r)
for (c = 0; c < ncols; ++c) {
if (distance[r][c] == 1) {
distance[r][c] = 0;
if (elevation)
elevation[r][c] = 0;
d = dirs[r][c];
if (dirs[NR(d)][NC(d)] < 0)
continue;
d_inits[k].r = r;
d_inits[k].c = c;
d_inits[k].cur_dist = 0;
if (elevation)
d_inits[k].target_elev = tmp_elevation[r][c];
k++;
}
}
counter = n_inits = k;
/* return 0; */
G_message(_("Calculate upstream parameters..."));
while (n_inits > 0) {
k = 0;
G_percent((counter - n_inits), counter, 10);
for (i = 0; i < n_inits; ++i) {
r = d_inits[i].r;
c = d_inits[i].c;
d = dirs[r][c];
next_r = NR(d);
next_c = NC(d);
tmp_dist = d_inits[i].cur_dist;
if (elevation)
target_elev = d_inits[i].target_elev;
easting = window.west + (c + 0.5) * window.ew_res;
northing = window.north - (r + 0.5) * window.ns_res;
cell_easting = window.west + (next_c + 0.5) * window.ew_res;
cell_northing = window.north - (next_r + 0.5) * window.ns_res;
cur_dist = tmp_dist +
G_distance(easting, northing, cell_easting, cell_northing);
if (near)
done = (distance[next_r][next_c] > cur_dist ||
distance[next_r][next_c] <= 0) ? 1 : 0;
else
done = (distance[next_r][next_c] < cur_dist ||
distance[next_r][next_c] <= 0) ? 1 : 0;
if (done) {
distance[next_r][next_c] = cur_dist;
if (elevation) {
elevation[next_r][next_c] =
target_elev - tmp_elevation[next_r][next_c];
}
if (dirs[NR(d)][NC(d)] < 1)
continue;
d_inits[k].r = next_r;
d_inits[k].c = next_c;
d_inits[k].cur_dist = cur_dist;
if (elevation)
d_inits[k].target_elev = target_elev;
k++;
} /* end of if done */
}
n_inits = k;
}
G_percent((counter - n_inits), counter, 10);
return 0;
}
/* *************************************************************** */
int test_array_2d(void)
{
int sum = 0, res = 0;
struct Cell_head region;
N_array_2d *data1;
N_array_2d *data11;
N_array_2d *data2;
N_array_2d *data22;
N_array_2d *data3;
N_array_2d *data33;
char buff[1024];
double min, max, ssum;
int nonzero;
N_array_2d *tmp;
/*Alloacte memory for all arrays */
data1 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, CELL_TYPE);
N_print_array_2d_info(data1);
data11 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, CELL_TYPE);
data2 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, FCELL_TYPE);
N_print_array_2d_info(data2);
data22 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, FCELL_TYPE);
data3 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, DCELL_TYPE);
N_print_array_2d_info(data3);
data33 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, DCELL_TYPE);
/*Fill the first arrays with data */
res = fill_array_2d(data1);
if (res != 0)
G_warning("test_array_2d: error while filling array with values");
sum += res;
res = fill_array_2d(data2);
if (res != 0)
G_warning("test_array_2d: error while filling array with values");
sum += res;
res = fill_array_2d(data3);
if (res != 0)
G_warning("test_array_2d: error while filling array with values");
sum += res;
/*Copy the data */
N_copy_array_2d(data1, data11);
N_copy_array_2d(data2, data22);
N_copy_array_2d(data3, data33);
/*Compare the data */
res = compare_array_2d(data1, data11);
if (res != 0)
G_warning("test_array_2d: error in N_copy_array_2d");
sum += res;
res = compare_array_2d(data2, data22);
if (res != 0)
G_warning("test_array_2d: error in N_copy_array_2d");
sum += res;
res = compare_array_2d(data3, data33);
if (res != 0)
G_warning("test_array_2d: error in N_copy_array_2d");
sum += res;
/*compute statistics */
N_calc_array_2d_stats(data1, &min, &max, &ssum, &nonzero, 0);
G_message("CELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 81 || ssum != 2025 || nonzero != 100) {
G_warning("test_array_2d: error in N_calc_array_2d_stats");
sum++;
}
N_calc_array_2d_stats(data1, &min, &max, &ssum, &nonzero, 1);
G_message("CELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 81 || ssum != 2025 || nonzero != 144) {
G_warning("test_array_2d: error in N_calc_array_2d_stats");
sum++;
}
N_calc_array_2d_stats(data2, &min, &max, &ssum, &nonzero, 0);
G_message("FCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 81 || ssum != 2025 || nonzero != 100) {
G_warning("test_array_2d: error in N_calc_array_2d_stats");
sum++;
}
N_calc_array_2d_stats(data2, &min, &max, &ssum, &nonzero, 1);
G_message("FCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 81 || ssum != 2025 || nonzero != 144) {
G_warning("test_array_2d: error in N_calc_array_2d_stats");
sum++;
}
N_calc_array_2d_stats(data3, &min, &max, &ssum, &nonzero, 0);
G_message("DCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 81 || ssum != 2025 || nonzero != 100) {
G_warning("test_array_2d: error in N_calc_array_2d_stats");
sum++;
}
N_calc_array_2d_stats(data3, &min, &max, &ssum, &nonzero, 1);
G_message("DCELL Min %g Max %g Sum %g nonzero %i\n", min, max, ssum,
nonzero);
if (min != 0 || max != 81 || ssum != 2025 || nonzero != 144) {
G_warning("test_array_2d: error in N_calc_array_2d_stats");
sum++;
}
/*test the array math functions */
tmp = N_math_array_2d(data1, data2, NULL, N_ARRAY_SUM);
N_math_array_2d(data2, data2, tmp, N_ARRAY_SUM);
res = N_convert_array_2d_null_to_zero(tmp);
if (res != 0)
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum = res;
N_free_array_2d(tmp);
tmp = N_math_array_2d(data2, data3, NULL, N_ARRAY_DIF);
N_math_array_2d(data1, data2, tmp, N_ARRAY_DIF);
res = N_convert_array_2d_null_to_zero(tmp);
if (res != 0)
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum = res;
N_free_array_2d(tmp);
tmp = N_math_array_2d(data1, data1, NULL, N_ARRAY_MUL);
N_math_array_2d(data1, data1, tmp, N_ARRAY_MUL);
res = N_convert_array_2d_null_to_zero(tmp);
if (res != 0)
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum = res;
N_free_array_2d(tmp);
tmp = N_math_array_2d(data2, data3, NULL, N_ARRAY_DIV);
N_math_array_2d(data1, data2, tmp, N_ARRAY_DIV);
res = N_convert_array_2d_null_to_zero(tmp);
if (res == 0) { /* if a division with zero is detected, the value is set to null, not to nan */
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum++;
}
N_free_array_2d(tmp);
/*check for correct norm calculation */
if (N_norm_array_2d(data1, data11, N_EUKLID_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
if (N_norm_array_2d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
if (N_norm_array_2d(data2, data3, N_EUKLID_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
if (N_norm_array_2d(data2, data3, N_MAXIMUM_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
/*fill arrays with null values */
res = fill_array_2d_null(data1);
if (res != 0)
G_warning
("test_array_2d: error while filling array with cell null values");
sum += res;
res = fill_array_2d_null(data2);
if (res != 0)
G_warning
("test_array_2d: error while filling array with fcell null values");
sum += res;
res = fill_array_2d_null(data3);
if (res != 0)
G_warning
("test_array_2d: error while filling array with dcell null values");
sum += res;
/*Copy the data */
N_copy_array_2d(data1, data11);
N_copy_array_2d(data2, data22);
N_copy_array_2d(data3, data33);
/*Compare the data */
compare_array_2d(data1, data11);
compare_array_2d(data2, data22);
compare_array_2d(data3, data33);
/*check for correct norm calculation in case of null values */
if (N_norm_array_2d(data1, data11, N_EUKLID_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
if (N_norm_array_2d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
if (N_norm_array_2d(data2, data3, N_EUKLID_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
if (N_norm_array_2d(data2, data3, N_MAXIMUM_NORM) != 0.0) {
G_warning("test_array_2d: error in N_norm_array_2d");
sum++;
}
/*test the array math functions with null values */
tmp = N_math_array_2d(data1, data11, NULL, N_ARRAY_SUM);
N_math_array_2d(data2, data22, tmp, N_ARRAY_SUM);
res = N_convert_array_2d_null_to_zero(tmp);
if (res == 0) {
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero ");
sum++;
}
N_free_array_2d(tmp);
tmp = N_math_array_2d(data2, data22, NULL, N_ARRAY_DIF);
N_math_array_2d(data3, data33, tmp, N_ARRAY_DIF);
res = N_convert_array_2d_null_to_zero(tmp);
if (res == 0) {
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum++;
}
N_free_array_2d(tmp);
tmp = N_math_array_2d(data1, data11, NULL, N_ARRAY_MUL);
N_math_array_2d(data3, data33, tmp, N_ARRAY_MUL);
res = N_convert_array_2d_null_to_zero(tmp);
if (res == 0) {
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum++;
}
N_free_array_2d(tmp);
tmp = N_math_array_2d(data2, data3, NULL, N_ARRAY_DIV);
N_math_array_2d(data1, data11, tmp, N_ARRAY_DIV);
res = N_convert_array_2d_null_to_zero(tmp);
if (res == 0) {
G_warning("test_array_2d: error in N_convert_array_2d_null_to_zero");
sum++;
}
N_free_array_2d(tmp);
N_free_array_2d(data1);
N_free_array_2d(data2);
N_free_array_2d(data3);
G_get_set_window(®ion);
data1 = N_alloc_array_2d(region.cols, region.rows, 0, CELL_TYPE);
data2 = N_alloc_array_2d(region.cols, region.rows, 0, FCELL_TYPE);
data3 = N_alloc_array_2d(region.cols, region.rows, 0, DCELL_TYPE);
fill_array_2d(data1);
fill_array_2d(data2);
fill_array_2d(data3);
/*raster IO methods */
N_write_array_2d_to_rast(data1, "gpde_lib_test_raster_1");
N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_2");
N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_3");
tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_1", NULL);
N_read_rast_to_array_2d("gpde_lib_test_raster_1", tmp);
N_free_array_2d(tmp);
tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_2", NULL);
N_read_rast_to_array_2d("gpde_lib_test_raster_2", tmp);
N_free_array_2d(tmp);
tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_3", NULL);
N_read_rast_to_array_2d("gpde_lib_test_raster_3", tmp);
N_free_array_2d(tmp);
sprintf(buff,
"g.remove rast=gpde_lib_test_raster_1,gpde_lib_test_raster_2,gpde_lib_test_raster_3");
system(buff);
N_free_array_2d(data1);
N_free_array_2d(data11);
N_free_array_2d(data2);
N_free_array_2d(data22);
N_free_array_2d(data3);
N_free_array_2d(data33);
return sum;
}
int seg_calculate_upstream(SEGMENT * distance, SEGMENT * dirs,
SEGMENT * elevation, SEGMENT * tmp_elevation,
int near)
{
int r, c;
int next_r, next_c;
double easting, northing;
double cell_easting, cell_northing;
int i, j, k, d, d_next;
DCELL minus_one_cell = -1;
DCELL zero_cell = 0;
int done;
int counter;
int n_inits = 0;
double cur_dist;
POINT *d_inits;
double tmp_dist = 0;
double target_elev = 0;
CELL dirs_cell;
DCELL distance_cell, elevation_cell, tmp_elevation_cell;
/* size_t elevation_data_size; */
struct Cell_head window;
Rast_get_window(&window);
if (elevation) {
/* elevation_data_size = Rast_cell_size(DCELL_TYPE); */
for (r = 0; r < nrows; ++r)
for (c = 0; c < ncols; ++c) {
Segment_get(elevation, &elevation_cell, r, c);
Segment_put(tmp_elevation, &elevation_cell, r, c);
}
}
for (r = 0; r < nrows; ++r)
for (c = 0; c < ncols; ++c) {
Segment_get(distance, &distance_cell, r, c);
for (i = 1; i < 9; ++i) {
if (NOT_IN_REGION(i))
continue; /* out of border */
j = DIAG(i);
next_r = NR(i);
next_c = NC(i);
Segment_get(dirs, &dirs_cell, next_r, next_c);
if (dirs_cell == j && distance_cell != 0) { /* is contributing cell */
Segment_put(distance, &minus_one_cell, r, c);
break;
}
} /* end for i */
Segment_get(distance, &distance_cell, r, c);
Segment_get(dirs, &dirs_cell, r, c);
if (distance_cell == 1) {
if (distance_cell == 1 && dirs_cell > 0)
n_inits++;
else if (dirs_cell > 0)
Segment_put(distance, &minus_one_cell, r, c);
}
}
d_inits = (POINT *) G_malloc(n_inits * sizeof(POINT));
k = 0;
for (r = 0; r < nrows; ++r)
for (c = 0; c < ncols; ++c) {
Segment_get(distance, &distance_cell, r, c);
if (distance_cell == 1) {
Segment_put(distance, &zero_cell, r, c);
if (elevation)
Segment_put(elevation, &zero_cell, r, c);
Segment_get(dirs, &d, r, c);
Segment_get(dirs, &d_next, NR(d), NR(d));
if (d_next < 0)
continue;
d_inits[k].r = r;
d_inits[k].c = c;
d_inits[k].cur_dist = 0;
if (elevation)
Segment_get(tmp_elevation, &(d_inits[k].target_elev), r,
c);
k++;
}
}
counter = n_inits = k;
G_message(_("Calculate upstream parameters..."));
while (n_inits > 0) {
k = 0;
G_percent((counter - n_inits), counter, 10);
for (i = 0; i < n_inits; ++i) {
r = d_inits[i].r;
c = d_inits[i].c;
Segment_get(dirs, &d, r, c);
next_r = NR(d);
next_c = NC(d);
tmp_dist = d_inits[i].cur_dist;
if (elevation)
target_elev = d_inits[i].target_elev;
easting = window.west + (c + 0.5) * window.ew_res;
northing = window.north - (r + 0.5) * window.ns_res;
cell_easting = window.west + (next_c + 0.5) * window.ew_res;
cell_northing = window.north - (next_r + 0.5) * window.ns_res;
cur_dist = tmp_dist +
G_distance(easting, northing, cell_easting, cell_northing);
Segment_get(distance, &distance_cell, next_r, next_c);
if (near)
done = (distance_cell > cur_dist ||
distance_cell <= 0) ? 1 : 0;
else
done = (distance_cell < cur_dist ||
distance_cell <= 0) ? 1 : 0;
if (done) {
Segment_put(distance, &cur_dist, next_r, next_c);
if (elevation) {
Segment_get(tmp_elevation, &tmp_elevation_cell, next_r,
next_c);
tmp_elevation_cell = target_elev - tmp_elevation_cell;
Segment_put(elevation, &tmp_elevation_cell, next_r,
next_c);
}
Segment_get(dirs, &dirs_cell, NR(d), NC(d));
if (dirs_cell < 1)
continue;
d_inits[k].r = next_r;
d_inits[k].c = next_c;
d_inits[k].cur_dist = cur_dist;
if (elevation)
d_inits[k].target_elev = target_elev;
k++;
} /* end of if done */
}
n_inits = k;
}
G_percent(1, 1, 1);
return 0;
}
int rectify(char *name, char *mapset, struct cache *ebuffer,
double aver_z, char *result, char *interp_method)
{
struct Cell_head cellhd;
int ncols, nrows;
int row, col;
double row_idx, col_idx;
int infd, outfd;
RASTER_MAP_TYPE map_type;
int cell_size;
void *trast, *tptr;
double n1, e1, z1;
double nx, ex, nx1, ex1, zx1;
struct cache *ibuffer;
select_current_env();
Rast_get_cellhd(name, mapset, &cellhd);
/* open the file to be rectified
* set window to cellhd first to be able to read file exactly
*/
Rast_set_input_window(&cellhd);
infd = Rast_open_old(name, mapset);
map_type = Rast_get_map_type(infd);
cell_size = Rast_cell_size(map_type);
ibuffer = readcell(infd, seg_mb_img, 0);
Rast_close(infd); /* (pmx) 17 april 2000 */
G_message(_("Rectify <%s@%s> (location <%s>)"),
name, mapset, G_location());
select_target_env();
G_set_window(&target_window);
G_message(_("into <%s@%s> (location <%s>) ..."),
result, G_mapset(), G_location());
nrows = target_window.rows;
ncols = target_window.cols;
if (strcmp(interp_method, "nearest") != 0) {
map_type = DCELL_TYPE;
cell_size = Rast_cell_size(map_type);
}
/* open the result file into target window
* this open must be first since we change the window later
* raster maps open for writing are not affected by window changes
* but those open for reading are
*/
outfd = Rast_open_new(result, map_type);
trast = Rast_allocate_output_buf(map_type);
for (row = 0; row < nrows; row++) {
n1 = target_window.north - (row + 0.5) * target_window.ns_res;
G_percent(row, nrows, 2);
Rast_set_null_value(trast, ncols, map_type);
tptr = trast;
for (col = 0; col < ncols; col++) {
DCELL *zp = CPTR(ebuffer, row, col);
e1 = target_window.west + (col + 0.5) * target_window.ew_res;
/* if target cell has no elevation, set to aver_z */
if (Rast_is_d_null_value(zp)) {
G_warning(_("No elevation available at row = %d, col = %d"), row, col);
z1 = aver_z;
}
else
z1 = *zp;
/* target coordinates e1, n1 to photo coordinates ex1, nx1 */
I_ortho_ref(e1, n1, z1, &ex1, &nx1, &zx1, &group.camera_ref,
group.XC, group.YC, group.ZC, group.M);
G_debug(5, "\t\tAfter ortho ref (photo cords): ex = %f \t nx = %f",
ex1, nx1);
/* photo coordinates ex1, nx1 to image coordinates ex, nx */
I_georef(ex1, nx1, &ex, &nx, group.E21, group.N21, 1);
G_debug(5, "\t\tAfter geo ref: ex = %f \t nx = %f", ex, nx);
/* convert to row/column indices of source raster */
row_idx = (cellhd.north - nx) / cellhd.ns_res;
col_idx = (ex - cellhd.west) / cellhd.ew_res;
/* resample data point */
interpolate(ibuffer, tptr, map_type, &row_idx, &col_idx, &cellhd);
tptr = G_incr_void_ptr(tptr, cell_size);
}
Rast_put_row(outfd, trast, map_type);
}
G_percent(1, 1, 1);
Rast_close(outfd); /* (pmx) 17 april 2000 */
G_free(trast);
close(ibuffer->fd);
release_cache(ibuffer);
Rast_get_cellhd(result, G_mapset(), &cellhd);
if (cellhd.proj == 0) { /* x,y imagery */
cellhd.proj = target_window.proj;
cellhd.zone = target_window.zone;
}
if (target_window.proj != cellhd.proj) {
cellhd.proj = target_window.proj;
G_warning(_("Raster map <%s@%s>: projection don't match current settings"),
name, mapset);
}
if (target_window.zone != cellhd.zone) {
cellhd.zone = target_window.zone;
G_warning(_("Raster map <%s@%s>: zone don't match current settings"),
name, mapset);
}
select_current_env();
return 1;
}
/*----------------------------------------------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
/* Declarations */
int dim_vect, nparameters, BW, npoints;
int nsply, nsplx, nsplx_adj, nsply_adj;
int nsubregion_col, nsubregion_row;
int subregion = 0, nsubregions = 0;
const char *dvr, *db, *mapset;
char table_name[GNAME_MAX];
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
double lambda, mean, stepN, stepE, HighThresh,
LowThresh;
double N_extension, E_extension, edgeE, edgeN;
int i, nterrain, count_terrain;
int last_row, last_column, flag_auxiliar = FALSE;
int *lineVect;
double *TN, *Q, *parVect; /* Interpolating and least-square vectors */
double **N, **obsVect, **obsVect_all; /* Interpolation and least-square matrix */
struct Map_info In, Out, Terrain;
struct Option *in_opt, *out_opt, *out_terrain_opt, *stepE_opt,
*stepN_opt, *lambda_f_opt, *Thresh_A_opt, *Thresh_B_opt;
struct Flag *spline_step_flag;
struct GModule *module;
struct Cell_head elaboration_reg, original_reg;
struct Reg_dimens dims;
struct bound_box general_box, overlap_box;
struct Point *observ;
struct lidar_cat *lcat;
dbDriver *driver;
/*----------------------------------------------------------------------------------------------------------*/
/* Options' declaration */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("LIDAR"));
module->description =
_("Corrects the v.lidar.growing output. It is the last of the three algorithms for LIDAR filtering.");
spline_step_flag = G_define_flag();
spline_step_flag->key = 'e';
spline_step_flag->label = _("Estimate point density and distance");
spline_step_flag->description =
_("Estimate point density and distance for the input vector points within the current region extends and quit");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
in_opt->description =
_("Input observation vector map name (v.lidar.growing output)");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->description = _("Output classified vector map name");
out_terrain_opt = G_define_option();
out_terrain_opt->key = "terrain";
out_terrain_opt->type = TYPE_STRING;
out_terrain_opt->key_desc = "name";
out_terrain_opt->required = YES;
out_terrain_opt->gisprompt = "new,vector,vector";
out_terrain_opt->description =
_("Only 'terrain' points output vector map");
stepE_opt = G_define_option();
stepE_opt->key = "ew_step";
stepE_opt->type = TYPE_DOUBLE;
stepE_opt->required = NO;
stepE_opt->answer = "25";
stepE_opt->description =
_("Length of each spline step in the east-west direction");
stepE_opt->guisection = _("Settings");
stepN_opt = G_define_option();
stepN_opt->key = "ns_step";
stepN_opt->type = TYPE_DOUBLE;
stepN_opt->required = NO;
stepN_opt->answer = "25";
stepN_opt->description =
_("Length of each spline step in the north-south direction");
stepN_opt->guisection = _("Settings");
lambda_f_opt = G_define_option();
lambda_f_opt->key = "lambda_c";
lambda_f_opt->type = TYPE_DOUBLE;
lambda_f_opt->required = NO;
lambda_f_opt->description =
_("Regularization weight in reclassification evaluation");
lambda_f_opt->answer = "1";
Thresh_A_opt = G_define_option();
Thresh_A_opt->key = "tch";
Thresh_A_opt->type = TYPE_DOUBLE;
Thresh_A_opt->required = NO;
Thresh_A_opt->description =
_("High threshold for object to terrain reclassification");
Thresh_A_opt->answer = "2";
Thresh_B_opt = G_define_option();
Thresh_B_opt->key = "tcl";
Thresh_B_opt->type = TYPE_DOUBLE;
Thresh_B_opt->required = NO;
Thresh_B_opt->description =
_("Low threshold for terrain to object reclassification");
Thresh_B_opt->answer = "1";
/* Parsing */
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
stepN = atof(stepN_opt->answer);
stepE = atof(stepE_opt->answer);
lambda = atof(lambda_f_opt->answer);
HighThresh = atof(Thresh_A_opt->answer);
LowThresh = atof(Thresh_B_opt->answer);
if (!(db = G_getenv_nofatal2("DB_DATABASE", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of database"));
if (!(dvr = G_getenv_nofatal2("DB_DRIVER", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of driver"));
/* Setting auxiliar table's name */
if (G_name_is_fully_qualified(out_opt->answer, xname, xmapset)) {
sprintf(table_name, "%s_aux", xname);
}
else
sprintf(table_name, "%s_aux", out_opt->answer);
/* Something went wrong in a previous v.lidar.correction execution */
if (db_table_exists(dvr, db, table_name)) {
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
db_set_error_handler_driver(driver);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Old auxiliar table could not be dropped"));
db_close_database_shutdown_driver(driver);
}
/* Checking vector names */
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
G_FATAL_EXIT);
/* Open input vector */
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
Vect_set_open_level(1); /* without topology */
if (1 > Vect_open_old(&In, in_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
/* Input vector must be 3D */
if (!Vect_is_3d(&In))
G_fatal_error(_("Input vector map <%s> is not 3D!"), in_opt->answer);
/* Estimate point density and mean distance for current region */
if (spline_step_flag->answer) {
double dens, dist;
if (P_estimate_splinestep(&In, &dens, &dist) == 0) {
G_message("Estimated point density: %.4g", dens);
G_message("Estimated mean distance between points: %.4g", dist);
}
else
G_warning(_("No points in current region!"));
Vect_close(&In);
exit(EXIT_SUCCESS);
}
/* Open output vector */
if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
}
if (0 > Vect_open_new(&Terrain, out_terrain_opt->answer, WITH_Z)) {
Vect_close(&In);
Vect_close(&Out);
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
}
/* Copy vector Head File */
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
Vect_copy_head_data(&In, &Terrain);
Vect_hist_copy(&In, &Terrain);
Vect_hist_command(&Terrain);
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
db_set_error_handler_driver(driver);
/* Create auxiliar table */
if ((flag_auxiliar =
P_Create_Aux2_Table(driver, table_name)) == FALSE) {
Vect_close(&In);
Vect_close(&Out);
Vect_close(&Terrain);
exit(EXIT_FAILURE);
}
db_create_index2(driver, table_name, "ID");
/* sqlite likes that ??? */
db_close_database_shutdown_driver(driver);
driver = db_start_driver_open_database(dvr, db);
/* Setting regions and boxes */
G_get_set_window(&original_reg);
G_get_set_window(&elaboration_reg);
Vect_region_box(&elaboration_reg, &overlap_box);
Vect_region_box(&elaboration_reg, &general_box);
/*------------------------------------------------------------------
| Subdividing and working with tiles:
| Each original region will be divided into several subregions.
| Each one will be overlaped by its neighbouring subregions.
| The overlapping is calculated as a fixed OVERLAP_SIZE times
| the largest spline step plus 2 * edge
----------------------------------------------------------------*/
/* Fixing parameters of the elaboration region */
P_zero_dim(&dims);
nsplx_adj = NSPLX_MAX;
nsply_adj = NSPLY_MAX;
if (stepN > stepE)
dims.overlap = OVERLAP_SIZE * stepN;
else
dims.overlap = OVERLAP_SIZE * stepE;
P_get_edge(P_BILINEAR, &dims, stepE, stepN);
P_set_dim(&dims, stepE, stepN, &nsplx_adj, &nsply_adj);
G_verbose_message(n_("adjusted EW spline %d",
"adjusted EW splines %d",
nsplx_adj), nsplx_adj);
G_verbose_message(n_("adjusted NS spline %d",
"adjusted NS splines %d",
nsply_adj), nsply_adj);
/* calculate number of subregions */
edgeE = dims.ew_size - dims.overlap - 2 * dims.edge_v;
edgeN = dims.sn_size - dims.overlap - 2 * dims.edge_h;
N_extension = original_reg.north - original_reg.south;
E_extension = original_reg.east - original_reg.west;
nsubregion_col = ceil(E_extension / edgeE) + 0.5;
nsubregion_row = ceil(N_extension / edgeN) + 0.5;
if (nsubregion_col < 0)
nsubregion_col = 0;
if (nsubregion_row < 0)
nsubregion_row = 0;
nsubregions = nsubregion_row * nsubregion_col;
elaboration_reg.south = original_reg.north;
last_row = FALSE;
while (last_row == FALSE) { /* For each row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_ROW);
if (elaboration_reg.north > original_reg.north) { /* First row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
FIRST_ROW);
}
if (elaboration_reg.south <= original_reg.south) { /* Last row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
LAST_ROW);
last_row = TRUE;
}
nsply =
ceil((elaboration_reg.north -
elaboration_reg.south) / stepN) + 0.5;
/*
if (nsply > NSPLY_MAX) {
nsply = NSPLY_MAX;
}
*/
G_debug(1, _("nsply = %d"), nsply);
elaboration_reg.east = original_reg.west;
last_column = FALSE;
while (last_column == FALSE) { /* For each column */
subregion++;
if (nsubregions > 1)
G_message(_("subregion %d of %d"), subregion, nsubregions);
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_COLUMN);
if (elaboration_reg.west < original_reg.west) { /* First column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, FIRST_COLUMN);
}
if (elaboration_reg.east >= original_reg.east) { /* Last column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, LAST_COLUMN);
last_column = TRUE;
}
nsplx =
ceil((elaboration_reg.east - elaboration_reg.west) / stepE) +
0.5;
/*
if (nsplx > NSPLX_MAX) {
nsplx = NSPLX_MAX;
}
*/
G_debug(1, _("nsplx = %d"), nsplx);
dim_vect = nsplx * nsply;
G_debug(1, _("read vector region map"));
observ =
P_Read_Vector_Correction(&In, &elaboration_reg, &npoints,
&nterrain, dim_vect, &lcat);
G_debug(5, _("npoints = %d, nterrain = %d"), npoints, nterrain);
if (npoints > 0) { /* If there is any point falling into elaboration_reg. */
count_terrain = 0;
nparameters = nsplx * nsply;
/* Mean calculation */
G_debug(3, _("Mean calculation"));
mean = P_Mean_Calc(&elaboration_reg, observ, npoints);
/*Least Squares system */
BW = P_get_BandWidth(P_BILINEAR, nsply); /* Bilinear interpolation */
N = G_alloc_matrix(nparameters, BW); /* Normal matrix */
TN = G_alloc_vector(nparameters); /* vector */
parVect = G_alloc_vector(nparameters); /* Bilinear parameters vector */
obsVect = G_alloc_matrix(nterrain + 1, 3); /* Observation vector with terrain points */
obsVect_all = G_alloc_matrix(npoints + 1, 3); /* Observation vector with all points */
Q = G_alloc_vector(nterrain + 1); /* "a priori" var-cov matrix */
lineVect = G_alloc_ivector(npoints + 1);
/* Setting obsVect vector & Q matrix */
G_debug(3, _("Only TERRAIN points"));
for (i = 0; i < npoints; i++) {
if (observ[i].cat == TERRAIN_SINGLE) {
obsVect[count_terrain][0] = observ[i].coordX;
obsVect[count_terrain][1] = observ[i].coordY;
obsVect[count_terrain][2] = observ[i].coordZ - mean;
Q[count_terrain] = 1; /* Q=I */
count_terrain++;
}
lineVect[i] = observ[i].lineID;
obsVect_all[i][0] = observ[i].coordX;
obsVect_all[i][1] = observ[i].coordY;
obsVect_all[i][2] = observ[i].coordZ - mean;
}
G_free(observ);
G_verbose_message(_("Bilinear interpolation"));
normalDefBilin(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, nterrain, nparameters,
BW);
nCorrectGrad(N, lambda, nsplx, nsply, stepE, stepN);
G_math_solver_cholesky_sband(N, parVect, TN, nparameters, BW);
G_free_matrix(N);
G_free_vector(TN);
G_free_vector(Q);
G_free_matrix(obsVect);
G_verbose_message( _("Correction and creation of terrain vector"));
P_Sparse_Correction(&In, &Out, &Terrain, &elaboration_reg,
general_box, overlap_box, obsVect_all, lcat,
parVect, lineVect, stepN, stepE,
dims.overlap, HighThresh, LowThresh,
nsplx, nsply, npoints, driver, mean, table_name);
G_free_vector(parVect);
G_free_matrix(obsVect_all);
G_free_ivector(lineVect);
}
else {
G_free(observ);
G_warning(_("No data within this subregion. "
"Consider changing the spline step."));
}
G_free(lcat);
} /*! END WHILE; last_column = TRUE */
} /*! END WHILE; last_row = TRUE */
/* Dropping auxiliar table */
if (npoints > 0) {
G_debug(1, _("Dropping <%s>"), table_name);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Auxiliar table could not be dropped"));
}
db_close_database_shutdown_driver(driver);
Vect_close(&In);
Vect_close(&Out);
Vect_close(&Terrain);
G_done_msg(" ");
exit(EXIT_SUCCESS);
} /*! END MAIN */
/*-------------------------------------------------------------------------------------------*/
int cross_correlation(struct Map_info *Map, double passWE, double passNS)
/*
Map: Vector map from which cross-crorrelation will take values
passWE: spline step in West-East direction
passNS: spline step in North-South direction
RETURN:
TRUE on success
FALSE on failure
*/
{
int bilin = TRUE; /*booleans */
int nsplx, nsply, nparam_spl, ndata;
double *mean, *rms, *stdev;
/* double lambda[PARAM_LAMBDA] = { 0.0001, 0.001, 0.01, 0.1, 1.0, 10.0 }; */ /* Fixed values (by the moment) */
double lambda[PARAM_LAMBDA] = { 0.0001, 0.001, 0.005, 0.01, 0.02, 0.05 }; /* Fixed values (by the moment) */
/* a more exhaustive search:
#define PARAM_LAMBDA 11
double lambda[PARAM_LAMBDA] = { 0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1.0, 5.0, 10.0 }; */
double *TN, *Q, *parVect; /* Interpolation and least-square vectors */
double **N, **obsVect; /* Interpolation and least-square matrix */
struct Point *observ;
struct Stats stat_vect;
/*struct line_pnts *points; */
/*struct line_cats *Cats; */
struct Cell_head region;
G_get_window(®ion);
extern int bspline_field;
extern char *bspline_column;
dbCatValArray cvarr;
G_debug(5,
"CrossCorrelation: Some tests using different lambda_i values will be done");
ndata = Vect_get_num_lines(Map);
if (ndata > NDATA_MAX)
G_warning(_("%d are too many points. "
"The cross validation would take too much time."), ndata);
/*points = Vect_new_line_struct (); */
/*Cats = Vect_new_cats_struct (); */
/* Current region is read and points recorded into observ */
observ = P_Read_Vector_Region_Map(Map, ®ion, &ndata, 1024, 1);
G_debug(5, "CrossCorrelation: %d points read in region. ", ndata);
G_verbose_message(_("%d points read in region"),
ndata);
if (ndata > 50)
G_warning(_("Maybe it takes too long. "
"It will depend on how many points you are considering."));
else
G_debug(5, "CrossCorrelation: It shouldn't take too long.");
if (ndata > 0) { /* If at least one point is in the region */
int i, j, lbd; /* lbd: lambda index */
int BW;
double mean_reg, *obs_mean;
int nrec, ctype = 0, verbosity;
struct field_info *Fi;
dbDriver *driver_cats;
mean = G_alloc_vector(PARAM_LAMBDA); /* Alloc as much mean, rms and stdev values as the total */
rms = G_alloc_vector(PARAM_LAMBDA); /* number of parameter used used for cross validation */
stdev = G_alloc_vector(PARAM_LAMBDA);
verbosity = G_verbose(); /* store for later reset */
/* Working with attributes */
if (bspline_field > 0) {
db_CatValArray_init(&cvarr);
Fi = Vect_get_field(Map, bspline_field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
bspline_field);
driver_cats =
db_start_driver_open_database(Fi->driver, Fi->database);
G_debug(1, _("CrossCorrelation: driver=%s db=%s"), Fi->driver,
Fi->database);
if (driver_cats == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
nrec =
db_select_CatValArray(driver_cats, Fi->table, Fi->key,
bspline_column, NULL, &cvarr);
G_debug(3, "nrec = %d", nrec);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type not supported"));
if (nrec < 0)
G_fatal_error(_("No records selected from table <%s> "),
Fi->table);
G_debug(1, "%d records selected from table",
nrec);
db_close_database_shutdown_driver(driver_cats);
}
/* Setting number of splines as a function of WE and SN spline steps */
nsplx = ceil((region.east - region.west) / passWE);
nsply = ceil((region.north - region.south) / passNS);
nparam_spl = nsplx * nsply; /* Total number of splines */
if (nparam_spl > 22900)
G_fatal_error(_("Too many splines (%d x %d). "
"Consider changing spline steps \"ew_step=\" \"ns_step=\"."),
nsplx, nsply);
BW = P_get_BandWidth(bilin, nsply);
/**/
/*Least Squares system */
N = G_alloc_matrix(nparam_spl, BW); /* Normal matrix */
TN = G_alloc_vector(nparam_spl); /* vector */
parVect = G_alloc_vector(nparam_spl); /* Parameters vector */
obsVect = G_alloc_matrix(ndata, 3); /* Observation vector */
Q = G_alloc_vector(ndata); /* "a priori" var-cov matrix */
obs_mean = G_alloc_vector(ndata);
stat_vect = alloc_Stats(ndata);
for (lbd = 0; lbd < PARAM_LAMBDA; lbd++) { /* For each lambda value */
G_message(_("Beginning cross validation with "
"lambda_i=%.4f ... (%d of %d)"), lambda[lbd],
lbd+1, PARAM_LAMBDA);
/*
How the cross correlation algorithm is done:
For each cycle, only the first ndata-1 "observ" elements are considered for the
interpolation. Within every interpolation mean is calculated to lowering edge
errors. The point left out will be used for an estimation. The error between the
estimation and the observation is recorded for further statistics.
At the end of the cycle, the last point, that is, the ndata-1 index, and the point
with j index are swapped.
*/
for (j = 0; j < ndata; j++) { /* Cross Correlation will use all ndata points */
double out_x, out_y, out_z; /* This point is left out */
for (i = 0; i < ndata; i++) { /* Each time, only the first ndata-1 points */
double dval; /* are considered in the interpolation */
/* Setting obsVect vector & Q matrix */
Q[i] = 1; /* Q=I */
obsVect[i][0] = observ[i].coordX;
obsVect[i][1] = observ[i].coordY;
if (bspline_field > 0) {
int cat, ival, ret;
/*type = Vect_read_line (Map, points, Cats, observ[i].lineID); */
/*if ( !(type & GV_POINTS ) ) continue; */
/*Vect_cat_get ( Cats, bspline_field, &cat ); */
cat = observ[i].cat;
if (cat < 0)
continue;
if (ctype == DB_C_TYPE_INT) {
ret =
db_CatValArray_get_value_int(&cvarr, cat,
&ival);
obsVect[i][2] = ival;
obs_mean[i] = ival;
}
else { /* DB_C_TYPE_DOUBLE */
ret =
db_CatValArray_get_value_double(&cvarr, cat,
&dval);
obsVect[i][2] = dval;
obs_mean[i] = dval;
}
if (ret != DB_OK) {
G_warning(_("No record for point (cat = %d)"),
cat);
continue;
}
}
else {
obsVect[i][2] = observ[i].coordZ;
obs_mean[i] = observ[i].coordZ;
}
} /* i index */
/* Mean calculation for every point less the last one */
mean_reg = calc_mean(obs_mean, ndata - 1);
for (i = 0; i < ndata; i++)
obsVect[i][2] -= mean_reg;
/* This is left out */
out_x = observ[ndata - 1].coordX;
out_y = observ[ndata - 1].coordY;
out_z = obsVect[ndata - 1][2];
if (bilin) { /* Bilinear interpolation */
normalDefBilin(N, TN, Q, obsVect, passWE, passNS, nsplx,
nsply, region.west, region.south,
ndata - 1, nparam_spl, BW);
nCorrectGrad(N, lambda[lbd], nsplx, nsply, passWE,
passNS);
}
else { /* Bicubic interpolation */
normalDefBicubic(N, TN, Q, obsVect, passWE, passNS, nsplx,
nsply, region.west, region.south,
ndata - 1, nparam_spl, BW);
nCorrectGrad(N, lambda[lbd], nsplx, nsply, passWE,
passNS);
}
/*
if (bilin) interpolation (&interp, P_BILINEAR);
else interpolation (&interp, P_BICUBIC);
*/
G_set_verbose(G_verbose_min());
G_math_solver_cholesky_sband(N, parVect, TN, nparam_spl, BW);
G_set_verbose(verbosity);
/* Estimation of j-point */
if (bilin)
stat_vect.estima[j] =
dataInterpolateBilin(out_x, out_y, passWE, passNS,
nsplx, nsply, region.west,
region.south, parVect);
else
stat_vect.estima[j] =
dataInterpolateBilin(out_x, out_y, passWE, passNS,
nsplx, nsply, region.west,
region.south, parVect);
/* Difference between estimated and observated i-point */
stat_vect.error[j] = out_z - stat_vect.estima[j];
G_debug(1, "CrossCorrelation: stat_vect.error[%d] = %lf", j,
stat_vect.error[j]);
/* Once the last value is left out, it is swapped with j-value */
observ = swap(observ, j, ndata - 1);
G_percent(j, ndata, 2);
}
mean[lbd] = calc_mean(stat_vect.error, stat_vect.n_points);
rms[lbd] =
calc_root_mean_square(stat_vect.error, stat_vect.n_points);
stdev[lbd] =
calc_standard_deviation(stat_vect.error, stat_vect.n_points);
G_message(_("Mean = %.5lf"), mean[lbd]);
G_message(_("Root Mean Square (RMS) = %.5lf"),
rms[lbd]);
G_message("---");
} /* ENDFOR each lambda value */
G_free_matrix(N);
G_free_vector(TN);
G_free_vector(Q);
G_free_matrix(obsVect);
G_free_vector(parVect);
#ifdef nodef
/*TODO: if the minimum lambda is wanted, the function declaration must be changed */
/* At this moment, consider rms only */
rms_min = find_minimum(rms, &lbd_min);
stdev_min = find_minimum(stdev, &lbd_min);
/* Writing some output */
G_message(_("Different number of splines and lambda_i values have "
"been taken for the cross correlation"));
G_message(_("The minimum value for the test (rms=%lf) was "
"obtained with: lambda_i = %.3f"),
rms_min,
lambda[lbd_min]);
*lambda_min = lambda[lbd_min];
#endif
G_message(_("Table of results:"));
fprintf(stdout, _(" lambda | mean | rms |\n"));
for (lbd = 0; lbd < PARAM_LAMBDA; lbd++) {
fprintf(stdout, " %9.5f | %10.4f | %10.4f |\n", lambda[lbd],
mean[lbd], rms[lbd]);
}
G_free_vector(mean);
G_free_vector(rms);
} /* ENDIF (ndata > 0) */
else
G_warning(_("No point lies into the current region"));
G_free(observ);
return TRUE;
}
int main(int argc, char *argv[])
{
const char *name;
const char *mapset;
long x, y;
double dx;
RASTER_MAP_TYPE map_type;
int i;
int from_stdin = FALSE;
struct GModule *module;
struct
{
struct Option *map, *fs, *cats, *vals, *raster, *file, *fmt_str,
*fmt_coeff;
} parm;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("category"));
module->description =
_("Manages category values and labels associated "
"with user-specified raster map layers.");
parm.map = G_define_standard_option(G_OPT_R_MAP);
parm.cats = G_define_standard_option(G_OPT_V_CATS);
parm.cats->multiple = YES;
parm.cats->guisection = _("Selection");
parm.vals = G_define_option();
parm.vals->key = "vals";
parm.vals->type = TYPE_DOUBLE;
parm.vals->multiple = YES;
parm.vals->required = NO;
parm.vals->label = _("Comma separated value list");
parm.vals->description = _("Example: 1.4,3.8,13");
parm.vals->guisection = _("Selection");
parm.fs = G_define_standard_option(G_OPT_F_SEP);
parm.fs->answer = "tab";
parm.raster = G_define_standard_option(G_OPT_R_INPUT);
parm.raster->key = "raster";
parm.raster->required = NO;
parm.raster->description =
_("Raster map from which to copy category table");
parm.raster->guisection = _("Define");
parm.file = G_define_standard_option(G_OPT_F_INPUT);
parm.file->key = "rules";
parm.file->required = NO;
parm.file->description =
_("File containing category label rules (or \"-\" to read from stdin)");
parm.file->guisection = _("Define");
parm.fmt_str = G_define_option();
parm.fmt_str->key = "format";
parm.fmt_str->type = TYPE_STRING;
parm.fmt_str->required = NO;
parm.fmt_str->label =
_("Default label or format string for dynamic labeling");
parm.fmt_str->description =
_("Used when no explicit label exists for the category");
parm.fmt_coeff = G_define_option();
parm.fmt_coeff->key = "coefficients";
parm.fmt_coeff->type = TYPE_DOUBLE;
parm.fmt_coeff->required = NO;
parm.fmt_coeff->key_desc = "mult1,offset1,mult2,offset2";
/* parm.fmt_coeff->answer = "0.0,0.0,0.0,0.0"; */
parm.fmt_coeff->label = _("Dynamic label coefficients");
parm.fmt_coeff->description =
_("Two pairs of category multiplier and offsets, for $1 and $2");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
name = parm.map->answer;
fs = G_option_to_separator(parm.fs);
mapset = G_find_raster2(name, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), name);
map_type = Rast_map_type(name, mapset);
/* create category labels */
if (parm.raster->answer || parm.file->answer ||
parm.fmt_str->answer || parm.fmt_coeff->answer) {
/* restrict editing to current mapset */
if (strcmp(mapset, G_mapset()) != 0)
G_fatal_error(_("Raster map <%s> not found in current mapset"),
name);
/* use cats from another map */
if (parm.raster->answer) {
int fd;
const char *cmapset;
cmapset = G_find_raster2(parm.raster->answer, "");
if (cmapset == NULL)
G_fatal_error(_("Raster map <%s> not found"),
parm.raster->answer);
fd = Rast_open_old(name, mapset);
Rast_init_cats("", &cats);
if (0 > Rast_read_cats(parm.raster->answer, cmapset, &cats))
G_fatal_error(_("Unable to read category file of raster map <%s@%s>"),
parm.raster->answer, cmapset);
Rast_write_cats(name, &cats);
G_message(_("Category table for <%s> set from <%s>"),
name, parm.raster->answer);
Rast_close(fd);
}
/* load cats from rules file */
if (parm.file->answer) {
FILE *fp;
char **tokens;
int ntokens;
char *e1;
char *e2;
if (strcmp("-", parm.file->answer) == 0) {
from_stdin = TRUE;
fp = stdin;
}
else {
fp = fopen(parm.file->answer, "r");
if (!fp)
G_fatal_error(_("Unable to open file <%s>"),
parm.file->answer);
}
Rast_init_cats("", &cats);
for (;;) {
char buf[1024];
DCELL d1, d2;
int parse_error = 0;
if (!G_getl2(buf, sizeof(buf), fp))
break;
tokens = G_tokenize(buf, fs);
ntokens = G_number_of_tokens(tokens);
if (ntokens == 3) {
d1 = strtod(tokens[0], &e1);
d2 = strtod(tokens[1], &e2);
if (*e1 == 0 && *e2 == 0)
Rast_set_d_cat(&d1, &d2, tokens[2], &cats);
else
parse_error = 1;
}
else if (ntokens == 2) {
d1 = strtod(tokens[0], &e1);
if (*e1 == 0)
Rast_set_d_cat(&d1, &d1, tokens[1], &cats);
else
parse_error = 1;
}
else if (!strlen(buf))
continue;
else
parse_error = 1;
if (parse_error)
G_fatal_error(_("Incorrect format of input rules. "
"Check separators. Invalid line is:\n%s"), buf);
}
G_free_tokens(tokens);
Rast_write_cats(name, &cats);
if (!from_stdin)
fclose(fp);
}
/* set dynamic cat rules for cats without explicit labels */
if (parm.fmt_str->answer || parm.fmt_coeff->answer) {
char *fmt_str;
double m1, a1, m2, a2;
/* read existing values */
Rast_init_cats("", &cats);
if (0 > Rast_read_cats(name, G_mapset(), &cats))
G_warning(_("Unable to read category file of raster map <%s@%s>"),
name, G_mapset());
if (parm.fmt_str->answer) {
fmt_str =
G_malloc(strlen(parm.fmt_str->answer) > strlen(cats.fmt)
? strlen(parm.fmt_str->answer) +
1 : strlen(cats.fmt) + 1);
strcpy(fmt_str, parm.fmt_str->answer);
}
else {
fmt_str = G_malloc(strlen(cats.fmt) + 1);
strcpy(fmt_str, cats.fmt);
}
m1 = cats.m1;
a1 = cats.a1;
m2 = cats.m2;
a2 = cats.a2;
if (parm.fmt_coeff->answer) {
m1 = atof(parm.fmt_coeff->answers[0]);
a1 = atof(parm.fmt_coeff->answers[1]);
m2 = atof(parm.fmt_coeff->answers[2]);
a2 = atof(parm.fmt_coeff->answers[3]);
}
Rast_set_cats_fmt(fmt_str, m1, a1, m2, a2, &cats);
Rast_write_cats(name, &cats);
}
Rast_free_cats(&cats);
exit(EXIT_SUCCESS);
}
else {
if (Rast_read_cats(name, mapset, &cats) < 0)
G_fatal_error(_("Unable to read category file of raster map <%s> in <%s>"),
name, mapset);
}
/* describe the category labels */
/* if no cats requested, use r.describe to get the cats */
if (parm.cats->answer == NULL) {
if (map_type == CELL_TYPE) {
get_cats(name, mapset);
while (next_cat(&x))
print_label(x);
exit(EXIT_SUCCESS);
}
}
else {
if (map_type != CELL_TYPE)
G_warning(_("The map is floating point! Ignoring cats list, using vals list"));
else { /* integer map */
for (i = 0; parm.cats->answers[i]; i++)
if (!scan_cats(parm.cats->answers[i], &x, &y)) {
G_usage();
exit(EXIT_FAILURE);
}
for (i = 0; parm.cats->answers[i]; i++) {
scan_cats(parm.cats->answers[i], &x, &y);
while (x <= y)
print_label(x++);
}
exit(EXIT_SUCCESS);
}
}
if (parm.vals->answer == NULL)
G_fatal_error(_("vals argument is required for floating point map!"));
for (i = 0; parm.vals->answers[i]; i++)
if (!scan_vals(parm.vals->answers[i], &dx)) {
G_usage();
exit(EXIT_FAILURE);
}
for (i = 0; parm.vals->answers[i]; i++) {
scan_vals(parm.vals->answers[i], &dx);
print_d_label(dx);
}
exit(EXIT_SUCCESS);
}
/* *************************************************************** */
int test_les(void)
{
N_spvector *spvector = NULL;
N_les *les = NULL;
N_les *sples = NULL;
int i, j;
les = N_alloc_les(TEST_N_NUM_ROWS, N_NORMAL_LES);
N_print_les(les);
N_free_les(les);
les = N_alloc_les_A(TEST_N_NUM_ROWS, N_NORMAL_LES);
N_print_les(les);
N_free_les(les);
les = N_alloc_les_Ax(TEST_N_NUM_ROWS, N_NORMAL_LES);
N_print_les(les);
N_free_les(les);
les = N_alloc_les_Ax_b(TEST_N_NUM_ROWS, N_NORMAL_LES);
N_print_les(les);
N_free_les(les);
les = N_alloc_nquad_les(6, 3, N_NORMAL_LES);
N_print_les(les);
N_free_les(les);
les = N_alloc_nquad_les_A(6, 3, N_NORMAL_LES);
N_print_les(les);
N_free_les(les);
les = N_alloc_nquad_les_Ax(6, 3, N_NORMAL_LES);
N_print_les(les);
N_free_les(les);
les = N_alloc_nquad_les_Ax_b(6, 3, N_NORMAL_LES);
N_print_les(les);
N_free_les(les);
les = N_alloc_les(TEST_N_NUM_ROWS, N_NORMAL_LES);
sples = N_alloc_les(TEST_N_NUM_ROWS, N_SPARSE_LES);
G_message(_("\t * testing les creation in parallel\n"));
#pragma omp parallel for private(i, j) shared(les)
for (i = 0; i < TEST_N_NUM_ROWS; i++) {
for (j = 0; j < TEST_N_NUM_ROWS; j++) {
if (i != j)
les->A[i][j] = 2e-2;
les->A[i][i] = -1e2 - i;
}
les->x[i] = 273.15 + i;
les->b[i] = 1e2 - i;
}
#pragma omp parallel for private(i, j) shared(sples, spvector)
for (i = 0; i < TEST_N_NUM_ROWS; i++) {
spvector = N_alloc_spvector(TEST_N_NUM_ROWS);
for (j = 0; j < TEST_N_NUM_ROWS; j++)
if (i != j)
spvector->index[j] = 2e-2;
spvector->index[0] = i;
spvector->values[0] = -1e2 - i;
N_add_spvector_to_les(sples, spvector, i);
sples->x[i] = 273.15 + i;
sples->b[i] = 1e2 - i;
}
N_free_les(les);
N_free_les(sples);
G_message(_("\t * testing les creation in serial\n"));
les = N_alloc_les(TEST_N_NUM_ROWS, N_NORMAL_LES);
sples = N_alloc_les(TEST_N_NUM_ROWS, N_SPARSE_LES);
for (i = 0; i < TEST_N_NUM_ROWS; i++) {
for (j = 0; j < TEST_N_NUM_ROWS; j++) {
if (i != j)
les->A[i][j] = 2e-2;
les->A[i][i] = -1e2 - i;
}
les->x[i] = 273.15 + i;
les->b[i] = 1e2 - i;
}
for (i = 0; i < TEST_N_NUM_ROWS; i++) {
spvector = N_alloc_spvector(TEST_N_NUM_ROWS);
for (j = 0; j < TEST_N_NUM_ROWS; j++)
if (i != j)
spvector->index[j] = 2e-2;
spvector->index[0] = i;
spvector->values[0] = -1e2 - i;
N_add_spvector_to_les(sples, spvector, i);
sples->x[i] = 273.15 + i;
sples->b[i] = 1e2 - i;
}
N_free_les(les);
N_free_les(sples);
return 0;
}
int do_astar(void)
{
int r, c, r_nbr, c_nbr, ct_dir;
GW_LARGE_INT first_cum, count;
int nextdr[8] = { 1, -1, 0, 0, -1, 1, 1, -1 };
int nextdc[8] = { 0, 0, -1, 1, 1, -1, 1, -1 };
CELL ele_val, ele_up, ele_nbr[8];
WAT_ALT wa;
ASP_FLAG af;
char is_in_list, is_worked;
HEAP_PNT heap_p;
/* sides
* |7|1|4|
* |2| |3|
* |5|0|6|
*/
int nbr_ew[8] = { 0, 1, 2, 3, 1, 0, 0, 1 };
int nbr_ns[8] = { 0, 1, 2, 3, 3, 2, 3, 2 };
double dx, dy, dist_to_nbr[8], ew_res, ns_res;
double slope[8];
struct Cell_head window;
int skip_diag;
count = 0;
first_cum = n_points;
G_message(_("A* Search..."));
Rast_get_window(&window);
for (ct_dir = 0; ct_dir < sides; ct_dir++) {
/* get r, c (r_nbr, c_nbr) for neighbours */
r_nbr = nextdr[ct_dir];
c_nbr = nextdc[ct_dir];
/* account for rare cases when ns_res != ew_res */
dy = abs(r_nbr) * window.ns_res;
dx = abs(c_nbr) * window.ew_res;
if (ct_dir < 4)
dist_to_nbr[ct_dir] = dx + dy;
else
dist_to_nbr[ct_dir] = sqrt(dx * dx + dy * dy);
}
ew_res = window.ew_res;
ns_res = window.ns_res;
while (heap_size > 0) {
G_percent(count++, n_points, 1);
if (count > n_points)
G_fatal_error(_("%lld surplus points"),
heap_size);
if (heap_size > n_points)
G_fatal_error
(_("Too many points in heap %lld, should be %lld"),
heap_size, n_points);
heap_p = heap_drop();
r = heap_p.pnt.r;
c = heap_p.pnt.c;
ele_val = heap_p.ele;
for (ct_dir = 0; ct_dir < sides; ct_dir++) {
/* get r, c (r_nbr, c_nbr) for neighbours */
r_nbr = r + nextdr[ct_dir];
c_nbr = c + nextdc[ct_dir];
slope[ct_dir] = ele_nbr[ct_dir] = 0;
skip_diag = 0;
/* check that neighbour is within region */
if (r_nbr < 0 || r_nbr >= nrows || c_nbr < 0 || c_nbr >= ncols)
continue;
seg_get(&aspflag, (char *)&af, r_nbr, c_nbr);
is_in_list = FLAG_GET(af.flag, INLISTFLAG);
is_worked = FLAG_GET(af.flag, WORKEDFLAG);
if (!is_worked) {
seg_get(&watalt, (char *)&wa, r_nbr, c_nbr);
ele_nbr[ct_dir] = wa.ele;
slope[ct_dir] = get_slope(ele_val, ele_nbr[ct_dir],
dist_to_nbr[ct_dir]);
}
/* avoid diagonal flow direction bias */
if (!is_in_list) {
if (ct_dir > 3 && slope[ct_dir] > 0) {
if (slope[nbr_ew[ct_dir]] > 0) {
/* slope to ew nbr > slope to center */
if (slope[ct_dir] <
get_slope(ele_nbr[nbr_ew[ct_dir]],
ele_nbr[ct_dir], ew_res))
skip_diag = 1;
}
if (!skip_diag && slope[nbr_ns[ct_dir]] > 0) {
/* slope to ns nbr > slope to center */
if (slope[ct_dir] <
get_slope(ele_nbr[nbr_ns[ct_dir]],
ele_nbr[ct_dir], ns_res))
skip_diag = 1;
}
}
}
if (!skip_diag) {
if (is_in_list == 0) {
ele_up = ele_nbr[ct_dir];
af.asp = drain[r_nbr - r + 1][c_nbr - c + 1];
heap_add(r_nbr, c_nbr, ele_up);
FLAG_SET(af.flag, INLISTFLAG);
seg_put(&aspflag, (char *)&af, r_nbr, c_nbr);
}
else if (is_in_list && is_worked == 0) {
if (FLAG_GET(af.flag, EDGEFLAG)) {
/* neighbour is edge in list, not yet worked */
if (af.asp < 0) {
/* adjust flow direction for edge cell */
af.asp = drain[r_nbr - r + 1][c_nbr - c + 1];
seg_put(&aspflag, (char *)&af, r_nbr, c_nbr);
}
}
else if (FLAG_GET(af.flag, DEPRFLAG)) {
G_debug(3, "real depression");
/* neighbour is inside real depression, not yet worked */
if (af.asp == 0 && ele_val <= ele_nbr[ct_dir]) {
af.asp = drain[r_nbr - r + 1][c_nbr - c + 1];
FLAG_UNSET(af.flag, DEPRFLAG);
seg_put(&aspflag, (char *)&af, r_nbr, c_nbr);
}
}
}
}
} /* end neighbours */
/* add astar points to sorted list for flow accumulation and stream extraction */
first_cum--;
seg_put(&astar_pts, (char *)&heap_p.pnt, 0, first_cum);
seg_get(&aspflag, (char *)&af, r, c);
FLAG_SET(af.flag, WORKEDFLAG);
seg_put(&aspflag, (char *)&af, r, c);
} /* end A* search */
G_percent(n_points, n_points, 1); /* finish it */
return 1;
}
int open_file(char *name)
{
int cell_file, buf_len;
int i, row;
CELL *buf;
/* open raster map */
cell_file = Rast_open_old(name, "");
if (Rast_get_map_type(cell_file) != CELL_TYPE) {
Rast_close(cell_file);
G_fatal_error(_("Input raster must be of type CELL."));
}
n_rows = Rast_window_rows();
n_cols = Rast_window_cols();
G_message(_("File %s -- %d rows X %d columns"), name, n_rows, n_cols);
n_cols += (PAD << 1);
/* copy raster map into our read/write file */
work_file_name = G_tempfile();
/* create the file and then open it for read and write */
close(creat(work_file_name, 0666));
if ((work_file = open(work_file_name, 2)) < 0) {
unlink(work_file_name);
G_fatal_error(_("%s: Unable to create temporary file <%s> -- errno = %d"),
error_prefix, work_file_name, errno);
}
buf_len = n_cols * sizeof(CELL);
buf = (CELL *) G_malloc(buf_len);
Rast_set_c_null_value(buf, n_cols);
for (i = 0; i < PAD; i++) {
if (write(work_file, buf, buf_len) != buf_len) {
unlink(work_file_name);
G_fatal_error(_("%s: Error writing temporary file"),
error_prefix);
}
}
for (row = 0; row < n_rows; row++) {
Rast_get_c_row(cell_file, buf + PAD, row);
if (write(work_file, buf, buf_len) != buf_len) {
unlink(work_file_name);
G_fatal_error(_("%s: Error writing temporary file"),
error_prefix);
}
}
Rast_set_c_null_value(buf, n_cols);
for (i = 0; i < PAD; i++) {
if (write(work_file, buf, buf_len) != buf_len) {
unlink(work_file_name);
G_fatal_error(_("%s: Error writing temporary file"),
error_prefix);
}
}
n_rows += (PAD << 1);
G_free(buf);
Rast_close(cell_file);
Rowio_setup(&row_io, work_file, MAX_ROW, n_cols * sizeof(CELL), read_row,
write_row);
return 0;
}
int main(int argc, char *argv[])
{
char command[GPATH_MAX];
int err, ret;
struct Option *opt1;
struct Option *opt2;
struct Option *opt3;
struct Option *opt4;
struct Option *opt5;
struct Option *opt6;
struct Option *opt7;
struct Option *opt8;
struct Option *opt9;
struct Option *opt10;
struct Option *opt11;
struct Option *opt12;
struct Option *opt13;
struct Option *opt14;
struct Option *opt15;
struct Option *opt16;
struct Flag *flag_sfd;
struct Flag *flag_flow;
struct Flag *flag_seg;
struct Flag *flag_abs;
struct Flag *flag_flat;
struct GModule *module;
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("hydrology"));
module->description = _("Calculates hydrological parameters and RUSLE factors.");
opt1 = G_define_standard_option(G_OPT_R_ELEV);
opt1->guisection = _("Inputs");
opt2 = G_define_standard_option(G_OPT_R_INPUT);
opt2->key = "depression";
opt2->label = _("Name of input depressions raster map");
opt2->description = _("All non-NULL and non-zero cells are considered as real depressions");
opt2->required = NO;
opt2->guisection = _("Inputs");
opt3 = G_define_standard_option(G_OPT_R_INPUT);
opt3->key = "flow";
opt3->description = _("Name of input raster representing amount of overland flow per cell");
opt3->required = NO;
opt3->guisection = _("Inputs");
opt4 = G_define_standard_option(G_OPT_R_INPUT);
opt4->key = "disturbed_land";
opt4->label = _("Name of input raster map percent of disturbed land");
opt4->description = _("For USLE");
opt4->required = NO;
opt4->guisection = _("Inputs");
opt5 = G_define_standard_option(G_OPT_R_INPUT);
opt5->key = "blocking";
opt5->label =
_("IName of input raster map blocking overland surface flow");
opt5->description =
_("For USLE. All non-NULL and non-zero cells are considered as blocking terrain.");
opt5->required = NO;
opt5->guisection = _("Inputs");
opt6 = G_define_option();
opt6->key = "threshold";
opt6->description =
_("Minimum size of exterior watershed basin");
opt6->required = NO;
opt6->type = TYPE_INTEGER;
opt6->guisection = _("Inputs");
opt7 = G_define_option();
opt7->key = "max_slope_length";
opt7->label =
_("Maximum length of surface flow in map units");
opt7->description = _("For USLE");
opt7->required = NO;
opt7->type = TYPE_DOUBLE;
opt7->guisection = _("Inputs");
opt8 = G_define_standard_option(G_OPT_R_OUTPUT);
opt8->key = "accumulation";
opt8->label =
_("Name for output accumulation raster map");
opt8->description =
_("Number of cells that drain through each cell");
opt8->required = NO;
opt8->guisection = _("Outputs");
opt9 = G_define_standard_option(G_OPT_R_OUTPUT);
opt9->key = "drainage";
opt9->description = _("Name for output drainage direction raster map");
opt9->required = NO;
opt9->guisection = _("Outputs");
opt10 = G_define_standard_option(G_OPT_R_OUTPUT);
opt10->key = "basin";
opt10->description =
_("Name for basins raster map");
opt10->description = _("Unique label for each watershed basin");
opt10->required = NO;
opt10->guisection = _("Outputs");
opt11 = G_define_standard_option(G_OPT_R_OUTPUT);
opt11->key = "stream";
opt11->description = _("Name for output stream segments raster map");
opt11->required = NO;
opt11->guisection = _("Outputs");
opt12 = G_define_standard_option(G_OPT_R_OUTPUT);
opt12->key = "half_basin";
opt12->label = _("Name for output half basins raster map");
opt12->description =
_("Each half-basin is given a unique value");
opt12->required = NO;
opt12->guisection = _("Outputs");
opt13 = G_define_standard_option(G_OPT_R_OUTPUT);
opt13->key = "length_slope";
opt13->label = _("Name for output slope length raster map");
opt13->description =
_("Slope length and steepness (LS) factor for USLE");
opt13->required = NO;
opt13->guisection = _("Outputs");
opt14 = G_define_standard_option(G_OPT_R_OUTPUT);
opt14->key = "slope_steepness";
opt14->label = _("Name for output slope steepness raster map");
opt14->description = _("Slope steepness (S) factor for USLE");
opt14->required = NO;
opt14->guisection = _("Outputs");
opt15 = G_define_option();
opt15->key = "convergence";
opt15->type = TYPE_INTEGER;
opt15->required = NO;
opt15->answer = "5";
opt15->label = _("Convergence factor for MFD (1-10)");
opt15->description =
_("1 = most diverging flow, 10 = most converging flow. Recommended: 5");
opt16 = G_define_option();
opt16->key = "memory";
opt16->type = TYPE_INTEGER;
opt16->required = NO;
opt16->answer = "300"; /* 300MB default value, please keep r.terraflow in sync */
opt16->description = _("Maximum memory to be used with -m flag (in MB)");
flag_sfd = G_define_flag();
flag_sfd->key = 's';
flag_sfd->label = _("SFD (D8) flow (default is MFD)");
flag_sfd->description =
_("SFD: single flow direction, MFD: multiple flow direction");
flag_flow = G_define_flag();
flag_flow->key = '4';
flag_flow->description =
_("Allow only horizontal and vertical flow of water");
flag_seg = G_define_flag();
flag_seg->key = 'm';
flag_seg->label =
_("Enable disk swap memory option: Operation is slow");
flag_seg->description =
_("Only needed if memory requirements exceed available RAM; see manual on how to calculate memory requirements");
flag_abs = G_define_flag();
flag_abs->key = 'a';
flag_abs->label =
_("Use positive flow accumulation even for likely underestimates");
flag_abs->description =
_("See manual for a detailed description of flow accumulation output");
flag_flat = G_define_flag();
flag_flat->key = 'b';
flag_flat->label =
_("Beautify flat areas");
flag_flat->description =
_("Flow direction in flat areas is modified to look prettier");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* Check option combinations */
/* Check for some output map */
if ((opt8->answer == NULL)
&& (opt9->answer == NULL)
&& (opt10->answer == NULL)
&& (opt11->answer == NULL)
&& (opt12->answer == NULL)
&& (opt14->answer == NULL)
&& (opt15->answer == NULL)) {
G_fatal_error(_("Sorry, you must choose an output map."));
}
err = 0;
/* basin and basin threshold */
err += (opt10->answer != NULL && opt6->answer == NULL);
/* stream and basin threshold */
err += (opt11->answer != NULL && opt6->answer == NULL);
/* half_basin and basin threshold */
err += (opt12->answer != NULL && opt6->answer == NULL);
/* LS factor and basin threshold */
err += (opt13->answer != NULL && opt6->answer == NULL);
/* S factor and basin threshold */
err += (opt14->answer != NULL && opt6->answer == NULL);
if (err) {
G_message(_("Sorry, if any of the following options are set:\n"
" basin, stream, half_basin, length_slope, or slope_steepness\n"
" you MUST provide a value for the basin "
"threshold parameter."));
G_usage();
exit(EXIT_FAILURE);
}
/* Build command line */
sprintf(command, "%s/etc/r.watershed.%s",
G_gisbase(),
flag_seg->answer ? "seg" : "ram");
new_argv[new_argc++] = command;
if (flag_sfd->answer)
new_argv[new_argc++] = "-s";
if (flag_flow->answer)
new_argv[new_argc++] = "-4";
if (flag_abs->answer)
new_argv[new_argc++] = "-a";
if (flag_flat->answer && !flag_seg->answer)
new_argv[new_argc++] = "-b";
if (flag_flat->answer && flag_seg->answer)
G_message(_("Beautify flat areas is not yet supported for disk swap mode"));
do_opt(opt1);
do_opt(opt2);
do_opt(opt3);
do_opt(opt4);
do_opt(opt5);
do_opt(opt6);
do_opt(opt7);
do_opt(opt8);
do_opt(opt9);
do_opt(opt10);
do_opt(opt11);
do_opt(opt12);
do_opt(opt13);
do_opt(opt14);
do_opt(opt15);
if (flag_seg->answer)
do_opt(opt16);
new_argv[new_argc++] = NULL;
G_debug(1, "Mode: %s", flag_seg->answer ? "Segmented" : "All in RAM");
ret = G_vspawn_ex(new_argv[0], new_argv);
if (ret != EXIT_SUCCESS)
G_warning(_("Subprocess failed with exit code %d"), ret);
/* record map metadata/history info */
if (opt8->answer)
write_hist(opt8->answer,
"Watershed accumulation: overland flow that traverses each cell",
opt1->answer, flag_seg->answer, flag_sfd->answer);
if (opt9->answer)
write_hist(opt9->answer,
"Watershed drainage direction (CCW from East divided by 45deg)",
opt1->answer, flag_seg->answer, flag_sfd->answer);
if (opt10->answer)
write_hist(opt10->answer,
"Watershed basins", opt1->answer, flag_seg->answer,
flag_sfd->answer);
if (opt11->answer)
write_hist(opt11->answer,
"Watershed stream segments", opt1->answer,
flag_seg->answer, flag_sfd->answer);
if (opt12->answer)
write_hist(opt12->answer,
"Watershed half-basins", opt1->answer, flag_seg->answer,
flag_sfd->answer);
if (opt13->answer)
write_hist(opt13->answer,
"Watershed slope length and steepness (LS) factor",
opt1->answer, flag_seg->answer, flag_sfd->answer);
if (opt14->answer)
write_hist(opt14->answer,
"Watershed slope steepness (S) factor",
opt1->answer, flag_seg->answer, flag_sfd->answer);
exit(ret);
}
/* ************************************************************************* */
int main(int argc, char *argv[])
{
RASTER3D_Region region, inputmap_bounds;
struct Cell_head region2d;
struct GModule *module;
struct History history;
void *map = NULL; /*The 3D Rastermap */
int i = 0, changemask = 0;
int *fd = NULL, output_type, cols, rows;
char *RasterFileName;
int overwrite = 0;
/* Initialize GRASS */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("conversion"));
G_add_keyword(_("raster"));
G_add_keyword(_("voxel"));
module->description = _("Converts 3D raster maps to 2D raster maps");
/* Get parameters from user */
set_params();
/* Have GRASS get inputs */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_debug(3, "Open 3D raster map <%s>", param.input->answer);
if (NULL == G_find_raster3d(param.input->answer, ""))
Rast3d_fatal_error(_("3D raster map <%s> not found"),
param.input->answer);
/*Set the defaults */
Rast3d_init_defaults();
/*Set the resolution of the output maps */
if (param.res->answer) {
/*Open the map with current region */
map = Rast3d_open_cell_old(param.input->answer,
G_find_raster3d(param.input->answer, ""),
RASTER3D_DEFAULT_WINDOW, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (map == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
param.input->answer);
/*Get the region of the map */
Rast3d_get_region_struct_map(map, ®ion);
/*set this region as current 3D window for map */
Rast3d_set_window_map(map, ®ion);
/*Set the 2d region appropriate */
Rast3d_extract2d_region(®ion, ®ion2d);
/*Make the new 2d region the default */
Rast_set_window(®ion2d);
} else {
/* Figure out the region from the map */
Rast3d_get_window(®ion);
/*Open the 3d raster map */
map = Rast3d_open_cell_old(param.input->answer,
G_find_raster3d(param.input->answer, ""),
®ion, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (map == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
param.input->answer);
}
/*Check if the g3d-region is equal to the 2D rows and cols */
rows = Rast_window_rows();
cols = Rast_window_cols();
/*If not equal, set the 3D window correct */
if (rows != region.rows || cols != region.cols) {
G_message(_("The 2D and 3D region settings are different. "
"Using the 2D window settings to adjust the 2D part of the 3D region."));
G_get_set_window(®ion2d);
region.ns_res = region2d.ns_res;
region.ew_res = region2d.ew_res;
region.rows = region2d.rows;
region.cols = region2d.cols;
Rast3d_adjust_region(®ion);
Rast3d_set_window_map(map, ®ion);
}
/* save the input map region for later use (history meta-data) */
Rast3d_get_region_struct_map(map, &inputmap_bounds);
/*Get the output type */
output_type = Rast3d_file_type_map(map);
/*prepare the filehandler */
fd = (int *) G_malloc(region.depths * sizeof (int));
if (fd == NULL)
fatal_error(map, NULL, 0, _("Out of memory"));
G_message(_("Creating %i raster maps"), region.depths);
/*Loop over all output maps! open */
for (i = 0; i < region.depths; i++) {
/*Create the outputmaps */
G_asprintf(&RasterFileName, "%s_%05d", param.output->answer, i + 1);
G_message(_("Raster map %i Filename: %s"), i + 1, RasterFileName);
overwrite = G_check_overwrite(argc, argv);
if (G_find_raster2(RasterFileName, "") && !overwrite)
G_fatal_error(_("Raster map %d Filename: %s already exists. Use the flag --o to overwrite."),
i + 1, RasterFileName);
if (output_type == FCELL_TYPE)
fd[i] = open_output_map(RasterFileName, FCELL_TYPE);
else if (output_type == DCELL_TYPE)
fd[i] = open_output_map(RasterFileName, DCELL_TYPE);
}
/*if requested set the Mask on */
if (param.mask->answer) {
if (Rast3d_mask_file_exists()) {
changemask = 0;
if (Rast3d_mask_is_off(map)) {
Rast3d_mask_on(map);
changemask = 1;
}
}
}
/*Create the Rastermaps */
g3d_to_raster(map, region, fd);
/*Loop over all output maps! close */
for (i = 0; i < region.depths; i++) {
close_output_map(fd[i]);
/* write history */
G_asprintf(&RasterFileName, "%s_%i", param.output->answer, i + 1);
G_debug(4, "Raster map %d Filename: %s", i + 1, RasterFileName);
Rast_short_history(RasterFileName, "raster", &history);
Rast_set_history(&history, HIST_DATSRC_1, "3D Raster map:");
Rast_set_history(&history, HIST_DATSRC_2, param.input->answer);
Rast_append_format_history(&history, "Level %d of %d", i + 1, region.depths);
Rast_append_format_history(&history, "Level z-range: %f to %f",
region.bottom + (i * region.tb_res),
region.bottom + (i + 1 * region.tb_res));
Rast_append_format_history(&history, "Input map full z-range: %f to %f",
inputmap_bounds.bottom, inputmap_bounds.top);
Rast_append_format_history(&history, "Input map z-resolution: %f",
inputmap_bounds.tb_res);
if (!param.res->answer) {
Rast_append_format_history(&history, "GIS region full z-range: %f to %f",
region.bottom, region.top);
Rast_append_format_history(&history, "GIS region z-resolution: %f",
region.tb_res);
}
Rast_command_history(&history);
Rast_write_history(RasterFileName, &history);
}
/*We set the Mask off, if it was off before */
if (param.mask->answer) {
if (Rast3d_mask_file_exists())
if (Rast3d_mask_is_on(map) && changemask)
Rast3d_mask_off(map);
}
/*Cleaning */
if (RasterFileName)
G_free(RasterFileName);
if (fd)
G_free(fd);
/* Close files and exit */
if (!Rast3d_close(map))
fatal_error(map, NULL, 0, _("Unable to close 3D raster map"));
map = NULL;
return (EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Map_info In, Out;
static struct line_pnts *Points;
struct line_cats *Cats;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out;
struct Option *method_opt, *afield_opt, *nfield_opt, *abcol,
*afcol, *ncol;
struct Flag *add_f;
int with_z;
int afield, nfield, mask_type;
dglGraph_s *graph;
int *component, nnodes, type, i, nlines, components, max_cat;
char buf[2000], *covered;
char *desc;
/* Attribute table */
dbString sql;
dbDriver *driver;
struct field_info *Fi;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("network"));
G_add_keyword(_("components"));
module->description =
_("Computes strongly and weakly connected components in the network.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
afield_opt = G_define_standard_option(G_OPT_V_FIELD);
afield_opt->key = "arc_layer";
afield_opt->answer = "1";
afield_opt->label = _("Arc layer");
afield_opt->guisection = _("Cost");
nfield_opt = G_define_standard_option(G_OPT_V_FIELD);
nfield_opt->key = "node_layer";
nfield_opt->answer = "2";
nfield_opt->label = _("Node layer");
nfield_opt->guisection = _("Cost");
afcol = G_define_standard_option(G_OPT_DB_COLUMN);
afcol->key = "arc_column";
afcol->required = NO;
afcol->description =
_("Arc forward/both direction(s) cost column (number)");
afcol->guisection = _("Cost");
abcol = G_define_standard_option(G_OPT_DB_COLUMN);
abcol->key = "arc_backward_column";
abcol->required = NO;
abcol->description = _("Arc backward direction cost column (number)");
abcol->guisection = _("Cost");
ncol = G_define_option();
ncol->key = "node_column";
ncol->type = TYPE_STRING;
ncol->required = NO;
ncol->description = _("Node cost column (number)");
ncol->guisection = _("Cost");
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->multiple = NO;
method_opt->options = "weak,strong";
desc = NULL;
G_asprintf(&desc,
"weak;%s;strong;%s",
_("Weakly connected components"),
_("Strongly connected components"));
method_opt->descriptions = desc;
method_opt->description = _("Type of components");
add_f = G_define_flag();
add_f->key = 'a';
add_f->description = _("Add points on nodes");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* TODO: make an option for this */
mask_type = GV_LINE | GV_BOUNDARY;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_check_input_output_name(map_in->answer, map_out->answer,
G_FATAL_EXIT);
Vect_set_open_level(2);
if (1 > Vect_open_old(&In, map_in->answer, ""))
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, map_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), map_out->answer);
}
/* parse filter option and select appropriate lines */
afield = Vect_get_field_number(&In, afield_opt->answer);
nfield = Vect_get_field_number(&In, nfield_opt->answer);
if (0 != Vect_net_build_graph(&In, mask_type, afield, nfield, afcol->answer,
abcol->answer, ncol->answer, 0, 2))
G_fatal_error(_("Unable to build graph for vector map <%s>"), Vect_get_full_name(&In));
graph = Vect_net_get_graph(&In);
nnodes = Vect_get_num_nodes(&In);
component = (int *)G_calloc(nnodes + 1, sizeof(int));
covered = (char *)G_calloc(nnodes + 1, sizeof(char));
if (!component || !covered) {
G_fatal_error(_("Out of memory"));
exit(EXIT_FAILURE);
}
/* Create table */
Fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, GV_KEY_COLUMN, Fi->database,
Fi->driver);
db_init_string(&sql);
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
sprintf(buf, "create table %s ( cat integer, comp integer)", Fi->table);
db_set_string(&sql, buf);
G_debug(2, "%s", db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
db_close_database_shutdown_driver(driver);
G_fatal_error(_("Unable to create table: '%s'"), db_get_string(&sql));
}
if (db_create_index2(driver, Fi->table, GV_KEY_COLUMN) != DB_OK)
G_warning(_("Cannot create index"));
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Cannot grant privileges on table <%s>"), Fi->table);
db_begin_transaction(driver);
if (method_opt->answer[0] == 'w') {
G_message(_("Computing weakly connected components..."));
components = NetA_weakly_connected_components(graph, component);
}
else {
G_message(_("Computing strongly connected components..."));
components = NetA_strongly_connected_components(graph, component);
}
G_debug(3, "Components: %d", components);
G_message(_("Writing output..."));
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
nlines = Vect_get_num_lines(&In);
max_cat = 1;
G_percent(0, nlines, 4);
for (i = 1; i <= nlines; i++) {
int comp, cat;
G_percent(i, nlines, 4);
type = Vect_read_line(&In, Points, Cats, i);
if (!Vect_cat_get(Cats, afield, &cat))
continue;
if (type == GV_LINE || type == GV_BOUNDARY) {
int node1, node2;
Vect_get_line_nodes(&In, i, &node1, &node2);
if (component[node1] == component[node2]) {
comp = component[node1];
}
else {
continue;
}
}
else if (type == GV_POINT) {
int node;
/* Vect_get_line_nodes(&In, i, &node, NULL); */
node = Vect_find_node(&In, Points->x[0], Points->y[0], Points->z[0], 0, 0);
if (!node)
continue;
comp = component[node];
covered[node] = 1;
}
else
continue;
cat = max_cat++;
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, cat);
Vect_write_line(&Out, type, Points, Cats);
insert_new_record(driver, Fi, &sql, cat, comp);
}
/*add points on nodes not covered by any point in the network */
if (add_f->answer) {
for (i = 1; i <= nnodes; i++)
if (!covered[i]) {
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, max_cat);
NetA_add_point_on_node(&In, &Out, i, Cats);
insert_new_record(driver, Fi, &sql, max_cat++, component[i]);
}
}
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
Vect_close(&In);
Vect_build(&Out);
Vect_close(&Out);
G_done_msg(_("Found %d components."), components);
exit(EXIT_SUCCESS);
}
