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;
}
