int close_file(char *name)
{
int cell_file, row, k;
int row_count, col_count;
CELL *buf;
cell_file = Rast_open_c_new(name);
row_count = n_rows - (PAD << 1);
col_count = n_cols - (PAD << 1);
G_message(_("Output file %d rows X %d columns"), row_count, col_count);
G_message(_("Window %d rows X %d columns"), Rast_window_rows(),
Rast_window_cols());
for (row = 0, k = PAD; row < row_count; row++, k++) {
buf = get_a_row(k);
Rast_put_row(cell_file, buf + PAD, CELL_TYPE);
}
Rast_close(cell_file);
Rowio_flush(&row_io);
close(Rowio_fileno(&row_io));
Rowio_release(&row_io);
unlink(work_file_name);
return 0;
}
/* Converts the buffer to cell and write it to disk */
static void write_fp_to_cell(int ofd, FCELL *buf)
{
CELL *cbuf;
int col;
cbuf = (CELL *) Rast_allocate_buf(CELL_TYPE);
for (col = 0; col < Rast_window_cols(); col++)
cbuf[col] = round_c(buf[col]);
Rast_put_row(ofd, cbuf, CELL_TYPE);
}
int
transform(int *datafds, int *outfds, int rows, int cols,
double **eigmat, int bands, CELL *mins, CELL *maxs)
{
int i, j, k, l;
double *sum;
CELL **rowbufs;
sum = G_alloc_vector(bands);
rowbufs = (CELL**)G_calloc(bands, sizeof(CELL*));
/* allocate row buffers for each band */
for (i = 0; i < bands; i++)
if ((rowbufs[i] = Rast_allocate_c_buf()) == NULL)
G_fatal_error(_("Unable to allocate cell buffers."));
for (i = 0; i < rows; i++) {
/* get one row of data */
for (j = 0; j < bands; j++)
Rast_get_c_row(datafds[j], rowbufs[j], i);
/* transform each cell in the row */
for (l = 0; l < cols; l++) {
for (j = 0; j < bands; j++) {
sum[j] = 0.0;
for (k = 0; k < bands; k++) {
sum[j] += eigmat[j][k] * (double)rowbufs[k][l];
}
}
for (j = 0; j < bands; j++) {
rowbufs[j][l] = (CELL) (sum[j] + 0.5);
if (rowbufs[j][l] > maxs[j])
maxs[j] = rowbufs[j][l];
if (rowbufs[j][l] < mins[j])
mins[j] = rowbufs[j][l];
}
}
/* output the row of data */
for (j = 0; j < bands; j++)
Rast_put_row(outfds[j], rowbufs[j], CELL_TYPE);
}
for (i = 0; i < bands; i++)
G_free(rowbufs[i]);
G_free(rowbufs);
G_free_vector(sum);
G_message(_("Transform completed.\n"));
return 0;
}
void *write_raster(void *buf, const int fd, const RASTER_MAP_TYPE rtype)
{
void *tmpbuf = buf;
int rows = Rast_window_rows();
int i;
G_message(_("Writing raster map..."));
for (i = 0; i < rows; i++) {
G_percent(i, rows, 10);
Rast_put_row(fd, tmpbuf, rtype);
tmpbuf =
G_incr_void_ptr(tmpbuf, Rast_cell_size(rtype) * Rast_window_cols());
}
return tmpbuf;
}
int output_raster(int fd)
{
int i, j;
for (i = 0; i < page.rows; i++, at_row++) {
switch (format) {
case USE_CHAR:
for (j = 0; j < page.cols; j++) {
cell[j] = (CELL) raster.c[i][j];
if (cell[j] == 0)
Rast_set_null_value(&cell[j], 1, CELL_TYPE);
}
break;
case USE_UCHAR:
for (j = 0; j < page.cols; j++) {
cell[j] = (CELL) raster.u[i][j];
if (cell[j] == 0)
Rast_set_null_value(&cell[j], 1, CELL_TYPE);
}
break;
case USE_SHORT:
for (j = 0; j < page.cols; j++) {
cell[j] = (CELL) raster.s[i][j];
if (cell[j] == 0)
Rast_set_null_value(&cell[j], 1, CELL_TYPE);
}
break;
case USE_CELL:
cell = raster.cell[i];
if (cell == 0)
Rast_set_null_value(&cell, 1, CELL_TYPE);
break;
}
G_percent(i, page.rows, 2);
Rast_put_row(fd, cell, CELL_TYPE);
}
G_percent(i, page.rows, 2);
return configure_plot();
}
int cseg_write_cellfile(CSEG * cseg, char *map_name)
{
int map_fd;
GW_LARGE_INT row, nrows;
CELL *buffer;
map_fd = Rast_open_c_new(map_name);
nrows = Rast_window_rows();
buffer = Rast_allocate_c_buf();
Segment_flush(&(cseg->seg));
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 1);
Segment_get_row(&(cseg->seg), buffer, row);
Rast_put_row(map_fd, buffer, CELL_TYPE);
}
G_percent(row, nrows, 1); /* finish it */
G_free(buffer);
Rast_close(map_fd);
return 0;
}
void array2raster(const void* data, const char* name,
const RASTER_MAP_TYPE type, const int maxr, const int maxc) {
//ORG void* rast = G_allocate_raster_buf(type);
void* rast = Rast_allocate_buf(type);
int fd;
//ORG if ((fd = G_open_raster_new(name, type)) < 0) {
if ((fd = Rast_open_new(name, type)) < 0) {
G_fatal_error("Unable to create raster map <%s>", name);
}
int row, col;
for (row = 0; row < maxr; ++row) {
for (col = 0; col < maxc; ++col) {
int i = row * maxc + col;
switch (type) {
case CELL_TYPE:
((int*) rast)[col] = ((int*) data)[i];
break;
case FCELL_TYPE:
((float*) rast)[col] = ((float*) data)[i];
break;
case DCELL_TYPE:
((double*) rast)[col] = ((double*) data)[i];
break;
}
}
//ORG if (G_put_raster_row(fd, rast, type) < 0) {
//ORG G_fatal_error("Failed writing raster map <%s>", name);
//ORG }
Rast_put_row(fd, rast, type);
}
G_free(rast);
//ORG G_close_cell(fd);
Rast_close(fd);
return;
}
int renumber(int in, int out)
{
CELL *cell, *c;
int row, col;
cell = Rast_allocate_c_buf();
G_message(_("%s: STEP 3 ... "), G_program_name());
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 5);
Rast_get_c_row(in, c = cell, row);
col = ncols;
while (col-- > 0) {
if (!Rast_is_c_null_value(c))
*c = table[*c];
c++;
}
Rast_put_row(out, cell, CELL_TYPE);
}
G_percent(row, nrows, 10);
G_free(cell);
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)
{
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 main(int argc, char *argv[])
{
struct GModule *module;
struct Option *coord, *out_file, *min, *max, *mult;
struct Flag *flag;
int *int_buf;
struct Cell_head w;
struct History history;
int cellfile;
double east, north, pt[2], cur[2], row, col, fmult;
double fmin, fmax;
int binary;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("buffer"));
G_add_keyword(_("geometry"));
G_add_keyword(_("circle"));
module->description =
_("Creates a raster map containing concentric "
"rings around a given point.");
out_file = G_define_standard_option(G_OPT_R_OUTPUT);
coord = G_define_standard_option(G_OPT_M_COORDS);
coord->required = YES;
coord->description = _("The coordinate of the center (east,north)");
min = G_define_option();
min->key = "min";
min->type = TYPE_DOUBLE;
min->required = NO;
min->description = _("Minimum radius for ring/circle map (in meters)");
max = G_define_option();
max->key = "max";
max->type = TYPE_DOUBLE;
max->required = NO;
max->description = _("Maximum radius for ring/circle map (in meters)");
mult = G_define_option();
mult->key = "multiplier";
mult->type = TYPE_DOUBLE;
mult->required = NO;
mult->description = _("Data value multiplier");
flag = G_define_flag();
flag->key = 'b';
flag->description = _("Generate binary raster map");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_scan_easting(coord->answers[0], &east, G_projection());
G_scan_northing(coord->answers[1], &north, G_projection());
pt[0] = east;
pt[1] = north;
fmult = 1.0;
if (min->answer)
sscanf(min->answer, "%lf", &fmin);
else
fmin = 0;
if (max->answer)
sscanf(max->answer, "%lf", &fmax);
else
fmax = HUGE_VAL;
if (fmin > fmax)
G_fatal_error(_("Please specify a radius in which min < max"));
if (mult->answer)
if (1 != sscanf(mult->answer, "%lf", &fmult))
fmult = 1.0;
/* nonsense test */
if (flag->answer && (!min->answer && !max->answer))
G_fatal_error(_("Please specify min and/or max radius when "
"using the binary flag"));
if (flag->answer)
binary = 1; /* generate binary pattern only, useful for MASK */
else
binary = 0;
G_get_set_window(&w);
cellfile = Rast_open_c_new(out_file->answer);
int_buf = (int *)G_malloc(w.cols * sizeof(int));
{
int c;
for (row = 0; row < w.rows; row++) {
G_percent(row, w.rows, 2);
cur[1] = Rast_row_to_northing(row + 0.5, &w);
for (col = 0; col < w.cols; col++) {
c = col;
cur[0] = Rast_col_to_easting(col + 0.5, &w);
int_buf[c] =
(int)(distance(pt, cur, fmin, fmax, binary) * fmult);
if (int_buf[c] == 0)
Rast_set_null_value(&int_buf[c], 1, CELL_TYPE);
}
Rast_put_row(cellfile, int_buf, CELL_TYPE);
}
}
G_free(int_buf);
Rast_close(cellfile);
Rast_short_history(out_file->answer, "raster", &history);
Rast_command_history(&history);
Rast_write_history(out_file->answer, &history);
G_done_msg(_("Raster map <%s> created."),
out_file->answer);
return (EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int fd, maskfd;
CELL *cell, *mask;
struct Cell_head window;
int row, col;
double north, east;
double dx, dy;
double maxdist, dist;
double sum1, sum2;
int i, n, max;
struct GModule *module;
struct History history;
struct
{
struct Option *input, *npoints, *output;
} parm;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("surface"));
G_add_keyword(_("interpolation"));
G_add_keyword(_("IDW"));
module->description = _("Surface generation program.");
parm.input = G_define_standard_option(G_OPT_R_INPUT);
parm.output = G_define_standard_option(G_OPT_R_OUTPUT);
parm.npoints = G_define_option();
parm.npoints->key = "npoints";
parm.npoints->key_desc = "count";
parm.npoints->type = TYPE_INTEGER;
parm.npoints->required = NO;
parm.npoints->description = _("Number of interpolation points");
parm.npoints->answer = "12";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* Make sure that the current projection is not lat/long */
if ((G_projection() == PROJECTION_LL))
G_fatal_error(_("Lat/long databases not supported by r.surf.idw2. Use r.surf.idw instead!"));
if (sscanf(parm.npoints->answer, "%d", &search_points) != 1 ||
search_points < 1)
G_fatal_error(_("%s=%s - illegal number of interpolation points"),
parm.npoints->key, parm.npoints->answer);
list = (struct Point *)G_calloc(search_points, sizeof(struct Point));
/* read the elevation points from the input raster map */
read_cell(parm.input->answer);
if (npoints == 0)
G_fatal_error(_("%s: no data points found"), G_program_name());
nsearch = npoints < search_points ? npoints : search_points;
/* get the window, allocate buffers, etc. */
G_get_set_window(&window);
cell = Rast_allocate_c_buf();
if ((maskfd = Rast_maskfd()) >= 0)
mask = Rast_allocate_c_buf();
else
mask = NULL;
fd = Rast_open_c_new(parm.output->answer);
G_message(_("Interpolating raster map <%s>... %d rows... "),
parm.output->answer, window.rows);
north = window.north - window.ns_res / 2.0;
for (row = 0; row < window.rows; row++) {
G_percent(row, window.rows, 2);
if (mask)
Rast_get_c_row(maskfd, mask, row);
north += window.ns_res;
east = window.west - window.ew_res / 2.0;
for (col = 0; col < window.cols; col++) {
east += window.ew_res;
/* don't interpolate outside of the mask */
if (mask && mask[col] == 0) {
cell[col] = 0;
continue;
}
/* fill list with first nsearch points */
for (i = 0; i < nsearch; i++) {
dy = points[i].north - north;
dx = points[i].east - east;
list[i].dist = dy * dy + dx * dx;
list[i].z = points[i].z;
}
/* find the maximum distance */
maxdist = list[max = 0].dist;
for (n = 1; n < nsearch; n++) {
if (maxdist < list[n].dist)
maxdist = list[max = n].dist;
}
/* go thru rest of the points now */
for (; i < npoints; i++) {
dy = points[i].north - north;
dx = points[i].east - east;
dist = dy * dy + dx * dx;
if (dist < maxdist) {
/* replace the largest dist */
list[max].z = points[i].z;
list[max].dist = dist;
maxdist = list[max = 0].dist;
for (n = 1; n < nsearch; n++) {
if (maxdist < list[n].dist)
maxdist = list[max = n].dist;
}
}
}
/* interpolate */
sum1 = 0.0;
sum2 = 0.0;
for (n = 0; n < nsearch; n++) {
if ((dist = list[n].dist)) {
sum1 += list[n].z / dist;
sum2 += 1.0 / dist;
}
else {
sum1 = list[n].z;
sum2 = 1.0;
break;
}
}
cell[col] = (CELL) (sum1 / sum2 + 0.5);
}
Rast_put_row(fd, cell, CELL_TYPE);
}
G_free(points);
G_free(cell);
Rast_close(fd);
/* writing history file */
Rast_short_history(parm.output->answer, "raster", &history);
Rast_command_history(&history);
Rast_write_history(parm.output->answer, &history);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int camera_angle(char *name)
{
int row, col, nrows, ncols;
double XC = group.XC;
double YC = group.YC;
double ZC = group.ZC;
double c_angle, c_angle_min, c_alt, c_az, slope, aspect;
double radians_to_degrees = 180.0 / M_PI;
/* double degrees_to_radians = M_PI / 180.0; */
DCELL e1, e2, e3, e4, e5, e6, e7, e8, e9;
double factor, V, H, dx, dy, dz, key;
double north, south, east, west, ns_med;
FCELL *fbuf0, *fbuf1, *fbuf2, *tmpbuf, *outbuf;
int elevfd, outfd;
struct Cell_head cellhd;
struct Colors colr;
FCELL clr_min, clr_max;
struct History hist;
char *type;
G_message(_("Calculating camera angle to local surface..."));
select_target_env();
/* align target window to elevation map, otherwise we get artefacts
* like in r.slope.aspect -a */
Rast_get_cellhd(elev_name, elev_mapset, &cellhd);
Rast_align_window(&target_window, &cellhd);
Rast_set_window(&target_window);
elevfd = Rast_open_old(elev_name, elev_mapset);
if (elevfd < 0) {
G_fatal_error(_("Could not open elevation raster"));
return 1;
}
nrows = target_window.rows;
ncols = target_window.cols;
outfd = Rast_open_new(name, FCELL_TYPE);
fbuf0 = Rast_allocate_buf(FCELL_TYPE);
fbuf1 = Rast_allocate_buf(FCELL_TYPE);
fbuf2 = Rast_allocate_buf(FCELL_TYPE);
outbuf = Rast_allocate_buf(FCELL_TYPE);
/* give warning if location units are different from meters and zfactor=1 */
factor = G_database_units_to_meters_factor();
if (factor != 1.0)
G_warning(_("Converting units to meters, factor=%.6f"), factor);
G_begin_distance_calculations();
north = Rast_row_to_northing(0.5, &target_window);
ns_med = Rast_row_to_northing(1.5, &target_window);
south = Rast_row_to_northing(2.5, &target_window);
east = Rast_col_to_easting(2.5, &target_window);
west = Rast_col_to_easting(0.5, &target_window);
V = G_distance(east, north, east, south) * 4;
H = G_distance(east, ns_med, west, ns_med) * 4;
c_angle_min = 90;
Rast_get_row(elevfd, fbuf1, 0, FCELL_TYPE);
Rast_get_row(elevfd, fbuf2, 1, FCELL_TYPE);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Rast_set_null_value(outbuf, ncols, FCELL_TYPE);
/* first and last row */
if (row == 0 || row == nrows - 1) {
Rast_put_row(outfd, outbuf, FCELL_TYPE);
continue;
}
tmpbuf = fbuf0;
fbuf0 = fbuf1;
fbuf1 = fbuf2;
fbuf2 = tmpbuf;
Rast_get_row(elevfd, fbuf2, row + 1, FCELL_TYPE);
north = Rast_row_to_northing(row + 0.5, &target_window);
for (col = 1; col < ncols - 1; col++) {
e1 = fbuf0[col - 1];
if (Rast_is_d_null_value(&e1))
continue;
e2 = fbuf0[col];
if (Rast_is_d_null_value(&e2))
continue;
e3 = fbuf0[col + 1];
if (Rast_is_d_null_value(&e3))
continue;
e4 = fbuf1[col - 1];
if (Rast_is_d_null_value(&e4))
continue;
e5 = fbuf1[col];
if (Rast_is_d_null_value(&e5))
continue;
e6 = fbuf1[col + 1];
if (Rast_is_d_null_value(&e6))
continue;
e7 = fbuf2[col - 1];
if (Rast_is_d_null_value(&e7))
continue;
e8 = fbuf2[col];
if (Rast_is_d_null_value(&e8))
continue;
e9 = fbuf2[col + 1];
if (Rast_is_d_null_value(&e9))
continue;
dx = ((e1 + e4 + e4 + e7) - (e3 + e6 + e6 + e9)) / H;
dy = ((e7 + e8 + e8 + e9) - (e1 + e2 + e2 + e3)) / V;
/* compute topographic parameters */
key = dx * dx + dy * dy;
/* slope in radians */
slope = atan(sqrt(key));
/* aspect in radians */
if (key == 0.)
aspect = 0.;
else if (dx == 0) {
if (dy > 0)
aspect = M_PI / 2;
else
aspect = 1.5 * M_PI;
}
else {
aspect = atan2(dy, dx);
if (aspect <= 0.)
aspect = 2 * M_PI + aspect;
}
/* camera altitude angle in radians */
east = Rast_col_to_easting(col + 0.5, &target_window);
dx = east - XC;
dy = north - YC;
dz = ZC - e5;
c_alt = atan(sqrt(dx * dx + dy * dy) / dz);
/* camera azimuth angle in radians */
c_az = atan(dy / dx);
if (east < XC && north != YC)
c_az += M_PI;
else if (north < YC && east > XC)
c_az += 2 * M_PI;
/* camera angle to real ground */
/* orthogonal to ground: 90 degrees */
/* parallel to ground: 0 degrees */
c_angle = asin(cos(c_alt) * cos(slope) - sin(c_alt) * sin(slope) * cos(c_az - aspect));
outbuf[col] = c_angle * radians_to_degrees;
if (c_angle_min > outbuf[col])
c_angle_min = outbuf[col];
}
Rast_put_row(outfd, outbuf, FCELL_TYPE);
}
G_percent(row, nrows, 2);
Rast_close(elevfd);
Rast_close(outfd);
G_free(fbuf0);
G_free(fbuf1);
G_free(fbuf2);
G_free(outbuf);
type = "raster";
Rast_short_history(name, type, &hist);
Rast_command_history(&hist);
Rast_write_history(name, &hist);
Rast_init_colors(&colr);
if (c_angle_min < 0) {
clr_min = (FCELL)((int)(c_angle_min / 10 - 1)) * 10;
clr_max = 0;
Rast_add_f_color_rule(&clr_min, 0, 0, 0, &clr_max, 0,
0, 0, &colr);
}
clr_min = 0;
clr_max = 10;
Rast_add_f_color_rule(&clr_min, 0, 0, 0, &clr_max, 255,
0, 0, &colr);
clr_min = 10;
clr_max = 40;
Rast_add_f_color_rule(&clr_min, 255, 0, 0, &clr_max, 255,
255, 0, &colr);
clr_min = 40;
clr_max = 90;
Rast_add_f_color_rule(&clr_min, 255, 255, 0, &clr_max, 0,
255, 0, &colr);
Rast_write_colors(name, G_mapset(), &colr);
select_current_env();
return 1;
}
int main(int argc, char **argv)
{
int n, verbose = 1,
backrow, backcol,
col, row,
len, flag,
srows, scols,
backrow_fd, backcol_fd, path_fd, in_row_fd, in_col_fd, out_fd;
const char *current_mapset,
*search_mapset,
*path_mapset,
*backrow_mapset,
*backcol_mapset, *in_row_file, *in_col_file, *out_file;
CELL *cell;
POINT *PRES_PT, *PRESENT_PT, *OLD_PT;
struct Cell_head window;
double east, north;
struct Option *opt1, *opt2, *opt3, *opt4;
struct Flag *flag1;
struct GModule *module;
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("fire"));
G_add_keyword(_("cumulative costs"));
module->description =
_("Recursively traces the least cost path backwards to "
"cells from which the cumulative cost was determined.");
opt1 = G_define_option();
opt1->key = "x_input";
opt1->type = TYPE_STRING;
opt1->required = YES;
opt1->gisprompt = "old,cell,raster";
opt1->description =
_("Name of raster map containing back-path easting information");
opt2 = G_define_option();
opt2->key = "y_input";
opt2->type = TYPE_STRING;
opt2->required = YES;
opt2->gisprompt = "old,cell,raster";
opt2->description =
_("Name of raster map containing back-path northing information");
opt3 = G_define_option();
opt3->key = "coordinate";
opt3->type = TYPE_STRING;
opt3->multiple = YES;
opt3->key_desc = "x,y";
opt3->description =
_("The map E and N grid coordinates of starting points");
opt4 = G_define_option();
opt4->key = "output";
opt4->type = TYPE_STRING;
opt4->required = YES;
opt4->gisprompt = "new,cell,raster";
opt4->description = _("Name of spread path raster map");
flag1 = G_define_flag();
flag1->key = 'v';
flag1->description = _("Run verbosely");
/* Do command line parsing */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
current_mapset = G_mapset();
in_row_file = G_tempfile();
in_col_file = G_tempfile();
out_file = G_tempfile();
/* Get database window parameters */
G_get_window(&window);
verbose = flag1->answer;
/* Check if backrow layer exists in data base */
search_mapset = "";
strcpy(backrow_layer, opt2->answer);
strcpy(backcol_layer, opt1->answer);
backrow_mapset = G_find_raster(backrow_layer, search_mapset);
backcol_mapset = G_find_raster(backcol_layer, search_mapset);
if (backrow_mapset == NULL)
G_fatal_error("%s - not found", backrow_layer);
if (backcol_mapset == NULL)
G_fatal_error("%s - not found", backcol_layer);
search_mapset = "";
strcpy(path_layer, opt4->answer);
path_mapset = G_find_raster(path_layer, search_mapset);
/* find number of rows and cols in window */
nrows = Rast_window_rows();
ncols = Rast_window_cols();
cell = Rast_allocate_c_buf();
/* Open back cell layers for reading */
backrow_fd = Rast_open_old(backrow_layer, backrow_mapset);
backcol_fd = Rast_open_old(backcol_layer, backcol_mapset);
/* Parameters for map submatrices */
len = sizeof(CELL);
srows = nrows / 4 + 1;
scols = ncols / 4 + 1;
if (verbose)
G_message
("\nReading the input map -%s- and -%s- and creating some temporary files...",
backrow_layer, backcol_layer);
/* Create segmented files for back cell and output layers */
in_row_fd = creat(in_row_file, 0666);
segment_format(in_row_fd, nrows, ncols, srows, scols, len);
close(in_row_fd);
in_col_fd = creat(in_col_file, 0666);
segment_format(in_col_fd, nrows, ncols, srows, scols, len);
close(in_col_fd);
out_fd = creat(out_file, 0666);
segment_format(out_fd, nrows, ncols, srows, scols, len);
close(out_fd);
/* Open initialize and segment all files */
in_row_fd = open(in_row_file, 2);
segment_init(&in_row_seg, in_row_fd, 4);
in_col_fd = open(in_col_file, 2);
segment_init(&in_col_seg, in_col_fd, 4);
out_fd = open(out_file, 2);
segment_init(&out_seg, out_fd, 4);
/* Write the back cell layers in the segmented files, and
* Change UTM coordinates to ROWs and COLUMNs */
for (row = 0; row < nrows; row++) {
Rast_get_c_row(backrow_fd, cell, row);
for (col = 0; col < ncols; col++)
if (cell[col] > 0)
cell[col] =
(window.north - cell[col]) / window.ns_res /* - 0.5 */ ;
else
cell[col] = -1;
segment_put_row(&in_row_seg, cell, row);
Rast_get_c_row(backcol_fd, cell, row);
for (col = 0; col < ncols; col++)
if (cell[col] > 0)
cell[col] =
(cell[col] - window.west) / window.ew_res /* - 0.5 */ ;
segment_put_row(&in_col_seg, cell, row);
}
/* Convert easting and northing from the command line to row and col */
if (opt3->answer) {
for (n = 0; opt3->answers[n] != NULL; n += 2) {
G_scan_easting(opt3->answers[n], &east, G_projection());
G_scan_northing(opt3->answers[n + 1], &north, G_projection());
row = (window.north - north) / window.ns_res;
col = (east - window.west) / window.ew_res;
/* ignore pt outside window */
if (east < window.west || east > window.east ||
north < window.south || north > window.north) {
G_warning("Ignoring point outside window: ");
G_warning(" %.4f,%.4f", east, north);
continue;
}
value = (char *)&backrow;
segment_get(&in_row_seg, value, row, col);
/* ignore pt in no-data area */
if (backrow < 0) {
G_warning("Ignoring point in NO-DATA area :");
G_warning(" %.4f,%.4f", east, north);
continue;
}
value = (char *)&backcol;
segment_get(&in_col_seg, value, row, col);
insert(&PRESENT_PT, row, col, backrow, backcol);
}
}
/* Set flag according to input */
if (path_mapset != NULL) {
if (head_start_pt == NULL)
/*output layer exists and start pts are not given on cmd line */
flag = 1;
/* output layer exists and starting pts are given on cmd line */
else
flag = 2;
}
else
flag = 3; /* output layer does not previously exist */
/* If the output layer containing the starting positions */
/* create a linked list of of them */
if (flag == 1) {
path_fd = Rast_open_old(path_layer, path_mapset);
/* Search for the marked starting pts and make list */
for (row = 0; row < nrows; row++) {
Rast_get_c_row(path_fd, cell, row);
for (col = 0; col < ncols; col++) {
if (cell[col] > 0) {
value = (char *)&backrow;
segment_get(&in_row_seg, value, row, col);
/* ignore pt in no-data area */
if (backrow < 0) {
G_warning("Ignoring point in NO-DATA area:");
G_warning(" %.4f,%.4f\n",
window.west + window.ew_res * (col + 0.5),
window.north - window.ns_res * (row + 0.5));
continue;
}
value = (char *)&backcol;
segment_get(&in_col_seg, value, row, col);
insert(&PRESENT_PT, row, col, backrow, backcol);
}
} /* loop over cols */
} /* loop over rows */
Rast_close(path_fd);
}
/* loop over the starting points to find the least cost paths */
if (verbose)
G_message("\nFinding the least cost paths ...");
PRES_PT = head_start_pt;
while (PRES_PT != NULL) {
path_finder(PRES_PT->row, PRES_PT->col, PRES_PT->backrow,
PRES_PT->backcol);
OLD_PT = PRES_PT;
PRES_PT = NEXT_PT;
G_free(OLD_PT);
}
/* Write pending updates by segment_put() to outputmap */
segment_flush(&out_seg);
if (verbose)
G_message("\nWriting the output map -%s-...", path_layer);
path_fd = Rast_open_c_new(path_layer);
for (row = 0; row < nrows; row++) {
segment_get_row(&out_seg, cell, row);
Rast_put_row(path_fd, cell, CELL_TYPE);
}
if (verbose)
G_message("finished.");
segment_release(&in_row_seg); /* release memory */
segment_release(&in_col_seg);
segment_release(&out_seg);
close(in_row_fd); /* close all files */
close(in_col_fd);
close(out_fd);
Rast_close(path_fd);
Rast_close(backrow_fd);
Rast_close(backcol_fd);
unlink(in_row_file); /* remove submatrix files */
unlink(in_col_file);
unlink(out_file);
exit(EXIT_SUCCESS);
}
void filter_holes(Gfile * out)
{
int row, col, nrows, ncols;
void *arast, *brast, *crast;
int i, pixel[9], cold, warm, shadow, nulo, lim;
Gfile tmp;
nrows = Rast_window_rows();
ncols = Rast_window_cols();
if (nrows < 3 || ncols < 3)
return;
/* Open to read */
if ((out->fd = Rast_open_old(out->name, "")) < 0)
G_fatal_error(_("Unable to open raster map <%s>"), out->name);
arast = Rast_allocate_buf(CELL_TYPE);
brast = Rast_allocate_buf(CELL_TYPE);
crast = Rast_allocate_buf(CELL_TYPE);
/* Open to write */
sprintf(tmp.name, "_%d.BBB", getpid());
tmp.rast = Rast_allocate_buf(CELL_TYPE);
if ((tmp.fd = Rast_open_new(tmp.name, CELL_TYPE)) < 0)
G_fatal_error(_("Unable to create raster map <%s>"), tmp.name);
G_important_message(_("Filling small holes in clouds..."));
/* Se puede acelerar creandolos nulos y luego arast = brast
brast = crast y cargando crast solamente
G_set_f_null_value(cell[2], ncols);
*/
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
/* Read row values */
if (row != 0) {
Rast_get_c_row(out->fd, arast, row - 1);
}
Rast_get_c_row(out->fd, brast, row);
if (row != (nrows - 1)) {
Rast_get_c_row(out->fd, crast, row + 1);
}
/* Analysis of all pixels */
for (col = 0; col < ncols; col++) {
pixel[0] = pval(brast, col);
if (pixel[0] == 0) {
if (row == 0) {
pixel[1] = -1;
pixel[2] = -1;
pixel[3] = -1;
if (col == 0) {
pixel[4] = -1;
pixel[5] = pval(brast, col + 1);
pixel[6] = -1;
pixel[7] = pval(crast, col);
pixel[8] = pval(crast, col + 1);
}
else if (col != (ncols - 1)) {
pixel[4] = pval(brast, col - 1);
pixel[5] = pval(brast, col + 1);
pixel[6] = pval(crast, col - 1);
pixel[7] = pval(crast, col);
pixel[8] = pval(crast, col + 1);
}
else {
pixel[4] = pval(brast, col - 1);
pixel[5] = -1;
pixel[6] = pval(crast, col - 1);
pixel[7] = pval(crast, col);
pixel[8] = -1;
}
}
else if (row != (nrows - 1)) {
if (col == 0) {
pixel[1] = -1;
pixel[2] = pval(arast, col);
pixel[3] = pval(arast, col + 1);
pixel[4] = -1;
pixel[5] = pval(brast, col + 1);
pixel[6] = -1;
pixel[7] = pval(crast, col);
pixel[8] = pval(crast, col + 1);
}
else if (col != (ncols - 1)) {
pixel[1] = pval(arast, col - 1);
pixel[2] = pval(arast, col);
pixel[3] = pval(arast, col + 1);
pixel[4] = pval(brast, col - 1);
pixel[5] = pval(brast, col + 1);
pixel[6] = pval(crast, col - 1);
pixel[7] = pval(crast, col);
pixel[8] = pval(crast, col + 1);
}
else {
pixel[1] = pval(arast, col - 1);
pixel[2] = pval(arast, col);
pixel[3] = -1;
pixel[4] = pval(brast, col - 1);
pixel[5] = -1;
pixel[6] = pval(crast, col - 1);
pixel[7] = pval(crast, col);
pixel[8] = -1;
}
}
else {
pixel[6] = -1;
pixel[7] = -1;
pixel[8] = -1;
if (col == 0) {
pixel[1] = -1;
pixel[2] = pval(arast, col);
pixel[3] = pval(arast, col + 1);
pixel[4] = -1;
pixel[5] = pval(brast, col + 1);
}
else if (col != (ncols - 1)) {
pixel[1] = pval(arast, col - 1);
pixel[2] = pval(arast, col);
pixel[3] = pval(arast, col + 1);
pixel[4] = pval(brast, col - 1);
pixel[5] = pval(brast, col + 1);
}
else {
pixel[1] = pval(arast, col - 1);
pixel[2] = pval(arast, col);
pixel[3] = -1;
pixel[4] = pval(brast, col - 1);
pixel[5] = -1;
}
}
cold = warm = shadow = nulo = 0;
for (i = 1; i < 9; i++) {
switch (pixel[i]) {
case IS_COLD_CLOUD:
cold++;
break;
case IS_WARM_CLOUD:
warm++;
break;
case IS_SHADOW:
shadow++;
break;
default:
nulo++;
break;
}
}
lim = (int)(cold + warm + shadow + nulo) / 2;
/* Entra pixel[0] = 0 */
if (nulo < lim) {
if (shadow >= (cold + warm))
pixel[0] = IS_SHADOW;
else
pixel[0] =
(warm > cold) ? IS_WARM_CLOUD : IS_COLD_CLOUD;
}
}
if (pixel[0] != 0) {
((CELL *) tmp.rast)[col] = pixel[0];
}
else {
Rast_set_c_null_value((CELL *) tmp.rast + col, 1);
}
}
Rast_put_row(tmp.fd, tmp.rast, CELL_TYPE);
}
G_percent(1, 1, 1);
G_free(arast);
G_free(brast);
G_free(crast);
Rast_close(out->fd);
G_free(tmp.rast);
Rast_close(tmp.fd);
G_remove("cats", out->name);
G_remove("cell", out->name);
G_remove("cellhd", out->name);
G_remove("cell_misc", out->name);
G_remove("hist", out->name);
G_rename("cats", tmp.name, out->name);
G_rename("cell", tmp.name, out->name);
G_rename("cellhd", tmp.name, out->name);
G_rename("cell_misc", tmp.name, out->name);
G_rename("hist", tmp.name, out->name);
return;
}
int close_array_seg(void)
{
struct Colors colors;
int incr, max, red, green, blue, rd, gr, bl, flag;
int c, r, map_fd;
CELL *cellrow, value;
CELL *theseg;
RAMSEG thesegseg;
cellrow = Rast_allocate_c_buf();
if (seg_flag || bas_flag || haf_flag) {
if (seg_flag) {
theseg = bas;
thesegseg = bas_seg;
}
else if (bas_flag) {
theseg = bas;
thesegseg = bas_seg;
}
else {
theseg = haf;
thesegseg = haf_seg;
}
max = n_basins;
G_debug(1, "%d basins created", max);
Rast_init_colors(&colors);
if (max > 0)
Rast_make_random_colors(&colors, 1, max);
else {
G_warning(_("No basins were created. Verify threshold and region settings."));
Rast_make_random_colors(&colors, 1, 2);
}
if (max < 1000 && max > 0) {
Rast_set_c_color((CELL) 0, 0, 0, 0, &colors);
r = 1;
incr = 0;
while (incr >= 0) {
G_percent(r, max, 2);
for (gr = 130 + incr; gr <= 255; gr += 20) {
for (rd = 90 + incr; rd <= 255; rd += 30) {
for (bl = 90 + incr; bl <= 255; bl += 40) {
flag = 1;
while (flag) {
Rast_get_c_color(&r, &red, &green, &blue, &colors);
/* if existing rule is too dark then append a new
rule to override it */
if ((blue * .11 + red * .30 + green * .59) <
100) {
Rast_set_c_color(r, rd, gr, bl, &colors);
flag = 0;
}
if (++r > max) {
gr = rd = bl = 300;
flag = 0;
incr = -1;
}
}
}
}
}
if (incr >= 0) {
incr += 15;
if (incr > 120)
incr = 7;
}
}
G_percent(r - 1, max, 3); /* finish it */
}
else
G_debug(1,
"Too many subbasins to reasonably check for color brightness");
/* using the existing stack of while/for/for/for/while loops ... */
}
/* stream segments map */
if (seg_flag) {
map_fd = Rast_open_c_new(seg_name);
for (r = 0; r < nrows; r++) {
Rast_set_c_null_value(cellrow, ncols); /* reset row to all NULL */
for (c = 0; c < ncols; c++) {
value = FLAG_GET(swale, r, c);
if (value)
cellrow[c] = bas[SEG_INDEX(bas_seg, r, c)];
}
Rast_put_row(map_fd, cellrow, CELL_TYPE);
}
Rast_close(map_fd);
Rast_write_colors(seg_name, this_mapset, &colors);
}
/* basins map */
if (bas_flag) {
map_fd = Rast_open_c_new(bas_name);
for (r = 0; r < nrows; r++) {
for (c = 0; c < ncols; c++) {
cellrow[c] = bas[SEG_INDEX(bas_seg, r, c)];
if (cellrow[c] == 0)
Rast_set_c_null_value(cellrow + c, 1);
}
Rast_put_row(map_fd, cellrow, CELL_TYPE);
}
Rast_close(map_fd);
Rast_write_colors(bas_name, this_mapset, &colors);
}
/* half_basins map */
if (haf_flag) {
map_fd = Rast_open_c_new(haf_name);
for (r = 0; r < nrows; r++) {
for (c = 0; c < ncols; c++) {
cellrow[c] = haf[SEG_INDEX(haf_seg, r, c)];
if (cellrow[c] == 0)
Rast_set_c_null_value(cellrow + c, 1);
}
Rast_put_row(map_fd, cellrow, CELL_TYPE);
}
Rast_close(map_fd);
Rast_write_colors(haf_name, this_mapset, &colors);
}
if (seg_flag || bas_flag || haf_flag)
Rast_free_colors(&colors);
G_free(haf);
G_free(bas);
G_free(cellrow);
if (arm_flag)
fclose(fp);
close_maps();
return 0;
}
void process(void)
{
/*--------------------------------------------------------------------------*/
/* INITIALISE */
/*--------------------------------------------------------------------------*/
DCELL *row_in, /* Buffer large enough to hold `wsize' */
*row_out = NULL, /* raster rows. When GRASS reads in a */
/* raster row, each element is of type */
/* DCELL */
*window_ptr, /* Stores local terrain window. */
centre; /* Elevation of central cell in window. */
CELL *featrow_out = NULL; /* store features in CELL */
struct Cell_head region; /* Structure to hold region information */
int nrows, /* Will store the current number of */
ncols, /* rows and columns in the raster. */
row, col, /* Counts through each row and column */
/* of the input raster. */
wind_row, /* Counts through each row and column */
wind_col, /* of the local neighbourhood window. */
*index_ptr; /* Row permutation vector for LU decomp. */
double **normal_ptr, /* Cross-products matrix. */
*obs_ptr, /* Observed vector. */
temp; /* Unused */
double *weight_ptr; /* Weighting matrix for observed values. */
/*--------------------------------------------------------------------------*/
/* GET RASTER AND WINDOW DETAILS */
/*--------------------------------------------------------------------------*/
G_get_window(®ion); /* Fill out the region structure (the */
/* geographical limits etc.) */
nrows = Rast_window_rows(); /* Find out the number of rows and */
ncols = Rast_window_cols(); /* columns of the raster. */
if ((region.ew_res / region.ns_res >= 1.01) || /* If EW and NS resolns are */
(region.ns_res / region.ew_res >= 1.01)) { /* >1% different, warn user. */
G_warning(_("E-W and N-S grid resolutions are different. Taking average."));
resoln = (region.ns_res + region.ew_res) / 2;
}
else
resoln = region.ns_res;
/*--------------------------------------------------------------------------*/
/* RESERVE MEMORY TO HOLD Z VALUES AND MATRICES */
/*--------------------------------------------------------------------------*/
row_in = (DCELL *) G_malloc(ncols * sizeof(DCELL) * wsize);
/* Reserve `wsize' rows of memory. */
if (mparam != FEATURE)
row_out = Rast_allocate_buf(DCELL_TYPE); /* Initialise output row buffer. */
else
featrow_out = Rast_allocate_buf(CELL_TYPE); /* Initialise output row buffer. */
window_ptr = (DCELL *) G_malloc(SQR(wsize) * sizeof(DCELL));
/* Reserve enough memory for local wind. */
weight_ptr = (double *)G_malloc(SQR(wsize) * sizeof(double));
/* Reserve enough memory weights matrix. */
normal_ptr = dmatrix(0, 5, 0, 5); /* Allocate memory for 6*6 matrix */
index_ptr = ivector(0, 5); /* and for 1D vector holding indices */
obs_ptr = dvector(0, 5); /* and for 1D vector holding observed z */
/* ---------------------------------------------------------------- */
/* - CALCULATE LEAST SQUARES COEFFICIENTS - */
/* ---------------------------------------------------------------- */
/*--- Calculate weighting matrix. ---*/
find_weight(weight_ptr);
/* Initial coefficients need only be found once since they are
constant for any given window size. The only element that
changes is the observed vector (RHS of normal equations). */
/*--- Find normal equations in matrix form. ---*/
find_normal(normal_ptr, weight_ptr);
/*--- Apply LU decomposition to normal equations. ---*/
if (constrained) {
G_ludcmp(normal_ptr, 5, index_ptr, &temp);
/* To constrain the quadtratic
through the central cell, ignore
the calculations involving the
coefficient f. Since these are
all in the last row and column of
the matrix, simply redimension. */
/* disp_matrix(normal_ptr,obs_ptr,obs_ptr,5);
*/
}
else {
G_ludcmp(normal_ptr, 6, index_ptr, &temp);
/* disp_matrix(normal_ptr,obs_ptr,obs_ptr,6);
*/
}
/*--------------------------------------------------------------------------*/
/* PROCESS INPUT RASTER AND WRITE OUT RASTER LINE BY LINE */
/*--------------------------------------------------------------------------*/
if (mparam != FEATURE)
for (wind_row = 0; wind_row < EDGE; wind_row++)
Rast_put_row(fd_out, row_out, DCELL_TYPE); /* Write out the edge cells as NULL. */
else
for (wind_row = 0; wind_row < EDGE; wind_row++)
Rast_put_row(fd_out, featrow_out, CELL_TYPE); /* Write out the edge cells as NULL. */
for (wind_row = 0; wind_row < wsize - 1; wind_row++)
Rast_get_row(fd_in, row_in + (wind_row * ncols), wind_row,
DCELL_TYPE);
/* Read in enough of the first rows to */
/* allow window to be examined. */
for (row = EDGE; row < (nrows - EDGE); row++) {
G_percent(row + 1, nrows - EDGE, 2);
Rast_get_row(fd_in, row_in + ((wsize - 1) * ncols), row + EDGE,
DCELL_TYPE);
for (col = EDGE; col < (ncols - EDGE); col++) {
/* Find central z value */
centre = *(row_in + EDGE * ncols + col);
for (wind_row = 0; wind_row < wsize; wind_row++)
for (wind_col = 0; wind_col < wsize; wind_col++)
/* Express all window values relative */
/* to the central elevation. */
*(window_ptr + (wind_row * wsize) + wind_col) =
*(row_in + (wind_row * ncols) + col + wind_col -
EDGE) - centre;
/*--- Use LU back substitution to solve normal equations. ---*/
find_obs(window_ptr, obs_ptr, weight_ptr);
/* disp_wind(window_ptr);
disp_matrix(normal_ptr,obs_ptr,obs_ptr,6);
*/
if (constrained) {
G_lubksb(normal_ptr, 5, index_ptr, obs_ptr);
/*
disp_matrix(normal_ptr,obs_ptr,obs_ptr,5);
*/
}
else {
G_lubksb(normal_ptr, 6, index_ptr, obs_ptr);
/*
disp_matrix(normal_ptr,obs_ptr,obs_ptr,6);
*/
}
/*--- Calculate terrain parameter based on quad. coefficients. ---*/
if (mparam == FEATURE)
*(featrow_out + col) = (CELL) feature(obs_ptr);
else
*(row_out + col) = param(mparam, obs_ptr);
if (mparam == ELEV)
*(row_out + col) += centre; /* Add central elevation back */
}
if (mparam != FEATURE)
Rast_put_row(fd_out, row_out, DCELL_TYPE); /* Write the row buffer to the output */
/* raster. */
else /* write FEATURE to CELL */
Rast_put_row(fd_out, featrow_out, CELL_TYPE); /* Write the row buffer to the output */
/* raster. */
/* 'Shuffle' rows down one, and read in */
/* one new row. */
for (wind_row = 0; wind_row < wsize - 1; wind_row++)
for (col = 0; col < ncols; col++)
*(row_in + (wind_row * ncols) + col) =
*(row_in + ((wind_row + 1) * ncols) + col);
}
for (wind_row = 0; wind_row < EDGE; wind_row++) {
if (mparam != FEATURE)
Rast_put_row(fd_out, row_out, DCELL_TYPE); /* Write out the edge cells as NULL. */
else
Rast_put_row(fd_out, featrow_out, CELL_TYPE); /* Write out the edge cells as NULL. */
}
/*--------------------------------------------------------------------------*/
/* FREE MEMORY USED TO STORE RASTER ROWS, LOCAL WINDOW AND MATRICES */
/*--------------------------------------------------------------------------*/
G_free(row_in);
if (mparam != FEATURE)
G_free(row_out);
else
G_free(featrow_out);
G_free(window_ptr);
free_dmatrix(normal_ptr, 0, 5, 0, 5);
free_dvector(obs_ptr, 0, 5);
free_ivector(index_ptr, 0, 5);
}
CELL clump(int in_fd, int out_fd, int diag, int print)
{
register int col;
register int n;
CELL NEW, OLD;
CELL *temp_cell, *temp_clump;
CELL *prev_in, *cur_in, *out_cell;
CELL *prev_clump, *cur_clump;
CELL X, LEFT;
CELL *index, *renumber;
CELL label;
int nrows, ncols;
int row;
int len;
int nalloc;
long cur_time;
char *cname;
int cfd, csize;
CELL cat;
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* allocate clump index */
nalloc = INCR;
index = (CELL *) G_malloc(nalloc * sizeof(CELL));
index[0] = 0;
renumber = NULL;
/* allocate CELL buffers two columns larger than current window */
len = (ncols + 2) * sizeof(CELL);
prev_in = (CELL *) G_malloc(len);
cur_in = (CELL *) G_malloc(len);
prev_clump = (CELL *) G_malloc(len);
cur_clump = (CELL *) G_malloc(len);
out_cell = (CELL *) G_malloc(len);
/* temp file for initial clump IDs */
cname = G_tempfile();
if ((cfd = open(cname, O_RDWR | O_CREAT | O_EXCL, 0600)) < 0)
G_fatal_error(_("Unable to open temp file"));
csize = ncols * sizeof(CELL);
time(&cur_time);
/* fake a previous row which is all NULL */
Rast_set_c_null_value(prev_in, ncols + 2);
/* set left and right edge to NULL */
Rast_set_c_null_value(&cur_in[0], 1);
Rast_set_c_null_value(&cur_in[ncols + 1], 1);
/* initialize clump labels */
G_zero(cur_clump, len);
G_zero(prev_clump, len);
label = 0;
/****************************************************
* PASS 1 *
* pass thru the input, create initial clump labels *
****************************************************/
G_message(_("Pass 1 of 2..."));
for (row = 0; row < nrows; row++) {
Rast_get_c_row(in_fd, cur_in + 1, row);
G_percent(row, nrows, 4);
Rast_set_c_null_value(&X, 1);
for (col = 1; col <= ncols; col++) {
LEFT = X;
X = cur_in[col];
if (Rast_is_c_null_value(&X)) { /* don't clump NULL data */
cur_clump[col] = 0;
continue;
}
/*
* if the cell value is different to the left and above
* (diagonal: and above left and above right)
* then we must start a new clump
*
* this new clump may eventually collide with another
* clump and will have to be merged
*/
/* try to connect the current cell to an existing clump */
OLD = NEW = 0;
/* same clump as to the left */
if (X == LEFT) {
OLD = cur_clump[col] = cur_clump[col - 1];
}
if (diag) {
/* check above right, center, left, in that order */
n = 2;
temp_clump = prev_clump + col + 1;
temp_cell = prev_in + col + 1;
do {
if (X == *temp_cell) {
cur_clump[col] = *temp_clump;
if (OLD == 0) {
OLD = *temp_clump;
}
else {
NEW = *temp_clump;
break;
}
}
temp_cell--;
temp_clump--;
} while (n-- > 0);
}
else {
/* check above */
if (X == prev_in[col]) {
temp_clump = prev_clump + col;
cur_clump[col] = *temp_clump;
if (OLD == 0) {
OLD = *temp_clump;
}
else {
NEW = *temp_clump;
}
}
}
if (NEW == 0 || OLD == NEW) { /* ok */
if (OLD == 0) {
/* start a new clump */
label++;
cur_clump[col] = label;
if (label >= nalloc) {
nalloc += INCR;
index =
(CELL *) G_realloc(index,
nalloc * sizeof(CELL));
}
index[label] = label;
}
continue;
}
/* conflict! preserve NEW clump ID and change OLD clump ID.
* Must go back to the left in the current row and to the right
* in the previous row to change all the clump values as well.
*/
/* left of the current row from 1 to col - 1 */
temp_clump = cur_clump;
n = col - 1;
while (n-- > 0) {
temp_clump++; /* skip left edge */
if (*temp_clump == OLD)
*temp_clump = NEW;
}
/* right of previous row from col + 1 to ncols */
temp_clump = prev_clump;
temp_clump += col;
n = ncols - col;
while (n-- > 0) {
temp_clump++; /* skip col */
if (*temp_clump == OLD)
*temp_clump = NEW;
}
/* modify the OLD index */
index[OLD] = NEW;
}
/* write initial clump IDs */
/* this works also with writing out cur_clump, but only
* prev_clump is complete and will not change any more */
if (row > 0) {
if (write(cfd, prev_clump + 1, csize) != csize)
G_fatal_error(_("Unable to write to temp file"));
}
/* switch the buffers so that the current buffer becomes the previous */
temp_cell = cur_in;
cur_in = prev_in;
prev_in = temp_cell;
temp_clump = cur_clump;
cur_clump = prev_clump;
prev_clump = temp_clump;
}
/* write last row with initial clump IDs */
if (write(cfd, prev_clump + 1, csize) != csize)
G_fatal_error(_("Unable to write to temp file"));
G_percent(1, 1, 1);
/* generate a renumbering scheme */
G_message(_("Generating renumbering scheme..."));
G_debug(1, "%d initial labels", label);
/* allocate final clump ID */
renumber = (CELL *) G_malloc((label + 1) * sizeof(CELL));
renumber[0] = 0;
cat = 1;
G_percent(0, label, 1);
for (n = 1; n <= label; n++) {
G_percent(n, label, 1);
OLD = n;
NEW = index[n];
if (OLD != NEW) {
renumber[n] = 0;
/* find valid clump ID */
while (OLD != NEW) {
OLD = NEW;
NEW = index[OLD];
}
index[n] = NEW;
}
else
/* set final clump id */
renumber[n] = cat++;
}
/* rewind temp file */
lseek(cfd, 0, SEEK_SET);
if (print) {
fprintf(stdout, "clumps=%d\n", cat - 1);
}
else {
/****************************************************
* PASS 2 *
* apply renumbering scheme to initial clump labels *
****************************************************/
/* the input raster is no longer needed,
* using instead the temp file with initial clump labels */
G_message(_("Pass 2 of 2..."));
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 4);
if (read(cfd, cur_clump, csize) != csize)
G_fatal_error(_("Unable to read from temp file"));
temp_clump = cur_clump;
temp_cell = out_cell;
for (col = 0; col < ncols; col++) {
*temp_cell = renumber[index[*temp_clump]];
if (*temp_cell == 0)
Rast_set_c_null_value(temp_cell, 1);
temp_clump++;
temp_cell++;
}
Rast_put_row(out_fd, out_cell, CELL_TYPE);
}
G_percent(1, 1, 1);
}
close(cfd);
unlink(cname);
print_time(&cur_time);
return 0;
}
/* Process the raster and do atmospheric corrections.
Params:
* INPUT FILE
ifd: input file descriptor
iref: input file has radiance values (default is reflectance) ?
iscale: input file's range (default is min = 0, max = 255)
ialt_fd: height map file descriptor, negative if global value is used
ivis_fd: visibility map file descriptor, negative if global value is used
* OUTPUT FILE
ofd: output file descriptor
oflt: if true use FCELL_TYPE for output
oscale: output file's range (default is min = 0, max = 255)
*/
static void process_raster(int ifd, InputMask imask, ScaleRange iscale,
int ialt_fd, int ivis_fd, int ofd, bool oint,
ScaleRange oscale)
{
FCELL *buf; /* buffer for the input values */
FCELL *alt = NULL; /* buffer for the elevation values */
FCELL *vis = NULL; /* buffer for the visibility values */
FCELL prev_alt = -1.f;
FCELL prev_vis = -1.f;
int row, col, nrows, ncols;
/* switch on optimization automatically if elevation and/or visibility map is given */
bool optimize = (ialt_fd >= 0 || ivis_fd >= 0);
#ifdef _NO_OPTIMIZE_
optimize = false;
#endif
/* do initial computation with global elevation and visibility values */
TransformInput ti;
ti = compute();
/* use a cache to increase computation speed when an elevation map
* and/or a visibility map is given */
TICache ticache;
/* allocate memory for buffers */
buf = (FCELL *) Rast_allocate_buf(FCELL_TYPE);
if (ialt_fd >= 0)
alt = (FCELL *) Rast_allocate_buf(FCELL_TYPE);
if (ivis_fd >= 0)
vis = (FCELL *) Rast_allocate_buf(FCELL_TYPE);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 1); /* keep the user informed of our progress */
/* read the next row */
Rast_get_row(ifd, buf, row, FCELL_TYPE);
/* read the next row of elevation values */
if (ialt_fd >= 0)
Rast_get_row(ialt_fd, alt, row, FCELL_TYPE);
/* read the next row of elevation values */
if (ivis_fd >= 0)
Rast_get_row(ivis_fd, vis, row, FCELL_TYPE);
/* loop over all the values in the row */
for (col = 0; col < ncols; col++) {
if ((vis && Rast_is_f_null_value(&vis[col])) ||
(alt && Rast_is_f_null_value(&alt[col])) ||
Rast_is_f_null_value(&buf[col])) {
Rast_set_f_null_value(&buf[col], 1);
continue;
}
if (ialt_fd >= 0) {
if (alt[col] < 0)
alt[col] = 0; /* on or below sea level, all the same for 6S */
else
alt[col] /= 1000.0f; /* converting to km from input which should be in meter */
/* round to nearest altitude bin */
/* rounding result: watch out for fp representation error */
alt[col] = ((int) (alt[col] * BIN_ALT + 0.5)) / BIN_ALT;
}
if (ivis_fd >= 0) {
if (vis[col] < 0)
vis[col] = 0; /* negative visibility is invalid, print a WARNING ? */
/* round to nearest visibility bin */
/* rounding result: watch out for fp representation error */
vis[col] = ((int) (vis[col] + 0.5));
}
/* check if both maps are active and if whether any value has changed */
if ((ialt_fd >= 0) && (ivis_fd >= 0) &&
((prev_vis != vis[col]) || (prev_alt != alt[col]))) {
prev_alt = alt[col]; /* update new values */
prev_vis = vis[col];
if (optimize) {
int in_cache = ticache.search(alt[col], vis[col], &ti);
if (!in_cache) {
pre_compute_hv(alt[col], vis[col]); /* re-compute transformation inputs */
ti = compute(); /* ... */
ticache.add(ti, alt[col], vis[col]);
}
}
else {
pre_compute_hv(alt[col], vis[col]); /* re-compute transformation inputs */
ti = compute(); /* ... */
}
}
else { /* only one of the maps is being used */
if ((ivis_fd >= 0) && (prev_vis != vis[col])) {
prev_vis = vis[col]; /* keep track of previous visibility */
if (optimize) {
int in_cache = ticache.search(0, vis[col], &ti);
if (!in_cache) {
pre_compute_v(vis[col]); /* re-compute transformation inputs */
ti = compute(); /* ... */
ticache.add(ti, 0, vis[col]);
}
}
else {
pre_compute_v(vis[col]); /* re-compute transformation inputs */
ti = compute(); /* ... */
}
}
if ((ialt_fd >= 0) && (prev_alt != alt[col])) {
prev_alt = alt[col]; /* keep track of previous altitude */
if (optimize) {
int in_cache = ticache.search(alt[col], 0, &ti);
if (!in_cache) {
pre_compute_h(alt[col]); /* re-compute transformation inputs */
ti = compute(); /* ... */
ticache.add(ti, alt[col], 0);
}
}
else {
pre_compute_h(alt[col]); /* re-compute transformation inputs */
ti = compute(); /* ... */
}
}
}
G_debug(3, "Computed r%d (%d), c%d (%d)", row, nrows, col, ncols);
/* transform from iscale.[min,max] to [0,1] */
buf[col] =
(buf[col] - iscale.min) / ((float)iscale.max -
(float)iscale.min);
buf[col] = transform(ti, imask, buf[col]);
/* transform from [0,1] to oscale.[min,max] */
buf[col] =
buf[col] * ((float)oscale.max - (float)oscale.min) +
oscale.min;
if (oint && (buf[col] > (float)oscale.max))
G_warning(_("The output data will overflow. Reflectance > 100%%"));
}
/* write output */
if (oint)
write_fp_to_cell(ofd, buf);
else
Rast_put_row(ofd, buf, FCELL_TYPE);
}
G_percent(1, 1, 1);
/* free allocated memory */
G_free(buf);
if (ialt_fd >= 0)
G_free(alt);
if (ivis_fd >= 0)
G_free(vis);
}
int main(int argc, char *argv[])
{
int r, c;
DCELL con1, con2;
double d1, d2;
DCELL *alt_row;
const char *con_name, *alt_name;
int file_fd;
DCELL value;
struct History history;
struct GModule *module;
struct Option *opt1, *opt2;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("surface"));
G_add_keyword(_("interpolation"));
module->description =
_("Generates surface raster map from rasterized contours.");
opt1 = G_define_standard_option(G_OPT_R_INPUT);
opt1->description = _("Name of input raster map containing contours");
opt2 = G_define_standard_option(G_OPT_R_OUTPUT);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
con_name = opt1->answer;
alt_name = opt2->answer;
nrows = Rast_window_rows();
ncols = Rast_window_cols();
i_val_l_f = nrows + ncols;
con = read_cell(con_name);
alt_row = (DCELL *) G_malloc(ncols * sizeof(DCELL));
seen = flag_create(nrows, ncols);
mask = flag_create(nrows, ncols);
if (NULL != G_find_file("cell", "MASK", G_mapset())) {
file_fd = Rast_open_old("MASK", G_mapset());
for (r = 0; r < nrows; r++) {
Rast_get_d_row_nomask(file_fd, alt_row, r);
for (c = 0; c < ncols; c++)
if (Rast_is_d_null_value(&(alt_row[c])) || alt_row[c] == 0)
FLAG_SET(mask, r, c);
}
Rast_close(file_fd);
}
zero = (NODE *) G_malloc(INIT_AR * sizeof(NODE));
minc = minr = 0;
maxc = ncols - 1;
maxr = nrows - 1;
array_size = INIT_AR;
file_fd = Rast_open_new(alt_name, DCELL_TYPE);
for (r = 0; r < nrows; r++) {
G_percent(r, nrows, 1);
Rast_set_d_null_value(alt_row, ncols);
for (c = 0; c < ncols; c++) {
if (FLAG_GET(mask, r, c))
continue;
value = con[r][c];
if (!Rast_is_d_null_value(&value)) {
alt_row[c] = value;
continue;
}
find_con(r, c, &d1, &d2, &con1, &con2);
if (!Rast_is_d_null_value(&con2))
alt_row[c] = d2 * con1 / (d1 + d2) +
d1 * con2 / (d1 + d2);
else
alt_row[c] = con1;
}
Rast_put_row(file_fd, alt_row, DCELL_TYPE);
}
G_percent(1, 1, 1);
free_cell(con);
flag_destroy(seen);
flag_destroy(mask);
Rast_close(file_fd);
Rast_short_history(alt_name, "raster", &history);
Rast_command_history(&history);
Rast_write_history(alt_name, &history);
exit(EXIT_SUCCESS);
}
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)
{
unsigned char *hue_n, *hue_r, *hue_g, *hue_b;
unsigned char *int_n, *int_r;
unsigned char *sat_n, *sat_r;
unsigned char *dummy;
CELL *r_array, *g_array, *b_array;
char *name_h, *name_i, *name_s;
int intensity;
int saturation;
int atrow, atcol;
int hue_file;
int int_file = 0;
int int_used;
int sat_file = 0;
int sat_used;
char *name_r, *name_g, *name_b;
int r_file = 0;
int r_used;
int g_file = 0;
int g_used;
int b_file = 0;
int b_used;
struct Cell_head window;
struct Colors hue_colors;
struct Colors int_colors;
struct Colors sat_colors;
struct Colors gray_colors;
struct History history;
struct GModule *module;
struct Option *opt_h, *opt_i, *opt_s;
struct Option *opt_r, *opt_g, *opt_b;
struct Flag *nulldraw;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("color transformation"));
G_add_keyword(_("RGB"));
G_add_keyword(_("HIS"));
module->description =
_("Generates red, green and blue raster map layers "
"combining hue, intensity and saturation (HIS) "
"values from user-specified input raster map layers.");
opt_h = G_define_option();
opt_h->key = "h_map";
opt_h->type = TYPE_STRING;
opt_h->required = YES;
opt_h->gisprompt = "old,cell,raster";
opt_h->description = _("Name of layer to be used for HUE");
opt_i = G_define_option();
opt_i->key = "i_map";
opt_i->type = TYPE_STRING;
opt_i->required = NO;
opt_i->gisprompt = "old,cell,raster";
opt_i->description = _("Name of layer to be used for INTENSITY");
opt_s = G_define_option();
opt_s->key = "s_map";
opt_s->type = TYPE_STRING;
opt_s->required = NO;
opt_s->gisprompt = "old,cell,raster";
opt_s->description = _("Name of layer to be used for SATURATION");
opt_r = G_define_option();
opt_r->key = "r_map";
opt_r->type = TYPE_STRING;
opt_r->required = YES;
opt_r->gisprompt = "new,cell,raster";
opt_r->description = _("Name of output layer to be used for RED");
opt_g = G_define_option();
opt_g->key = "g_map";
opt_g->type = TYPE_STRING;
opt_g->required = YES;
opt_g->gisprompt = "new,cell,raster";
opt_g->description = _("Name of output layer to be used for GREEN");
opt_b = G_define_option();
opt_b->key = "b_map";
opt_b->type = TYPE_STRING;
opt_b->required = YES;
opt_b->gisprompt = "new,cell,raster";
opt_b->description = _("Name of output layer to be used for BLUE");
nulldraw = G_define_flag();
nulldraw->key = 'n';
nulldraw->description = _("Respect NULL values while drawing");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* read in current window */
G_get_window(&window);
/* Get name of layer to be used for hue */
name_h = opt_h->answer;
/* Make sure map is available */
hue_file = Rast_open_old(name_h, "");
hue_r = G_malloc(window.cols);
hue_g = G_malloc(window.cols);
hue_b = G_malloc(window.cols);
hue_n = G_malloc(window.cols);
dummy = G_malloc(window.cols);
/* Reading color lookup table */
if (Rast_read_colors(name_h, "", &hue_colors) == -1)
G_fatal_error(_("Color file for <%s> not available"), name_h);
int_used = 0;
if (opt_i->answer != NULL) {
/* Get name of layer to be used for intensity */
name_i = opt_i->answer;
int_used = 1;
/* Make sure map is available */
int_file = Rast_open_old(name_i, "");
int_r = G_malloc(window.cols);
int_n = G_malloc(window.cols);
/* Reading color lookup table */
if (Rast_read_colors(name_i, "", &int_colors) == -1)
G_fatal_error(_("Color file for <%s> not available"), name_i);
}
sat_used = 0;
if (opt_s->answer != NULL) {
/* Get name of layer to be used for saturation */
name_s = opt_s->answer;
sat_used = 1;
/* Make sure map is available */
sat_file = Rast_open_old(name_s, "");
sat_r = G_malloc(window.cols);
sat_n = G_malloc(window.cols);
/* Reading color lookup table */
if (Rast_read_colors(name_s, "", &sat_colors) == -1)
G_fatal_error(_("Color file for <%s> not available"), name_s);
}
r_used = 0;
if (opt_r->answer != NULL) {
name_r = opt_r->answer;
r_file = Rast_open_c_new(name_r);
r_used = 1;
}
g_used = 0;
if (opt_g->answer != NULL) {
name_g = opt_g->answer;
g_file = Rast_open_c_new(name_g);
g_used = 1;
}
b_used = 0;
if (opt_b->answer != NULL) {
name_b = opt_b->answer;
b_file = Rast_open_c_new(name_b);
b_used = 1;
}
r_array = Rast_allocate_c_buf();
g_array = Rast_allocate_c_buf();
b_array = Rast_allocate_c_buf();
/* Make color table */
make_gray_scale(&gray_colors);
/* Now do the work */
intensity = 255; /* default is to not change intensity */
saturation = 255; /* default is to not change saturation */
for (atrow = 0; atrow < window.rows; atrow++) {
G_percent(atrow, window.rows, 2);
Rast_get_row_colors(hue_file, atrow, &hue_colors, hue_r, hue_g, hue_b, hue_n);
if (int_used)
Rast_get_row_colors(int_file, atrow, &int_colors, int_r, dummy, dummy, int_n);
if (sat_used)
Rast_get_row_colors(sat_file, atrow, &sat_colors, sat_r, dummy, dummy, sat_n);
for (atcol = 0; atcol < window.cols; atcol++) {
if (nulldraw->answer) {
if (hue_n[atcol]
|| (int_used && int_n[atcol])
|| (sat_used && sat_n[atcol])) {
Rast_set_c_null_value(&r_array[atcol], 1);
Rast_set_c_null_value(&g_array[atcol], 1);
Rast_set_c_null_value(&b_array[atcol], 1);
continue;
}
}
if (int_used)
intensity = int_r[atcol];
if (sat_used)
saturation = sat_r[atcol];
HIS_to_RGB(hue_r[atcol], hue_g[atcol], hue_b[atcol],
intensity, saturation,
&r_array[atcol], &g_array[atcol], &b_array[atcol]);
}
if (r_used)
Rast_put_row(r_file, r_array, CELL_TYPE);
if (g_used)
Rast_put_row(g_file, g_array, CELL_TYPE);
if (b_used)
Rast_put_row(b_file, b_array, CELL_TYPE);
}
G_percent(window.rows, window.rows, 5);
/* Close the cell files */
Rast_close(hue_file);
if (int_used)
Rast_close(int_file);
if (sat_used)
Rast_close(sat_file);
if (r_used) {
Rast_close(r_file);
Rast_write_colors(name_r, G_mapset(), &gray_colors);
Rast_short_history(name_r, "raster", &history);
Rast_command_history(&history);
Rast_write_history(name_r, &history);
Rast_put_cell_title(name_r, "Red extracted from HIS");
}
if (g_used) {
Rast_close(g_file);
Rast_write_colors(name_g, G_mapset(), &gray_colors);
Rast_short_history(name_g, "raster", &history);
Rast_command_history(&history);
Rast_write_history(name_g, &history);
Rast_put_cell_title(name_g, "Green extracted from HIS");
}
if (b_used) {
Rast_close(b_file);
Rast_write_colors(name_b, G_mapset(), &gray_colors);
Rast_short_history(name_b, "raster", &history);
Rast_command_history(&history);
Rast_write_history(name_b, &history);
Rast_put_cell_title(name_b, "Blue extracted from HIS");
}
return EXIT_SUCCESS;
}
static int
write_pca(double **eigmat, int *inp_fd, char *out_basename,
int bands, int scale, int scale_min, int scale_max)
{
int i, j;
void *outbuf, *outptr;
double min = 0.;
double max = 0.;
double old_range = 0.;
double new_range = 0.;
int rows = Rast_window_rows();
int cols = Rast_window_cols();
int cell_mapsiz = Rast_cell_size(CELL_TYPE);
int dcell_mapsiz = Rast_cell_size(DCELL_TYPE);
DCELL *d_buf;
/* 2 passes for rescale. 1 pass for no rescale */
int PASSES = (scale) ? 2 : 1;
/* temporary row storage */
d_buf = (DCELL *) G_malloc(cols * sizeof(double));
/* allocate memory for output row buffer */
outbuf = (scale) ? Rast_allocate_buf(CELL_TYPE) :
Rast_allocate_buf(DCELL_TYPE);
if (!outbuf)
G_fatal_error(_("Unable to allocate memory for raster row"));
for (i = 0; i < bands; i++) {
char name[100];
int out_fd;
int pass;
sprintf(name, "%s.%d", out_basename, i + 1);
G_message(_("Transforming <%s>..."), name);
/* open a new file for output */
if (scale)
out_fd = Rast_open_c_new(name);
else {
out_fd = Rast_open_fp_new(name);
Rast_set_fp_type(DCELL_TYPE);
}
for (pass = 1; pass <= PASSES; pass++) {
void *rowbuf = NULL;
int row, col;
if (scale && (pass == PASSES)) {
G_message(_("Rescaling <%s> to range %d,%d..."),
name, scale_min, scale_max);
old_range = max - min;
new_range = (double)(scale_max - scale_min);
}
for (row = 0; row < rows; row++) {
void *rowptr;
G_percent(row, rows, 2);
/* reset d_buf */
for (col = 0; col < cols; col++)
d_buf[col] = 0.;
for (j = 0; j < bands; j++) {
RASTER_MAP_TYPE maptype =
Rast_get_map_type(inp_fd[j]);
/* don't assume each image is of the same type */
if (rowbuf)
G_free(rowbuf);
if (!(rowbuf = Rast_allocate_buf(maptype)))
G_fatal_error(_("Unable allocate memory for row buffer"));
Rast_get_row(inp_fd[j], rowbuf, row, maptype);
rowptr = rowbuf;
outptr = outbuf;
/* add into the output cell eigmat[i][j] * corresp cell
* of j-th band for current j */
for (col = 0; col < cols; col++) {
/* handle null cells */
if (Rast_is_null_value(rowptr, maptype)) {
if (scale) {
Rast_set_null_value(outptr, 1, CELL_TYPE);
outptr = G_incr_void_ptr(outptr, cell_mapsiz);
}
else {
Rast_set_null_value(outptr, 1, DCELL_TYPE);
outptr =
G_incr_void_ptr(outptr, dcell_mapsiz);
}
rowptr =
G_incr_void_ptr(rowptr,
Rast_cell_size(maptype));
continue;
}
/* corresp. cell of j-th band */
d_buf[col] +=
eigmat[i][j] * Rast_get_d_value(rowptr,
maptype);
/* the cell entry is complete */
if (j == (bands - 1)) {
if (scale && (pass == 1)) {
if ((row == 0) && (col == 0))
min = max = d_buf[0];
if (d_buf[col] < min)
min = d_buf[col];
if (d_buf[col] > max)
max = d_buf[col];
}
else if (scale) {
if (min == max) {
Rast_set_c_value(outptr, 1,
CELL_TYPE);
}
else {
/* map data to 0, (new_range-1) and then adding new_min */
CELL tmpcell =
round_c((new_range *
(d_buf[col] -
min) / old_range) +
scale_min);
Rast_set_c_value(outptr, tmpcell,
CELL_TYPE);
}
}
else { /* (!scale) */
Rast_set_d_value(outptr, d_buf[col],
DCELL_TYPE);
}
}
outptr = (scale) ?
G_incr_void_ptr(outptr, cell_mapsiz) :
G_incr_void_ptr(outptr, dcell_mapsiz);
rowptr =
G_incr_void_ptr(rowptr, Rast_cell_size(maptype));
}
} /* for j = 0 to bands */
if (pass == PASSES) {
if (scale)
Rast_put_row(out_fd, outbuf, CELL_TYPE);
else
Rast_put_row(out_fd, outbuf, DCELL_TYPE);
}
}
G_percent(row, rows, 2);
/* close output file */
if (pass == PASSES)
Rast_close(out_fd);
}
}
if (d_buf)
G_free(d_buf);
if (outbuf)
G_free(outbuf);
return 0;
}
void Indep(void)
{
int Count, DRow, DCol;
int Found, R, C;
double RowDist, RowDistSq, ColDist;
struct History history;
G_debug(2, "indep()");
Count = 0;
Found = 0;
while (CellCount > 0) {
G_debug(3, "(CellCount):%d", CellCount);
G_debug(3, "(Count):%d", Count);
DRow = DoNext[Count].R;
DCol = DoNext[Count++].C;
if (0 != FlagGet(Cells, DRow, DCol)) {
/* FLAG_SET( Out, DRow, DCol); */
Out[DRow][DCol] = ++Found;
for (R = DRow; R < Rs; R++) {
RowDist = NS * (R - DRow);
if (RowDist > MaxDistSq) {
R = Rs;
}
else {
RowDistSq = RowDist * RowDist;
for (C = DCol; C < Cs; C++) {
ColDist = EW * (C - DCol);
G_debug(3, "(RowDistSq):%.12lf", RowDistSq);
G_debug(3, "(ColDist):%.12lf", ColDist);
G_debug(3, "(MaxDistSq):%.12lf", MaxDistSq);
if (MaxDistSq >= RowDistSq + ColDist * ColDist) {
if (0 != FlagGet(Cells, R, C)) {
G_debug(2, "unset()");
FLAG_UNSET(Cells, R, C);
CellCount--;
}
}
else {
C = Cs;
}
}
}
}
G_debug(2, "it1()");
for (R = DRow - 1; R >= 0; R--) {
RowDist = NS * (DRow - R);
if (RowDist > MaxDistSq) {
R = 0;
}
else {
RowDistSq = RowDist * RowDist;
for (C = DCol; C < Cs; C++) {
ColDist = EW * (C - DCol);
if (MaxDistSq >= RowDistSq + ColDist * ColDist) {
if (0 != FlagGet(Cells, R, C)) {
G_debug(2, "unset()");
FLAG_UNSET(Cells, R, C);
CellCount--;
}
}
else {
C = Cs;
}
}
}
}
G_debug(2, "it2()");
for (R = DRow; R < Rs; R++) {
RowDist = NS * (R - DRow);
if (RowDist > MaxDistSq) {
R = Rs;
}
else {
RowDistSq = RowDist * RowDist;
for (C = DCol - 1; C >= 0; C--) {
ColDist = EW * (DCol - C);
if (MaxDistSq >= RowDistSq + ColDist * ColDist) {
if (0 != FlagGet(Cells, R, C)) {
G_debug(2, "unset()");
FLAG_UNSET(Cells, R, C);
CellCount--;
}
}
else {
C = 0;
}
}
}
}
G_debug(2, "it3()");
for (R = DRow - 1; R >= 0; R--) {
RowDist = NS * (DRow - R);
if (RowDist > MaxDistSq) {
R = 0;
}
else {
RowDistSq = RowDist * RowDist;
for (C = DCol - 1; C >= 0; C--) {
ColDist = EW * (DCol - C);
if (MaxDistSq >= RowDistSq + ColDist * ColDist) {
if (0 != FlagGet(Cells, R, C)) {
G_debug(2, "unset()");
FLAG_UNSET(Cells, R, C);
CellCount--;
}
}
else {
C = 0;
}
}
}
}
}
}
G_debug(2, "outputting()");
OutFD = Rast_open_c_new(Output->answer);
G_message(_("Writing raster map <%s>..."),
Output->answer);
for (R = 0; R < Rs; R++) {
G_percent(R, Rs, 2);
for (C = 0; C < Cs; C++) {
CellBuffer[C] = Out[R][C];
}
Rast_put_row(OutFD, CellBuffer, CELL_TYPE);
}
G_percent(1, 1, 1);
Rast_close(OutFD);
Rast_short_history(Output->answer, "raster", &history);
Rast_command_history(&history);
Rast_write_history(Output->answer, &history);
}
int main(int argc, char *argv[])
{
struct GModule *module;
int infile;
const char *mapset;
size_t cell_size;
int ytile, xtile, y, overlap;
int *outfiles;
void *inbuf;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("tiling"));
module->description =
_("Splits a raster map into tiles.");
parm.rastin = G_define_standard_option(G_OPT_R_INPUT);
parm.rastout = G_define_option();
parm.rastout->key = "output";
parm.rastout->type = TYPE_STRING;
parm.rastout->required = YES;
parm.rastout->multiple = NO;
parm.rastout->description = _("Output base name");
parm.width = G_define_option();
parm.width->key = "width";
parm.width->type = TYPE_INTEGER;
parm.width->required = YES;
parm.width->multiple = NO;
parm.width->description = _("Width of tiles (columns)");
parm.height = G_define_option();
parm.height->key = "height";
parm.height->type = TYPE_INTEGER;
parm.height->required = YES;
parm.height->multiple = NO;
parm.height->description = _("Height of tiles (rows)");
parm.overlap = G_define_option();
parm.overlap->key = "overlap";
parm.overlap->type = TYPE_INTEGER;
parm.overlap->required = NO;
parm.overlap->multiple = NO;
parm.overlap->description = _("Overlap of tiles");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_get_set_window(&src_w);
overlap = parm.overlap->answer ? atoi(parm.overlap->answer) : 0;
mapset = G_find_raster2(parm.rastin->answer, "");
if (mapset == NULL)
G_fatal_error(_("Raster map <%s> not found"), parm.rastin->answer);
/* set window to old map */
Rast_get_cellhd(parm.rastin->answer, "", &src_w);
dst_w = src_w;
dst_w.cols = atoi(parm.width->answer);
dst_w.rows = atoi(parm.height->answer);
G_adjust_Cell_head(&dst_w, 1, 1);
xtiles = (src_w.cols + dst_w.cols - 1) / dst_w.cols;
ytiles = (src_w.rows + dst_w.rows - 1) / dst_w.rows;
G_debug(1, "X: %d * %d, Y: %d * %d",
xtiles, dst_w.cols, ytiles, dst_w.rows);
src_w.cols = xtiles * dst_w.cols + 2 * overlap;
src_w.rows = ytiles * dst_w.rows + 2 * overlap;
src_w.west = src_w.west - overlap * src_w.ew_res;
src_w.east = src_w.west + (src_w.cols + 2 * overlap) * src_w.ew_res;
src_w.north = src_w.north + overlap * src_w.ns_res;
src_w.south = src_w.north - (src_w.rows + 2 * overlap) * src_w.ns_res;
Rast_set_input_window(&src_w);
/* set the output region */
ovl_w = dst_w;
ovl_w.cols = ovl_w.cols + 2 * overlap;
ovl_w.rows = ovl_w.rows + 2 * overlap;
G_adjust_Cell_head(&ovl_w, 1, 1);
Rast_set_output_window(&ovl_w);
infile = Rast_open_old(parm.rastin->answer, "");
map_type = Rast_get_map_type(infile);
cell_size = Rast_cell_size(map_type);
inbuf = Rast_allocate_input_buf(map_type);
outfiles = G_malloc(xtiles * sizeof(int));
G_debug(1, "X: %d * %d, Y: %d * %d",
xtiles, dst_w.cols, ytiles, dst_w.rows);
G_message(_("Generating %d x %d = %d tiles..."), xtiles, ytiles, xtiles * ytiles);
for (ytile = 0; ytile < ytiles; ytile++) {
G_debug(1, "reading y tile: %d", ytile);
G_percent(ytile, ytiles, 2);
for (xtile = 0; xtile < xtiles; xtile++) {
char name[GNAME_MAX];
sprintf(name, "%s-%03d-%03d", parm.rastout->answer, ytile, xtile);
outfiles[xtile] = Rast_open_new(name, map_type);
}
for (y = 0; y < ovl_w.rows; y++) {
int row = ytile * dst_w.rows + y;
G_debug(1, "reading row: %d", row);
Rast_get_row(infile, inbuf, row, map_type);
for (xtile = 0; xtile < xtiles; xtile++) {
int cells = xtile * dst_w.cols;
void *ptr = G_incr_void_ptr(inbuf, cells * cell_size);
Rast_put_row(outfiles[xtile], ptr, map_type);
}
}
for (xtile = 0; xtile < xtiles; xtile++) {
Rast_close(outfiles[xtile]);
write_support_files(xtile, ytile, overlap);
}
}
Rast_close(infile);
return EXIT_SUCCESS;
}
int main( int argc, char **argv )
{
char *name = nullptr;
struct Option *map;
struct Cell_head window;
G_gisinit( argv[0] );
G_define_module();
map = G_define_standard_option( G_OPT_R_OUTPUT );
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
name = map->answer;
#ifdef Q_OS_WIN
_setmode( _fileno( stdin ), _O_BINARY );
_setmode( _fileno( stdout ), _O_BINARY );
//setvbuf( stdin, NULL, _IONBF, BUFSIZ );
// setting _IONBF on stdout works on windows correctly, data written immediately even without fflush(stdout)
//setvbuf( stdout, NULL, _IONBF, BUFSIZ );
#endif
QgsGrassDataFile stdinFile;
stdinFile.open( stdin );
QDataStream stdinStream( &stdinFile );
QFile stdoutFile;
stdoutFile.open( stdout, QIODevice::WriteOnly | QIODevice::Unbuffered );
QDataStream stdoutStream( &stdoutFile );
qint32 proj, zone;
stdinStream >> proj >> zone;
QgsRectangle extent;
qint32 rows, cols;
stdinStream >> extent >> cols >> rows;
checkStream( stdinStream );
QString err = QgsGrass::setRegion( &window, extent, rows, cols );
if ( !err.isEmpty() )
{
G_fatal_error( "Cannot set region: %s", err.toUtf8().constData() );
}
window.proj = ( int ) proj;
window.zone = ( int ) zone;
G_set_window( &window );
Qgis::DataType qgis_type;
qint32 type;
stdinStream >> type;
checkStream( stdinStream );
qgis_type = ( Qgis::DataType )type;
RASTER_MAP_TYPE grass_type;
switch ( qgis_type )
{
case Qgis::Int32:
grass_type = CELL_TYPE;
break;
case Qgis::Float32:
grass_type = FCELL_TYPE;
break;
case Qgis::Float64:
grass_type = DCELL_TYPE;
break;
default:
G_fatal_error( "QGIS data type %d not supported", qgis_type );
return 1;
}
cf = Rast_open_new( name, grass_type );
if ( cf < 0 )
{
G_fatal_error( "Unable to create raster map <%s>", name );
return 1;
}
void *buf = Rast_allocate_buf( grass_type );
int expectedSize = cols * QgsRasterBlock::typeSize( qgis_type );
bool isCanceled = false;
QByteArray byteArray;
for ( int row = 0; row < rows; row++ )
{
stdinStream >> isCanceled;
checkStream( stdinStream );
if ( isCanceled )
{
break;
}
double noDataValue;
stdinStream >> noDataValue;
stdinStream >> byteArray;
checkStream( stdinStream );
if ( byteArray.size() != expectedSize )
{
G_fatal_error( "Wrong byte array size, expected %d bytes, got %d, row %d / %d", expectedSize, byteArray.size(), row, rows );
return 1;
}
qint32 *cell = nullptr;
float *fcell = nullptr;
double *dcell = nullptr;
if ( grass_type == CELL_TYPE )
cell = ( qint32 * ) byteArray.data();
else if ( grass_type == FCELL_TYPE )
fcell = ( float * ) byteArray.data();
else if ( grass_type == DCELL_TYPE )
dcell = ( double * ) byteArray.data();
void *ptr = buf;
for ( int col = 0; col < cols; col++ )
{
if ( grass_type == CELL_TYPE )
{
if ( ( CELL )cell[col] == ( CELL )noDataValue )
{
Rast_set_c_null_value( ( CELL * )ptr, 1 );
}
else
{
Rast_set_c_value( ptr, ( CELL )( cell[col] ), grass_type );
}
}
else if ( grass_type == FCELL_TYPE )
{
if ( ( FCELL )fcell[col] == ( FCELL )noDataValue )
{
Rast_set_f_null_value( ( FCELL * )ptr, 1 );
}
else
{
Rast_set_f_value( ptr, ( FCELL )( fcell[col] ), grass_type );
}
}
else if ( grass_type == DCELL_TYPE )
{
if ( ( DCELL )dcell[col] == ( DCELL )noDataValue )
{
Rast_set_d_null_value( ( DCELL * )ptr, 1 );
}
else
{
Rast_set_d_value( ptr, ( DCELL )dcell[col], grass_type );
}
}
ptr = G_incr_void_ptr( ptr, Rast_cell_size( grass_type ) );
}
Rast_put_row( cf, buf, grass_type );
#ifndef Q_OS_WIN
// Because stdin is somewhere buffered on Windows (not clear if in QProcess or by Windows)
// we cannot in QgsGrassImport wait for this because it hangs. Setting _IONBF on stdin does not help
// and there is no flush() on QProcess.
// OTOH, smaller stdin buffer is probably blocking QgsGrassImport so that the import can be canceled immediately.
stdoutStream << ( bool )true; // row written
stdoutFile.flush();
#endif
}
if ( isCanceled )
{
Rast_unopen( cf );
}
else
{
Rast_close( cf );
struct History history;
Rast_short_history( name, "raster", &history );
Rast_command_history( &history );
Rast_write_history( name, &history );
}
exit( EXIT_SUCCESS );
}
int close_maps(char *stream_rast, char *stream_vect, char *dir_rast)
{
int stream_fd, dir_fd, r, c, i;
CELL *cell_buf1, *cell_buf2;
struct History history;
CELL stream_id;
ASP_FLAG af;
/* cheating... */
stream_fd = dir_fd = -1;
cell_buf1 = cell_buf2 = NULL;
G_message(_("Writing output raster maps..."));
/* write requested output rasters */
if (stream_rast) {
stream_fd = Rast_open_new(stream_rast, CELL_TYPE);
cell_buf1 = Rast_allocate_c_buf();
}
if (dir_rast) {
dir_fd = Rast_open_new(dir_rast, CELL_TYPE);
cell_buf2 = Rast_allocate_c_buf();
}
for (r = 0; r < nrows; r++) {
G_percent(r, nrows, 2);
if (stream_rast)
Rast_set_c_null_value(cell_buf1, ncols); /* reset row to all NULL */
if (dir_rast)
Rast_set_c_null_value(cell_buf2, ncols); /* reset row to all NULL */
for (c = 0; c < ncols; c++) {
if (stream_rast) {
cseg_get(&stream, &stream_id, r, c);
if (stream_id)
cell_buf1[c] = stream_id;
}
if (dir_rast) {
seg_get(&aspflag, (char *)&af, r, c);
if (!FLAG_GET(af.flag, NULLFLAG)) {
cell_buf2[c] = af.asp;
}
}
}
if (stream_rast)
Rast_put_row(stream_fd, cell_buf1, CELL_TYPE);
if (dir_rast)
Rast_put_row(dir_fd, cell_buf2, CELL_TYPE);
}
G_percent(nrows, nrows, 2); /* finish it */
if (stream_rast) {
Rast_close(stream_fd);
G_free(cell_buf1);
Rast_short_history(stream_rast, "raster", &history);
Rast_command_history(&history);
Rast_write_history(stream_rast, &history);
}
if (dir_rast) {
struct Colors colors;
Rast_close(dir_fd);
G_free(cell_buf2);
Rast_short_history(dir_rast, "raster", &history);
Rast_command_history(&history);
Rast_write_history(dir_rast, &history);
Rast_init_colors(&colors);
Rast_make_aspect_colors(&colors, -8, 8);
Rast_write_colors(dir_rast, G_mapset(), &colors);
}
/* close stream vector */
if (stream_vect) {
if (close_streamvect(stream_vect) < 0)
G_fatal_error(_("Unable to write vector map <%s>"), stream_vect);
}
/* rearranging desk chairs on the Titanic... */
G_free(outlets);
/* free stream nodes */
for (i = 1; i <= n_stream_nodes; i++) {
if (stream_node[i].n_alloc > 0) {
G_free(stream_node[i].trib);
}
}
G_free(stream_node);
return 1;
}
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)
{
char *mapname, /* ptr to name of output layer */
*setname, /* ptr to name of input mapset */
*ipolname; /* name of interpolation method */
int fdi, /* input map file descriptor */
fdo, /* output map file descriptor */
method, /* position of method in table */
permissions, /* mapset permissions */
cell_type, /* output celltype */
cell_size, /* size of a cell in bytes */
row, col, /* counters */
irows, icols, /* original rows, cols */
orows, ocols, have_colors, /* Input map has a colour table */
overwrite, /* Overwrite */
curr_proj; /* output projection (see gis.h) */
void *obuffer, /* buffer that holds one output row */
*obufptr; /* column ptr in output buffer */
struct cache *ibuffer; /* buffer that holds the input map */
func interpolate; /* interpolation routine */
double xcoord1, xcoord2, /* temporary x coordinates */
ycoord1, ycoord2, /* temporary y coordinates */
col_idx, /* column index in input matrix */
row_idx, /* row index in input matrix */
onorth, osouth, /* save original border coords */
oeast, owest, inorth, isouth, ieast, iwest;
char north_str[30], south_str[30], east_str[30], west_str[30];
struct Colors colr; /* Input map colour table */
struct History history;
struct pj_info iproj, /* input map proj parameters */
oproj; /* output map proj parameters */
struct Key_Value *in_proj_info, /* projection information of */
*in_unit_info, /* input and output mapsets */
*out_proj_info, *out_unit_info;
struct GModule *module;
struct Flag *list, /* list files in source location */
*nocrop, /* don't crop output map */
*print_bounds, /* print output bounds and exit */
*gprint_bounds; /* same but print shell style */
struct Option *imapset, /* name of input mapset */
*inmap, /* name of input layer */
*inlocation, /* name of input location */
*outmap, /* name of output layer */
*indbase, /* name of input database */
*interpol, /* interpolation method:
nearest neighbor, bilinear, cubic */
*memory, /* amount of memory for cache */
*res; /* resolution of target map */
struct Cell_head incellhd, /* cell header of input map */
outcellhd; /* and output map */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("projection"));
G_add_keyword(_("transformation"));
module->description =
_("Re-projects a raster map from given location to the current location.");
inmap = G_define_standard_option(G_OPT_R_INPUT);
inmap->description = _("Name of input raster map to re-project");
inmap->required = NO;
inmap->guisection = _("Source");
inlocation = G_define_option();
inlocation->key = "location";
inlocation->type = TYPE_STRING;
inlocation->required = YES;
inlocation->description = _("Location containing input raster map");
inlocation->gisprompt = "old,location,location";
inlocation->key_desc = "name";
imapset = G_define_standard_option(G_OPT_M_MAPSET);
imapset->label = _("Mapset containing input raster map");
imapset->description = _("default: name of current mapset");
imapset->guisection = _("Source");
indbase = G_define_option();
indbase->key = "dbase";
indbase->type = TYPE_STRING;
indbase->required = NO;
indbase->description = _("Path to GRASS database of input location");
indbase->gisprompt = "old,dbase,dbase";
indbase->key_desc = "path";
indbase->guisection = _("Source");
outmap = G_define_standard_option(G_OPT_R_OUTPUT);
outmap->required = NO;
outmap->description = _("Name for output raster map (default: same as 'input')");
outmap->guisection = _("Target");
ipolname = make_ipol_list();
interpol = G_define_option();
interpol->key = "method";
interpol->type = TYPE_STRING;
interpol->required = NO;
interpol->answer = "nearest";
interpol->options = ipolname;
interpol->description = _("Interpolation method to use");
interpol->guisection = _("Target");
interpol->descriptions = make_ipol_desc();
memory = G_define_option();
memory->key = "memory";
memory->type = TYPE_INTEGER;
memory->required = NO;
memory->description = _("Cache size (MiB)");
res = G_define_option();
res->key = "resolution";
res->type = TYPE_DOUBLE;
res->required = NO;
res->description = _("Resolution of output raster map");
res->guisection = _("Target");
list = G_define_flag();
list->key = 'l';
list->description = _("List raster maps in input location and exit");
nocrop = G_define_flag();
nocrop->key = 'n';
nocrop->description = _("Do not perform region cropping optimization");
print_bounds = G_define_flag();
print_bounds->key = 'p';
print_bounds->description =
_("Print input map's bounds in the current projection and exit");
print_bounds->guisection = _("Target");
gprint_bounds = G_define_flag();
gprint_bounds->key = 'g';
gprint_bounds->description =
_("Print input map's bounds in the current projection and exit (shell style)");
gprint_bounds->guisection = _("Target");
/* The parser checks if the map already exists in current mapset,
we switch out the check and do it
in the module after the parser */
overwrite = G_check_overwrite(argc, argv);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* get the method */
for (method = 0; (ipolname = menu[method].name); method++)
if (strcmp(ipolname, interpol->answer) == 0)
break;
if (!ipolname)
G_fatal_error(_("<%s=%s> unknown %s"),
interpol->key, interpol->answer, interpol->key);
interpolate = menu[method].method;
mapname = outmap->answer ? outmap->answer : inmap->answer;
if (mapname && !list->answer && !overwrite &&
G_find_raster(mapname, G_mapset()))
G_fatal_error(_("option <%s>: <%s> exists."), "output", mapname);
setname = imapset->answer ? imapset->answer : G_store(G_mapset());
if (strcmp(inlocation->answer, G_location()) == 0 &&
(!indbase->answer || strcmp(indbase->answer, G_gisdbase()) == 0))
#if 0
G_fatal_error(_("Input and output locations can not be the same"));
#else
G_warning(_("Input and output locations are the same"));
#endif
G_get_window(&outcellhd);
if(gprint_bounds->answer && !print_bounds->answer)
print_bounds->answer = gprint_bounds->answer;
curr_proj = G_projection();
/* Get projection info for output mapset */
if ((out_proj_info = G_get_projinfo()) == NULL)
G_fatal_error(_("Unable to get projection info of output raster map"));
if ((out_unit_info = G_get_projunits()) == NULL)
G_fatal_error(_("Unable to get projection units of output raster map"));
if (pj_get_kv(&oproj, out_proj_info, out_unit_info) < 0)
G_fatal_error(_("Unable to get projection key values of output raster map"));
/* Change the location */
G__create_alt_env();
G__setenv("GISDBASE", indbase->answer ? indbase->answer : G_gisdbase());
G__setenv("LOCATION_NAME", inlocation->answer);
permissions = G__mapset_permissions(setname);
if (permissions < 0) /* can't access mapset */
G_fatal_error(_("Mapset <%s> in input location <%s> - %s"),
setname, inlocation->answer,
permissions == 0 ? _("permission denied")
: _("not found"));
/* if requested, list the raster maps in source location - MN 5/2001 */
if (list->answer) {
int i;
char **list;
G_verbose_message(_("Checking location <%s> mapset <%s>"),
inlocation->answer, setname);
list = G_list(G_ELEMENT_RASTER, G__getenv("GISDBASE"),
G__getenv("LOCATION_NAME"), setname);
for (i = 0; list[i]; i++) {
fprintf(stdout, "%s\n", list[i]);
}
fflush(stdout);
exit(EXIT_SUCCESS); /* leave r.proj after listing */
}
if (!inmap->answer)
G_fatal_error(_("Required parameter <%s> not set"), inmap->key);
if (!G_find_raster(inmap->answer, setname))
G_fatal_error(_("Raster map <%s> in location <%s> in mapset <%s> not found"),
inmap->answer, inlocation->answer, setname);
/* Read input map colour table */
have_colors = Rast_read_colors(inmap->answer, setname, &colr);
/* Get projection info for input mapset */
if ((in_proj_info = G_get_projinfo()) == NULL)
G_fatal_error(_("Unable to get projection info of input map"));
if ((in_unit_info = G_get_projunits()) == NULL)
G_fatal_error(_("Unable to get projection units of input map"));
if (pj_get_kv(&iproj, in_proj_info, in_unit_info) < 0)
G_fatal_error(_("Unable to get projection key values of input map"));
G_free_key_value(in_proj_info);
G_free_key_value(in_unit_info);
G_free_key_value(out_proj_info);
G_free_key_value(out_unit_info);
if (G_verbose() > G_verbose_std())
pj_print_proj_params(&iproj, &oproj);
/* this call causes r.proj to read the entire map into memeory */
Rast_get_cellhd(inmap->answer, setname, &incellhd);
Rast_set_input_window(&incellhd);
if (G_projection() == PROJECTION_XY)
G_fatal_error(_("Unable to work with unprojected data (xy location)"));
/* Save default borders so we can show them later */
inorth = incellhd.north;
isouth = incellhd.south;
ieast = incellhd.east;
iwest = incellhd.west;
irows = incellhd.rows;
icols = incellhd.cols;
onorth = outcellhd.north;
osouth = outcellhd.south;
oeast = outcellhd.east;
owest = outcellhd.west;
orows = outcellhd.rows;
ocols = outcellhd.cols;
if (print_bounds->answer) {
G_message(_("Input map <%s@%s> in location <%s>:"),
inmap->answer, setname, inlocation->answer);
if (pj_do_proj(&iwest, &isouth, &iproj, &oproj) < 0)
G_fatal_error(_("Error in pj_do_proj (projection of input coordinate pair)"));
if (pj_do_proj(&ieast, &inorth, &iproj, &oproj) < 0)
G_fatal_error(_("Error in pj_do_proj (projection of input coordinate pair)"));
G_format_northing(inorth, north_str, curr_proj);
G_format_northing(isouth, south_str, curr_proj);
G_format_easting(ieast, east_str, curr_proj);
G_format_easting(iwest, west_str, curr_proj);
if(gprint_bounds->answer) {
fprintf(stdout, "n=%s s=%s w=%s e=%s rows=%d cols=%d\n",
north_str, south_str, west_str, east_str, irows, icols);
}
else {
fprintf(stdout, "Source cols: %d\n", icols);
fprintf(stdout, "Source rows: %d\n", irows);
fprintf(stdout, "Local north: %s\n", north_str);
fprintf(stdout, "Local south: %s\n", south_str);
fprintf(stdout, "Local west: %s\n", west_str);
fprintf(stdout, "Local east: %s\n", east_str);
}
/* somehow approximate local ewres, nsres ?? (use 'g.region -m' on lat/lon side) */
exit(EXIT_SUCCESS);
}
/* Cut non-overlapping parts of input map */
if (!nocrop->answer)
bordwalk(&outcellhd, &incellhd, &oproj, &iproj);
/* Add 2 cells on each side for bilinear/cubic & future interpolation methods */
/* (should probably be a factor based on input and output resolution) */
incellhd.north += 2 * incellhd.ns_res;
incellhd.east += 2 * incellhd.ew_res;
incellhd.south -= 2 * incellhd.ns_res;
incellhd.west -= 2 * incellhd.ew_res;
if (incellhd.north > inorth)
incellhd.north = inorth;
if (incellhd.east > ieast)
incellhd.east = ieast;
if (incellhd.south < isouth)
incellhd.south = isouth;
if (incellhd.west < iwest)
incellhd.west = iwest;
Rast_set_input_window(&incellhd);
/* And switch back to original location */
G__switch_env();
/* Adjust borders of output map */
if (!nocrop->answer)
bordwalk(&incellhd, &outcellhd, &iproj, &oproj);
#if 0
outcellhd.west = outcellhd.south = HUGE_VAL;
outcellhd.east = outcellhd.north = -HUGE_VAL;
for (row = 0; row < incellhd.rows; row++) {
ycoord1 = Rast_row_to_northing((double)(row + 0.5), &incellhd);
for (col = 0; col < incellhd.cols; col++) {
xcoord1 = Rast_col_to_easting((double)(col + 0.5), &incellhd);
pj_do_proj(&xcoord1, &ycoord1, &iproj, &oproj);
if (xcoord1 > outcellhd.east)
outcellhd.east = xcoord1;
if (ycoord1 > outcellhd.north)
outcellhd.north = ycoord1;
if (xcoord1 < outcellhd.west)
outcellhd.west = xcoord1;
if (ycoord1 < outcellhd.south)
outcellhd.south = ycoord1;
}
}
#endif
if (res->answer != NULL) /* set user defined resolution */
outcellhd.ns_res = outcellhd.ew_res = atof(res->answer);
G_adjust_Cell_head(&outcellhd, 0, 0);
Rast_set_output_window(&outcellhd);
G_message(" ");
G_message(_("Input:"));
G_message(_("Cols: %d (%d)"), incellhd.cols, icols);
G_message(_("Rows: %d (%d)"), incellhd.rows, irows);
G_message(_("North: %f (%f)"), incellhd.north, inorth);
G_message(_("South: %f (%f)"), incellhd.south, isouth);
G_message(_("West: %f (%f)"), incellhd.west, iwest);
G_message(_("East: %f (%f)"), incellhd.east, ieast);
G_message(_("EW-res: %f"), incellhd.ew_res);
G_message(_("NS-res: %f"), incellhd.ns_res);
G_message(" ");
G_message(_("Output:"));
G_message(_("Cols: %d (%d)"), outcellhd.cols, ocols);
G_message(_("Rows: %d (%d)"), outcellhd.rows, orows);
G_message(_("North: %f (%f)"), outcellhd.north, onorth);
G_message(_("South: %f (%f)"), outcellhd.south, osouth);
G_message(_("West: %f (%f)"), outcellhd.west, owest);
G_message(_("East: %f (%f)"), outcellhd.east, oeast);
G_message(_("EW-res: %f"), outcellhd.ew_res);
G_message(_("NS-res: %f"), outcellhd.ns_res);
G_message(" ");
/* open and read the relevant parts of the input map and close it */
G__switch_env();
Rast_set_input_window(&incellhd);
fdi = Rast_open_old(inmap->answer, setname);
cell_type = Rast_get_map_type(fdi);
ibuffer = readcell(fdi, memory->answer);
Rast_close(fdi);
G__switch_env();
Rast_set_output_window(&outcellhd);
if (strcmp(interpol->answer, "nearest") == 0) {
fdo = Rast_open_new(mapname, cell_type);
obuffer = (CELL *) Rast_allocate_output_buf(cell_type);
}
else {
fdo = Rast_open_fp_new(mapname);
cell_type = FCELL_TYPE;
obuffer = (FCELL *) Rast_allocate_output_buf(cell_type);
}
cell_size = Rast_cell_size(cell_type);
xcoord1 = xcoord2 = outcellhd.west + (outcellhd.ew_res / 2);
/**/ ycoord1 = ycoord2 = outcellhd.north - (outcellhd.ns_res / 2);
/**/ G_important_message(_("Projecting..."));
G_percent(0, outcellhd.rows, 2);
for (row = 0; row < outcellhd.rows; row++) {
obufptr = obuffer;
for (col = 0; col < outcellhd.cols; col++) {
/* project coordinates in output matrix to */
/* coordinates in input matrix */
if (pj_do_proj(&xcoord1, &ycoord1, &oproj, &iproj) < 0)
Rast_set_null_value(obufptr, 1, cell_type);
else {
/* convert to row/column indices of input matrix */
col_idx = (xcoord1 - incellhd.west) / incellhd.ew_res;
row_idx = (incellhd.north - ycoord1) / incellhd.ns_res;
/* and resample data point */
interpolate(ibuffer, obufptr, cell_type,
&col_idx, &row_idx, &incellhd);
}
obufptr = G_incr_void_ptr(obufptr, cell_size);
xcoord2 += outcellhd.ew_res;
xcoord1 = xcoord2;
ycoord1 = ycoord2;
}
Rast_put_row(fdo, obuffer, cell_type);
xcoord1 = xcoord2 = outcellhd.west + (outcellhd.ew_res / 2);
ycoord2 -= outcellhd.ns_res;
ycoord1 = ycoord2;
G_percent(row, outcellhd.rows - 1, 2);
}
Rast_close(fdo);
if (have_colors > 0) {
Rast_write_colors(mapname, G_mapset(), &colr);
Rast_free_colors(&colr);
}
Rast_short_history(mapname, "raster", &history);
Rast_command_history(&history);
Rast_write_history(mapname, &history);
G_done_msg(NULL);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int out_fd, base_raster;
char *infile, *outmap;
int percent;
double zrange_min, zrange_max, d_tmp;
double irange_min, irange_max;
unsigned long estimated_lines;
RASTER_MAP_TYPE rtype, base_raster_data_type;
struct History history;
char title[64];
SEGMENT base_segment;
struct PointBinning point_binning;
void *base_array;
void *raster_row;
struct Cell_head region;
struct Cell_head input_region;
int rows, last_rows, row0, cols; /* scan box size */
int row; /* counters */
int pass, npasses;
unsigned long line, line_total;
unsigned int counter;
unsigned long n_invalid;
char buff[BUFFSIZE];
double x, y, z;
double intensity;
int arr_row, arr_col;
unsigned long count, count_total;
int point_class;
double zscale = 1.0;
double iscale = 1.0;
double res = 0.0;
struct BinIndex bin_index_nodes;
bin_index_nodes.num_nodes = 0;
bin_index_nodes.max_nodes = 0;
bin_index_nodes.nodes = 0;
struct GModule *module;
struct Option *input_opt, *output_opt, *percent_opt, *type_opt, *filter_opt, *class_opt;
struct Option *method_opt, *base_raster_opt;
struct Option *zrange_opt, *zscale_opt;
struct Option *irange_opt, *iscale_opt;
struct Option *trim_opt, *pth_opt, *res_opt;
struct Option *file_list_opt;
struct Flag *print_flag, *scan_flag, *shell_style, *over_flag, *extents_flag;
struct Flag *intens_flag, *intens_import_flag;
struct Flag *set_region_flag;
struct Flag *base_rast_res_flag;
struct Flag *only_valid_flag;
/* LAS */
LASReaderH LAS_reader;
LASHeaderH LAS_header;
LASSRSH LAS_srs;
LASPointH LAS_point;
int return_filter;
const char *projstr;
struct Cell_head cellhd, loc_wind;
unsigned int n_filtered;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("import"));
G_add_keyword(_("LIDAR"));
G_add_keyword(_("statistics"));
G_add_keyword(_("conversion"));
G_add_keyword(_("aggregation"));
G_add_keyword(_("binning"));
module->description =
_("Creates a raster map from LAS LiDAR points using univariate statistics.");
input_opt = G_define_standard_option(G_OPT_F_BIN_INPUT);
input_opt->required = NO;
input_opt->label = _("LAS input file");
input_opt->description = _("LiDAR input files in LAS format (*.las or *.laz)");
input_opt->guisection = _("Input");
output_opt = G_define_standard_option(G_OPT_R_OUTPUT);
output_opt->required = NO;
output_opt->guisection = _("Output");
file_list_opt = G_define_standard_option(G_OPT_F_INPUT);
file_list_opt->key = "file";
file_list_opt->label = _("File containing names of LAS input files");
file_list_opt->description = _("LiDAR input files in LAS format (*.las or *.laz)");
file_list_opt->required = NO;
file_list_opt->guisection = _("Input");
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = NO;
method_opt->description = _("Statistic to use for raster values");
method_opt->options =
"n,min,max,range,sum,mean,stddev,variance,coeff_var,median,percentile,skewness,trimmean";
method_opt->answer = "mean";
method_opt->guisection = _("Statistic");
G_asprintf((char **)&(method_opt->descriptions),
"n;%s;"
"min;%s;"
"max;%s;"
"range;%s;"
"sum;%s;"
"mean;%s;"
"stddev;%s;"
"variance;%s;"
"coeff_var;%s;"
"median;%s;"
"percentile;%s;"
"skewness;%s;"
"trimmean;%s",
_("Number of points in cell"),
_("Minimum value of point values in cell"),
_("Maximum value of point values in cell"),
_("Range of point values in cell"),
_("Sum of point values in cell"),
_("Mean (average) value of point values in cell"),
_("Standard deviation of point values in cell"),
_("Variance of point values in cell"),
_("Coefficient of variance of point values in cell"),
_("Median value of point values in cell"),
_("pth (nth) percentile of point values in cell"),
_("Skewness of point values in cell"),
_("Trimmed mean of point values in cell"));
type_opt = G_define_standard_option(G_OPT_R_TYPE);
type_opt->required = NO;
type_opt->answer = "FCELL";
base_raster_opt = G_define_standard_option(G_OPT_R_INPUT);
base_raster_opt->key = "base_raster";
base_raster_opt->required = NO;
base_raster_opt->label =
_("Subtract raster values from the Z coordinates");
base_raster_opt->description =
_("The scale for Z is applied beforehand, the range filter for"
" Z afterwards");
base_raster_opt->guisection = _("Transform");
zrange_opt = G_define_option();
zrange_opt->key = "zrange";
zrange_opt->type = TYPE_DOUBLE;
zrange_opt->required = NO;
zrange_opt->key_desc = "min,max";
zrange_opt->description = _("Filter range for Z data (min,max)");
zrange_opt->guisection = _("Selection");
zscale_opt = G_define_option();
zscale_opt->key = "zscale";
zscale_opt->type = TYPE_DOUBLE;
zscale_opt->required = NO;
zscale_opt->answer = "1.0";
zscale_opt->description = _("Scale to apply to Z data");
zscale_opt->guisection = _("Transform");
irange_opt = G_define_option();
irange_opt->key = "intensity_range";
irange_opt->type = TYPE_DOUBLE;
irange_opt->required = NO;
irange_opt->key_desc = "min,max";
irange_opt->description = _("Filter range for intensity values (min,max)");
irange_opt->guisection = _("Selection");
iscale_opt = G_define_option();
iscale_opt->key = "intensity_scale";
iscale_opt->type = TYPE_DOUBLE;
iscale_opt->required = NO;
iscale_opt->answer = "1.0";
iscale_opt->description = _("Scale to apply to intensity values");
iscale_opt->guisection = _("Transform");
percent_opt = G_define_option();
percent_opt->key = "percent";
percent_opt->type = TYPE_INTEGER;
percent_opt->required = NO;
percent_opt->answer = "100";
percent_opt->options = "1-100";
percent_opt->description = _("Percent of map to keep in memory");
/* I would prefer to call the following "percentile", but that has too
* much namespace overlap with the "percent" option above */
pth_opt = G_define_option();
pth_opt->key = "pth";
pth_opt->type = TYPE_INTEGER;
pth_opt->required = NO;
pth_opt->options = "1-100";
pth_opt->description = _("pth percentile of the values");
pth_opt->guisection = _("Statistic");
trim_opt = G_define_option();
trim_opt->key = "trim";
trim_opt->type = TYPE_DOUBLE;
trim_opt->required = NO;
trim_opt->options = "0-50";
trim_opt->label = _("Discard given percentage of the smallest and largest values");
trim_opt->description =
_("Discard <trim> percent of the smallest and <trim> percent of the largest observations");
trim_opt->guisection = _("Statistic");
res_opt = G_define_option();
res_opt->key = "resolution";
res_opt->type = TYPE_DOUBLE;
res_opt->required = NO;
res_opt->description =
_("Output raster resolution");
res_opt->guisection = _("Output");
filter_opt = G_define_option();
filter_opt->key = "return_filter";
filter_opt->type = TYPE_STRING;
filter_opt->required = NO;
filter_opt->label = _("Only import points of selected return type");
filter_opt->description = _("If not specified, all points are imported");
filter_opt->options = "first,last,mid";
filter_opt->guisection = _("Selection");
class_opt = G_define_option();
class_opt->key = "class_filter";
class_opt->type = TYPE_INTEGER;
class_opt->multiple = YES;
class_opt->required = NO;
class_opt->label = _("Only import points of selected class(es)");
class_opt->description = _("Input is comma separated integers. "
"If not specified, all points are imported.");
class_opt->guisection = _("Selection");
print_flag = G_define_flag();
print_flag->key = 'p';
print_flag->description =
_("Print LAS file info and exit");
extents_flag = G_define_flag();
extents_flag->key = 'e';
extents_flag->label =
_("Use the extent of the input for the raster extent");
extents_flag->description =
_("Set internally computational region extents based on the"
" point cloud");
extents_flag->guisection = _("Output");
set_region_flag = G_define_flag();
set_region_flag->key = 'n';
set_region_flag->label =
_("Set computation region to match the new raster map");
set_region_flag->description =
_("Set computation region to match the 2D extent and resolution"
" of the newly created new raster map");
set_region_flag->guisection = _("Output");
over_flag = G_define_flag();
over_flag->key = 'o';
over_flag->label =
_("Override projection check (use current location's projection)");
over_flag->description =
_("Assume that the dataset has same projection as the current location");
scan_flag = G_define_flag();
scan_flag->key = 's';
scan_flag->description = _("Scan data file for extent then exit");
shell_style = G_define_flag();
shell_style->key = 'g';
shell_style->description =
_("In scan mode, print using shell script style");
intens_flag = G_define_flag();
intens_flag->key = 'i';
intens_flag->label =
_("Use intensity values rather than Z values");
intens_flag->description =
_("Uses intensity values everywhere as if they would be Z"
" coordinates");
intens_import_flag = G_define_flag();
intens_import_flag->key = 'j';
intens_import_flag->description =
_("Use Z values for filtering, but intensity values for statistics");
base_rast_res_flag = G_define_flag();
base_rast_res_flag->key = 'd';
base_rast_res_flag->label =
_("Use base raster resolution instead of computational region");
base_rast_res_flag->description =
_("For getting values from base raster, use its actual"
" resolution instead of computational region resolution");
only_valid_flag = G_define_flag();
only_valid_flag->key = 'v';
only_valid_flag->label = _("Use only valid points");
only_valid_flag->description =
_("Points invalid according to APSRS LAS specification will be"
" filtered out");
only_valid_flag->guisection = _("Selection");
G_option_required(input_opt, file_list_opt, NULL);
G_option_exclusive(input_opt, file_list_opt, NULL);
G_option_required(output_opt, print_flag, scan_flag, shell_style, NULL);
G_option_exclusive(intens_flag, intens_import_flag, NULL);
G_option_requires(base_rast_res_flag, base_raster_opt, NULL);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
int only_valid = FALSE;
n_invalid = 0;
if (only_valid_flag->answer)
only_valid = TRUE;
/* we could use rules but this gives more info and allows continuing */
if (set_region_flag->answer && !(extents_flag->answer || res_opt->answer)) {
G_warning(_("Flag %c makes sense only with %s option or -%c flag"),
set_region_flag->key, res_opt->key, extents_flag->key);
/* avoid the call later on */
set_region_flag->answer = '\0';
}
struct StringList infiles;
if (file_list_opt->answer) {
if (access(file_list_opt->answer, F_OK) != 0)
G_fatal_error(_("File <%s> does not exist"), file_list_opt->answer);
string_list_from_file(&infiles, file_list_opt->answer);
}
else {
string_list_from_one_item(&infiles, input_opt->answer);
}
/* parse input values */
outmap = output_opt->answer;
if (shell_style->answer && !scan_flag->answer) {
scan_flag->answer = 1; /* pointer not int, so set = shell_style->answer ? */
}
/* check zrange and extent relation */
if (scan_flag->answer || extents_flag->answer) {
if (zrange_opt->answer)
G_warning(_("zrange will not be taken into account during scan"));
}
Rast_get_window(®ion);
/* G_get_window seems to be unreliable if the location has been changed */
G_get_set_window(&loc_wind); /* TODO: v.in.lidar uses G_get_default_window() */
estimated_lines = 0;
int i;
for (i = 0; i < infiles.num_items; i++) {
infile = infiles.items[i];
/* don't if file not found */
if (access(infile, F_OK) != 0)
G_fatal_error(_("Input file <%s> does not exist"), infile);
/* Open LAS file*/
LAS_reader = LASReader_Create(infile);
if (LAS_reader == NULL)
G_fatal_error(_("Unable to open file <%s> as a LiDAR point cloud"),
infile);
LAS_header = LASReader_GetHeader(LAS_reader);
if (LAS_header == NULL) {
G_fatal_error(_("Unable to read LAS header of <%s>"), infile);
}
LAS_srs = LASHeader_GetSRS(LAS_header);
/* print info or check projection if we are actually importing */
if (print_flag->answer) {
/* print filename when there is more than one file */
if (infiles.num_items > 1)
fprintf(stdout, "File: %s\n", infile);
/* Print LAS header */
print_lasinfo(LAS_header, LAS_srs);
}
else {
/* report that we are checking more files */
if (i == 1)
G_message(_("First file's projection checked,"
" checking projection of the other files..."));
/* Fetch input map projection in GRASS form. */
projstr = LASSRS_GetWKT_CompoundOK(LAS_srs);
/* we are printing the non-warning messages only for first file */
projection_check_wkt(cellhd, loc_wind, projstr, over_flag->answer,
shell_style->answer || i);
/* if there is a problem in some other file, first OK message
* is printed but than a warning, this is not ideal but hopefully
* not so confusing when importing multiple files */
}
if (scan_flag->answer || extents_flag->answer) {
/* we assign to the first one (i==0) but update for the rest */
scan_bounds(LAS_reader, shell_style->answer, extents_flag->answer, i,
zscale, ®ion);
}
/* number of estimated point across all files */
/* TODO: this should be ull which won't work with percent report */
estimated_lines += LASHeader_GetPointRecordsCount(LAS_header);
/* We are closing all again and we will be opening them later,
* so we don't have to worry about limit for open files. */
LASSRS_Destroy(LAS_srs);
LASHeader_Destroy(LAS_header);
LASReader_Destroy(LAS_reader);
}
/* if we are not importing, end */
if (print_flag->answer || scan_flag->answer)
exit(EXIT_SUCCESS);
return_filter = LAS_ALL;
if (filter_opt->answer) {
if (strcmp(filter_opt->answer, "first") == 0)
return_filter = LAS_FIRST;
else if (strcmp(filter_opt->answer, "last") == 0)
return_filter = LAS_LAST;
else if (strcmp(filter_opt->answer, "mid") == 0)
return_filter = LAS_MID;
else
G_fatal_error(_("Unknown filter option <%s>"), filter_opt->answer);
}
struct ReturnFilter return_filter_struct;
return_filter_struct.filter = return_filter;
struct ClassFilter class_filter;
class_filter_create_from_strings(&class_filter, class_opt->answers);
percent = atoi(percent_opt->answer);
/* TODO: we already used zscale */
/* TODO: we don't report intensity range */
if (zscale_opt->answer)
zscale = atof(zscale_opt->answer);
if (iscale_opt->answer)
iscale = atof(iscale_opt->answer);
/* parse zrange */
if (zrange_opt->answer != NULL) {
if (zrange_opt->answers[0] == NULL)
G_fatal_error(_("Invalid zrange"));
sscanf(zrange_opt->answers[0], "%lf", &zrange_min);
sscanf(zrange_opt->answers[1], "%lf", &zrange_max);
if (zrange_min > zrange_max) {
d_tmp = zrange_max;
zrange_max = zrange_min;
zrange_min = d_tmp;
}
}
/* parse irange */
if (irange_opt->answer != NULL) {
if (irange_opt->answers[0] == NULL)
G_fatal_error(_("Invalid %s"), irange_opt->key);
sscanf(irange_opt->answers[0], "%lf", &irange_min);
sscanf(irange_opt->answers[1], "%lf", &irange_max);
if (irange_min > irange_max) {
d_tmp = irange_max;
irange_max = irange_min;
irange_min = d_tmp;
}
}
point_binning_set(&point_binning, method_opt->answer, pth_opt->answer,
trim_opt->answer, FALSE);
base_array = NULL;
if (strcmp("CELL", type_opt->answer) == 0)
rtype = CELL_TYPE;
else if (strcmp("DCELL", type_opt->answer) == 0)
rtype = DCELL_TYPE;
else
rtype = FCELL_TYPE;
if (point_binning.method == METHOD_N)
rtype = CELL_TYPE;
if (res_opt->answer) {
/* align to resolution */
res = atof(res_opt->answer);
if (!G_scan_resolution(res_opt->answer, &res, region.proj))
G_fatal_error(_("Invalid input <%s=%s>"), res_opt->key, res_opt->answer);
if (res <= 0)
G_fatal_error(_("Option '%s' must be > 0.0"), res_opt->key);
region.ns_res = region.ew_res = res;
region.north = ceil(region.north / res) * res;
region.south = floor(region.south / res) * res;
region.east = ceil(region.east / res) * res;
region.west = floor(region.west / res) * res;
G_adjust_Cell_head(®ion, 0, 0);
}
else if (extents_flag->answer) {
/* align to current region */
Rast_align_window(®ion, &loc_wind);
}
Rast_set_output_window(®ion);
rows = last_rows = region.rows;
npasses = 1;
if (percent < 100) {
rows = (int)(region.rows * (percent / 100.0));
npasses = region.rows / rows;
last_rows = region.rows - npasses * rows;
if (last_rows)
npasses++;
else
last_rows = rows;
}
cols = region.cols;
G_debug(2, "region.n=%f region.s=%f region.ns_res=%f", region.north,
region.south, region.ns_res);
G_debug(2, "region.rows=%d [box_rows=%d] region.cols=%d", region.rows,
rows, region.cols);
/* using row-based chunks (used for output) when input and output
* region matches and using segment library when they don't */
int use_segment = 0;
int use_base_raster_res = 0;
/* TODO: see if the input region extent is smaller than the raster
* if yes, the we need to load the whole base raster if the -e
* flag was defined (alternatively clip the regions) */
if (base_rast_res_flag->answer)
use_base_raster_res = 1;
if (base_raster_opt->answer && (res_opt->answer || use_base_raster_res
|| extents_flag->answer))
use_segment = 1;
if (base_raster_opt->answer && !use_segment) {
/* TODO: do we need to test existence first? mapset? */
base_raster = Rast_open_old(base_raster_opt->answer, "");
base_raster_data_type = Rast_get_map_type(base_raster);
base_array = G_calloc((size_t)rows * (cols + 1), Rast_cell_size(base_raster_data_type));
}
if (base_raster_opt->answer && use_segment) {
if (use_base_raster_res) {
/* read raster actual extent and resolution */
Rast_get_cellhd(base_raster_opt->answer, "", &input_region);
/* TODO: make it only as small as the output is or points are */
Rast_set_input_window(&input_region); /* we have split window */
} else {
Rast_get_input_window(&input_region);
}
rast_segment_open(&base_segment, base_raster_opt->answer, &base_raster_data_type);
}
if (!scan_flag->answer) {
if (!check_rows_cols_fit_to_size_t(rows, cols))
G_fatal_error(_("Unable to process the hole map at once. "
"Please set the '%s' option to some value lower than 100."),
percent_opt->key);
point_binning_memory_test(&point_binning, rows, cols, rtype);
}
/* open output map */
out_fd = Rast_open_new(outmap, rtype);
/* allocate memory for a single row of output data */
raster_row = Rast_allocate_output_buf(rtype);
G_message(_("Reading data ..."));
count_total = line_total = 0;
/* main binning loop(s) */
for (pass = 1; pass <= npasses; pass++) {
if (npasses > 1)
G_message(_("Pass #%d (of %d) ..."), pass, npasses);
/* figure out segmentation */
row0 = (pass - 1) * rows;
if (pass == npasses) {
rows = last_rows;
}
if (base_array) {
G_debug(2, "filling base raster array");
for (row = 0; row < rows; row++) {
Rast_get_row(base_raster, base_array + ((size_t) row * cols * Rast_cell_size(base_raster_data_type)), row, base_raster_data_type);
}
}
G_debug(2, "pass=%d/%d rows=%d", pass, npasses, rows);
point_binning_allocate(&point_binning, rows, cols, rtype);
line = 0;
count = 0;
counter = 0;
G_percent_reset();
/* loop of input files */
for (i = 0; i < infiles.num_items; i++) {
infile = infiles.items[i];
/* we already know file is there, so just do basic checks */
LAS_reader = LASReader_Create(infile);
if (LAS_reader == NULL)
G_fatal_error(_("Unable to open file <%s>"), infile);
while ((LAS_point = LASReader_GetNextPoint(LAS_reader)) != NULL) {
line++;
counter++;
if (counter == 100000) { /* speed */
if (line < estimated_lines)
G_percent(line, estimated_lines, 3);
counter = 0;
}
/* We always count them and report because behavior
* changed in between 7.0 and 7.2 from undefined (but skipping
* invalid points) to filtering them out only when requested. */
if (!LASPoint_IsValid(LAS_point)) {
n_invalid++;
if (only_valid)
continue;
}
x = LASPoint_GetX(LAS_point);
y = LASPoint_GetY(LAS_point);
if (intens_flag->answer)
/* use intensity as z here to allow all filters (and
* modifications) below to be applied for intensity */
z = LASPoint_GetIntensity(LAS_point);
else
z = LASPoint_GetZ(LAS_point);
int return_n = LASPoint_GetReturnNumber(LAS_point);
int n_returns = LASPoint_GetNumberOfReturns(LAS_point);
if (return_filter_is_out(&return_filter_struct, return_n, n_returns)) {
n_filtered++;
continue;
}
point_class = (int) LASPoint_GetClassification(LAS_point);
if (class_filter_is_out(&class_filter, point_class))
continue;
if (y <= region.south || y > region.north) {
continue;
}
if (x < region.west || x >= region.east) {
continue;
}
/* find the bin in the current array box */
arr_row = (int)((region.north - y) / region.ns_res) - row0;
if (arr_row < 0 || arr_row >= rows)
continue;
arr_col = (int)((x - region.west) / region.ew_res);
z = z * zscale;
if (base_array) {
double base_z;
if (row_array_get_value_row_col(base_array, arr_row, arr_col,
cols, base_raster_data_type,
&base_z))
z -= base_z;
else
continue;
}
else if (use_segment) {
double base_z;
if (rast_segment_get_value_xy(&base_segment, &input_region,
base_raster_data_type, x, y,
&base_z))
z -= base_z;
else
continue;
}
if (zrange_opt->answer) {
if (z < zrange_min || z > zrange_max) {
continue;
}
}
if (intens_import_flag->answer || irange_opt->answer) {
intensity = LASPoint_GetIntensity(LAS_point);
intensity *= iscale;
if (irange_opt->answer) {
if (intensity < irange_min || intensity > irange_max) {
continue;
}
}
/* use intensity for statistics */
if (intens_import_flag->answer)
z = intensity;
}
count++;
/* G_debug(5, "x: %f, y: %f, z: %f", x, y, z); */
update_value(&point_binning, &bin_index_nodes, cols,
arr_row, arr_col, rtype, x, y, z);
} /* while !EOF of one input file */
/* close input LAS file */
LASReader_Destroy(LAS_reader);
} /* end of loop for all input files files */
G_percent(1, 1, 1); /* flush */
G_debug(2, "pass %d finished, %lu coordinates in box", pass, count);
count_total += count;
line_total += line;
/* calc stats and output */
G_message(_("Writing to map ..."));
for (row = 0; row < rows; row++) {
/* potentially vector writing can be independent on the binning */
write_values(&point_binning, &bin_index_nodes, raster_row, row,
cols, rtype, NULL);
/* write out line of raster data */
Rast_put_row(out_fd, raster_row, rtype);
}
/* free memory */
point_binning_free(&point_binning, &bin_index_nodes);
} /* passes loop */
if (base_array)
Rast_close(base_raster);
if (use_segment)
Segment_close(&base_segment);
G_percent(1, 1, 1); /* flush */
G_free(raster_row);
/* close raster file & write history */
Rast_close(out_fd);
sprintf(title, "Raw X,Y,Z data binned into a raster grid by cell %s",
method_opt->answer);
Rast_put_cell_title(outmap, title);
Rast_short_history(outmap, "raster", &history);
Rast_command_history(&history);
Rast_set_history(&history, HIST_DATSRC_1, infile);
Rast_write_history(outmap, &history);
/* set computation region to the new raster map */
/* TODO: should be in the done message */
if (set_region_flag->answer)
G_put_window(®ion);
if (n_invalid && only_valid)
G_message(_("%lu input points were invalid and filtered out"),
n_invalid);
if (n_invalid && !only_valid)
G_message(_("%lu input points were invalid, use -%c flag to filter"
" them out"), n_invalid, only_valid_flag->key);
if (infiles.num_items > 1) {
sprintf(buff, _("Raster map <%s> created."
" %lu points from %d files found in region."),
outmap, count_total, infiles.num_items);
}
else {
sprintf(buff, _("Raster map <%s> created."
" %lu points found in region."),
outmap, count_total);
}
G_done_msg("%s", buff);
G_debug(1, "Processed %lu points.", line_total);
string_list_free(&infiles);
exit(EXIT_SUCCESS);
}