int blank_array(void *array, int nrows, int ncols, RASTER_MAP_TYPE map_type,
int value)
{
/* flood fill initialize the array to either 0 or NULL */
/* "value" can be either 0 (for 0.0) or -1 (for NULL) */
int row, col;
void *ptr;
ptr = array;
switch (value) {
case 0:
/* fill with 0 */
/* simpler to use Rast_raster_cpy() or similar ?? */
for (row = 0; row < nrows; row++) {
for (col = 0; col < ncols; col++) {
Rast_set_c_value(ptr, 0, map_type);
ptr = G_incr_void_ptr(ptr, Rast_cell_size(map_type));
}
}
break;
case -1:
/* fill with NULL */
/* alloc for col+1, do we come up (nrows) short? no. */
Rast_set_null_value(array, nrows * ncols, map_type);
break;
default:
return -1;
}
return 0;
}
int output_raster(int fd)
{
int i, j;
for (i = 0; i < page.rows; i++, at_row++) {
switch (format) {
case USE_CHAR:
for (j = 0; j < page.cols; j++) {
cell[j] = (CELL) raster.c[i][j];
if (cell[j] == 0)
Rast_set_null_value(&cell[j], 1, CELL_TYPE);
}
break;
case USE_UCHAR:
for (j = 0; j < page.cols; j++) {
cell[j] = (CELL) raster.u[i][j];
if (cell[j] == 0)
Rast_set_null_value(&cell[j], 1, CELL_TYPE);
}
break;
case USE_SHORT:
for (j = 0; j < page.cols; j++) {
cell[j] = (CELL) raster.s[i][j];
if (cell[j] == 0)
Rast_set_null_value(&cell[j], 1, CELL_TYPE);
}
break;
case USE_CELL:
cell = raster.cell[i];
if (cell == 0)
Rast_set_null_value(&cell, 1, CELL_TYPE);
break;
}
G_percent(i, page.rows, 2);
Rast_put_row(fd, cell, CELL_TYPE);
}
G_percent(i, page.rows, 2);
return configure_plot();
}
void p_bilinear(struct cache *ibuffer, /* input buffer */
void *obufptr, /* ptr in output buffer */
int cell_type, /* raster map type of obufptr */
double *row_idx, /* row index */
double *col_idx, /* column index */
struct Cell_head *cellhd /* information of output map */
)
{
int row; /* row indices for interp */
int col; /* column indices for interp */
int i, j;
DCELL t, u; /* intermediate slope */
DCELL result; /* result of interpolation */
DCELL c[2][2];
/* cut indices to integer */
row = (int)floor(*row_idx - 0.5);
col = (int)floor(*col_idx - 0.5);
/* check for out of bounds - if out of bounds set NULL value and return */
if (row < 0 || row + 1 >= cellhd->rows || col < 0 || col + 1 >= cellhd->cols) {
Rast_set_null_value(obufptr, 1, cell_type);
return;
}
for (i = 0; i < 2; i++)
for (j = 0; j < 2; j++) {
const DCELL *cellp = CPTR(ibuffer, row + i, col + j);
if (Rast_is_d_null_value(cellp)) {
Rast_set_null_value(obufptr, 1, cell_type);
return;
}
c[i][j] = *cellp;
}
/* do the interpolation */
t = *col_idx - 0.5 - col;
u = *row_idx - 0.5 - row;
result = Rast_interp_bilinear(t, u, c[0][0], c[0][1], c[1][0], c[1][1]);
Rast_set_d_value(obufptr, result, cell_type);
}
void p_cubic_f(struct cache *ibuffer, /* input buffer */
void *obufptr, /* ptr in output buffer */
int cell_type, /* raster map type of obufptr */
double *row_idx, /* row index */
double *col_idx, /* column index */
struct Cell_head *cellhd /* cell header of input layer */
)
{
/* start nearest neighbor to do some basic tests */
int row, col; /* row/col of nearest neighbor */
DCELL *cellp, cell;
/* cut indices to integer */
row = (int)floor(*row_idx);
col = (int)floor(*col_idx);
/* check for out of bounds - if out of bounds set NULL value */
if (row < 0 || row >= cellhd->rows || col < 0 || col >= cellhd->cols) {
Rast_set_null_value(obufptr, 1, cell_type);
return;
}
cellp = CPTR(ibuffer, row, col);
/* if nearest is null, all the other interps will be null */
if (Rast_is_d_null_value(cellp)) {
Rast_set_null_value(obufptr, 1, cell_type);
return;
}
cell = *cellp;
p_cubic(ibuffer, obufptr, cell_type, row_idx, col_idx, cellhd);
/* fallback to bilinear if cubic is null */
if (Rast_is_d_null_value(obufptr)) {
p_bilinear(ibuffer, obufptr, cell_type, row_idx, col_idx, cellhd);
/* fallback to nearest if bilinear is null */
if (Rast_is_d_null_value(obufptr))
Rast_set_d_value(obufptr, cell, cell_type);
}
}
int read_row(void *buf)
{
void *p;
if (last_read)
return (0);
if (first_read) {
blank_line(buf);
first_read = 0;
}
else {
if (row_count >= n_rows) {
last_read = 1;
blank_line(buf);
}
else {
/* The buf variable is a void pointer and thus */
/* points to anything. Therefore, it's size is */
/* unknown and thus, it cannot be used for pointer */
/* arithmetic (some compilers treat this as an error */
/* - SGI MIPSPro compiler for one). Make the */
/* assumption that data_size is the proper number of */
/* bytes and cast the buf variable to char * before */
/* incrementing */
p = ((char *)buf) + data_size;
Rast_get_row(input_fd, p, row_count++, data_type);
p = buf;
Rast_set_null_value(p, 1, data_type);
/* Again we need to cast p to char * under the */
/* assumption that the increment is the proper */
/* number of bytes. */
p = ((char *)p) + (row_length + 1) * data_size;
Rast_set_null_value(p, 1, data_type);
}
}
return (row_length + 2);
}
int mask_raster_array(void *rast, int ncols,
int change_null, RASTER_MAP_TYPE data_type)
{
DCELL x;
while (ncols-- > 0) {
x = Rast_get_d_value(rast, data_type);
if (change_null && Rast_is_null_value(rast, data_type))
Rast_set_d_value(rast, new_null, data_type);
if (mask_d_select(&x, &d_mask))
Rast_set_null_value(rast, 1, data_type);
rast = G_incr_void_ptr(rast, Rast_cell_size(data_type));
}
return 0;
}
/* ************************************************************************* */
void
copy_result(N_array_2d * status, N_array_2d * c_start, double *result,
struct Cell_head *region, N_array_2d * target, int tflag)
{
int y, x, rows, cols, count, stat;
double d1 = 0;
DCELL val;
rows = region->rows;
cols = region->cols;
count = 0;
for (y = 0; y < rows; y++) {
G_percent(y, rows - 1, 10);
for (x = 0; x < cols; x++) {
stat = (int)N_get_array_2d_d_value(status, x, y);
if (stat == N_CELL_ACTIVE) { /*only active cells */
d1 = result[count];
val = (DCELL) d1;
count++;
}
else if (stat == N_CELL_DIRICHLET) { /*dirichlet cells */
d1 = N_get_array_2d_d_value(c_start, x, y);
val = (DCELL) d1;
}
else if (tflag == 1 && stat == N_CELL_TRANSMISSION) {/*transmission cells*/
d1 = N_get_array_2d_d_value(c_start, x, y);
val = (DCELL) d1;
}
else {
Rast_set_null_value(&val, 1, DCELL_TYPE);
}
N_put_array_2d_d_value(target, x, y, val);
}
}
return;
}
int main(int argc, char **argv)
{
char *mapname, /* ptr to name of output layer */
*setname, /* ptr to name of input mapset */
*ipolname; /* name of interpolation method */
int fdi, /* input map file descriptor */
fdo, /* output map file descriptor */
method, /* position of method in table */
permissions, /* mapset permissions */
cell_type, /* output celltype */
cell_size, /* size of a cell in bytes */
row, col, /* counters */
irows, icols, /* original rows, cols */
orows, ocols, have_colors, /* Input map has a colour table */
overwrite, /* Overwrite */
curr_proj; /* output projection (see gis.h) */
void *obuffer, /* buffer that holds one output row */
*obufptr; /* column ptr in output buffer */
struct cache *ibuffer; /* buffer that holds the input map */
func interpolate; /* interpolation routine */
double xcoord1, xcoord2, /* temporary x coordinates */
ycoord1, ycoord2, /* temporary y coordinates */
col_idx, /* column index in input matrix */
row_idx, /* row index in input matrix */
onorth, osouth, /* save original border coords */
oeast, owest, inorth, isouth, ieast, iwest;
char north_str[30], south_str[30], east_str[30], west_str[30];
struct Colors colr; /* Input map colour table */
struct History history;
struct pj_info iproj, /* input map proj parameters */
oproj; /* output map proj parameters */
struct Key_Value *in_proj_info, /* projection information of */
*in_unit_info, /* input and output mapsets */
*out_proj_info, *out_unit_info;
struct GModule *module;
struct Flag *list, /* list files in source location */
*nocrop, /* don't crop output map */
*print_bounds, /* print output bounds and exit */
*gprint_bounds; /* same but print shell style */
struct Option *imapset, /* name of input mapset */
*inmap, /* name of input layer */
*inlocation, /* name of input location */
*outmap, /* name of output layer */
*indbase, /* name of input database */
*interpol, /* interpolation method:
nearest neighbor, bilinear, cubic */
*memory, /* amount of memory for cache */
*res; /* resolution of target map */
struct Cell_head incellhd, /* cell header of input map */
outcellhd; /* and output map */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("projection"));
G_add_keyword(_("transformation"));
module->description =
_("Re-projects a raster map from given location to the current location.");
inmap = G_define_standard_option(G_OPT_R_INPUT);
inmap->description = _("Name of input raster map to re-project");
inmap->required = NO;
inmap->guisection = _("Source");
inlocation = G_define_option();
inlocation->key = "location";
inlocation->type = TYPE_STRING;
inlocation->required = YES;
inlocation->description = _("Location containing input raster map");
inlocation->gisprompt = "old,location,location";
inlocation->key_desc = "name";
imapset = G_define_standard_option(G_OPT_M_MAPSET);
imapset->label = _("Mapset containing input raster map");
imapset->description = _("default: name of current mapset");
imapset->guisection = _("Source");
indbase = G_define_option();
indbase->key = "dbase";
indbase->type = TYPE_STRING;
indbase->required = NO;
indbase->description = _("Path to GRASS database of input location");
indbase->gisprompt = "old,dbase,dbase";
indbase->key_desc = "path";
indbase->guisection = _("Source");
outmap = G_define_standard_option(G_OPT_R_OUTPUT);
outmap->required = NO;
outmap->description = _("Name for output raster map (default: same as 'input')");
outmap->guisection = _("Target");
ipolname = make_ipol_list();
interpol = G_define_option();
interpol->key = "method";
interpol->type = TYPE_STRING;
interpol->required = NO;
interpol->answer = "nearest";
interpol->options = ipolname;
interpol->description = _("Interpolation method to use");
interpol->guisection = _("Target");
interpol->descriptions = make_ipol_desc();
memory = G_define_option();
memory->key = "memory";
memory->type = TYPE_INTEGER;
memory->required = NO;
memory->description = _("Cache size (MiB)");
res = G_define_option();
res->key = "resolution";
res->type = TYPE_DOUBLE;
res->required = NO;
res->description = _("Resolution of output raster map");
res->guisection = _("Target");
list = G_define_flag();
list->key = 'l';
list->description = _("List raster maps in input location and exit");
nocrop = G_define_flag();
nocrop->key = 'n';
nocrop->description = _("Do not perform region cropping optimization");
print_bounds = G_define_flag();
print_bounds->key = 'p';
print_bounds->description =
_("Print input map's bounds in the current projection and exit");
print_bounds->guisection = _("Target");
gprint_bounds = G_define_flag();
gprint_bounds->key = 'g';
gprint_bounds->description =
_("Print input map's bounds in the current projection and exit (shell style)");
gprint_bounds->guisection = _("Target");
/* The parser checks if the map already exists in current mapset,
we switch out the check and do it
in the module after the parser */
overwrite = G_check_overwrite(argc, argv);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* get the method */
for (method = 0; (ipolname = menu[method].name); method++)
if (strcmp(ipolname, interpol->answer) == 0)
break;
if (!ipolname)
G_fatal_error(_("<%s=%s> unknown %s"),
interpol->key, interpol->answer, interpol->key);
interpolate = menu[method].method;
mapname = outmap->answer ? outmap->answer : inmap->answer;
if (mapname && !list->answer && !overwrite &&
G_find_raster(mapname, G_mapset()))
G_fatal_error(_("option <%s>: <%s> exists."), "output", mapname);
setname = imapset->answer ? imapset->answer : G_store(G_mapset());
if (strcmp(inlocation->answer, G_location()) == 0 &&
(!indbase->answer || strcmp(indbase->answer, G_gisdbase()) == 0))
#if 0
G_fatal_error(_("Input and output locations can not be the same"));
#else
G_warning(_("Input and output locations are the same"));
#endif
G_get_window(&outcellhd);
if(gprint_bounds->answer && !print_bounds->answer)
print_bounds->answer = gprint_bounds->answer;
curr_proj = G_projection();
/* Get projection info for output mapset */
if ((out_proj_info = G_get_projinfo()) == NULL)
G_fatal_error(_("Unable to get projection info of output raster map"));
if ((out_unit_info = G_get_projunits()) == NULL)
G_fatal_error(_("Unable to get projection units of output raster map"));
if (pj_get_kv(&oproj, out_proj_info, out_unit_info) < 0)
G_fatal_error(_("Unable to get projection key values of output raster map"));
/* Change the location */
G__create_alt_env();
G__setenv("GISDBASE", indbase->answer ? indbase->answer : G_gisdbase());
G__setenv("LOCATION_NAME", inlocation->answer);
permissions = G__mapset_permissions(setname);
if (permissions < 0) /* can't access mapset */
G_fatal_error(_("Mapset <%s> in input location <%s> - %s"),
setname, inlocation->answer,
permissions == 0 ? _("permission denied")
: _("not found"));
/* if requested, list the raster maps in source location - MN 5/2001 */
if (list->answer) {
int i;
char **list;
G_verbose_message(_("Checking location <%s> mapset <%s>"),
inlocation->answer, setname);
list = G_list(G_ELEMENT_RASTER, G__getenv("GISDBASE"),
G__getenv("LOCATION_NAME"), setname);
for (i = 0; list[i]; i++) {
fprintf(stdout, "%s\n", list[i]);
}
fflush(stdout);
exit(EXIT_SUCCESS); /* leave r.proj after listing */
}
if (!inmap->answer)
G_fatal_error(_("Required parameter <%s> not set"), inmap->key);
if (!G_find_raster(inmap->answer, setname))
G_fatal_error(_("Raster map <%s> in location <%s> in mapset <%s> not found"),
inmap->answer, inlocation->answer, setname);
/* Read input map colour table */
have_colors = Rast_read_colors(inmap->answer, setname, &colr);
/* Get projection info for input mapset */
if ((in_proj_info = G_get_projinfo()) == NULL)
G_fatal_error(_("Unable to get projection info of input map"));
if ((in_unit_info = G_get_projunits()) == NULL)
G_fatal_error(_("Unable to get projection units of input map"));
if (pj_get_kv(&iproj, in_proj_info, in_unit_info) < 0)
G_fatal_error(_("Unable to get projection key values of input map"));
G_free_key_value(in_proj_info);
G_free_key_value(in_unit_info);
G_free_key_value(out_proj_info);
G_free_key_value(out_unit_info);
if (G_verbose() > G_verbose_std())
pj_print_proj_params(&iproj, &oproj);
/* this call causes r.proj to read the entire map into memeory */
Rast_get_cellhd(inmap->answer, setname, &incellhd);
Rast_set_input_window(&incellhd);
if (G_projection() == PROJECTION_XY)
G_fatal_error(_("Unable to work with unprojected data (xy location)"));
/* Save default borders so we can show them later */
inorth = incellhd.north;
isouth = incellhd.south;
ieast = incellhd.east;
iwest = incellhd.west;
irows = incellhd.rows;
icols = incellhd.cols;
onorth = outcellhd.north;
osouth = outcellhd.south;
oeast = outcellhd.east;
owest = outcellhd.west;
orows = outcellhd.rows;
ocols = outcellhd.cols;
if (print_bounds->answer) {
G_message(_("Input map <%s@%s> in location <%s>:"),
inmap->answer, setname, inlocation->answer);
if (pj_do_proj(&iwest, &isouth, &iproj, &oproj) < 0)
G_fatal_error(_("Error in pj_do_proj (projection of input coordinate pair)"));
if (pj_do_proj(&ieast, &inorth, &iproj, &oproj) < 0)
G_fatal_error(_("Error in pj_do_proj (projection of input coordinate pair)"));
G_format_northing(inorth, north_str, curr_proj);
G_format_northing(isouth, south_str, curr_proj);
G_format_easting(ieast, east_str, curr_proj);
G_format_easting(iwest, west_str, curr_proj);
if(gprint_bounds->answer) {
fprintf(stdout, "n=%s s=%s w=%s e=%s rows=%d cols=%d\n",
north_str, south_str, west_str, east_str, irows, icols);
}
else {
fprintf(stdout, "Source cols: %d\n", icols);
fprintf(stdout, "Source rows: %d\n", irows);
fprintf(stdout, "Local north: %s\n", north_str);
fprintf(stdout, "Local south: %s\n", south_str);
fprintf(stdout, "Local west: %s\n", west_str);
fprintf(stdout, "Local east: %s\n", east_str);
}
/* somehow approximate local ewres, nsres ?? (use 'g.region -m' on lat/lon side) */
exit(EXIT_SUCCESS);
}
/* Cut non-overlapping parts of input map */
if (!nocrop->answer)
bordwalk(&outcellhd, &incellhd, &oproj, &iproj);
/* Add 2 cells on each side for bilinear/cubic & future interpolation methods */
/* (should probably be a factor based on input and output resolution) */
incellhd.north += 2 * incellhd.ns_res;
incellhd.east += 2 * incellhd.ew_res;
incellhd.south -= 2 * incellhd.ns_res;
incellhd.west -= 2 * incellhd.ew_res;
if (incellhd.north > inorth)
incellhd.north = inorth;
if (incellhd.east > ieast)
incellhd.east = ieast;
if (incellhd.south < isouth)
incellhd.south = isouth;
if (incellhd.west < iwest)
incellhd.west = iwest;
Rast_set_input_window(&incellhd);
/* And switch back to original location */
G__switch_env();
/* Adjust borders of output map */
if (!nocrop->answer)
bordwalk(&incellhd, &outcellhd, &iproj, &oproj);
#if 0
outcellhd.west = outcellhd.south = HUGE_VAL;
outcellhd.east = outcellhd.north = -HUGE_VAL;
for (row = 0; row < incellhd.rows; row++) {
ycoord1 = Rast_row_to_northing((double)(row + 0.5), &incellhd);
for (col = 0; col < incellhd.cols; col++) {
xcoord1 = Rast_col_to_easting((double)(col + 0.5), &incellhd);
pj_do_proj(&xcoord1, &ycoord1, &iproj, &oproj);
if (xcoord1 > outcellhd.east)
outcellhd.east = xcoord1;
if (ycoord1 > outcellhd.north)
outcellhd.north = ycoord1;
if (xcoord1 < outcellhd.west)
outcellhd.west = xcoord1;
if (ycoord1 < outcellhd.south)
outcellhd.south = ycoord1;
}
}
#endif
if (res->answer != NULL) /* set user defined resolution */
outcellhd.ns_res = outcellhd.ew_res = atof(res->answer);
G_adjust_Cell_head(&outcellhd, 0, 0);
Rast_set_output_window(&outcellhd);
G_message(" ");
G_message(_("Input:"));
G_message(_("Cols: %d (%d)"), incellhd.cols, icols);
G_message(_("Rows: %d (%d)"), incellhd.rows, irows);
G_message(_("North: %f (%f)"), incellhd.north, inorth);
G_message(_("South: %f (%f)"), incellhd.south, isouth);
G_message(_("West: %f (%f)"), incellhd.west, iwest);
G_message(_("East: %f (%f)"), incellhd.east, ieast);
G_message(_("EW-res: %f"), incellhd.ew_res);
G_message(_("NS-res: %f"), incellhd.ns_res);
G_message(" ");
G_message(_("Output:"));
G_message(_("Cols: %d (%d)"), outcellhd.cols, ocols);
G_message(_("Rows: %d (%d)"), outcellhd.rows, orows);
G_message(_("North: %f (%f)"), outcellhd.north, onorth);
G_message(_("South: %f (%f)"), outcellhd.south, osouth);
G_message(_("West: %f (%f)"), outcellhd.west, owest);
G_message(_("East: %f (%f)"), outcellhd.east, oeast);
G_message(_("EW-res: %f"), outcellhd.ew_res);
G_message(_("NS-res: %f"), outcellhd.ns_res);
G_message(" ");
/* open and read the relevant parts of the input map and close it */
G__switch_env();
Rast_set_input_window(&incellhd);
fdi = Rast_open_old(inmap->answer, setname);
cell_type = Rast_get_map_type(fdi);
ibuffer = readcell(fdi, memory->answer);
Rast_close(fdi);
G__switch_env();
Rast_set_output_window(&outcellhd);
if (strcmp(interpol->answer, "nearest") == 0) {
fdo = Rast_open_new(mapname, cell_type);
obuffer = (CELL *) Rast_allocate_output_buf(cell_type);
}
else {
fdo = Rast_open_fp_new(mapname);
cell_type = FCELL_TYPE;
obuffer = (FCELL *) Rast_allocate_output_buf(cell_type);
}
cell_size = Rast_cell_size(cell_type);
xcoord1 = xcoord2 = outcellhd.west + (outcellhd.ew_res / 2);
/**/ ycoord1 = ycoord2 = outcellhd.north - (outcellhd.ns_res / 2);
/**/ G_important_message(_("Projecting..."));
G_percent(0, outcellhd.rows, 2);
for (row = 0; row < outcellhd.rows; row++) {
obufptr = obuffer;
for (col = 0; col < outcellhd.cols; col++) {
/* project coordinates in output matrix to */
/* coordinates in input matrix */
if (pj_do_proj(&xcoord1, &ycoord1, &oproj, &iproj) < 0)
Rast_set_null_value(obufptr, 1, cell_type);
else {
/* convert to row/column indices of input matrix */
col_idx = (xcoord1 - incellhd.west) / incellhd.ew_res;
row_idx = (incellhd.north - ycoord1) / incellhd.ns_res;
/* and resample data point */
interpolate(ibuffer, obufptr, cell_type,
&col_idx, &row_idx, &incellhd);
}
obufptr = G_incr_void_ptr(obufptr, cell_size);
xcoord2 += outcellhd.ew_res;
xcoord1 = xcoord2;
ycoord1 = ycoord2;
}
Rast_put_row(fdo, obuffer, cell_type);
xcoord1 = xcoord2 = outcellhd.west + (outcellhd.ew_res / 2);
ycoord2 -= outcellhd.ns_res;
ycoord1 = ycoord2;
G_percent(row, outcellhd.rows - 1, 2);
}
Rast_close(fdo);
if (have_colors > 0) {
Rast_write_colors(mapname, G_mapset(), &colr);
Rast_free_colors(&colr);
}
Rast_short_history(mapname, "raster", &history);
Rast_command_history(&history);
Rast_write_history(mapname, &history);
G_done_msg(NULL);
exit(EXIT_SUCCESS);
}
int camera_angle(char *name)
{
int row, col, nrows, ncols;
double XC = group.XC;
double YC = group.YC;
double ZC = group.ZC;
double c_angle, c_angle_min, c_alt, c_az, slope, aspect;
double radians_to_degrees = 180.0 / M_PI;
/* double degrees_to_radians = M_PI / 180.0; */
DCELL e1, e2, e3, e4, e5, e6, e7, e8, e9;
double factor, V, H, dx, dy, dz, key;
double north, south, east, west, ns_med;
FCELL *fbuf0, *fbuf1, *fbuf2, *tmpbuf, *outbuf;
int elevfd, outfd;
struct Cell_head cellhd;
struct Colors colr;
FCELL clr_min, clr_max;
struct History hist;
char *type;
G_message(_("Calculating camera angle to local surface..."));
select_target_env();
/* align target window to elevation map, otherwise we get artefacts
* like in r.slope.aspect -a */
Rast_get_cellhd(elev_name, elev_mapset, &cellhd);
Rast_align_window(&target_window, &cellhd);
Rast_set_window(&target_window);
elevfd = Rast_open_old(elev_name, elev_mapset);
if (elevfd < 0) {
G_fatal_error(_("Could not open elevation raster"));
return 1;
}
nrows = target_window.rows;
ncols = target_window.cols;
outfd = Rast_open_new(name, FCELL_TYPE);
fbuf0 = Rast_allocate_buf(FCELL_TYPE);
fbuf1 = Rast_allocate_buf(FCELL_TYPE);
fbuf2 = Rast_allocate_buf(FCELL_TYPE);
outbuf = Rast_allocate_buf(FCELL_TYPE);
/* give warning if location units are different from meters and zfactor=1 */
factor = G_database_units_to_meters_factor();
if (factor != 1.0)
G_warning(_("Converting units to meters, factor=%.6f"), factor);
G_begin_distance_calculations();
north = Rast_row_to_northing(0.5, &target_window);
ns_med = Rast_row_to_northing(1.5, &target_window);
south = Rast_row_to_northing(2.5, &target_window);
east = Rast_col_to_easting(2.5, &target_window);
west = Rast_col_to_easting(0.5, &target_window);
V = G_distance(east, north, east, south) * 4;
H = G_distance(east, ns_med, west, ns_med) * 4;
c_angle_min = 90;
Rast_get_row(elevfd, fbuf1, 0, FCELL_TYPE);
Rast_get_row(elevfd, fbuf2, 1, FCELL_TYPE);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Rast_set_null_value(outbuf, ncols, FCELL_TYPE);
/* first and last row */
if (row == 0 || row == nrows - 1) {
Rast_put_row(outfd, outbuf, FCELL_TYPE);
continue;
}
tmpbuf = fbuf0;
fbuf0 = fbuf1;
fbuf1 = fbuf2;
fbuf2 = tmpbuf;
Rast_get_row(elevfd, fbuf2, row + 1, FCELL_TYPE);
north = Rast_row_to_northing(row + 0.5, &target_window);
for (col = 1; col < ncols - 1; col++) {
e1 = fbuf0[col - 1];
if (Rast_is_d_null_value(&e1))
continue;
e2 = fbuf0[col];
if (Rast_is_d_null_value(&e2))
continue;
e3 = fbuf0[col + 1];
if (Rast_is_d_null_value(&e3))
continue;
e4 = fbuf1[col - 1];
if (Rast_is_d_null_value(&e4))
continue;
e5 = fbuf1[col];
if (Rast_is_d_null_value(&e5))
continue;
e6 = fbuf1[col + 1];
if (Rast_is_d_null_value(&e6))
continue;
e7 = fbuf2[col - 1];
if (Rast_is_d_null_value(&e7))
continue;
e8 = fbuf2[col];
if (Rast_is_d_null_value(&e8))
continue;
e9 = fbuf2[col + 1];
if (Rast_is_d_null_value(&e9))
continue;
dx = ((e1 + e4 + e4 + e7) - (e3 + e6 + e6 + e9)) / H;
dy = ((e7 + e8 + e8 + e9) - (e1 + e2 + e2 + e3)) / V;
/* compute topographic parameters */
key = dx * dx + dy * dy;
/* slope in radians */
slope = atan(sqrt(key));
/* aspect in radians */
if (key == 0.)
aspect = 0.;
else if (dx == 0) {
if (dy > 0)
aspect = M_PI / 2;
else
aspect = 1.5 * M_PI;
}
else {
aspect = atan2(dy, dx);
if (aspect <= 0.)
aspect = 2 * M_PI + aspect;
}
/* camera altitude angle in radians */
east = Rast_col_to_easting(col + 0.5, &target_window);
dx = east - XC;
dy = north - YC;
dz = ZC - e5;
c_alt = atan(sqrt(dx * dx + dy * dy) / dz);
/* camera azimuth angle in radians */
c_az = atan(dy / dx);
if (east < XC && north != YC)
c_az += M_PI;
else if (north < YC && east > XC)
c_az += 2 * M_PI;
/* camera angle to real ground */
/* orthogonal to ground: 90 degrees */
/* parallel to ground: 0 degrees */
c_angle = asin(cos(c_alt) * cos(slope) - sin(c_alt) * sin(slope) * cos(c_az - aspect));
outbuf[col] = c_angle * radians_to_degrees;
if (c_angle_min > outbuf[col])
c_angle_min = outbuf[col];
}
Rast_put_row(outfd, outbuf, FCELL_TYPE);
}
G_percent(row, nrows, 2);
Rast_close(elevfd);
Rast_close(outfd);
G_free(fbuf0);
G_free(fbuf1);
G_free(fbuf2);
G_free(outbuf);
type = "raster";
Rast_short_history(name, type, &hist);
Rast_command_history(&hist);
Rast_write_history(name, &hist);
Rast_init_colors(&colr);
if (c_angle_min < 0) {
clr_min = (FCELL)((int)(c_angle_min / 10 - 1)) * 10;
clr_max = 0;
Rast_add_f_color_rule(&clr_min, 0, 0, 0, &clr_max, 0,
0, 0, &colr);
}
clr_min = 0;
clr_max = 10;
Rast_add_f_color_rule(&clr_min, 0, 0, 0, &clr_max, 255,
0, 0, &colr);
clr_min = 10;
clr_max = 40;
Rast_add_f_color_rule(&clr_min, 255, 0, 0, &clr_max, 255,
255, 0, &colr);
clr_min = 40;
clr_max = 90;
Rast_add_f_color_rule(&clr_min, 255, 255, 0, &clr_max, 0,
255, 0, &colr);
Rast_write_colors(name, G_mapset(), &colr);
select_current_env();
return 1;
}
int main(int argc, char *argv[])
{
int 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);
}
/* ************************************************************************* */
void g3d_to_raster(void *map, RASTER3D_Region region, int *fd)
{
DCELL d1 = 0;
FCELL f1 = 0;
int x, y, z;
int rows, cols, depths, typeIntern, pos = 0;
FCELL *fcell = NULL;
DCELL *dcell = NULL;
rows = region.rows;
cols = region.cols;
depths = region.depths;
G_debug(2, "g3d_to_raster: Writing %i raster maps with %i rows %i cols.",
depths, rows, cols);
typeIntern = Rast3d_tile_type_map(map);
if (typeIntern == FCELL_TYPE)
fcell = Rast_allocate_f_buf();
else if (typeIntern == DCELL_TYPE)
dcell = Rast_allocate_d_buf();
pos = 0;
/*Every Rastermap */
for (z = 0; z < depths; z++) { /*From the bottom to the top */
G_debug(2, "Writing raster map %d of %d", z + 1, depths);
for (y = 0; y < rows; y++) {
G_percent(y, rows - 1, 10);
for (x = 0; x < cols; x++) {
if (typeIntern == FCELL_TYPE) {
Rast3d_get_value(map, x, y, z, &f1, typeIntern);
if (Rast3d_is_null_value_num(&f1, FCELL_TYPE))
Rast_set_null_value(&fcell[x], 1, FCELL_TYPE);
else
fcell[x] = f1;
} else {
Rast3d_get_value(map, x, y, z, &d1, typeIntern);
if (Rast3d_is_null_value_num(&d1, DCELL_TYPE))
Rast_set_null_value(&dcell[x], 1, DCELL_TYPE);
else
dcell[x] = d1;
}
}
if (typeIntern == FCELL_TYPE)
Rast_put_f_row(fd[pos], fcell);
if (typeIntern == DCELL_TYPE)
Rast_put_d_row(fd[pos], dcell);
}
G_debug(2, "Finished writing map %d.", z + 1);
pos++;
}
if (dcell)
G_free(dcell);
if (fcell)
G_free(fcell);
}
int rectify(char *name, char *mapset, struct cache *ebuffer,
double aver_z, char *result, char *interp_method)
{
struct Cell_head cellhd;
int ncols, nrows;
int row, col;
double row_idx, col_idx;
int infd, outfd;
RASTER_MAP_TYPE map_type;
int cell_size;
void *trast, *tptr;
double n1, e1, z1;
double nx, ex, nx1, ex1, zx1;
struct cache *ibuffer;
select_current_env();
Rast_get_cellhd(name, mapset, &cellhd);
/* open the file to be rectified
* set window to cellhd first to be able to read file exactly
*/
Rast_set_input_window(&cellhd);
infd = Rast_open_old(name, mapset);
map_type = Rast_get_map_type(infd);
cell_size = Rast_cell_size(map_type);
ibuffer = readcell(infd, seg_mb_img, 0);
Rast_close(infd); /* (pmx) 17 april 2000 */
G_message(_("Rectify <%s@%s> (location <%s>)"),
name, mapset, G_location());
select_target_env();
G_set_window(&target_window);
G_message(_("into <%s@%s> (location <%s>) ..."),
result, G_mapset(), G_location());
nrows = target_window.rows;
ncols = target_window.cols;
if (strcmp(interp_method, "nearest") != 0) {
map_type = DCELL_TYPE;
cell_size = Rast_cell_size(map_type);
}
/* open the result file into target window
* this open must be first since we change the window later
* raster maps open for writing are not affected by window changes
* but those open for reading are
*/
outfd = Rast_open_new(result, map_type);
trast = Rast_allocate_output_buf(map_type);
for (row = 0; row < nrows; row++) {
n1 = target_window.north - (row + 0.5) * target_window.ns_res;
G_percent(row, nrows, 2);
Rast_set_null_value(trast, ncols, map_type);
tptr = trast;
for (col = 0; col < ncols; col++) {
DCELL *zp = CPTR(ebuffer, row, col);
e1 = target_window.west + (col + 0.5) * target_window.ew_res;
/* if target cell has no elevation, set to aver_z */
if (Rast_is_d_null_value(zp)) {
G_warning(_("No elevation available at row = %d, col = %d"), row, col);
z1 = aver_z;
}
else
z1 = *zp;
/* target coordinates e1, n1 to photo coordinates ex1, nx1 */
I_ortho_ref(e1, n1, z1, &ex1, &nx1, &zx1, &group.camera_ref,
group.XC, group.YC, group.ZC, group.M);
G_debug(5, "\t\tAfter ortho ref (photo cords): ex = %f \t nx = %f",
ex1, nx1);
/* photo coordinates ex1, nx1 to image coordinates ex, nx */
I_georef(ex1, nx1, &ex, &nx, group.E21, group.N21, 1);
G_debug(5, "\t\tAfter geo ref: ex = %f \t nx = %f", ex, nx);
/* convert to row/column indices of source raster */
row_idx = (cellhd.north - nx) / cellhd.ns_res;
col_idx = (ex - cellhd.west) / cellhd.ew_res;
/* resample data point */
interpolate(ibuffer, tptr, map_type, &row_idx, &col_idx, &cellhd);
tptr = G_incr_void_ptr(tptr, cell_size);
}
Rast_put_row(outfd, trast, map_type);
}
G_percent(1, 1, 1);
Rast_close(outfd); /* (pmx) 17 april 2000 */
G_free(trast);
close(ibuffer->fd);
release_cache(ibuffer);
Rast_get_cellhd(result, G_mapset(), &cellhd);
if (cellhd.proj == 0) { /* x,y imagery */
cellhd.proj = target_window.proj;
cellhd.zone = target_window.zone;
}
if (target_window.proj != cellhd.proj) {
cellhd.proj = target_window.proj;
G_warning(_("Raster map <%s@%s>: projection don't match current settings"),
name, mapset);
}
if (target_window.zone != cellhd.zone) {
cellhd.zone = target_window.zone;
G_warning(_("Raster map <%s@%s>: zone don't match current settings"),
name, mapset);
}
select_current_env();
return 1;
}
int main(int argc, char *argv[])
{
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);
}
/* ************************************************************************* */
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[])
{
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);
}
static int
write_pca(double **eigmat, int *inp_fd, char *out_basename,
int bands, int scale, int scale_min, int scale_max)
{
int i, j;
void *outbuf, *outptr;
double min = 0.;
double max = 0.;
double old_range = 0.;
double new_range = 0.;
int rows = Rast_window_rows();
int cols = Rast_window_cols();
int cell_mapsiz = Rast_cell_size(CELL_TYPE);
int dcell_mapsiz = Rast_cell_size(DCELL_TYPE);
DCELL *d_buf;
/* 2 passes for rescale. 1 pass for no rescale */
int PASSES = (scale) ? 2 : 1;
/* temporary row storage */
d_buf = (DCELL *) G_malloc(cols * sizeof(double));
/* allocate memory for output row buffer */
outbuf = (scale) ? Rast_allocate_buf(CELL_TYPE) :
Rast_allocate_buf(DCELL_TYPE);
if (!outbuf)
G_fatal_error(_("Unable to allocate memory for raster row"));
for (i = 0; i < bands; i++) {
char name[100];
int out_fd;
int pass;
sprintf(name, "%s.%d", out_basename, i + 1);
G_message(_("Transforming <%s>..."), name);
/* open a new file for output */
if (scale)
out_fd = Rast_open_c_new(name);
else {
out_fd = Rast_open_fp_new(name);
Rast_set_fp_type(DCELL_TYPE);
}
for (pass = 1; pass <= PASSES; pass++) {
void *rowbuf = NULL;
int row, col;
if (scale && (pass == PASSES)) {
G_message(_("Rescaling <%s> to range %d,%d..."),
name, scale_min, scale_max);
old_range = max - min;
new_range = (double)(scale_max - scale_min);
}
for (row = 0; row < rows; row++) {
void *rowptr;
G_percent(row, rows, 2);
/* reset d_buf */
for (col = 0; col < cols; col++)
d_buf[col] = 0.;
for (j = 0; j < bands; j++) {
RASTER_MAP_TYPE maptype =
Rast_get_map_type(inp_fd[j]);
/* don't assume each image is of the same type */
if (rowbuf)
G_free(rowbuf);
if (!(rowbuf = Rast_allocate_buf(maptype)))
G_fatal_error(_("Unable allocate memory for row buffer"));
Rast_get_row(inp_fd[j], rowbuf, row, maptype);
rowptr = rowbuf;
outptr = outbuf;
/* add into the output cell eigmat[i][j] * corresp cell
* of j-th band for current j */
for (col = 0; col < cols; col++) {
/* handle null cells */
if (Rast_is_null_value(rowptr, maptype)) {
if (scale) {
Rast_set_null_value(outptr, 1, CELL_TYPE);
outptr = G_incr_void_ptr(outptr, cell_mapsiz);
}
else {
Rast_set_null_value(outptr, 1, DCELL_TYPE);
outptr =
G_incr_void_ptr(outptr, dcell_mapsiz);
}
rowptr =
G_incr_void_ptr(rowptr,
Rast_cell_size(maptype));
continue;
}
/* corresp. cell of j-th band */
d_buf[col] +=
eigmat[i][j] * Rast_get_d_value(rowptr,
maptype);
/* the cell entry is complete */
if (j == (bands - 1)) {
if (scale && (pass == 1)) {
if ((row == 0) && (col == 0))
min = max = d_buf[0];
if (d_buf[col] < min)
min = d_buf[col];
if (d_buf[col] > max)
max = d_buf[col];
}
else if (scale) {
if (min == max) {
Rast_set_c_value(outptr, 1,
CELL_TYPE);
}
else {
/* map data to 0, (new_range-1) and then adding new_min */
CELL tmpcell =
round_c((new_range *
(d_buf[col] -
min) / old_range) +
scale_min);
Rast_set_c_value(outptr, tmpcell,
CELL_TYPE);
}
}
else { /* (!scale) */
Rast_set_d_value(outptr, d_buf[col],
DCELL_TYPE);
}
}
outptr = (scale) ?
G_incr_void_ptr(outptr, cell_mapsiz) :
G_incr_void_ptr(outptr, dcell_mapsiz);
rowptr =
G_incr_void_ptr(rowptr, Rast_cell_size(maptype));
}
} /* for j = 0 to bands */
if (pass == PASSES) {
if (scale)
Rast_put_row(out_fd, outbuf, CELL_TYPE);
else
Rast_put_row(out_fd, outbuf, DCELL_TYPE);
}
}
G_percent(row, rows, 2);
/* close output file */
if (pass == PASSES)
Rast_close(out_fd);
}
}
if (d_buf)
G_free(d_buf);
if (outbuf)
G_free(outbuf);
return 0;
}
int main(int argc, char *argv[])
{
char *input;
char *output;
char *title;
char *temp;
FILE *fd, *ft;
int cf, direction, sz;
struct Cell_head cellhd;
struct History history;
void *rast, *rast_ptr;
int row, col;
int nrows, ncols;
double x;
char y[128];
struct GModule *module;
struct
{
struct Option *input, *output, *title, *mult, *nv, *type;
} parm;
struct
{
struct Flag *s;
} flag;
char *null_val_str;
DCELL mult;
RASTER_MAP_TYPE data_type;
double atof();
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("import"));
G_add_keyword(_("conversion"));
G_add_keyword("ASCII");
module->description =
_("Converts a GRASS ASCII raster file to binary raster map.");
parm.input = G_define_standard_option(G_OPT_F_INPUT);
parm.input->label =
_("Name of input file to be imported");
parm.input->description = _("'-' for standard input");
parm.output = G_define_standard_option(G_OPT_R_OUTPUT);
parm.type = G_define_option();
parm.type->key = "type";
parm.type->type = TYPE_STRING;
parm.type->required = NO;
parm.type->options = "CELL,FCELL,DCELL";
parm.type->label = _("Storage type for resultant raster map");
parm.type->description = _("Default: CELL for integer values, DCELL for floating-point values");
parm.title = G_define_option();
parm.title->key = "title";
parm.title->key_desc = "phrase";
parm.title->type = TYPE_STRING;
parm.title->required = NO;
parm.title->description = _("Title for resultant raster map");
parm.mult = G_define_option();
parm.mult->key = "multiplier";
parm.mult->type = TYPE_DOUBLE;
parm.mult->description = _("Default: read from header");
parm.mult->required = NO;
parm.mult->label = _("Multiplier for ASCII data");
parm.nv = G_define_standard_option(G_OPT_M_NULL_VALUE);
parm.nv->description = _("Default: read from header");
parm.nv->label = _("String representing NULL value data cell");
parm.nv->guisection = _("NULL data");
flag.s = G_define_flag();
flag.s->key = 's';
flag.s->description =
_("SURFER (Golden Software) ASCII file will be imported");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
input = parm.input->answer;
output = parm.output->answer;
temp = G_tempfile();
ft = fopen(temp, "w+");
if (ft == NULL)
G_fatal_error(_("Unable to open temporary file <%s>"), temp);
if ((title = parm.title->answer))
G_strip(title);
if (!parm.mult->answer)
Rast_set_d_null_value(&mult, 1);
else if ((sscanf(parm.mult->answer, "%lf", &mult)) != 1)
G_fatal_error(_("Wrong entry for multiplier: %s"), parm.mult->answer);
null_val_str = parm.nv->answer;
data_type = -1;
if (parm.type->answer) {
switch(parm.type->answer[0]) {
case 'C':
data_type = CELL_TYPE;
break;
case 'F':
data_type = FCELL_TYPE;
break;
case 'D':
data_type = DCELL_TYPE;
break;
}
}
if (strcmp(input, "-") == 0) {
Tmp_file = G_tempfile();
if (NULL == (Tmp_fd = fopen(Tmp_file, "w+")))
G_fatal_error(_("Unable to open temporary file <%s>"), Tmp_file);
unlink(Tmp_file);
if (0 > file_cpy(stdin, Tmp_fd))
G_fatal_error(_("Unable to read input from stdin"));
fd = Tmp_fd;
}
else
fd = fopen(input, "r");
if (fd == NULL) {
G_fatal_error(_("Unable to read input from <%s>"), input);
}
direction = 1;
sz = 0;
if (flag.s->answer) {
sz = getgrdhead(fd, &cellhd);
/* for Surfer files, the data type is always FCELL_TYPE,
the multiplier and the null_val_str are never used */
data_type = FCELL_TYPE;
mult = 1.;
null_val_str = "";
/* rows in surfer files are ordered from bottom to top,
opposite of normal GRASS ordering */
direction = -1;
}
else
sz = gethead(fd, &cellhd, &data_type, &mult, &null_val_str);
if (!sz)
G_fatal_error(_("Can't get cell header"));
nrows = cellhd.rows;
ncols = cellhd.cols;
Rast_set_window(&cellhd);
if (nrows != Rast_window_rows())
G_fatal_error(_("OOPS: rows changed from %d to %d"), nrows,
Rast_window_rows());
if (ncols != Rast_window_cols())
G_fatal_error(_("OOPS: cols changed from %d to %d"), ncols,
Rast_window_cols());
rast_ptr = Rast_allocate_buf(data_type);
rast = rast_ptr;
cf = Rast_open_new(output, data_type);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
for (col = 0; col < ncols; col++) {
if (fscanf(fd, "%s", y) != 1) {
Rast_unopen(cf);
G_fatal_error(_("Data conversion failed at row %d, col %d"),
row + 1, col + 1);
}
if (strcmp(y, null_val_str)) {
x = atof(y);
if ((float)x == GS_BLANK) {
Rast_set_null_value(rast_ptr, 1, data_type);
}
else {
Rast_set_d_value(rast_ptr,
(DCELL) (x * mult), data_type);
}
}
else {
Rast_set_null_value(rast_ptr, 1, data_type);
}
rast_ptr = G_incr_void_ptr(rast_ptr, Rast_cell_size(data_type));
}
fwrite(rast, Rast_cell_size(data_type), ncols, ft);
rast_ptr = rast;
}
G_percent(nrows, nrows, 2);
G_debug(1, "Creating support files for %s", output);
sz = 0;
if (direction < 0) {
sz = -ncols * Rast_cell_size(data_type);
G_fseek(ft, sz, SEEK_END);
sz *= 2;
}
else {
G_fseek(ft, 0L, SEEK_SET);
}
for (row = 0; row < nrows; row += 1) {
fread(rast, Rast_cell_size(data_type), ncols, ft);
Rast_put_row(cf, rast, data_type);
G_fseek(ft, sz, SEEK_CUR);
}
fclose(ft);
unlink(temp);
Rast_close(cf);
if (title)
Rast_put_cell_title(output, title);
Rast_short_history(output, "raster", &history);
Rast_command_history(&history);
Rast_write_history(output, &history);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
static int blank_line(void *buf)
{
Rast_set_null_value(buf, row_length + 2, data_type);
return 0;
}