int main(int argc, char *argv[])
{
FILE *in_fp;
int out_fd;
char *infile, *outmap;
int xcol, ycol, zcol, max_col, percent;
int do_zfilter;
int method = -1;
int bin_n, bin_min, bin_max, bin_sum, bin_sumsq, bin_index;
double zrange_min, zrange_max, d_tmp;
char *fs; /* field delim */
off_t filesize;
int linesize;
long estimated_lines;
int from_stdin;
int can_seek;
RASTER_MAP_TYPE rtype;
struct History history;
char title[64];
void *n_array, *min_array, *max_array, *sum_array, *sumsq_array,
*index_array;
void *raster_row, *ptr;
struct Cell_head region;
int rows, cols; /* scan box size */
int row, col; /* counters */
int pass, npasses;
unsigned long line;
char buff[BUFFSIZE];
double x, y, z;
char **tokens;
int ntokens; /* number of tokens */
double pass_north, pass_south;
int arr_row, arr_col;
unsigned long count, count_total;
double min = 0.0 / 0.0; /* init as nan */
double max = 0.0 / 0.0; /* init as nan */
double zscale = 1.0;
size_t offset, n_offset;
int n = 0;
double sum = 0.;
double sumsq = 0.;
double variance, mean, skew, sumdev;
int pth = 0;
double trim = 0.0;
int j, k;
int head_id, node_id;
int r_low, r_up;
struct GModule *module;
struct Option *input_opt, *output_opt, *delim_opt, *percent_opt,
*type_opt;
struct Option *method_opt, *xcol_opt, *ycol_opt, *zcol_opt, *zrange_opt,
*zscale_opt;
struct Option *trim_opt, *pth_opt;
struct Flag *scan_flag, *shell_style, *skipline;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster, import, LIDAR");
module->description =
_("Create a raster map from an assemblage of many coordinates using univariate statistics.");
input_opt = G_define_standard_option(G_OPT_F_INPUT);
input_opt->description =
_("ASCII file containing input data (or \"-\" to read from stdin)");
output_opt = G_define_standard_option(G_OPT_R_OUTPUT);
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");
type_opt = G_define_option();
type_opt->key = "type";
type_opt->type = TYPE_STRING;
type_opt->required = NO;
type_opt->options = "CELL,FCELL,DCELL";
type_opt->answer = "FCELL";
type_opt->description = _("Storage type for resultant raster map");
delim_opt = G_define_standard_option(G_OPT_F_SEP);
delim_opt->guisection = _("Input");
xcol_opt = G_define_option();
xcol_opt->key = "x";
xcol_opt->type = TYPE_INTEGER;
xcol_opt->required = NO;
xcol_opt->answer = "1";
xcol_opt->description =
_("Column number of x coordinates in input file (first column is 1)");
xcol_opt->guisection = _("Input");
ycol_opt = G_define_option();
ycol_opt->key = "y";
ycol_opt->type = TYPE_INTEGER;
ycol_opt->required = NO;
ycol_opt->answer = "2";
ycol_opt->description = _("Column number of y coordinates in input file");
ycol_opt->guisection = _("Input");
zcol_opt = G_define_option();
zcol_opt->key = "z";
zcol_opt->type = TYPE_INTEGER;
zcol_opt->required = NO;
zcol_opt->answer = "3";
zcol_opt->description = _("Column number of data values in input file");
zcol_opt->guisection = _("Input");
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)");
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");
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");
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->description =
_("Discard <trim> percent of the smallest and <trim> percent of the largest observations");
trim_opt->guisection = _("Statistic");
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");
skipline = G_define_flag();
skipline->key = 'i';
skipline->description = _("Ignore broken lines");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* parse input values */
infile = input_opt->answer;
outmap = output_opt->answer;
if (shell_style->answer && !scan_flag->answer) {
scan_flag->answer = 1;
}
fs = delim_opt->answer;
if (strcmp(fs, "\\t") == 0)
fs = "\t";
if (strcmp(fs, "tab") == 0)
fs = "\t";
if (strcmp(fs, "space") == 0)
fs = " ";
xcol = atoi(xcol_opt->answer);
ycol = atoi(ycol_opt->answer);
zcol = atoi(zcol_opt->answer);
if ((xcol < 0) || (ycol < 0) || (zcol < 0))
G_fatal_error(_("Please specify a reasonable column number."));
max_col = (xcol > ycol) ? xcol : ycol;
max_col = (zcol > max_col) ? zcol : max_col;
percent = atoi(percent_opt->answer);
zscale = atof(zscale_opt->answer);
/* parse zrange */
do_zfilter = FALSE;
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);
do_zfilter = TRUE;
if (zrange_min > zrange_max) {
d_tmp = zrange_max;
zrange_max = zrange_min;
zrange_min = d_tmp;
}
}
/* figure out what maps we need in memory */
/* n n
min min
max max
range min max max - min
sum sum
mean sum n sum/n
stddev sum sumsq n sqrt((sumsq - sum*sum/n)/n)
variance sum sumsq n (sumsq - sum*sum/n)/n
coeff_var sum sumsq n sqrt((sumsq - sum*sum/n)/n) / (sum/n)
median n array index to linked list
percentile n array index to linked list
skewness n array index to linked list
trimmean n array index to linked list
*/
bin_n = FALSE;
bin_min = FALSE;
bin_max = FALSE;
bin_sum = FALSE;
bin_sumsq = FALSE;
bin_index = FALSE;
if (strcmp(method_opt->answer, "n") == 0) {
method = METHOD_N;
bin_n = TRUE;
}
if (strcmp(method_opt->answer, "min") == 0) {
method = METHOD_MIN;
bin_min = TRUE;
}
if (strcmp(method_opt->answer, "max") == 0) {
method = METHOD_MAX;
bin_max = TRUE;
}
if (strcmp(method_opt->answer, "range") == 0) {
method = METHOD_RANGE;
bin_min = TRUE;
bin_max = TRUE;
}
if (strcmp(method_opt->answer, "sum") == 0) {
method = METHOD_SUM;
bin_sum = TRUE;
}
if (strcmp(method_opt->answer, "mean") == 0) {
method = METHOD_MEAN;
bin_sum = TRUE;
bin_n = TRUE;
}
if (strcmp(method_opt->answer, "stddev") == 0) {
method = METHOD_STDDEV;
bin_sum = TRUE;
bin_sumsq = TRUE;
bin_n = TRUE;
}
if (strcmp(method_opt->answer, "variance") == 0) {
method = METHOD_VARIANCE;
bin_sum = TRUE;
bin_sumsq = TRUE;
bin_n = TRUE;
}
if (strcmp(method_opt->answer, "coeff_var") == 0) {
method = METHOD_COEFF_VAR;
bin_sum = TRUE;
bin_sumsq = TRUE;
bin_n = TRUE;
}
if (strcmp(method_opt->answer, "median") == 0) {
method = METHOD_MEDIAN;
bin_index = TRUE;
}
if (strcmp(method_opt->answer, "percentile") == 0) {
if (pth_opt->answer != NULL)
pth = atoi(pth_opt->answer);
else
G_fatal_error(_("Unable to calculate percentile without the pth option specified!"));
method = METHOD_PERCENTILE;
bin_index = TRUE;
}
if (strcmp(method_opt->answer, "skewness") == 0) {
method = METHOD_SKEWNESS;
bin_index = TRUE;
}
if (strcmp(method_opt->answer, "trimmean") == 0) {
if (trim_opt->answer != NULL)
trim = atof(trim_opt->answer) / 100.0;
else
G_fatal_error(_("Unable to calculate trimmed mean without the trim option specified!"));
method = METHOD_TRIMMEAN;
bin_index = TRUE;
}
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 (method == METHOD_N)
rtype = CELL_TYPE;
G_get_window(®ion);
rows = (int)(region.rows * (percent / 100.0));
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);
npasses = (int)ceil(1.0 * region.rows / rows);
if (!scan_flag->answer) {
/* allocate memory (test for enough before we start) */
if (bin_n)
n_array = G_calloc(rows * (cols + 1), G_raster_size(CELL_TYPE));
if (bin_min)
min_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
if (bin_max)
max_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
if (bin_sum)
sum_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
if (bin_sumsq)
sumsq_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
if (bin_index)
index_array =
G_calloc(rows * (cols + 1), G_raster_size(CELL_TYPE));
/* and then free it again */
if (bin_n)
G_free(n_array);
if (bin_min)
G_free(min_array);
if (bin_max)
G_free(max_array);
if (bin_sum)
G_free(sum_array);
if (bin_sumsq)
G_free(sumsq_array);
if (bin_index)
G_free(index_array);
/** end memory test **/
}
/* open input file */
if (strcmp("-", infile) == 0) {
from_stdin = TRUE;
in_fp = stdin;
infile = G_store("stdin"); /* filename for history metadata */
}
else {
if ((in_fp = fopen(infile, "r")) == NULL)
G_fatal_error(_("Unable to open input file <%s>"), infile);
}
can_seek = fseek(in_fp, 0, SEEK_SET) == 0;
/* can't rewind() non-files */
if (!can_seek && npasses != 1) {
G_warning(_("If input is not from a file it is only possible to perform a single pass."));
npasses = 1;
}
if (scan_flag->answer) {
if (zrange_opt->answer)
G_warning(_("zrange will not be taken into account during scan"));
scan_bounds(in_fp, xcol, ycol, zcol, fs, shell_style->answer,
skipline->answer, zscale);
if (!from_stdin)
fclose(in_fp);
exit(EXIT_SUCCESS);
}
/* open output map */
out_fd = G_open_raster_new(outmap, rtype);
if (out_fd < 0)
G_fatal_error(_("Unable to create raster map <%s>"), outmap);
if (can_seek) {
/* guess at number of lines in the file without actually reading it all in */
for (line = 0; line < 10; line++) { /* arbitrarily use 10th line for guess */
if (0 == G_getl2(buff, BUFFSIZE - 1, in_fp))
break;
linesize = strlen(buff) + 1;
}
fseek(in_fp, 0L, SEEK_END);
filesize = ftell(in_fp);
rewind(in_fp);
if (linesize < 6) /* min possible: "0,0,0\n" */
linesize = 6;
estimated_lines = filesize / linesize;
G_debug(2, "estimated number of lines in file: %ld", estimated_lines);
}
else
estimated_lines = -1;
/* allocate memory for a single row of output data */
raster_row = G_allocate_raster_buf(rtype);
G_message(_("Reading data ..."));
count_total = 0;
/* main binning loop(s) */
for (pass = 1; pass <= npasses; pass++) {
if (npasses > 1)
G_message(_("Pass #%d (of %d) ..."), pass, npasses);
if (can_seek)
rewind(in_fp);
/* figure out segmentation */
pass_north = region.north - (pass - 1) * rows * region.ns_res;
if (pass == npasses)
rows = region.rows - (pass - 1) * rows;
pass_south = pass_north - rows * region.ns_res;
G_debug(2, "pass=%d/%d pass_n=%f pass_s=%f rows=%d",
pass, npasses, pass_north, pass_south, rows);
if (bin_n) {
G_debug(2, "allocating n_array");
n_array = G_calloc(rows * (cols + 1), G_raster_size(CELL_TYPE));
blank_array(n_array, rows, cols, CELL_TYPE, 0);
}
if (bin_min) {
G_debug(2, "allocating min_array");
min_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
blank_array(min_array, rows, cols, rtype, -1); /* fill with NULLs */
}
if (bin_max) {
G_debug(2, "allocating max_array");
max_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
blank_array(max_array, rows, cols, rtype, -1); /* fill with NULLs */
}
if (bin_sum) {
G_debug(2, "allocating sum_array");
sum_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
blank_array(sum_array, rows, cols, rtype, 0);
}
if (bin_sumsq) {
G_debug(2, "allocating sumsq_array");
sumsq_array = G_calloc(rows * (cols + 1), G_raster_size(rtype));
blank_array(sumsq_array, rows, cols, rtype, 0);
}
if (bin_index) {
G_debug(2, "allocating index_array");
index_array =
G_calloc(rows * (cols + 1), G_raster_size(CELL_TYPE));
blank_array(index_array, rows, cols, CELL_TYPE, -1); /* fill with NULLs */
}
line = 0;
count = 0;
G_percent_reset();
while (0 != G_getl2(buff, BUFFSIZE - 1, in_fp)) {
line++;
if (line % 10000 == 0) { /* mod for speed */
if (!can_seek)
G_clicker();
else if (line < estimated_lines)
G_percent(line, estimated_lines, 3);
}
if ((buff[0] == '#') || (buff[0] == '\0')) {
continue; /* line is a comment or blank */
}
G_chop(buff); /* remove leading and trailing whitespace from the string. unneded?? */
tokens = G_tokenize(buff, fs);
ntokens = G_number_of_tokens(tokens);
if ((ntokens < 3) || (max_col > ntokens)) {
if (skipline->answer) {
G_warning(_("Not enough data columns. "
"Incorrect delimiter or column number? "
"Found the following character(s) in row %lu:\n[%s]"),
line, buff);
G_warning(_("Line ignored as requested"));
continue; /* line is garbage */
}
else {
G_fatal_error(_("Not enough data columns. "
"Incorrect delimiter or column number? "
"Found the following character(s) in row %lu:\n[%s]"),
line, buff);
}
}
/* too slow?
if ( G_projection() == PROJECTION_LL ) {
G_scan_easting( tokens[xcol-1], &x, region.proj);
G_scan_northing( tokens[ycol-1], &y, region.proj);
}
else {
*/
if (1 != sscanf(tokens[ycol - 1], "%lf", &y))
G_fatal_error(_("Bad y-coordinate line %lu column %d. <%s>"),
line, ycol, tokens[ycol - 1]);
if (y <= pass_south || y > pass_north) {
G_free_tokens(tokens);
continue;
}
if (1 != sscanf(tokens[xcol - 1], "%lf", &x))
G_fatal_error(_("Bad x-coordinate line %lu column %d. <%s>"),
line, xcol, tokens[xcol - 1]);
if (x < region.west || x > region.east) {
G_free_tokens(tokens);
continue;
}
if (1 != sscanf(tokens[zcol - 1], "%lf", &z))
G_fatal_error(_("Bad z-coordinate line %lu column %d. <%s>"),
line, zcol, tokens[zcol - 1]);
z = z * zscale;
if (zrange_opt->answer) {
if (z < zrange_min || z > zrange_max) {
G_free_tokens(tokens);
continue;
}
}
count++;
/* G_debug(5, "x: %f, y: %f, z: %f", x, y, z); */
G_free_tokens(tokens);
/* find the bin in the current array box */
arr_row = (int)((pass_north - y) / region.ns_res);
arr_col = (int)((x - region.west) / region.ew_res);
/* G_debug(5, "arr_row: %d arr_col: %d", arr_row, arr_col); */
/* The range should be [0,cols-1]. We use (int) to round down,
but if the point exactly on eastern edge arr_col will be /just/
on the max edge .0000000 and end up on the next row.
We could make above bounds check "if(x>=region.east) continue;"
But instead we go to all sorts of trouble so that not one single
data point is lost. GE is too small to catch them all.
We don't try to make y happy as percent segmenting will make some
points happen twice that way; so instead we use the y<= test above.
*/
if (arr_col >= cols) {
if (((x - region.west) / region.ew_res) - cols <
10 * GRASS_EPSILON)
arr_col--;
else { /* oh well, we tried. */
G_debug(3,
"skipping extraneous data point [%.3f], column %d of %d",
x, arr_col, cols);
continue;
}
}
if (bin_n)
update_n(n_array, cols, arr_row, arr_col);
if (bin_min)
update_min(min_array, cols, arr_row, arr_col, rtype, z);
if (bin_max)
update_max(max_array, cols, arr_row, arr_col, rtype, z);
if (bin_sum)
update_sum(sum_array, cols, arr_row, arr_col, rtype, z);
if (bin_sumsq)
update_sumsq(sumsq_array, cols, arr_row, arr_col, rtype, z);
if (bin_index) {
ptr = index_array;
ptr =
G_incr_void_ptr(ptr,
((arr_row * cols) +
arr_col) * G_raster_size(CELL_TYPE));
if (G_is_null_value(ptr, CELL_TYPE)) { /* first node */
head_id = new_node();
nodes[head_id].next = -1;
nodes[head_id].z = z;
G_set_raster_value_c(ptr, head_id, CELL_TYPE); /* store index to head */
}
else { /* head is already there */
head_id = G_get_raster_value_c(ptr, CELL_TYPE); /* get index to head */
head_id = add_node(head_id, z);
if (head_id != -1)
G_set_raster_value_c(ptr, head_id, CELL_TYPE); /* store index to head */
}
}
} /* while !EOF */
G_percent(1, 1, 1); /* flush */
G_debug(2, "pass %d finished, %lu coordinates in box", pass, count);
count_total += count;
/* calc stats and output */
G_message(_("Writing to map ..."));
for (row = 0; row < rows; row++) {
switch (method) {
case METHOD_N: /* n is a straight copy */
G_raster_cpy(raster_row,
n_array +
(row * cols * G_raster_size(CELL_TYPE)), cols,
CELL_TYPE);
break;
case METHOD_MIN:
G_raster_cpy(raster_row,
min_array + (row * cols * G_raster_size(rtype)),
cols, rtype);
break;
case METHOD_MAX:
G_raster_cpy(raster_row,
max_array + (row * cols * G_raster_size(rtype)),
cols, rtype);
break;
case METHOD_SUM:
G_raster_cpy(raster_row,
sum_array + (row * cols * G_raster_size(rtype)),
cols, rtype);
break;
case METHOD_RANGE: /* (max-min) */
ptr = raster_row;
for (col = 0; col < cols; col++) {
offset = (row * cols + col) * G_raster_size(rtype);
min = G_get_raster_value_d(min_array + offset, rtype);
max = G_get_raster_value_d(max_array + offset, rtype);
G_set_raster_value_d(ptr, max - min, rtype);
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
case METHOD_MEAN: /* (sum / n) */
ptr = raster_row;
for (col = 0; col < cols; col++) {
offset = (row * cols + col) * G_raster_size(rtype);
n_offset = (row * cols + col) * G_raster_size(CELL_TYPE);
n = G_get_raster_value_c(n_array + n_offset, CELL_TYPE);
sum = G_get_raster_value_d(sum_array + offset, rtype);
if (n == 0)
G_set_null_value(ptr, 1, rtype);
else
G_set_raster_value_d(ptr, (sum / n), rtype);
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
case METHOD_STDDEV: /* sqrt(variance) */
case METHOD_VARIANCE: /* (sumsq - sum*sum/n)/n */
case METHOD_COEFF_VAR: /* 100 * stdev / mean */
ptr = raster_row;
for (col = 0; col < cols; col++) {
offset = (row * cols + col) * G_raster_size(rtype);
n_offset = (row * cols + col) * G_raster_size(CELL_TYPE);
n = G_get_raster_value_c(n_array + n_offset, CELL_TYPE);
sum = G_get_raster_value_d(sum_array + offset, rtype);
sumsq = G_get_raster_value_d(sumsq_array + offset, rtype);
if (n == 0)
G_set_null_value(ptr, 1, rtype);
else {
variance = (sumsq - sum * sum / n) / n;
if (variance < GRASS_EPSILON)
variance = 0.0;
if (method == METHOD_STDDEV)
G_set_raster_value_d(ptr, sqrt(variance), rtype);
else if (method == METHOD_VARIANCE)
G_set_raster_value_d(ptr, variance, rtype);
else if (method == METHOD_COEFF_VAR)
G_set_raster_value_d(ptr,
100 * sqrt(variance) / (sum /
n),
rtype);
}
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
case METHOD_MEDIAN: /* median, if only one point in cell we will use that */
ptr = raster_row;
for (col = 0; col < cols; col++) {
n_offset = (row * cols + col) * G_raster_size(CELL_TYPE);
if (G_is_null_value(index_array + n_offset, CELL_TYPE)) /* no points in cell */
G_set_null_value(ptr, 1, rtype);
else { /* one or more points in cell */
head_id =
G_get_raster_value_c(index_array + n_offset,
CELL_TYPE);
node_id = head_id;
n = 0;
while (node_id != -1) { /* count number of points in cell */
n++;
node_id = nodes[node_id].next;
}
if (n == 1) /* only one point, use that */
G_set_raster_value_d(ptr, nodes[head_id].z,
rtype);
else if (n % 2 != 0) { /* odd number of points: median_i = (n + 1) / 2 */
n = (n + 1) / 2;
node_id = head_id;
for (j = 1; j < n; j++) /* get "median element" */
node_id = nodes[node_id].next;
G_set_raster_value_d(ptr, nodes[node_id].z,
rtype);
}
else { /* even number of points: median = (val_below + val_above) / 2 */
z = (n + 1) / 2.0;
n = floor(z);
node_id = head_id;
for (j = 1; j < n; j++) /* get element "below" */
node_id = nodes[node_id].next;
z = (nodes[node_id].z +
nodes[nodes[node_id].next].z) / 2;
G_set_raster_value_d(ptr, z, rtype);
}
}
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
case METHOD_PERCENTILE: /* rank = (pth*(n+1))/100; interpolate linearly */
ptr = raster_row;
for (col = 0; col < cols; col++) {
n_offset = (row * cols + col) * G_raster_size(CELL_TYPE);
if (G_is_null_value(index_array + n_offset, CELL_TYPE)) /* no points in cell */
G_set_null_value(ptr, 1, rtype);
else {
head_id =
G_get_raster_value_c(index_array + n_offset,
CELL_TYPE);
node_id = head_id;
n = 0;
while (node_id != -1) { /* count number of points in cell */
n++;
node_id = nodes[node_id].next;
}
z = (pth * (n + 1)) / 100.0;
r_low = floor(z); /* lower rank */
if (r_low < 1)
r_low = 1;
else if (r_low > n)
r_low = n;
r_up = ceil(z); /* upper rank */
if (r_up > n)
r_up = n;
node_id = head_id;
for (j = 1; j < r_low; j++) /* search lower value */
node_id = nodes[node_id].next;
z = nodes[node_id].z; /* save lower value */
node_id = head_id;
for (j = 1; j < r_up; j++) /* search upper value */
node_id = nodes[node_id].next;
z = (z + nodes[node_id].z) / 2;
G_set_raster_value_d(ptr, z, rtype);
}
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
case METHOD_SKEWNESS: /* skewness = sum(xi-mean)^3/(N-1)*s^3 */
ptr = raster_row;
for (col = 0; col < cols; col++) {
n_offset = (row * cols + col) * G_raster_size(CELL_TYPE);
if (G_is_null_value(index_array + n_offset, CELL_TYPE)) /* no points in cell */
G_set_null_value(ptr, 1, rtype);
else {
head_id =
G_get_raster_value_c(index_array + n_offset,
CELL_TYPE);
node_id = head_id;
n = 0; /* count */
sum = 0.0; /* sum */
sumsq = 0.0; /* sum of squares */
sumdev = 0.0; /* sum of (xi - mean)^3 */
skew = 0.0; /* skewness */
while (node_id != -1) {
z = nodes[node_id].z;
n++;
sum += z;
sumsq += (z * z);
node_id = nodes[node_id].next;
}
if (n > 1) { /* if n == 1, skew is "0.0" */
mean = sum / n;
node_id = head_id;
while (node_id != -1) {
z = nodes[node_id].z;
sumdev += pow((z - mean), 3);
node_id = nodes[node_id].next;
}
variance = (sumsq - sum * sum / n) / n;
if (variance < GRASS_EPSILON)
skew = 0.0;
else
skew =
sumdev / ((n - 1) *
pow(sqrt(variance), 3));
}
G_set_raster_value_d(ptr, skew, rtype);
}
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
case METHOD_TRIMMEAN:
ptr = raster_row;
for (col = 0; col < cols; col++) {
n_offset = (row * cols + col) * G_raster_size(CELL_TYPE);
if (G_is_null_value(index_array + n_offset, CELL_TYPE)) /* no points in cell */
G_set_null_value(ptr, 1, rtype);
else {
head_id =
G_get_raster_value_c(index_array + n_offset,
CELL_TYPE);
node_id = head_id;
n = 0;
while (node_id != -1) { /* count number of points in cell */
n++;
node_id = nodes[node_id].next;
}
if (1 == n)
mean = nodes[head_id].z;
else {
k = floor(trim * n + 0.5); /* number of ranks to discard on each tail */
if (k > 0 && (n - 2 * k) > 0) { /* enough elements to discard */
node_id = head_id;
for (j = 0; j < k; j++) /* move to first rank to consider */
node_id = nodes[node_id].next;
j = k + 1;
k = n - k;
n = 0;
sum = 0.0;
while (j <= k) { /* get values in interval */
n++;
sum += nodes[node_id].z;
node_id = nodes[node_id].next;
j++;
}
}
else {
node_id = head_id;
n = 0;
sum = 0.0;
while (node_id != -1) {
n++;
sum += nodes[node_id].z;
node_id = nodes[node_id].next;
}
}
mean = sum / n;
}
G_set_raster_value_d(ptr, mean, rtype);
}
ptr = G_incr_void_ptr(ptr, G_raster_size(rtype));
}
break;
default:
G_fatal_error("?");
}
/* write out line of raster data */
if (1 != G_put_raster_row(out_fd, raster_row, rtype)) {
G_close_cell(out_fd);
G_fatal_error(_("Writing map, row %d"),
((pass - 1) * rows) + row);
}
}
/* free memory */
if (bin_n)
G_free(n_array);
if (bin_min)
G_free(min_array);
if (bin_max)
G_free(max_array);
if (bin_sum)
G_free(sum_array);
if (bin_sumsq)
G_free(sumsq_array);
if (bin_index) {
G_free(index_array);
G_free(nodes);
num_nodes = 0;
max_nodes = 0;
nodes = NULL;
}
} /* passes loop */
G_percent(1, 1, 1); /* flush */
G_free(raster_row);
/* close input file */
if (!from_stdin)
fclose(in_fp);
/* close raster file & write history */
G_close_cell(out_fd);
sprintf(title, "Raw x,y,z data binned into a raster grid by cell %s",
method_opt->answer);
G_put_cell_title(outmap, title);
G_short_history(outmap, "raster", &history);
G_command_history(&history);
strncpy(history.datsrc_1, infile, RECORD_LEN);
history.datsrc_1[RECORD_LEN - 1] = '\0'; /* strncpy() doesn't null terminate if maxfill */
G_write_history(outmap, &history);
sprintf(buff, _("%lu points found in region."), count_total);
G_done_msg(buff);
G_debug(1, "Processed %lu lines.", line);
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);
}
