void Rast_align_window(struct Cell_head *window, const struct Cell_head *ref) { int preserve; window->ns_res = ref->ns_res; window->ew_res = ref->ew_res; window->zone = ref->zone; window->proj = ref->proj; preserve = window->proj == PROJECTION_LL && window->east == (window->west + 360); window->south = Rast_row_to_northing(ceil(Rast_northing_to_row(window->south, ref)), ref); window->north = Rast_row_to_northing(floor(Rast_northing_to_row(window->north, ref)), ref); window->east = Rast_col_to_easting(ceil(Rast_easting_to_col(window->east, ref)), ref); window->west = Rast_col_to_easting(floor(Rast_easting_to_col(window->west, ref)), ref); if (window->proj == PROJECTION_LL) { while (window->north > 90.0) window->north -= window->ns_res; while (window->south < -90.0) window->south += window->ns_res; if (preserve) window->east = window->west + 360; else while (window->east - window->west > 360.0) window->east -= window->ew_res; } G_adjust_Cell_head(window, 0, 0); }
int draw_outline(void) { int raster_size; row = col = top = 0; /* get started for read of first */ bottom = 1; /* line from raster map */ scan_length = read_next(); k = 0; raster_size = Rast_cell_size(map_type); while (read_next()) { /* read rest of file, one row at *//* a time */ n1 = Rast_row_to_northing((double)row - 1., &(PS.w)); n2 = Rast_row_to_northing((double)row, &(PS.w)); n3 = Rast_row_to_northing((double)row + 1., &(PS.w)); for (col = 0; col < scan_length - 1; col++) { e1 = Rast_col_to_easting((double)col - 1., &(PS.w)); e2 = Rast_col_to_easting((double)col, &(PS.w)); e3 = Rast_col_to_easting((double)col + 1., &(PS.w)); tl = G_incr_void_ptr(buffer[top], col * raster_size); /* top left in window */ tr = G_incr_void_ptr(buffer[top], (col + 1) * raster_size); /* top right in window */ bl = G_incr_void_ptr(buffer[bottom], col * raster_size); /* bottom left in window */ br = G_incr_void_ptr(buffer[bottom], (col + 1) * raster_size); /* bottom right in window */ draw_boundaries(); if (k == 3) k = 0; } row++; } return 0; } /* draw_outlines */
static void snap_to_grid(struct Cell_head *cur_hd, const struct Cell_head *ref_hd) { int lidx = (int) floor(Rast_easting_to_col( cur_hd->west, ref_hd)); int ridx = (int) floor(Rast_easting_to_col( cur_hd->east, ref_hd)); int bidx = (int) floor(Rast_northing_to_row(cur_hd->south, ref_hd)); int tidx = (int) floor(Rast_northing_to_row(cur_hd->north, ref_hd)); cur_hd->west = Rast_col_to_easting( lidx + 0.0, ref_hd); cur_hd->east = Rast_col_to_easting( ridx + 1.0, ref_hd); cur_hd->south = Rast_row_to_northing(bidx + 1.0, ref_hd); cur_hd->north = Rast_row_to_northing(tidx + 0.0, ref_hd); }
void find_minimum_distance(const struct CatEdgeList *list1, const struct CatEdgeList *list2, double *east1, double *north1, double *east2, double *north2, double *distance, const struct Cell_head *region, int overlap, const char *name1, const char *name2) { int i1, i2; double dist; double e1, n1, e2, n2; extern double G_distance(); extern double Rast_row_to_northing(); extern double Rast_col_to_easting(); int zerro_row, zerro_col; int nulldistance = 0; if (overlap) nulldistance = null_distance(name1, name2, &zerro_row, &zerro_col); for (i1 = 0; i1 < list1->ncells; i1++) { e1 = Rast_col_to_easting(list1->col[i1] + 0.5, region); n1 = Rast_row_to_northing(list1->row[i1] + 0.5, region); for (i2 = 0; i2 < list2->ncells; i2++) { if (!nulldistance) { e2 = Rast_col_to_easting(list2->col[i2] + 0.5, region); n2 = Rast_row_to_northing(list2->row[i2] + 0.5, region); dist = G_distance(e1, n1, e2, n2); } else { e2 = e1 = Rast_col_to_easting(zerro_col + 0.5, region); n2 = n1 = Rast_row_to_northing(zerro_row + 0.5, region); dist = 0.; } if ((i1 == 0 && i2 == 0) || (dist < *distance)) { *distance = dist; *east1 = e1; *north1 = n1; *east2 = e2; *north2 = n2; } if (nulldistance) break; } if (nulldistance) break; } }
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[]) { 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); }
struct Point *P_Read_Raster_Region_masked(SEGMENT *mask_seg, struct Cell_head *Original, struct bound_box output_box, struct bound_box General, int *num_points, int dim_vect, double mean) { int col, row, startcol, endcol, startrow, endrow, nrows, ncols; int pippo, npoints; double X, Y; struct Point *obs; char mask_val; pippo = dim_vect; obs = (struct Point *)G_calloc(pippo, sizeof(struct Point)); /* Reading points inside output box and inside General box */ npoints = 0; nrows = Original->rows; ncols = Original->cols; /* original region = output region * -> General box is somewhere inside output region */ if (Original->north > General.N) { startrow = (double)((Original->north - General.N) / Original->ns_res - 1); if (startrow < 0) startrow = 0; } else startrow = 0; if (Original->south < General.S) { endrow = (double)((Original->north - General.S) / Original->ns_res + 1); if (endrow > nrows) endrow = nrows; } else endrow = nrows; if (General.W > Original->west) { startcol = (double)((General.W - Original->west) / Original->ew_res - 1); if (startcol < 0) startcol = 0; } else startcol = 0; if (General.E < Original->east) { endcol = (double)((General.E - Original->west) / Original->ew_res + 1); if (endcol > ncols) endcol = ncols; } else endcol = ncols; for (row = startrow; row < endrow; row++) { for (col = startcol; col < endcol; col++) { Segment_get(mask_seg, &mask_val, row, col); if (!mask_val) continue; X = Rast_col_to_easting((double)(col) + 0.5, Original); Y = Rast_row_to_northing((double)(row) + 0.5, Original); /* Here, mean is just for asking if obs point is in box */ if (Vect_point_in_box(X, Y, mean, &General)) { /* General */ if (npoints >= pippo) { pippo += dim_vect; obs = (struct Point *)G_realloc((void *)obs, (signed int)pippo * sizeof(struct Point)); } /* Storing observation vector */ obs[npoints].coordX = X; obs[npoints].coordY = Y; obs[npoints].coordZ = 0; npoints++; } } } *num_points = npoints; return obs; }
static void resamp_unweighted(void) { stat_func *method_fn; DCELL *values; int *col_map, *row_map; int row, col; method_fn = menu[method].method; values = G_malloc(row_scale * col_scale * sizeof(DCELL)); col_map = G_malloc((dst_w.cols + 1) * sizeof(int)); row_map = G_malloc((dst_w.rows + 1) * sizeof(int)); for (col = 0; col <= dst_w.cols; col++) { double x = Rast_col_to_easting(col, &dst_w); col_map[col] = (int)floor(Rast_easting_to_col(x, &src_w) + 0.5); } for (row = 0; row <= dst_w.rows; row++) { double y = Rast_row_to_northing(row, &dst_w); row_map[row] = (int)floor(Rast_northing_to_row(y, &src_w) + 0.5); } for (row = 0; row < dst_w.rows; row++) { int maprow0 = row_map[row + 0]; int maprow1 = row_map[row + 1]; int count = maprow1 - maprow0; int i; G_percent(row, dst_w.rows, 2); for (i = 0; i < count; i++) Rast_get_d_row(infile, bufs[i], maprow0 + i); for (col = 0; col < dst_w.cols; col++) { int mapcol0 = col_map[col + 0]; int mapcol1 = col_map[col + 1]; int null = 0; int n = 0; int i, j; for (i = maprow0; i < maprow1; i++) for (j = mapcol0; j < mapcol1; j++) { DCELL *src = &bufs[i - maprow0][j]; DCELL *dst = &values[n++]; if (Rast_is_d_null_value(src)) { Rast_set_d_null_value(dst, 1); null = 1; } else *dst = *src; } if (null && nulls) Rast_set_d_null_value(&outbuf[col], 1); else (*method_fn) (&outbuf[col], values, n, closure); } Rast_put_d_row(outfile, outbuf); } }
static void resamp_weighted(void) { stat_func_w *method_fn; DCELL(*values)[2]; double *col_map, *row_map; int row, col; method_fn = menu[method].method_w; values = G_malloc(row_scale * col_scale * 2 * sizeof(DCELL)); col_map = G_malloc((dst_w.cols + 1) * sizeof(double)); row_map = G_malloc((dst_w.rows + 1) * sizeof(double)); for (col = 0; col <= dst_w.cols; col++) { double x = Rast_col_to_easting(col, &dst_w); col_map[col] = Rast_easting_to_col(x, &src_w); } for (row = 0; row <= dst_w.rows; row++) { double y = Rast_row_to_northing(row, &dst_w); row_map[row] = Rast_northing_to_row(y, &src_w); } for (row = 0; row < dst_w.rows; row++) { double y0 = row_map[row + 0]; double y1 = row_map[row + 1]; int maprow0 = (int)floor(y0); int maprow1 = (int)ceil(y1); int count = maprow1 - maprow0; int i; G_percent(row, dst_w.rows, 2); for (i = 0; i < count; i++) Rast_get_d_row(infile, bufs[i], maprow0 + i); for (col = 0; col < dst_w.cols; col++) { double x0 = col_map[col + 0]; double x1 = col_map[col + 1]; int mapcol0 = (int)floor(x0); int mapcol1 = (int)ceil(x1); int null = 0; int n = 0; int i, j; for (i = maprow0; i < maprow1; i++) { double ky = (i == maprow0) ? 1 - (y0 - maprow0) : (i == maprow1 - 1) ? 1 - (maprow1 - y1) : 1; for (j = mapcol0; j < mapcol1; j++) { double kx = (j == mapcol0) ? 1 - (x0 - mapcol0) : (j == mapcol1 - 1) ? 1 - (mapcol1 - x1) : 1; DCELL *src = &bufs[i - maprow0][j]; DCELL *dst = &values[n++][0]; if (Rast_is_d_null_value(src)) { Rast_set_d_null_value(&dst[0], 1); null = 1; } else { dst[0] = *src; dst[1] = kx * ky; } } } if (null && nulls) Rast_set_d_null_value(&outbuf[col], 1); else (*method_fn) (&outbuf[col], values, n, closure); } Rast_put_d_row(outfile, outbuf); } }
int main(int argc, char *argv[]) { int out_fd; CELL *result, *rp; int nrows, ncols; int row, col, count_sum; int field; struct GModule *module; struct Option *in_opt, *out_opt, *field_opt; struct Option *method_opt, *size_opt; struct Map_info In; double radius; struct boxlist *List; struct Cell_head region; struct bound_box box; struct line_pnts *Points; struct line_cats *Cats; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("vector")); G_add_keyword(_("algebra")); G_add_keyword(_("statistics")); G_add_keyword(_("raster")); G_add_keyword(_("aggregation")); module->label = _("Neighborhood analysis tool for vector point maps."); module->description = _("Makes each cell value a " "function of the attribute values assigned to the vector points or centroids " "around it, and stores new cell values in an output raster map."); in_opt = G_define_standard_option(G_OPT_V_INPUT); field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL); out_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 = YES; method_opt->options = "count"; method_opt->answer = "count"; method_opt->description = _("Neighborhood operation"); size_opt = G_define_option(); size_opt->key = "size"; size_opt->type = TYPE_DOUBLE; size_opt->required = YES; size_opt->description = _("Neighborhood diameter in map units"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); radius = atof(size_opt->answer) / 2; /* open input vector */ Vect_set_open_level(2); if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < 0) G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer); field = Vect_get_field_number(&In, field_opt->answer); G_get_set_window(®ion); nrows = Rast_window_rows(); ncols = Rast_window_cols(); result = Rast_allocate_buf(CELL_TYPE); Points = Vect_new_line_struct(); Cats = Vect_new_cats_struct(); List = Vect_new_boxlist(0); /*open the new cellfile */ out_fd = Rast_open_new(out_opt->answer, CELL_TYPE); box.T = PORT_DOUBLE_MAX; box.B = -PORT_DOUBLE_MAX; count_sum = 0; for (row = 0; row < nrows; row++) { double x, y; G_percent(row, nrows, 2); y = Rast_row_to_northing(row + 0.5, ®ion); box.N = y + radius; box.S = y - radius; Rast_set_null_value(result, ncols, CELL_TYPE); rp = result; for (col = 0; col < ncols; col++) { int i, count; CELL value; x = Rast_col_to_easting(col + 0.5, ®ion); box.E = x + radius; box.W = x - radius; Vect_select_lines_by_box(&In, &box, GV_POINTS, List); G_debug(3, " %d lines in box", List->n_values); count = 0; for (i = 0; i < List->n_values; i++) { Vect_read_line(&In, Points, Cats, List->id[i]); if (field != -1 && Vect_cat_get(Cats, field, NULL) == 0) continue; if (Vect_points_distance(x, y, 0.0, Points->x[0], Points->y[0], 0.0, 0) <= radius) count++; } if (count > 0) { value = count; Rast_set_d_value(rp, value, CELL_TYPE); } rp = G_incr_void_ptr(rp, Rast_cell_size(CELL_TYPE)); count_sum += count; } Rast_put_row(out_fd, result, CELL_TYPE); } G_percent(1, 1, 1); Vect_close(&In); Rast_close(out_fd); if (count_sum < 1) G_warning(_("No points found")); exit(EXIT_SUCCESS); }
struct Point *P_Read_Raster_Region_Map(SEGMENT *in_seg, struct Cell_head *Elaboration, struct Cell_head *Original, int *num_points, int dim_vect) { int col, row, startcol, endcol, startrow, endrow, nrows, ncols; int pippo, npoints; double x, y, z; struct Point *obs; struct bound_box elaboration_box; pippo = dim_vect; obs = (struct Point *)G_calloc(pippo, sizeof(struct Point)); /* Reading points inside elaboration zone */ Vect_region_box(Elaboration, &elaboration_box); npoints = 0; nrows = Original->rows; ncols = Original->cols; if (Original->north > Elaboration->north) startrow = (Original->north - Elaboration->north) / Original->ns_res - 1; else startrow = 0; if (Original->north > Elaboration->south) { endrow = (Original->north - Elaboration->south) / Original->ns_res + 1; if (endrow > nrows) endrow = nrows; } else endrow = nrows; if (Elaboration->west > Original->west) startcol = (Elaboration->west - Original->west) / Original->ew_res - 1; else startcol = 0; if (Elaboration->east > Original->west) { endcol = (Elaboration->east - Original->west) / Original->ew_res + 1; if (endcol > ncols) endcol = ncols; } else endcol = ncols; for (row = startrow; row < endrow; row++) { for (col = startcol; col < endcol; col++) { Segment_get(in_seg, &z, row, col); if (!Rast_is_d_null_value(&z)) { x = Rast_col_to_easting((double)(col) + 0.5, Original); y = Rast_row_to_northing((double)(row) + 0.5, Original); if (Vect_point_in_box(x, y, 0, &elaboration_box)) { npoints++; if (npoints >= pippo) { pippo += dim_vect; obs = (struct Point *)G_realloc((void *)obs, (signed int)pippo * sizeof(struct Point)); } /* Storing observation vector */ obs[npoints - 1].coordX = x; obs[npoints - 1].coordY = y; obs[npoints - 1].coordZ = z; } } } } *num_points = npoints; return obs; }
int extract_points(int z_flag) { struct line_pnts *points = Vect_new_line_struct(); CELL *cellbuf; FCELL *fcellbuf; DCELL *dcellbuf; int row, col; double x, y; int count; switch (data_type) { case CELL_TYPE: cellbuf = Rast_allocate_c_buf(); break; case FCELL_TYPE: fcellbuf = Rast_allocate_f_buf(); break; case DCELL_TYPE: dcellbuf = Rast_allocate_d_buf(); break; } G_message(_("Extracting points...")); count = 1; for (row = 0; row < cell_head.rows; row++) { G_percent(row, n_rows, 2); y = Rast_row_to_northing((double)(row + .5), &cell_head); switch (data_type) { case CELL_TYPE: Rast_get_c_row(input_fd, cellbuf, row); break; case FCELL_TYPE: Rast_get_f_row(input_fd, fcellbuf, row); break; case DCELL_TYPE: Rast_get_d_row(input_fd, dcellbuf, row); break; } for (col = 0; col < cell_head.cols; col++) { int cat, val; double dval; x = Rast_col_to_easting((double)(col + .5), &cell_head); switch (data_type) { case CELL_TYPE: if (Rast_is_c_null_value(cellbuf + col)) continue; val = cellbuf[col]; dval = val; break; case FCELL_TYPE: if (Rast_is_f_null_value(fcellbuf + col)) continue; dval = fcellbuf[col]; break; case DCELL_TYPE: if (Rast_is_d_null_value(dcellbuf + col)) continue; dval = dcellbuf[col]; break; } /* value_flag is used only for CELL type */ cat = (value_flag) ? val : count; Vect_reset_line(points); Vect_reset_cats(Cats); Vect_cat_set(Cats, 1, cat); Vect_append_point(points, x, y, dval); Vect_write_line(&Map, GV_POINT, points, Cats); if ((driver != NULL) && !value_flag) { insert_value(cat, val, dval); } count++; } } G_percent(row, n_rows, 2); switch (data_type) { case CELL_TYPE: G_free(cellbuf); break; case FCELL_TYPE: G_free(fcellbuf); break; case DCELL_TYPE: G_free(dcellbuf); break; } Vect_destroy_line_struct(points); return (1); }
int main(int argc, char *argv[]) { struct GModule *module; struct Option *rastin, *rastout, *method; struct History history; char title[64]; char buf_nsres[100], buf_ewres[100]; struct Colors colors; int infile, outfile; DCELL *outbuf; int row, col; struct Cell_head dst_w, src_w; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("resample")); module->description = _("Resamples raster map layers to a finer grid using interpolation."); rastin = G_define_standard_option(G_OPT_R_INPUT); rastout = G_define_standard_option(G_OPT_R_OUTPUT); method = G_define_option(); method->key = "method"; method->type = TYPE_STRING; method->required = NO; method->description = _("Interpolation method"); method->options = "nearest,bilinear,bicubic,lanczos"; method->answer = "bilinear"; if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (G_strcasecmp(method->answer, "nearest") == 0) neighbors = 1; else if (G_strcasecmp(method->answer, "bilinear") == 0) neighbors = 2; else if (G_strcasecmp(method->answer, "bicubic") == 0) neighbors = 4; else if (G_strcasecmp(method->answer, "lanczos") == 0) neighbors = 5; else G_fatal_error(_("Invalid method: %s"), method->answer); G_get_set_window(&dst_w); /* set window to old map */ Rast_get_cellhd(rastin->answer, "", &src_w); /* enlarge source window */ { double north = Rast_row_to_northing(0.5, &dst_w); double south = Rast_row_to_northing(dst_w.rows - 0.5, &dst_w); int r0 = (int)floor(Rast_northing_to_row(north, &src_w) - 0.5) - 2; int r1 = (int)floor(Rast_northing_to_row(south, &src_w) - 0.5) + 3; double west = Rast_col_to_easting(0.5, &dst_w); double east = Rast_col_to_easting(dst_w.cols - 0.5, &dst_w); int c0 = (int)floor(Rast_easting_to_col(west, &src_w) - 0.5) - 2; int c1 = (int)floor(Rast_easting_to_col(east, &src_w) - 0.5) + 3; src_w.south -= src_w.ns_res * (r1 - src_w.rows); src_w.north += src_w.ns_res * (-r0); src_w.west -= src_w.ew_res * (-c0); src_w.east += src_w.ew_res * (c1 - src_w.cols); src_w.rows = r1 - r0; src_w.cols = c1 - c0; } Rast_set_input_window(&src_w); /* allocate buffers for input rows */ for (row = 0; row < neighbors; row++) bufs[row] = Rast_allocate_d_input_buf(); cur_row = -100; /* open old map */ infile = Rast_open_old(rastin->answer, ""); /* reset window to current region */ Rast_set_output_window(&dst_w); outbuf = Rast_allocate_d_output_buf(); /* open new map */ outfile = Rast_open_new(rastout->answer, DCELL_TYPE); switch (neighbors) { case 1: /* nearest */ for (row = 0; row < dst_w.rows; row++) { double north = Rast_row_to_northing(row + 0.5, &dst_w); double maprow_f = Rast_northing_to_row(north, &src_w) - 0.5; int maprow0 = (int)floor(maprow_f + 0.5); G_percent(row, dst_w.rows, 2); read_rows(infile, maprow0); for (col = 0; col < dst_w.cols; col++) { double east = Rast_col_to_easting(col + 0.5, &dst_w); double mapcol_f = Rast_easting_to_col(east, &src_w) - 0.5; int mapcol0 = (int)floor(mapcol_f + 0.5); double c = bufs[0][mapcol0]; if (Rast_is_d_null_value(&c)) { Rast_set_d_null_value(&outbuf[col], 1); } else { outbuf[col] = c; } } Rast_put_d_row(outfile, outbuf); } break; case 2: /* bilinear */ for (row = 0; row < dst_w.rows; row++) { double north = Rast_row_to_northing(row + 0.5, &dst_w); double maprow_f = Rast_northing_to_row(north, &src_w) - 0.5; int maprow0 = (int)floor(maprow_f); double v = maprow_f - maprow0; G_percent(row, dst_w.rows, 2); read_rows(infile, maprow0); for (col = 0; col < dst_w.cols; col++) { double east = Rast_col_to_easting(col + 0.5, &dst_w); double mapcol_f = Rast_easting_to_col(east, &src_w) - 0.5; int mapcol0 = (int)floor(mapcol_f); int mapcol1 = mapcol0 + 1; double u = mapcol_f - mapcol0; double c00 = bufs[0][mapcol0]; double c01 = bufs[0][mapcol1]; double c10 = bufs[1][mapcol0]; double c11 = bufs[1][mapcol1]; if (Rast_is_d_null_value(&c00) || Rast_is_d_null_value(&c01) || Rast_is_d_null_value(&c10) || Rast_is_d_null_value(&c11)) { Rast_set_d_null_value(&outbuf[col], 1); } else { outbuf[col] = Rast_interp_bilinear(u, v, c00, c01, c10, c11); } } Rast_put_d_row(outfile, outbuf); } break; case 4: /* bicubic */ for (row = 0; row < dst_w.rows; row++) { double north = Rast_row_to_northing(row + 0.5, &dst_w); double maprow_f = Rast_northing_to_row(north, &src_w) - 0.5; int maprow1 = (int)floor(maprow_f); int maprow0 = maprow1 - 1; double v = maprow_f - maprow1; G_percent(row, dst_w.rows, 2); read_rows(infile, maprow0); for (col = 0; col < dst_w.cols; col++) { double east = Rast_col_to_easting(col + 0.5, &dst_w); double mapcol_f = Rast_easting_to_col(east, &src_w) - 0.5; int mapcol1 = (int)floor(mapcol_f); int mapcol0 = mapcol1 - 1; int mapcol2 = mapcol1 + 1; int mapcol3 = mapcol1 + 2; double u = mapcol_f - mapcol1; double c00 = bufs[0][mapcol0]; double c01 = bufs[0][mapcol1]; double c02 = bufs[0][mapcol2]; double c03 = bufs[0][mapcol3]; double c10 = bufs[1][mapcol0]; double c11 = bufs[1][mapcol1]; double c12 = bufs[1][mapcol2]; double c13 = bufs[1][mapcol3]; double c20 = bufs[2][mapcol0]; double c21 = bufs[2][mapcol1]; double c22 = bufs[2][mapcol2]; double c23 = bufs[2][mapcol3]; double c30 = bufs[3][mapcol0]; double c31 = bufs[3][mapcol1]; double c32 = bufs[3][mapcol2]; double c33 = bufs[3][mapcol3]; if (Rast_is_d_null_value(&c00) || Rast_is_d_null_value(&c01) || Rast_is_d_null_value(&c02) || Rast_is_d_null_value(&c03) || Rast_is_d_null_value(&c10) || Rast_is_d_null_value(&c11) || Rast_is_d_null_value(&c12) || Rast_is_d_null_value(&c13) || Rast_is_d_null_value(&c20) || Rast_is_d_null_value(&c21) || Rast_is_d_null_value(&c22) || Rast_is_d_null_value(&c23) || Rast_is_d_null_value(&c30) || Rast_is_d_null_value(&c31) || Rast_is_d_null_value(&c32) || Rast_is_d_null_value(&c33)) { Rast_set_d_null_value(&outbuf[col], 1); } else { outbuf[col] = Rast_interp_bicubic(u, v, c00, c01, c02, c03, c10, c11, c12, c13, c20, c21, c22, c23, c30, c31, c32, c33); } } Rast_put_d_row(outfile, outbuf); } break; case 5: /* lanczos */ for (row = 0; row < dst_w.rows; row++) { double north = Rast_row_to_northing(row + 0.5, &dst_w); double maprow_f = Rast_northing_to_row(north, &src_w) - 0.5; int maprow1 = (int)floor(maprow_f + 0.5); int maprow0 = maprow1 - 2; double v = maprow_f - maprow1; G_percent(row, dst_w.rows, 2); read_rows(infile, maprow0); for (col = 0; col < dst_w.cols; col++) { double east = Rast_col_to_easting(col + 0.5, &dst_w); double mapcol_f = Rast_easting_to_col(east, &src_w) - 0.5; int mapcol2 = (int)floor(mapcol_f + 0.5); int mapcol0 = mapcol2 - 2; int mapcol4 = mapcol2 + 2; double u = mapcol_f - mapcol2; double c[25]; int ci = 0, i, j, do_lanczos = 1; for (i = 0; i < 5; i++) { for (j = mapcol0; j <= mapcol4; j++) { c[ci] = bufs[i][j]; if (Rast_is_d_null_value(&(c[ci]))) { Rast_set_d_null_value(&outbuf[col], 1); do_lanczos = 0; break; } ci++; } if (!do_lanczos) break; } if (do_lanczos) { outbuf[col] = Rast_interp_lanczos(u, v, c); } } Rast_put_d_row(outfile, outbuf); } break; } G_percent(dst_w.rows, dst_w.rows, 2); Rast_close(infile); Rast_close(outfile); /* record map metadata/history info */ sprintf(title, "Resample by %s interpolation", method->answer); Rast_put_cell_title(rastout->answer, title); Rast_short_history(rastout->answer, "raster", &history); Rast_set_history(&history, HIST_DATSRC_1, rastin->answer); G_format_resolution(src_w.ns_res, buf_nsres, src_w.proj); G_format_resolution(src_w.ew_res, buf_ewres, src_w.proj); Rast_format_history(&history, HIST_DATSRC_2, "Source map NS res: %s EW res: %s", buf_nsres, buf_ewres); Rast_command_history(&history); Rast_write_history(rastout->answer, &history); /* copy color table from source map */ if (Rast_read_colors(rastin->answer, "", &colors) < 0) G_fatal_error(_("Unable to read color table for %s"), rastin->answer); Rast_mark_colors_as_fp(&colors); Rast_write_colors(rastout->answer, G_mapset(), &colors); return (EXIT_SUCCESS); }
int main(int argc, char *argv[]) { extern struct Cell_head window; union RASTER_PTR elevbuf, tmpbuf, outbuf; CELL min, max; DCELL dvalue, dvalue2, dmin, dmax; struct History hist; RASTER_MAP_TYPE data_type; struct Range range; struct FPRange fprange; double drow, dcol; int elev_fd, output_fd, zeros; struct { struct Option *opt1, *opt2, *opt3, *opt4, *north, *east, *year, *month, *day, *hour, *minutes, *seconds, *timezone; } parm; struct Flag *flag1, *flag3, *flag4; struct GModule *module; char *name, *outname; double dazi, dalti; double azi, alti; double nstep, estep; double maxh; double east, east1, north, north1; int row1, col1; char OK; double timezone; int year, month, day, hour, minutes, seconds; long retval; int solparms, locparms, use_solpos; double sunrise, sunset, current_time; int sretr = 0, ssetr = 0, sretr_sec = 0, ssetr_sec = 0; double dsretr, dssetr; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("sun position")); module->label = _("Calculates cast shadow areas from sun position and elevation raster map."); module->description = _("Either exact sun position (A) is specified, or date/time to calculate " "the sun position (B) by r.sunmask itself."); parm.opt1 = G_define_standard_option(G_OPT_R_ELEV); parm.opt2 = G_define_standard_option(G_OPT_R_OUTPUT); parm.opt2->required = NO; parm.opt3 = G_define_option(); parm.opt3->key = "altitude"; parm.opt3->type = TYPE_DOUBLE; parm.opt3->required = NO; parm.opt3->options = "0-89.999"; parm.opt3->description = _("Altitude of the sun above horizon, degrees (A)"); parm.opt3->guisection = _("Position"); parm.opt4 = G_define_option(); parm.opt4->key = "azimuth"; parm.opt4->type = TYPE_DOUBLE; parm.opt4->required = NO; parm.opt4->options = "0-360"; parm.opt4->description = _("Azimuth of the sun from the north, degrees (A)"); parm.opt4->guisection = _("Position"); parm.year = G_define_option(); parm.year->key = "year"; parm.year->type = TYPE_INTEGER; parm.year->required = NO; parm.year->description = _("Year (B)"); parm.year->options = "1950-2050"; parm.year->guisection = _("Time"); parm.month = G_define_option(); parm.month->key = "month"; parm.month->type = TYPE_INTEGER; parm.month->required = NO; parm.month->description = _("Month (B)"); parm.month->options = "0-12"; parm.month->guisection = _("Time"); parm.day = G_define_option(); parm.day->key = "day"; parm.day->type = TYPE_INTEGER; parm.day->required = NO; parm.day->description = _("Day (B)"); parm.day->options = "0-31"; parm.day->guisection = _("Time"); parm.hour = G_define_option(); parm.hour->key = "hour"; parm.hour->type = TYPE_INTEGER; parm.hour->required = NO; parm.hour->description = _("Hour (B)"); parm.hour->options = "0-24"; parm.hour->guisection = _("Time"); parm.minutes = G_define_option(); parm.minutes->key = "minute"; parm.minutes->type = TYPE_INTEGER; parm.minutes->required = NO; parm.minutes->description = _("Minutes (B)"); parm.minutes->options = "0-60"; parm.minutes->guisection = _("Time"); parm.seconds = G_define_option(); parm.seconds->key = "second"; parm.seconds->type = TYPE_INTEGER; parm.seconds->required = NO; parm.seconds->description = _("Seconds (B)"); parm.seconds->options = "0-60"; parm.seconds->guisection = _("Time"); parm.timezone = G_define_option(); parm.timezone->key = "timezone"; parm.timezone->type = TYPE_INTEGER; parm.timezone->required = NO; parm.timezone->label = _("Timezone"); parm.timezone->description = _("East positive, offset from GMT, also use to adjust daylight savings"); parm.timezone->guisection = _("Time"); parm.east = G_define_option(); parm.east->key = "east"; parm.east->key_desc = "value"; parm.east->type = TYPE_STRING; parm.east->required = NO; parm.east->label = _("Easting coordinate (point of interest)"); parm.east->description = _("Default: map center"); parm.east->guisection = _("Position"); parm.north = G_define_option(); parm.north->key = "north"; parm.north->key_desc = "value"; parm.north->type = TYPE_STRING; parm.north->required = NO; parm.north->label = _("Northing coordinate (point of interest)"); parm.north->description = _("Default: map center"); parm.north->guisection = _("Position"); flag1 = G_define_flag(); flag1->key = 'z'; flag1->description = _("Don't ignore zero elevation"); flag3 = G_define_flag(); flag3->key = 's'; flag3->description = _("Calculate sun position only and exit"); flag3->guisection = _("Print"); flag4 = G_define_flag(); flag4->key = 'g'; flag4->description = _("Print the sun position output in shell script style"); flag4->guisection = _("Print"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); zeros = flag1->answer; G_get_window(&window); /* if not given, get east and north: XX */ if (!parm.north->answer || !parm.east->answer) { north = (window.north - window.south) / 2. + window.south; east = (window.west - window.east) / 2. + window.east; G_verbose_message(_("Using map center coordinates: %f %f"), east, north); } else { /* user defined east, north: */ sscanf(parm.north->answer, "%lf", &north); sscanf(parm.east->answer, "%lf", &east); if (strlen(parm.east->answer) == 0) G_fatal_error(_("Empty east coordinate specified")); if (strlen(parm.north->answer) == 0) G_fatal_error(_("Empty north coordinate specified")); } /* check which method to use for sun position: either user defines directly sun position or it is calculated */ if (parm.opt3->answer && parm.opt4->answer) solparms = 1; /* opt3 & opt4 complete */ else solparms = 0; /* calculate sun position */ if (parm.year->answer && parm.month->answer && parm.day->answer && parm.hour->answer && parm.minutes->answer && parm.seconds->answer && parm.timezone->answer) locparms = 1; /* complete */ else locparms = 0; if (solparms && locparms) /* both defined */ G_fatal_error(_("Either define sun position or location/date/time parameters")); if (!solparms && !locparms) /* nothing defined */ G_fatal_error(_("Neither sun position nor east/north, date/time/timezone definition are complete")); /* if here, one definition was complete */ if (locparms) { G_message(_("Calculating sun position... (using solpos (V. %s) from NREL)"), SOLPOSVERSION); use_solpos = 1; } else { G_message(_("Using user defined sun azimuth, altitude settings (ignoring eventual other values)")); use_solpos = 0; } name = parm.opt1->answer; outname = parm.opt2->answer; if (!use_solpos) { sscanf(parm.opt3->answer, "%lf", &dalti); sscanf(parm.opt4->answer, "%lf", &dazi); } else { sscanf(parm.year->answer, "%i", &year); sscanf(parm.month->answer, "%i", &month); sscanf(parm.day->answer, "%i", &day); sscanf(parm.hour->answer, "%i", &hour); sscanf(parm.minutes->answer, "%i", &minutes); sscanf(parm.seconds->answer, "%i", &seconds); sscanf(parm.timezone->answer, "%lf", &timezone); } /* NOTES: G_calc_solar_position () - the algorithm will compensate for leap year. - longitude, latitude: decimal degree - timezone: DO NOT ADJUST FOR DAYLIGHT SAVINGS TIME. - timezone: negative for zones west of Greenwich - lat/long: east and north positive - the atmospheric refraction is calculated for 1013hPa, 15�C - time: local time from your watch Order of parameters: long, lat, timezone, year, month, day, hour, minutes, seconds */ if (use_solpos) { G_debug(3, "\nlat:%f long:%f", north, east); retval = calc_solar_position(east, north, timezone, year, month, day, hour, minutes, seconds); /* Remove +0.5 above if you want round-down instead of round-to-nearest */ sretr = (int)floor(pdat->sretr); /* sunrise */ dsretr = pdat->sretr; sretr_sec = (int) floor(((dsretr - floor(dsretr)) * 60 - floor((dsretr - floor(dsretr)) * 60)) * 60); ssetr = (int)floor(pdat->ssetr); /* sunset */ dssetr = pdat->ssetr; ssetr_sec = (int) floor(((dssetr - floor(dssetr)) * 60 - floor((dssetr - floor(dssetr)) * 60)) * 60); /* print the results */ if (retval == 0) { /* error check */ if (flag3->answer) { if (flag4->answer) { fprintf(stdout, "date=%d/%02d/%02d\n", pdat->year, pdat->month, pdat->day); fprintf(stdout, "daynum=%d\n", pdat->daynum); fprintf(stdout, "time=%02i:%02i:%02i\n", pdat->hour, pdat->minute, pdat->second); fprintf(stdout, "decimaltime=%f\n", pdat->hour + (pdat->minute * 100.0 / 60.0 + pdat->second * 100.0 / 3600.0) / 100.); fprintf(stdout, "longitudine=%f\n", pdat->longitude); fprintf(stdout, "latitude=%f\n", pdat->latitude); fprintf(stdout, "timezone=%f\n", pdat->timezone); fprintf(stdout, "sunazimuth=%f\n", pdat->azim); fprintf(stdout, "sunangleabovehorizon=%f\n", pdat->elevref); if (sretr / 60 <= 24.0) { fprintf(stdout, "sunrise=%02d:%02d:%02d\n", sretr / 60, sretr % 60, sretr_sec); fprintf(stdout, "sunset=%02d:%02d:%02d\n", ssetr / 60, ssetr % 60, ssetr_sec); } } else { fprintf(stdout, "%d/%02d/%02d, daynum: %d, time: %02i:%02i:%02i (decimal time: %f)\n", pdat->year, pdat->month, pdat->day, pdat->daynum, pdat->hour, pdat->minute, pdat->second, pdat->hour + (pdat->minute * 100.0 / 60.0 + pdat->second * 100.0 / 3600.0) / 100.); fprintf(stdout, "long: %f, lat: %f, timezone: %f\n", pdat->longitude, pdat->latitude, pdat->timezone); fprintf(stdout, "Solar position: sun azimuth: %f, sun angle above horz. (refraction corrected): %f\n", pdat->azim, pdat->elevref); if (sretr / 60 <= 24.0) { fprintf(stdout, "Sunrise time (without refraction): %02d:%02d:%02d\n", sretr / 60, sretr % 60, sretr_sec); fprintf(stdout, "Sunset time (without refraction): %02d:%02d:%02d\n", ssetr / 60, ssetr % 60, ssetr_sec); } } } sunrise = pdat->sretr / 60.; /* decimal minutes */ sunset = pdat->ssetr / 60.; current_time = pdat->hour + (pdat->minute / 60.) + (pdat->second / 3600.); } else /* fatal error in G_calc_solar_position() */ G_fatal_error(_("Please correct settings")); } if (use_solpos) { dalti = pdat->elevref; dazi = pdat->azim; } /* otherwise already defined */ /* check sunrise */ if (use_solpos) { G_debug(3, "current_time:%f sunrise:%f", current_time, sunrise); if ((current_time < sunrise)) { if (sretr / 60 <= 24.0) G_message(_("Time (%02i:%02i:%02i) is before sunrise (%02d:%02d:%02d)"), pdat->hour, pdat->minute, pdat->second, sretr / 60, sretr % 60, sretr_sec); else G_message(_("Time (%02i:%02i:%02i) is before sunrise"), pdat->hour, pdat->minute, pdat->second); G_warning(_("Nothing to calculate. Please verify settings.")); } if ((current_time > sunset)) { if (sretr / 60 <= 24.0) G_message(_("Time (%02i:%02i:%02i) is after sunset (%02d:%02d:%02d)"), pdat->hour, pdat->minute, pdat->second, ssetr / 60, ssetr % 60, ssetr_sec); else G_message(_("Time (%02i:%02i:%02i) is after sunset"), pdat->hour, pdat->minute, pdat->second); G_warning(_("Nothing to calculate. Please verify settings.")); } } if (flag3->answer && (use_solpos == 1)) { /* we only want the sun position */ exit(EXIT_SUCCESS); } else if (flag3->answer && (use_solpos == 0)) { /* are you joking ? */ G_message(_("You already know the sun position")); exit(EXIT_SUCCESS); } if (!outname) G_fatal_error(_("Option <%s> required"), parm.opt2->key); elev_fd = Rast_open_old(name, ""); output_fd = Rast_open_c_new(outname); data_type = Rast_get_map_type(elev_fd); elevbuf.v = Rast_allocate_buf(data_type); tmpbuf.v = Rast_allocate_buf(data_type); outbuf.v = Rast_allocate_buf(CELL_TYPE); /* binary map */ if (data_type == CELL_TYPE) { if ((Rast_read_range(name, "", &range)) < 0) G_fatal_error(_("Unable to open range file for raster map <%s>"), name); Rast_get_range_min_max(&range, &min, &max); dmin = (double)min; dmax = (double)max; } else { Rast_read_fp_range(name, "", &fprange); Rast_get_fp_range_min_max(&fprange, &dmin, &dmax); } azi = 2 * M_PI * dazi / 360; alti = 2 * M_PI * dalti / 360; nstep = cos(azi) * window.ns_res; estep = sin(azi) * window.ew_res; row1 = 0; G_message(_("Calculating shadows from DEM...")); while (row1 < window.rows) { G_percent(row1, window.rows, 2); col1 = 0; drow = -1; Rast_get_row(elev_fd, elevbuf.v, row1, data_type); while (col1 < window.cols) { dvalue = raster_value(elevbuf, data_type, col1); /* outbuf.c[col1]=1; */ Rast_set_null_value(&outbuf.c[col1], 1, CELL_TYPE); OK = 1; east = Rast_col_to_easting(col1 + 0.5, &window); north = Rast_row_to_northing(row1 + 0.5, &window); east1 = east; north1 = north; if (dvalue == 0.0 && !zeros) OK = 0; while (OK == 1) { east += estep; north += nstep; if (north > window.north || north < window.south || east > window.east || east < window.west) OK = 0; else { maxh = tan(alti) * sqrt((north1 - north) * (north1 - north) + (east1 - east) * (east1 - east)); if ((maxh) > (dmax - dvalue)) OK = 0; else { dcol = Rast_easting_to_col(east, &window); if (drow != Rast_northing_to_row(north, &window)) { drow = Rast_northing_to_row(north, &window); Rast_get_row(elev_fd, tmpbuf.v, (int)drow, data_type); } dvalue2 = raster_value(tmpbuf, data_type, (int)dcol); if ((dvalue2 - dvalue) > (maxh)) { OK = 0; outbuf.c[col1] = 1; } } } } G_debug(3, "Analysing col %i", col1); col1 += 1; } G_debug(3, "Writing result row %i of %i", row1, window.rows); Rast_put_row(output_fd, outbuf.c, CELL_TYPE); row1 += 1; } G_percent(1, 1, 1); Rast_close(output_fd); Rast_close(elev_fd); /* writing history file */ Rast_short_history(outname, "raster", &hist); Rast_format_history(&hist, HIST_DATSRC_1, "raster elevation map %s", name); Rast_command_history(&hist); Rast_write_history(outname, &hist); exit(EXIT_SUCCESS); }
/* ************************************************************************* */ void rast3d_cross_section(void *map,RASTER3D_Region region, int elevfd, int outfd) { int col, row; int rows, cols, depths, typeIntern; FCELL *fcell = NULL; DCELL *dcell = NULL; void *elevrast; void *ptr; int intvalue; float fvalue; double dvalue; double elevation = 0; double north, east; struct Cell_head window; Rast_get_window(&window); rows = region.rows; cols = region.cols; depths = region.depths; /*Typ of the RASTER3D Tile */ typeIntern = Rast3d_tile_type_map(map); /*Allocate mem for the output maps row */ if (typeIntern == FCELL_TYPE) fcell = Rast_allocate_f_buf(); else if (typeIntern == DCELL_TYPE) dcell = Rast_allocate_d_buf(); /*Mem for the input map row */ elevrast = Rast_allocate_buf(globalElevMapType); for (row = 0; row < rows; row++) { G_percent(row, rows - 1, 10); /*Read the input map row */ Rast_get_row(elevfd, elevrast, row, globalElevMapType); for (col = 0, ptr = elevrast; col < cols; col++, ptr = G_incr_void_ptr(ptr, Rast_cell_size(globalElevMapType))) { if (Rast_is_null_value(ptr, globalElevMapType)) { if (typeIntern == FCELL_TYPE) Rast_set_null_value(&fcell[col], 1, FCELL_TYPE); else if (typeIntern == DCELL_TYPE) Rast_set_null_value(&dcell[col], 1, DCELL_TYPE); continue; } /*Read the elevation value */ if (globalElevMapType == CELL_TYPE) { intvalue = *(CELL *) ptr; elevation = intvalue; } else if (globalElevMapType == FCELL_TYPE) { fvalue = *(FCELL *) ptr; elevation = fvalue; } else if (globalElevMapType == DCELL_TYPE) { dvalue = *(DCELL *) ptr; elevation = dvalue; } /* Compute the coordinates */ north = Rast_row_to_northing((double)row + 0.5, &window); east = Rast_col_to_easting((double)col + 0.5, &window); /* Get the voxel value */ if (typeIntern == FCELL_TYPE) Rast3d_get_region_value(map, north, east, elevation, &fcell[col], FCELL_TYPE); if (typeIntern == DCELL_TYPE) Rast3d_get_region_value(map, north, east, elevation, &dcell[col], DCELL_TYPE); } /*Write the data to the output map */ if (typeIntern == FCELL_TYPE) Rast_put_f_row(outfd, fcell); if (typeIntern == DCELL_TYPE) Rast_put_d_row(outfd, dcell); } G_debug(3, "\nDone\n"); /*Free the mem */ if (elevrast) G_free(elevrast); if (dcell) G_free(dcell); if (fcell) G_free(fcell); }
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); }
static int update_list(int count) { struct COOR *new_ptr1, *new_ptr2, *new_ptr3; G_debug(3, "update_list: count:%d row:%d col:%d", count, row, col - 1); switch (count) { case 0: G_debug(1, "Isolated cell (%d,%d)", row, col); break; case 1: /* begin or end line */ if (ml) h_ptr = end_line(h_ptr, 0); if (tl) v_list[col].left = end_line(v_list[col].left, 0); if (tc) v_list[col].center = end_line(v_list[col].center, 0); if (tr) v_list[col].right = end_line(v_list[col].right, 0); if (mr) h_ptr = start_line(0); if (br) v_list[col + 1].left = start_line(0); if (bc) v_list[col].center = start_line(0); if (bl) v_list[col - 1].right = start_line(0); break; case 2: /* straight or bent line */ if (tl != 0 && br != 0) { /* slanted line (\) */ v_list[col + 1].left = v_list[col].left; v_list[col].left = NULL; } else if (tr != 0 && bl != 0) { /* slanted line (/) */ v_list[col - 1].right = v_list[col].right; v_list[col].right = NULL; } /* first take care of the cases where both non-zero neighbours are in a upper-left corner (cw from ml to tr) */ else if (ml != 0 && tc != 0) { /* bend (_|) */ join_lines(h_ptr, v_list[col].center); h_ptr = v_list[col].center = NULL; } else if (ml != 0 && tr != 0) { /* bend (_/) */ join_lines(h_ptr, v_list[col].right); h_ptr = v_list[col].left = NULL; } else if (tl != 0 && tr != 0) { /* bend (\/) */ join_lines(v_list[col].left, v_list[col].right); v_list[col].left = v_list[col].right = NULL; } else if (tl != 0 && tc != 0) /* bend (\|) */ v_list[col].center = end_line(v_list[col].center, 1); else if (tr != 0 && tc != 0) /* bend |/ */ v_list[col].center = end_line(v_list[col].center, 1); else if (tl != 0 && ml != 0) h_ptr = end_line(h_ptr, 1); /* now take care of the cases when non-zero neighbours are next to nonzero neighbours in a top-left corner */ else if (bl != 0 && ml != 0) v_list[col].center = start_line(1); else if (tr != 0 && mr != 0) h_ptr = start_line(1); else if (!((tc != 0 && bc != 0) || (ml != 0 && mr != 0))) /* if not horiz or vertical line */ { /* one of the non zero neighbours is in the top left corner, and the other one is one of bl - mr, not next to the first one */ if (ml || tl || tc || tr) { /* old line bends toward *//* new area */ new_ptr1 = get_ptr(); if (ml) { /* join new to where came from */ if (h_ptr == NULL) G_debug(1, "h_ptr is NULL!"); /* this should never happen by the logic of algorithm */ extend_line(h_ptr, new_ptr1); h_ptr = NULL; } else if (tl) { if (v_list[col].left == NULL) G_debug(1, "v_list[col].left is NULL!"); /* this should never happen by the logic of algorithm */ extend_line(v_list[col].left, new_ptr1); v_list[col].left = NULL; } else if (tc) { if (v_list[col].center == NULL) G_debug(1, "v_list[col].center is NULL!"); /* this should never happen by the logic of algorithm */ extend_line(v_list[col].center, new_ptr1); v_list[col].center = NULL; } else { /* tr */ if (v_list[col].right == NULL) G_debug(1, "v_list[col].right is NULL!"); /* this should never happen by the logic of algorithm */ extend_line(v_list[col].right, new_ptr1); v_list[col].right = NULL; } if (mr) /* find out where going */ /* tr is 0 here */ h_ptr = new_ptr1; else if (br) v_list[col + 1].left = new_ptr1; else if (bc) v_list[col].center = new_ptr1; else /* bl, ml is 0 here */ v_list[col - 1].right = new_ptr1; } else { /* lower-left */ /* if the non-zero neigbours are adjacent */ if (mr && br) h_ptr = start_line(1); else if ((br && bc) || (bl && bc)) v_list[col].center = start_line(1); else /* the non-zero neigbours are not adjacent */ { /* starting in middle of line */ new_ptr1 = get_ptr(); new_ptr2 = get_ptr(); new_ptr3 = get_ptr(); new_ptr1->fptr = new_ptr2; new_ptr1->bptr = new_ptr3; new_ptr3->bptr = new_ptr2->bptr = new_ptr1; if (mr && bc) { h_ptr = new_ptr2; v_list[col].center = new_ptr3; } else if (mr && bl) { h_ptr = new_ptr2; v_list[col - 1].right = new_ptr3; } else if (bl && br) { v_list[col - 1].right = new_ptr3; v_list[col + 1].left = new_ptr2; } } /* starting in the middle of the line */ } } else if (value_flag) { /* horizontal or vertical line */ int ml_val, mc_val, mr_val; /* horiz */ int tc_val, bc_val; /* vert */ ml_val = mc_val = mr_val = tc_val = bc_val = 0; /* only CELL supported */ if (data_type == CELL_TYPE) { ml_val = ((CELL *) middle)[col - 1]; mc_val = ((CELL *) middle)[col]; mr_val = ((CELL *) middle)[col + 1]; tc_val = ((CELL *) top)[col]; bc_val = ((CELL *) bottom)[col]; } if ((mc && mr) && mc_val != mr_val) { /* break the horizontal line */ h_ptr = end_line(h_ptr, 1); h_ptr = start_line(1); } else if ((mc && bc) && mc_val != bc_val) { /* break the vertical line */ v_list[col].center = end_line(v_list[col].center, 1); v_list[col].center = start_line(1); } if ((mc && ml) && mc_val != ml_val) { h_ptr->bptr->val = mc_val; } else if ((mc && tc) && mc_val != tc_val) { v_list[col].center->bptr->val = mc_val; } } break; case 3: if (ml || tl || tc || (tr && !mr)) { if (ml) /* stop horz. and vert. lines */ h_ptr = end_line(h_ptr, 1); if (tc) v_list[col].center = end_line(v_list[col].center, 1); /* stop diag lines if no horz,vert */ if ((tl) && (!ml) && (!tc)) v_list[col].left = end_line(v_list[col].left, 1); if ((tr) && (!mr) && (!tc)) v_list[col].right = end_line(v_list[col].right, 1); } if (mr) /* start horz. and vert */ h_ptr = start_line(1); if (bc) v_list[col].center = start_line(1); /* start diag if no horz,vert */ if ((br) && (!mr) && (!bc)) v_list[col + 1].left = start_line(1); if ((bl) && (!ml) && (!bc)) v_list[col - 1].right = start_line(1); break; case 4: if (ml) /* end horz. and vert lines */ h_ptr = end_line(h_ptr, 1); if (tc) v_list[col].center = end_line(v_list[col].center, 1); /* end diag lines only if no horz,vert */ if ((tl) && (!ml) && (!tc)) v_list[col].left = end_line(v_list[col].left, 1); if ((tr) && (!mr) && (!tc)) v_list[col].right = end_line(v_list[col].right, 1); if (mr) /* start horz. and vert */ h_ptr = start_line(1); if (bc) v_list[col].center = start_line(1); /* start diag if no horz,vert */ if ((br) && (!mr) && (!bc)) v_list[col + 1].left = start_line(1); if ((bl) && (!ml) && (!bc)) if (bl) v_list[col - 1].right = start_line(1); break; case 5: /* G_message(_("crowded cell %xH (%d,%d) -continuing"),count,row,col); */ /* I think 5 neighbours is nor crowded, so we shouldn't worry the user Olga */ if (ml) /* end horz. and vert lines */ h_ptr = end_line(h_ptr, 1); if (tc) v_list[col].center = end_line(v_list[col].center, 1); /* end diag lines only if no horz,vert */ if ((tl) && (!ml) && (!tc)) v_list[col].left = end_line(v_list[col].left, 1); if ((tr) && (!mr) && (!tc)) v_list[col].right = end_line(v_list[col].right, 1); if (mr) /* start horz. and vert */ h_ptr = start_line(1); if (bc) v_list[col].center = start_line(1); /* start diag if no horz,vert */ if ((br) && (!mr) && (!bc)) v_list[col + 1].left = start_line(1); if ((bl) && (!ml) && (!bc)) v_list[col - 1].right = start_line(1); break; case 6: /* the same as case 5 */ G_debug(1, "Crowded cell %xH (%d,%d), continuing", count, row, col); if (ml) /* end horz. and vert lines */ h_ptr = end_line(h_ptr, 1); if (tc) v_list[col].center = end_line(v_list[col].center, 1); /* end diag lines only if no horz,vert */ if ((tl) && (!ml) && (!tc)) v_list[col].left = end_line(v_list[col].left, 1); if ((tr) && (!mr) && (!tc)) v_list[col].right = end_line(v_list[col].right, 1); if (mr) /* start horz. and vert */ h_ptr = start_line(1); if (bc) v_list[col].center = start_line(1); /* start diag if no horz,vert */ if ((br) && (!mr) && (!bc)) v_list[col + 1].left = start_line(1); if ((bl) && (!ml) && (!bc)) v_list[col - 1].right = start_line(1); break; default: G_message(_("Crowded cell at (%f, %f): row %d, col %d, count %d"), Rast_col_to_easting((double)col - .5, &cell_head), Rast_row_to_northing((double)row + .5, &cell_head), row, col - 1, count); G_fatal_error(_("Raster map is not thinned properly.\nPlease run r.thin.")); } /* switch count */ return 0; }