void task4(void)
{
task_sleep();
flag_create(&wait_flag);
lprintf("start task4\n");
for (;;) {
task_tsleep(50);
flag_set(&wait_flag);
lprintf("set_flag task4\n");
}
}
int open_files(struct globals *globals)
{
struct Ref Ref; /* group reference list */
int *in_fd, bounds_fd, is_null;
int n, row, col, srows, scols, inlen, outlen, nseg;
DCELL **inbuf; /* buffers to store lines from each of the imagery group rasters */
CELL *boundsbuf, bounds_val;
int have_bounds = 0;
CELL s, id;
struct Range range; /* min/max values of bounds map */
struct FPRange *fp_range; /* min/max values of each input raster */
DCELL *min, *max;
struct ngbr_stats Ri, Rk;
/*allocate memory for flags */
globals->null_flag = flag_create(globals->nrows, globals->ncols);
globals->candidate_flag = flag_create(globals->nrows, globals->ncols);
flag_clear_all(globals->null_flag);
flag_clear_all(globals->candidate_flag);
G_debug(1, "Checking image group...");
/* ****** open the input rasters ******* */
if (!I_get_group_ref(globals->image_group, &Ref))
G_fatal_error(_("Group <%s> not found in the current mapset"),
globals->image_group);
if (Ref.nfiles <= 0)
G_fatal_error(_("Group <%s> contains no raster maps"),
globals->image_group);
/* Read Imagery Group */
in_fd = G_malloc(Ref.nfiles * sizeof(int));
inbuf = (DCELL **) G_malloc(Ref.nfiles * sizeof(DCELL *));
fp_range = G_malloc(Ref.nfiles * sizeof(struct FPRange));
min = G_malloc(Ref.nfiles * sizeof(DCELL));
max = G_malloc(Ref.nfiles * sizeof(DCELL));
G_debug(1, "Opening input rasters...");
for (n = 0; n < Ref.nfiles; n++) {
inbuf[n] = Rast_allocate_d_buf();
in_fd[n] = Rast_open_old(Ref.file[n].name, Ref.file[n].mapset);
}
/* Get min/max values of each input raster for scaling */
globals->max_diff = 0.;
globals->nbands = Ref.nfiles;
for (n = 0; n < Ref.nfiles; n++) {
/* returns -1 on error, 2 on empty range, quitting either way. */
if (Rast_read_fp_range(Ref.file[n].name, Ref.file[n].mapset, &fp_range[n]) != 1)
G_fatal_error(_("No min/max found in raster map <%s>"),
Ref.file[n].name);
Rast_get_fp_range_min_max(&(fp_range[n]), &min[n], &max[n]);
G_debug(1, "Range for layer %d: min = %f, max = %f",
n, min[n], max[n]);
}
if (globals->weighted == FALSE)
globals->max_diff = Ref.nfiles;
else {
/* max difference with selected similarity method */
Ri.mean = max;
Rk.mean = min;
globals->max_diff = 1;
globals->max_diff = (*globals->calculate_similarity) (&Ri, &Rk, globals);
}
/* ********** find out file segmentation size ************ */
G_debug(1, "Calculate temp file sizes...");
/* size of each element to be stored */
inlen = sizeof(DCELL) * Ref.nfiles;
outlen = sizeof(CELL);
G_debug(1, "data element size, in: %d , out: %d ", inlen, outlen);
globals->datasize = sizeof(double) * globals->nbands;
/* count non-null cells */
globals->notnullcells = (long)globals->nrows * globals->ncols;
for (row = 0; row < globals->nrows; row++) {
for (n = 0; n < Ref.nfiles; n++) {
Rast_get_d_row(in_fd[n], inbuf[n], row);
}
for (col = 0; col < globals->ncols; col++) {
is_null = 0; /*Assume there is data */
for (n = 0; n < Ref.nfiles; n++) {
if (Rast_is_d_null_value(&inbuf[n][col])) {
is_null = 1;
}
}
if (is_null) {
globals->notnullcells--;
FLAG_SET(globals->null_flag, row, col);
}
}
}
G_verbose_message(_("Non-NULL cells: %ld"), globals->notnullcells);
if (globals->notnullcells < 2)
G_fatal_error(_("Insufficient number of non-NULL cells in current region"));
/* segment lib segment size */
srows = 64;
scols = 64;
nseg = manage_memory(srows, scols, globals);
/* create segment structures */
if (Segment_open
(&globals->bands_seg, G_tempfile(), globals->nrows, globals->ncols, srows,
scols, inlen, nseg) != 1)
G_fatal_error("Unable to create input temporary files");
if (Segment_open
(&globals->rid_seg, G_tempfile(), globals->nrows, globals->ncols, srows,
scols, outlen, nseg * 2) != 1)
G_fatal_error("Unable to create input temporary files");
/* load input bands to segment structure */
if (Ref.nfiles > 1)
G_message(_("Loading input bands..."));
else
G_message(_("Loading input band..."));
globals->bands_val = (double *)G_malloc(inlen);
globals->second_val = (double *)G_malloc(inlen);
/* initial segment ID */
s = 1;
globals->row_min = globals->nrows;
globals->row_max = 0;
globals->col_min = globals->ncols;
globals->col_max = 0;
for (row = 0; row < globals->nrows; row++) {
G_percent(row, globals->nrows, 4);
for (n = 0; n < Ref.nfiles; n++) {
Rast_get_d_row(in_fd[n], inbuf[n], row);
}
for (col = 0; col < globals->ncols; col++) {
is_null = 0; /*Assume there is data */
for (n = 0; n < Ref.nfiles; n++) {
globals->bands_val[n] = inbuf[n][col];
if (Rast_is_d_null_value(&inbuf[n][col])) {
is_null = 1;
}
else {
if (globals->weighted == FALSE)
/* scaled version */
globals->bands_val[n] = (inbuf[n][col] - min[n]) / (max[n] - min[n]);
}
}
if (Segment_put(&globals->bands_seg,
(void *)globals->bands_val, row, col) != 1)
G_fatal_error(_("Unable to write to temporary file"));
if (!is_null) {
if (!globals->seeds) {
/* sequentially number all cells with a unique segment ID */
id = s;
s++;
}
/* get min/max row/col to narrow the processing window */
if (globals->row_min > row)
globals->row_min = row;
if (globals->row_max < row)
globals->row_max = row;
if (globals->col_min > col)
globals->col_min = col;
if (globals->col_max < col)
globals->col_max = col;
}
else {
/* all input bands NULL */
Rast_set_c_null_value(&id, 1);
FLAG_SET(globals->null_flag, row, col);
}
if (!globals->seeds || is_null) {
if (Segment_put(&globals->rid_seg,
(void *)&id, row, col) != 1)
G_fatal_error(_("Unable to write to temporary file"));
}
}
}
G_percent(1, 1, 1);
G_debug(1, "nrows: %d, min row: %d, max row %d",
globals->nrows, globals->row_min, globals->row_max);
G_debug(1, "ncols: %d, min col: %d, max col %d",
globals->ncols, globals->col_min, globals->col_max);
globals->row_max++;
globals->col_max++;
globals->ncells = (long)(globals->row_max - globals->row_min) *
(globals->col_max - globals->col_min);
/* bounds/constraints */
Rast_set_c_null_value(&globals->upper_bound, 1);
Rast_set_c_null_value(&globals->lower_bound, 1);
if (globals->bounds_map != NULL) {
if (Segment_open
(&globals->bounds_seg, G_tempfile(), globals->nrows, globals->ncols,
srows, scols, sizeof(CELL), nseg) != TRUE)
G_fatal_error("Unable to create bounds temporary files");
if (Rast_read_range(globals->bounds_map, globals->bounds_mapset, &range) != 1)
G_fatal_error(_("No min/max found in raster map <%s>"),
globals->bounds_map);
Rast_get_range_min_max(&range, &globals->upper_bound,
&globals->lower_bound);
if (Rast_is_c_null_value(&globals->upper_bound) ||
Rast_is_c_null_value(&globals->lower_bound)) {
G_fatal_error(_("No min/max found in raster map <%s>"),
globals->bounds_map);
}
bounds_fd = Rast_open_old(globals->bounds_map, globals->bounds_mapset);
boundsbuf = Rast_allocate_c_buf();
for (row = 0; row < globals->nrows; row++) {
Rast_get_c_row(bounds_fd, boundsbuf, row);
for (col = 0; col < globals->ncols; col++) {
bounds_val = boundsbuf[col];
if (FLAG_GET(globals->null_flag, row, col)) {
Rast_set_c_null_value(&bounds_val, 1);
}
else {
if (!Rast_is_c_null_value(&bounds_val)) {
have_bounds = 1;
if (globals->lower_bound > bounds_val)
globals->lower_bound = bounds_val;
if (globals->upper_bound < bounds_val)
globals->upper_bound = bounds_val;
}
}
if (Segment_put(&globals->bounds_seg, &bounds_val, row, col) != 1)
G_fatal_error(_("Unable to write to temporary file"));
}
}
Rast_close(bounds_fd);
G_free(boundsbuf);
if (!have_bounds) {
G_warning(_("There are no boundary constraints in '%s'"), globals->bounds_map);
Rast_set_c_null_value(&globals->upper_bound, 1);
Rast_set_c_null_value(&globals->lower_bound, 1);
Segment_close(&globals->bounds_seg);
globals->bounds_map = NULL;
globals->bounds_mapset = NULL;
}
}
else {
G_debug(1, "no boundary constraint supplied.");
}
/* other info */
globals->candidate_count = 0; /* counter for remaining candidate pixels */
/* Free memory */
for (n = 0; n < Ref.nfiles; n++) {
G_free(inbuf[n]);
Rast_close(in_fd[n]);
}
globals->rs.sum = G_malloc(globals->datasize);
globals->rs.mean = G_malloc(globals->datasize);
globals->reg_tree = rgtree_create(globals->nbands, globals->datasize);
globals->n_regions = s - 1;
if (globals->seeds) {
load_seeds(globals, srows, scols, nseg);
}
G_debug(1, "Number of initial regions: %d", globals->n_regions);
G_free(inbuf);
G_free(in_fd);
G_free(fp_range);
G_free(min);
G_free(max);
return TRUE;
}
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);
}
