int get_cell(int col, float* buf_row, void* buf, RASTER_MAP_TYPE raster_type) {
switch (raster_type) {
case CELL_TYPE:
if (Rast_is_null_value(&((CELL *) buf)[col],CELL_TYPE))
Rast_set_f_null_value(&buf_row[col],1);
else
buf_row[col] = (FCELL) ((CELL *) buf)[col];
break;
case FCELL_TYPE:
if (Rast_is_null_value(&((FCELL *) buf)[col],FCELL_TYPE))
Rast_set_f_null_value(&buf_row[col],1);
else
buf_row[col] = (FCELL) ((FCELL *) buf)[col];
break;
case DCELL_TYPE:
if (Rast_is_null_value(&((DCELL *) buf)[col],DCELL_TYPE))
Rast_set_f_null_value(&buf_row[col],1);
else
buf_row[col] = (FCELL) ((DCELL *) buf)[col];
break;
}
return 0;
}
/* ************************************************************************* */
double get_raster_value_as_double(int MapType, void *ptr, double nullval)
{
double val = nullval;
if (MapType == CELL_TYPE) {
if (Rast_is_null_value(ptr, MapType)) {
val = nullval;
} else {
val = *(CELL *) ptr;
}
}
if (MapType == FCELL_TYPE) {
if (Rast_is_null_value(ptr, MapType)) {
val = nullval;
} else {
val = *(FCELL *) ptr;
}
}
if (MapType == DCELL_TYPE) {
if (Rast_is_null_value(ptr, MapType)) {
val = nullval;
} else {
val = *(DCELL *) ptr;
}
}
return val;
}
/*!
\brief Draw raster row in RGB mode
\param A_row row number
\param r_raster red data buffer
\param g_raster green data buffer
\param b_raster blue data buffer
\param r_colors colors used for red channel
\param g_colors colors used for green channel
\param b_colors colors used for blue channel
\param r_type raster type used for red channel
\param g_type raster type used for red channel
\param b_type raster type used for red channel
\return
*/
int D_draw_raster_RGB(int A_row,
const void *r_raster, const void *g_raster,
const void *b_raster, struct Colors *r_colors,
struct Colors *g_colors, struct Colors *b_colors,
RASTER_MAP_TYPE r_type, RASTER_MAP_TYPE g_type,
RASTER_MAP_TYPE b_type)
{
static unsigned char *r_buf, *g_buf, *b_buf, *n_buf;
static int nalloc;
int r_size = Rast_cell_size(r_type);
int g_size = Rast_cell_size(g_type);
int b_size = Rast_cell_size(b_type);
int ncols = src[0][1] - src[0][0];
int i;
/* reallocate color_buf if necessary */
if (nalloc < ncols) {
nalloc = ncols;
r_buf = G_realloc(r_buf, nalloc);
g_buf = G_realloc(g_buf, nalloc);
b_buf = G_realloc(b_buf, nalloc);
n_buf = G_realloc(n_buf, nalloc);
}
/* convert cell values to bytes */
Rast_lookup_colors(r_raster, r_buf, n_buf, n_buf, n_buf, ncols,
r_colors, r_type);
Rast_lookup_colors(g_raster, n_buf, g_buf, n_buf, n_buf, ncols,
g_colors, g_type);
Rast_lookup_colors(b_raster, n_buf, n_buf, b_buf, n_buf, ncols,
b_colors, b_type);
if (D__overlay_mode)
for (i = 0; i < ncols; i++) {
n_buf[i] = (Rast_is_null_value(r_raster, r_type) ||
Rast_is_null_value(g_raster, g_type) ||
Rast_is_null_value(b_raster, b_type));
r_raster = G_incr_void_ptr(r_raster, r_size);
g_raster = G_incr_void_ptr(g_raster, g_size);
b_raster = G_incr_void_ptr(b_raster, b_size);
}
A_row = COM_raster(ncols, A_row, r_buf, g_buf, b_buf,
D__overlay_mode ? n_buf : NULL);
return (A_row < src[1][1])
? A_row : -1;
}
static void embed_nulls(int fd, void *buf, int row, RASTER_MAP_TYPE map_type,
int null_is_zero, int with_mask)
{
struct fileinfo *fcb = &R__.fileinfo[fd];
size_t size = Rast_cell_size(map_type);
char *null_buf;
int i;
/* this is because without null file the nulls can be only due to 0's
in data row or mask */
if (null_is_zero && !fcb->null_file_exists
&& (R__.auto_mask <= 0 || !with_mask))
return;
null_buf = G_alloca(R__.rd_window.cols);
get_null_value_row(fd, null_buf, row, with_mask);
for (i = 0; i < R__.rd_window.cols; i++) {
/* also check for nulls which might be already embedded by quant
rules in case of fp map. */
if (null_buf[i] || Rast_is_null_value(buf, map_type)) {
/* G__set_[f/d]_null_value() sets it to 0 is the embedded mode
is not set and calls G_set_[f/d]_null_value() otherwise */
Rast__set_null_value(buf, 1, null_is_zero, map_type);
}
buf = G_incr_void_ptr(buf, size);
}
G_freea(null_buf);
}
static int draw_cell(int A_row,
const void *array,
struct Colors *colors, RASTER_MAP_TYPE data_type)
{
static unsigned char *red, *grn, *blu, *set;
static int nalloc;
int ncols = src[0][1] - src[0][0];
int i;
if (nalloc < ncols) {
nalloc = ncols;
red = G_realloc(red, nalloc);
grn = G_realloc(grn, nalloc);
blu = G_realloc(blu, nalloc);
set = G_realloc(set, nalloc);
}
Rast_lookup_colors(array, red, grn, blu, set, ncols, colors,
data_type);
if (D__overlay_mode)
for (i = 0; i < ncols; i++) {
set[i] = Rast_is_null_value(array, data_type);
array = G_incr_void_ptr(array, Rast_cell_size(data_type));
}
A_row =
COM_raster(ncols, A_row, red, grn, blu, D__overlay_mode ? set : NULL);
return (A_row < src[1][1])
? A_row : -1;
}
static void put_data_gdal(int fd, const void *rast, int row, int n,
int zeros_r_nulls, RASTER_MAP_TYPE map_type)
{
#ifdef HAVE_GDAL
struct fileinfo *fcb = &R__.fileinfo[fd];
int size = Rast_cell_size(map_type);
DCELL null_val = fcb->gdal->null_val;
const void *src;
void *work_buf, *dst;
GDALDataType datatype;
CPLErr err;
int i;
if (row < 0 || row >= fcb->cellhd.rows)
return;
if (n <= 0)
return;
work_buf = G__alloca(n * size);
switch (map_type) {
case CELL_TYPE:
datatype = GDT_Int32;
break;
case FCELL_TYPE:
datatype = GDT_Float32;
break;
case DCELL_TYPE:
datatype = GDT_Float64;
break;
}
src = rast;
dst = work_buf;
for (i = 0; i < n; i++) {
if (Rast_is_null_value(src, map_type) ||
(zeros_r_nulls && !*(CELL *) src))
Rast_set_d_value(dst, null_val, map_type);
else
memcpy(dst, src, size);
src = G_incr_void_ptr(src, size);
dst = G_incr_void_ptr(dst, size);
}
err = Rast_gdal_raster_IO(fcb->gdal->band, GF_Write, 0, row, n, 1,
work_buf, n, 1, datatype, 0, 0);
G__freea(work_buf);
if (err != CE_None)
G_fatal_error(_("Error writing data via GDAL for row %d of <%s>"),
row, fcb->name);
#endif
}
int update_min(void *array, int cols, int row, int col,
RASTER_MAP_TYPE map_type, double value)
{
void *ptr = get_cell_ptr(array, cols, row, col, map_type);
DCELL old_val;
if (Rast_is_null_value(ptr, map_type))
Rast_set_d_value(ptr, (DCELL) value, map_type);
else {
old_val = Rast_get_d_value(ptr, map_type);
if (value < old_val)
Rast_set_d_value(ptr, (DCELL) value, map_type);
}
return 0;
}
static int calc_mu(int *fds, double *mu, int bands)
{
int i;
int rows = Rast_window_rows();
int cols = Rast_window_cols();
void *rowbuf = NULL;
for (i = 0; i < bands; i++) {
RASTER_MAP_TYPE maptype;
int row, col;
double sum = 0.;
maptype = Rast_get_map_type(fds[i]);
/* don't assume each image is of the same type */
if (rowbuf)
G_free(rowbuf);
if ((rowbuf = Rast_allocate_buf(maptype)) == NULL)
G_fatal_error(_("Unable allocate memory for row buffer"));
G_message(_("Computing means for band %d..."), i + 1);
for (row = 0; row < rows; row++) {
void *ptr = rowbuf;
G_percent(row, rows - 1, 2);
Rast_get_row(fds[i], rowbuf, row, maptype);
for (col = 0; col < cols; col++) {
/* skip null cells */
if (Rast_is_null_value(ptr, maptype)) {
ptr = G_incr_void_ptr(ptr, Rast_cell_size(maptype));
continue;
}
sum += Rast_get_d_value(ptr, maptype);
ptr = G_incr_void_ptr(ptr, Rast_cell_size(maptype));
}
}
mu[i] = sum / (double)(rows * cols);
}
if (rowbuf)
G_free(rowbuf);
return 0;
}
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;
}
/*!
* \brief Update range structure based on raster row (floating-point)
*
* This routine updates the <i>range</i> data just like
* Rast_update_range(), but for <i>n</i> values from the <i>cell</i>
* array.
*
* \param cell raster values
* \param n number of values
* \param range pointer to Range structure which holds range info
* \param data_type raster type (CELL, FCELL, DCELL)
*/
void Rast_row_update_fp_range(const void *rast, int n,
struct FPRange *range,
RASTER_MAP_TYPE data_type)
{
size_t size = Rast_cell_size(data_type);
DCELL val = 0.0;
while (n-- > 0) {
switch (data_type) {
case CELL_TYPE:
val = (DCELL) * ((CELL *) rast);
break;
case FCELL_TYPE:
val = (DCELL) * ((FCELL *) rast);
break;
case DCELL_TYPE:
val = *((DCELL *) rast);
break;
}
if (Rast_is_null_value(rast, data_type)) {
rast = G_incr_void_ptr(rast, size);
continue;
}
if (range->first_time) {
range->first_time = 0;
range->min = val;
range->max = val;
}
else {
if (val < range->min)
range->min = val;
if (val > range->max)
range->max = val;
}
rast = G_incr_void_ptr(rast, size);
}
}
double calculateF(area_des ad, int fd, char **par, double *result)
{
FCELL *buf;
FCELL corrCell;
FCELL precCell;
int i, j;
int mask_fd = -1, *mask_buf;
int ris = 0;
int masked = FALSE;
int a = 0; /* a=0 if all cells are null */
long m = 0;
long tot = 0;
long zero = 0;
long totCorr = 0;
double indice = 0;
double somma = 0;
double p = 0;
double area = 0;
double t;
avl_tree albero = NULL;
AVL_table *array;
generic_cell uc;
uc.t = FCELL_TYPE;
/* open mask if needed */
if (ad->mask == 1) {
if ((mask_fd = open(ad->mask_name, O_RDONLY, 0755)) < 0)
return RLI_ERRORE;
mask_buf = G_malloc(ad->cl * sizeof(int));
if (mask_buf == NULL) {
G_fatal_error("malloc mask_buf failed");
return RLI_ERRORE;
}
masked = TRUE;
}
Rast_set_f_null_value(&precCell, 1);
for (j = 0; j < ad->rl; j++) { /* for each row */
if (masked) {
if (read(mask_fd, mask_buf, (ad->cl * sizeof(int))) < 0) {
G_fatal_error("mask read failed");
return RLI_ERRORE;
}
}
buf = RLI_get_fcell_raster_row(fd, j + ad->y, ad);
for (i = 0; i < ad->cl; i++) { /* for each fcell in the row */
area++;
corrCell = buf[i + ad->x];
if (masked && mask_buf[i + ad->x] == 0) {
Rast_set_f_null_value(&corrCell, 1);
area--;
}
if (!(Rast_is_null_value(&corrCell, uc.t))) {
a = 1;
if (Rast_is_null_value(&precCell, uc.t)) {
precCell = corrCell;
}
if (corrCell != precCell) {
if (albero == NULL) {
uc.val.fc = precCell;
albero = avl_make(uc, totCorr);
if (albero == NULL) {
G_fatal_error("avl_make error");
return RLI_ERRORE;
}
m++;
}
else {
uc.val.fc = precCell;
ris = avl_add(&albero, uc, totCorr);
switch (ris) {
case AVL_ERR:
{
G_fatal_error("avl_add error");
return RLI_ERRORE;
}
case AVL_ADD:
{
m++;
break;
}
case AVL_PRES:
{
break;
}
default:
{
G_fatal_error("avl_make unknown error");
return RLI_ERRORE;
}
}
}
totCorr = 1;
} /* endif not equal fcells */
else { /*equal fcells */
totCorr++;
}
precCell = corrCell;
}
}
}
/*last closing */
if (a != 0) {
if (albero == NULL) {
uc.val.fc = precCell;
albero = avl_make(uc, totCorr);
if (albero == NULL) {
G_fatal_error("avl_make error");
return RLI_ERRORE;
}
m++;
}
else {
uc.val.fc = precCell;
ris = avl_add(&albero, uc, totCorr);
switch (ris) {
case AVL_ERR:
{
G_fatal_error("avl_add error");
return RLI_ERRORE;
}
case AVL_ADD:
{
m++;
break;
}
case AVL_PRES:
{
break;
}
default:
{
G_fatal_error("avl_add unknown error");
return RLI_ERRORE;
}
}
}
}
array = G_malloc(m * sizeof(AVL_tableRow));
if (array == NULL) {
G_fatal_error("malloc array failed");
return RLI_ERRORE;
}
tot = avl_to_array(albero, zero, array);
if (tot != m) {
G_warning("avl_to_array unaspected value. the result could be wrong");
return RLI_ERRORE;
}
char *sval;
sval = par[0];
double alpha_double;
alpha_double = (double)atof(sval);
/* calculate index summary */
for (i = 0; i < m; i++) {
t = (double)(array[i]->tot);
p = t / area;
G_debug(1, "Valore p: %g, valore pow: %g", p, pow(p, alpha_double));
somma = somma + pow(p, alpha_double);
}
indice = (1 / (1 - alpha_double)) * log(somma);
if (isnan(indice) || isinf(indice)) {
indice = -1;
}
G_debug(1, "Valore somma: %g Valore indice: %g", somma, indice);
*result = indice;
G_free(array);
if (masked)
G_free(mask_buf);
return RLI_OK;
}
int patch_number(int fd, char **par, area_des ad, double *result)
{
CELL *buf, *sup;
int count = 0, i, j, connected = 0, complete_line = 1, other_above = 0;
struct Cell_head hd;
CELL complete_value;
int mask_fd = -1, *mask_buf, *mask_sup, null_count = 0;
Rast_set_c_null_value(&complete_value, 1);
Rast_get_cellhd(ad->raster, "", &hd);
sup = Rast_allocate_c_buf();
/* open mask if needed */
if (ad->mask == 1) {
if ((mask_fd = open(ad->mask_name, O_RDONLY, 0755)) < 0)
return 0;
mask_buf = malloc(ad->cl * sizeof(int));
mask_sup = malloc(ad->cl * sizeof(int));
}
/*calculate number of patch */
for (i = 0; i < ad->rl; i++) {
buf = RLI_get_cell_raster_row(fd, i + ad->y, ad);
if (i > 0) {
sup = RLI_get_cell_raster_row(fd, i - 1 + ad->y, ad);
}
/* mask values */
if (ad->mask == 1) {
int k;
if (i > 0) {
int *tmp;
tmp = mask_sup;
mask_buf = mask_sup;
}
if (read(mask_fd, mask_buf, (ad->cl * sizeof(int))) < 0)
return 0;
for (k = 0; k < ad->cl; k++) {
if (mask_buf[k] == 0) {
Rast_set_c_null_value(mask_buf + k, 1);
null_count++;
}
}
}
if (complete_line) {
if (!Rast_is_null_value(&(buf[ad->x]), CELL_TYPE) &&
buf[ad->x] != complete_value)
count++;
for (j = 0; j < ad->cl - 1; j++) {
if (buf[j + ad->x] != buf[j + 1 + ad->x]) {
complete_line = 0;
if (!Rast_is_null_value(&(buf[j + 1 + ad->x]), CELL_TYPE)
&& buf[j + 1 + ad->x] != complete_value)
count++;
}
}
if (complete_line) {
complete_value = buf[ad->x];
}
}
else {
complete_line = 1;
connected = 0;
other_above = 0;
for (j = 0; j < ad->cl; j++) {
if (sup[j + ad->x] == buf[j + ad->x]) {
connected = 1;
if (other_above) {
other_above = 0;
count--;
}
}
else {
if (connected &&
!Rast_is_null_value(&(buf[j + ad->x]), CELL_TYPE))
other_above = 1;
}
if (j < ad->cl - 1 && buf[j + ad->x] != buf[j + 1 + ad->x]) {
complete_line = 0;
if (!connected &&
!Rast_is_null_value(&(buf[j + ad->x]), CELL_TYPE)) {
count++;
connected = 0;
other_above = 0;
}
else {
connected = 0;
other_above = 0;
}
}
}
if (!connected &&
sup[ad->cl - 1 + ad->x] != buf[ad->cl - 1 + ad->x]) {
if (!Rast_is_null_value
(&(buf[ad->cl - 1 + ad->x]), CELL_TYPE)) {
count++;
complete_line = 0;
}
}
if (complete_line)
complete_value = buf[ad->x];
}
}
*result = count;
G_free(sup);
return RLI_OK;
}
int main(int argc, char **argv)
{
struct Cell_head window;
RASTER_MAP_TYPE raster_type, mag_raster_type = -1;
int layer_fd;
void *raster_row, *ptr;
int nrows, ncols;
int aspect_c = -1;
float aspect_f = -1.0;
double scale;
int skip, no_arrow;
char *mag_map = NULL;
void *mag_raster_row = NULL, *mag_ptr = NULL;
double length = -1;
int mag_fd = -1;
struct FPRange range;
double mag_min, mag_max;
struct GModule *module;
struct Option *opt1, *opt2, *opt3, *opt4, *opt5,
*opt6, *opt7, *opt8, *opt9;
struct Flag *align;
double t, b, l, r;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("raster"));
module->description =
_("Draws arrows representing cell aspect direction "
"for a raster map containing aspect data.");
opt1 = G_define_standard_option(G_OPT_R_MAP);
opt1->description = _("Name of raster aspect map to be displayed");
opt2 = G_define_option();
opt2->key = "type";
opt2->type = TYPE_STRING;
opt2->required = NO;
opt2->answer = "grass";
opt2->options = "grass,compass,agnps,answers";
opt2->description = _("Type of existing raster aspect map");
opt3 = G_define_option();
opt3->key = "arrow_color";
opt3->type = TYPE_STRING;
opt3->required = NO;
opt3->answer = "green";
opt3->gisprompt = "old_color,color,color";
opt3->description = _("Color for drawing arrows");
opt3->guisection = _("Colors");
opt4 = G_define_option();
opt4->key = "grid_color";
opt4->type = TYPE_STRING;
opt4->required = NO;
opt4->answer = "gray";
opt4->gisprompt = "old_color,color,color_none";
opt4->description = _("Color for drawing grid or \"none\"");
opt4->guisection = _("Colors");
opt5 = G_define_option();
opt5->key = "x_color";
opt5->type = TYPE_STRING;
opt5->required = NO;
opt5->answer = DEFAULT_FG_COLOR;
opt5->gisprompt = "old_color,color,color_none";
opt5->description = _("Color for drawing X's (null values)");
opt5->guisection = _("Colors");
opt6 = G_define_option();
opt6->key = "unknown_color";
opt6->type = TYPE_STRING;
opt6->required = NO;
opt6->answer = "red";
opt6->gisprompt = "old_color,color,color_none";
opt6->description = _("Color for showing unknown information");
opt6->guisection = _("Colors");
opt9 = G_define_option();
opt9->key = "skip";
opt9->type = TYPE_INTEGER;
opt9->required = NO;
opt9->answer = "1";
opt9->description = _("Draw arrow every Nth grid cell");
opt7 = G_define_option();
opt7->key = "magnitude_map";
opt7->type = TYPE_STRING;
opt7->required = NO;
opt7->multiple = NO;
opt7->gisprompt = "old,cell,raster";
opt7->description =
_("Raster map containing values used for arrow length");
opt8 = G_define_option();
opt8->key = "scale";
opt8->type = TYPE_DOUBLE;
opt8->required = NO;
opt8->answer = "1.0";
opt8->description = _("Scale factor for arrows (magnitude map)");
align = G_define_flag();
align->key = 'a';
align->description = _("Align grids with raster cells");
/* Check command line */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
layer_name = opt1->answer;
arrow_color = D_translate_color(opt3->answer);
x_color = D_translate_color(opt5->answer);
unknown_color = D_translate_color(opt6->answer);
if (strcmp("none", opt4->answer) == 0)
grid_color = -1;
else
grid_color = D_translate_color(opt4->answer);
if (strcmp("grass", opt2->answer) == 0)
map_type = 1;
else if (strcmp("agnps", opt2->answer) == 0)
map_type = 2;
else if (strcmp("answers", opt2->answer) == 0)
map_type = 3;
else if (strcmp("compass", opt2->answer) == 0)
map_type = 4;
scale = atof(opt8->answer);
if (scale <= 0.0)
G_fatal_error(_("Illegal value for scale factor"));
skip = atoi(opt9->answer);
if (skip <= 0)
G_fatal_error(_("Illegal value for skip factor"));
if (opt7->answer) {
if (map_type != 1 && map_type != 4)
G_fatal_error(_("Magnitude is only supported for GRASS and compass aspect maps."));
mag_map = opt7->answer;
}
else if (scale != 1.0)
G_warning(_("Scale option requires magnitude_map"));
/* Setup driver and check important information */
if (D_open_driver() != 0)
G_fatal_error(_("No graphics device selected. "
"Use d.mon to select graphics device."));
D_setup(0);
/* Read in the map window associated with window */
G_get_window(&window);
if (align->answer) {
struct Cell_head wind;
Rast_get_cellhd(layer_name, "", &wind);
/* expand window extent by one wind resolution */
wind.west += wind.ew_res * ((int)((window.west - wind.west) / wind.ew_res) - (window.west < wind.west));
wind.east += wind.ew_res * ((int)((window.east - wind.east) / wind.ew_res) + (window.east > wind.east));
wind.south += wind.ns_res * ((int)((window.south - wind.south) / wind.ns_res) - (window.south < wind.south));
wind.north += wind.ns_res * ((int)((window.north - wind.north) / wind.ns_res) + (window.north > wind.north));
wind.rows = (wind.north - wind.south) / wind.ns_res;
wind.cols = (wind.east - wind.west) / wind.ew_res;
Rast_set_window(&wind);
nrows = wind.rows;
ncols = wind.cols;
t = (wind.north - window.north) * nrows / (wind.north - wind.south);
b = t + (window.north - window.south) * nrows / (wind.north - wind.south);
l = (window.west - wind.west) * ncols / (wind.east - wind.west);
r = l + (window.east - window.west) * ncols / (wind.east - wind.west);
} else {
nrows = window.rows;
ncols = window.cols;
t = 0;
b = nrows;
l = 0;
r = ncols;
}
D_set_src(t, b, l, r);
D_update_conversions();
/* figure out arrow scaling if using a magnitude map */
if (opt7->answer) {
Rast_init_fp_range(&range); /* really needed? */
if (Rast_read_fp_range(mag_map, "", &range) != 1)
G_fatal_error(_("Problem reading range file"));
Rast_get_fp_range_min_max(&range, &mag_min, &mag_max);
scale *= 1.5 / fabs(mag_max);
G_debug(3, "scaling=%.2f rast_max=%.2f", scale, mag_max);
}
if (grid_color > 0) { /* ie not "none" */
/* Set color */
D_use_color(grid_color);
/* Draw vertical grids */
for (col = 0; col < ncols; col++)
D_line_abs(col, 0, col, nrows);
/* Draw horizontal grids */
for (row = 0; row < nrows; row++)
D_line_abs(0, row, ncols, row);
}
/* open the raster map */
layer_fd = Rast_open_old(layer_name, "");
raster_type = Rast_get_map_type(layer_fd);
/* allocate the cell array */
raster_row = Rast_allocate_buf(raster_type);
if (opt7->answer) {
/* open the magnitude raster map */
mag_fd = Rast_open_old(mag_map, "");
mag_raster_type = Rast_get_map_type(mag_fd);
/* allocate the cell array */
mag_raster_row = Rast_allocate_buf(mag_raster_type);
}
/* loop through cells, find value, determine direction (n,s,e,w,ne,se,sw,nw),
and call appropriate function to draw an arrow on the cell */
for (row = 0; row < nrows; row++) {
Rast_get_row(layer_fd, raster_row, row, raster_type);
ptr = raster_row;
if (opt7->answer) {
Rast_get_row(mag_fd, mag_raster_row, row, mag_raster_type);
mag_ptr = mag_raster_row;
}
for (col = 0; col < ncols; col++) {
if (row % skip != 0)
no_arrow = TRUE;
else
no_arrow = FALSE;
if (col % skip != 0)
no_arrow = TRUE;
/* find aspect direction based on cell value */
if (raster_type == CELL_TYPE)
aspect_f = *((CELL *) ptr);
else if (raster_type == FCELL_TYPE)
aspect_f = *((FCELL *) ptr);
else if (raster_type == DCELL_TYPE)
aspect_f = *((DCELL *) ptr);
if (opt7->answer) {
if (mag_raster_type == CELL_TYPE)
length = *((CELL *) mag_ptr);
else if (mag_raster_type == FCELL_TYPE)
length = *((FCELL *) mag_ptr);
else if (mag_raster_type == DCELL_TYPE)
length = *((DCELL *) mag_ptr);
length *= scale;
if (Rast_is_null_value(mag_ptr, mag_raster_type)) {
G_debug(5, "Invalid arrow length [NULL]. Skipping.");
no_arrow = TRUE;
}
else if (length <= 0.0) { /* use fabs() or theta+=180? */
G_debug(5, "Illegal arrow length [%.3f]. Skipping.",
length);
no_arrow = TRUE;
}
}
if (no_arrow) {
ptr = G_incr_void_ptr(ptr, Rast_cell_size(raster_type));
if (opt7->answer)
mag_ptr =
G_incr_void_ptr(mag_ptr,
Rast_cell_size(mag_raster_type));
no_arrow = FALSE;
continue;
}
/* treat AGNPS and ANSWERS data like old zero-as-null CELL */
/* TODO: update models */
if (map_type == 2 || map_type == 3) {
if (Rast_is_null_value(ptr, raster_type))
aspect_c = 0;
else
aspect_c = (int)(aspect_f + 0.5);
}
/** Now draw the arrows **/
/* case switch for standard GRASS aspect map
measured in degrees counter-clockwise from east */
if (map_type == 1) {
D_use_color(arrow_color);
if (Rast_is_null_value(ptr, raster_type)) {
D_use_color(x_color);
draw_x();
D_use_color(arrow_color);
}
else if (aspect_f >= 0.0 && aspect_f <= 360.0) {
if (opt7->answer)
arrow_mag(aspect_f, length);
else
arrow_360(aspect_f);
}
else {
D_use_color(unknown_color);
unknown_();
D_use_color(arrow_color);
}
}
/* case switch for AGNPS type aspect map */
else if (map_type == 2) {
D_use_color(arrow_color);
switch (aspect_c) {
case 0:
D_use_color(x_color);
draw_x();
D_use_color(arrow_color);
break;
case 1:
arrow_n();
break;
case 2:
arrow_ne();
break;
case 3:
arrow_e();
break;
case 4:
arrow_se();
break;
case 5:
arrow_s();
break;
case 6:
arrow_sw();
break;
case 7:
arrow_w();
break;
case 8:
arrow_nw();
break;
default:
D_use_color(unknown_color);
unknown_();
D_use_color(arrow_color);
break;
}
}
/* case switch for ANSWERS type aspect map */
else if (map_type == 3) {
D_use_color(arrow_color);
if (aspect_c >= 15 && aspect_c <= 360) /* start at zero? */
arrow_360((double)aspect_c);
else if (aspect_c == 400) {
D_use_color(unknown_color);
unknown_();
D_use_color(arrow_color);
}
else {
D_use_color(x_color);
draw_x();
D_use_color(arrow_color);
}
}
/* case switch for compass type aspect map
measured in degrees clockwise from north */
else if (map_type == 4) {
D_use_color(arrow_color);
if (Rast_is_null_value(ptr, raster_type)) {
D_use_color(x_color);
draw_x();
D_use_color(arrow_color);
}
else if (aspect_f >= 0.0 && aspect_f <= 360.0) {
if (opt7->answer)
arrow_mag(90 - aspect_f, length);
else
arrow_360(90 - aspect_f);
}
else {
D_use_color(unknown_color);
unknown_();
D_use_color(arrow_color);
}
}
ptr = G_incr_void_ptr(ptr, Rast_cell_size(raster_type));
if (opt7->answer)
mag_ptr =
G_incr_void_ptr(mag_ptr, Rast_cell_size(mag_raster_type));
}
}
Rast_close(layer_fd);
if (opt7->answer)
Rast_close(mag_fd);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
/*!
* \brief Returns 1 if the value of N_array_2d struct at position col, row
* is of type null, otherwise 0
*
* This function checks automatically the type of the array and checks for the
* data type null value.
*
* \param data N_array_2d *
* \param col int
* \param row int
* \return int - 1 = is null, 0 otherwise
* */
int N_is_array_2d_value_null(N_array_2d * data, int col, int row)
{
if (data->offset == 0) {
if (data->type == CELL_TYPE && data->cell_array != NULL) {
G_debug(6,
"N_is_array_2d_value_null: null value is of type CELL at pos [%i][%i]",
col, row);
return Rast_is_null_value((void *)
&(data->
cell_array[row * data->cols_intern +
col]), CELL_TYPE);
}
else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
G_debug(6,
"N_is_array_2d_value_null: null value is of type FCELL at pos [%i][%i]",
col, row);
return Rast_is_null_value((void *)
&(data->
fcell_array[row * data->cols_intern +
col]), FCELL_TYPE);
}
else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
G_debug(6,
"N_is_array_2d_value_null: null value is of type DCELL at pos [%i][%i]",
col, row);
return Rast_is_null_value((void *)
&(data->
dcell_array[row * data->cols_intern +
col]), DCELL_TYPE);
}
}
else {
if (data->type == CELL_TYPE && data->cell_array != NULL) {
G_debug(6,
"N_is_array_2d_value_null: null value is of type CELL at pos [%i][%i]",
col, row);
return Rast_is_null_value((void *)
&(data->
cell_array[(row +
data->offset) *
data->cols_intern + col +
data->offset]), CELL_TYPE);
}
else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
G_debug(6,
"N_is_array_2d_value_null: null value is of type FCELL at pos [%i][%i]",
col, row);
return Rast_is_null_value((void *)
&(data->
fcell_array[(row +
data->offset) *
data->cols_intern + col +
data->offset]), FCELL_TYPE);
}
else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
G_debug(6,
"N_is_array_2d_value_null: null value is of type DCELL at pos [%i][%i]",
col, row);
return Rast_is_null_value((void *)
&(data->
dcell_array[(row +
data->offset) *
data->cols_intern + col +
data->offset]), DCELL_TYPE);
}
}
return 0;
}
int null_distance(const char *name1, const char *name2, int *zerro_row, int *zerro_col)
{
RASTER_MAP_TYPE maptype1, maptype2;
const char *mapset;
int mapd1, mapd2;
void *inrast1, *inrast2;
int nrows, ncols, row, col;
void *cell1, *cell2;
/* NOTE: no need to controll, if the map exists. it should be checked in edge.c */
mapset = G_find_raster2(name1, "");
maptype1 = Rast_map_type(name1, mapset);
mapd1 = Rast_open_old(name1, mapset);
inrast1 = Rast_allocate_buf(maptype1);
mapset = G_find_raster2(name2, "");
maptype2 = Rast_map_type(name2, mapset);
mapd2 = Rast_open_old(name2, mapset);
inrast2 = Rast_allocate_buf(maptype2);
G_message(_("Reading maps <%s,%s> while finding 0 distance ..."), name1,
name2);
ncols = Rast_window_cols();
nrows = Rast_window_rows();
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Rast_get_row(mapd1, inrast1, row, maptype1);
Rast_get_row(mapd2, inrast2, row, maptype2);
for (col = 0; col < ncols; col++) {
/* first raster */
switch (maptype1) {
case CELL_TYPE:
cell1 = ((CELL **) inrast1)[col];
break;
case FCELL_TYPE:
cell1 = ((FCELL **) inrast1)[col];
break;
case DCELL_TYPE:
cell1 = ((DCELL **) inrast1)[col];
break;
}
/* second raster */
switch (maptype2) {
case CELL_TYPE:
cell2 = ((CELL **) inrast2)[col];
break;
case FCELL_TYPE:
cell2 = ((FCELL **) inrast2)[col];
break;
case DCELL_TYPE:
cell2 = ((DCELL **) inrast2)[col];
break;
}
if (!Rast_is_null_value(&cell1, maptype1) &&
!Rast_is_null_value(&cell2, maptype2)) {
*zerro_row = row;
*zerro_col = col;
/* memory cleanup */
G_free(inrast1);
G_free(inrast2);
/* closing raster maps */
Rast_close(mapd1);
Rast_close(mapd2);
return 1;
}
}
}
/* memory cleanup */
G_free(inrast1);
G_free(inrast2);
/* closing raster maps */
Rast_close(mapd1);
Rast_close(mapd2);
return 0;
}
int init_vars(int argc, char *argv[])
{
int r, c;
int ele_fd, wat_fd, fd = -1;
int seg_rows, seg_cols, num_cseg_total, num_open_segs, num_open_array_segs;
double memory_divisor, heap_mem, seg_factor, disk_space;
/* int page_block, num_cseg; */
int max_bytes;
CELL *buf, alt_value, *alt_value_buf, block_value;
char asp_value;
DCELL wat_value;
DCELL dvalue;
WAT_ALT wa, *wabuf;
ASP_FLAG af, af_nbr, *afbuf;
char MASK_flag;
void *elebuf, *ptr, *watbuf, *watptr;
int ele_map_type, wat_map_type;
size_t ele_size, wat_size;
int ct_dir, r_nbr, c_nbr;
G_gisinit(argv[0]);
/* input */
ele_flag = pit_flag = run_flag = ril_flag = 0;
/* output */
wat_flag = asp_flag = bas_flag = seg_flag = haf_flag = tci_flag = 0;
bas_thres = 0;
/* shed, unused */
arm_flag = dis_flag = 0;
/* RUSLE */
ob_flag = st_flag = sl_flag = sg_flag = ls_flag = er_flag = 0;
nxt_avail_pt = 0;
/* dep_flag = 0; */
max_length = d_zero = 0.0;
d_one = 1.0;
ril_value = -1.0;
/* dep_slope = 0.0; */
max_bytes = 0;
sides = 8;
mfd = 1;
c_fac = 5;
abs_acc = 0;
ele_scale = 1;
segs_mb = 300;
/* scan options */
for (r = 1; r < argc; r++) {
if (sscanf(argv[r], "elevation=%s", ele_name) == 1)
ele_flag++;
else if (sscanf(argv[r], "accumulation=%s", wat_name) == 1)
wat_flag++;
else if (sscanf(argv[r], "tci=%s", tci_name) == 1)
tci_flag++;
else if (sscanf(argv[r], "drainage=%s", asp_name) == 1)
asp_flag++;
else if (sscanf(argv[r], "depression=%s", pit_name) == 1)
pit_flag++;
else if (sscanf(argv[r], "threshold=%d", &bas_thres) == 1) ;
else if (sscanf(argv[r], "max_slope_length=%lf", &max_length) == 1) ;
else if (sscanf(argv[r], "basin=%s", bas_name) == 1)
bas_flag++;
else if (sscanf(argv[r], "stream=%s", seg_name) == 1)
seg_flag++;
else if (sscanf(argv[r], "half_basin=%s", haf_name) == 1)
haf_flag++;
else if (sscanf(argv[r], "flow=%s", run_name) == 1)
run_flag++;
else if (sscanf(argv[r], "ar=%s", arm_name) == 1)
arm_flag++;
/* slope length
else if (sscanf(argv[r], "slope_length=%s", sl_name) == 1)
sl_flag++; */
else if (sscanf(argv[r], "slope_steepness=%s", sg_name) == 1)
sg_flag++;
else if (sscanf(argv[r], "length_slope=%s", ls_name) == 1)
ls_flag++;
else if (sscanf(argv[r], "blocking=%s", ob_name) == 1)
ob_flag++;
else if (sscanf(argv[r], "memory=%lf", &segs_mb) == 1) ;
else if (sscanf(argv[r], "disturbed_land=%s", ril_name) == 1) {
if (sscanf(ril_name, "%lf", &ril_value) == 0) {
ril_value = -1.0;
ril_flag++;
}
}
/* slope deposition
else if (sscanf (argv[r], "sd=%[^\n]", dep_name) == 1) dep_flag++; */
else if (sscanf(argv[r], "-%d", &sides) == 1) {
if (sides != 4)
usage(argv[0]);
}
else if (sscanf(argv[r], "convergence=%d", &c_fac) == 1) ;
else if (strcmp(argv[r], "-s") == 0)
mfd = 0;
else if (strcmp(argv[r], "-a") == 0)
abs_acc = 1;
else
usage(argv[0]);
}
/* check options */
if (mfd == 1 && (c_fac < 1 || c_fac > 10)) {
G_fatal_error("Convergence factor must be between 1 and 10.");
}
if ((ele_flag != 1)
||
((arm_flag == 1) &&
((bas_thres <= 0) || ((haf_flag != 1) && (bas_flag != 1))))
||
((bas_thres <= 0) &&
((bas_flag == 1) || (seg_flag == 1) || (haf_flag == 1) ||
(sl_flag == 1) || (sg_flag == 1) || (ls_flag == 1)))
)
usage(argv[0]);
tot_parts = 4;
if (sl_flag || sg_flag || ls_flag)
er_flag = 1;
/* do RUSLE */
if (er_flag)
tot_parts++;
/* define basins */
if (seg_flag || bas_flag || haf_flag)
tot_parts++;
G_message(_n("SECTION 1 beginning: Initiating Variables. %d section total.",
"SECTION 1 beginning: Initiating Variables. %d sections total.",
tot_parts),
tot_parts);
this_mapset = G_mapset();
/* for sd factor
if (dep_flag) {
if (sscanf (dep_name, "%lf", &dep_slope) != 1) {
dep_flag = -1;
}
}
*/
G_get_set_window(&window);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
if (max_length <= d_zero)
max_length = 10 * nrows * window.ns_res + 10 * ncols * window.ew_res;
if (window.ew_res < window.ns_res)
half_res = .5 * window.ew_res;
else
half_res = .5 * window.ns_res;
diag = sqrt(window.ew_res * window.ew_res +
window.ns_res * window.ns_res);
if (sides == 4)
diag *= 0.5;
/* Segment rows and cols: 64 */
seg_rows = SROW;
seg_cols = SCOL;
/* seg_factor * <size in bytes> = segment size in KB */
seg_factor = seg_rows * seg_rows / 1024.;
if (segs_mb < 3.0) {
segs_mb = 3;
G_warning(_("Maximum memory to be used was smaller than 3 MB,"
" set to 3 MB."));
}
/* balance segment files */
/* elevation + accumulation: * 2 */
memory_divisor = sizeof(WAT_ALT) * 2;
disk_space = sizeof(WAT_ALT);
/* aspect and flags: * 4 */
memory_divisor += sizeof(ASP_FLAG) * 4;
disk_space += sizeof(ASP_FLAG);
/* astar_points: / 16 */
/* ideally only a few but large segments */
memory_divisor += sizeof(POINT) / 16.;
disk_space += sizeof(POINT);
/* heap points: / 4 */
memory_divisor += sizeof(HEAP_PNT) / 4.;
disk_space += sizeof(HEAP_PNT);
/* TCI: as is */
if (tci_flag) {
memory_divisor += sizeof(double);
disk_space += sizeof(double);
}
/* RUSLE */
if (er_flag) {
/* r_h */
memory_divisor += 4;
disk_space += 4;
/* s_l */
memory_divisor += 8;
disk_space += 8;
/* s_g */
if (sg_flag) {
memory_divisor += 8;
disk_space += 8;
}
/* l_s */
if (ls_flag) {
memory_divisor += 8;
disk_space += 8;
}
/* ril */
if (ril_flag) {
memory_divisor += 8;
disk_space += 8;
}
}
/* KB -> MB */
memory_divisor = memory_divisor * seg_factor / 1024.;
disk_space = disk_space * seg_factor / 1024.;
num_open_segs = segs_mb / memory_divisor;
heap_mem = num_open_segs * seg_factor * sizeof(HEAP_PNT) / (4. * 1024.);
G_debug(1, "segs MB: %.0f", segs_mb);
G_debug(1, "region rows: %d", nrows);
G_debug(1, "seg rows: %d", seg_rows);
G_debug(1, "region cols: %d", ncols);
G_debug(1, "seg cols: %d", seg_cols);
num_cseg_total = nrows / SROW + 1;
G_debug(1, " row segments:\t%d", num_cseg_total);
num_cseg_total = ncols / SCOL + 1;
G_debug(1, "column segments:\t%d", num_cseg_total);
num_cseg_total = (ncols / seg_cols + 1) * (nrows / seg_rows + 1);
G_debug(1, " total segments:\t%d", num_cseg_total);
G_debug(1, " open segments:\t%d", num_open_segs);
/* nonsense to have more segments open than exist */
if (num_open_segs > num_cseg_total)
num_open_segs = num_cseg_total;
G_debug(1, " open segments after adjusting:\t%d", num_open_segs);
disk_space *= num_cseg_total;
if (disk_space < 1024.0)
G_verbose_message(_("Will need up to %.2f MB of disk space"), disk_space);
else
G_verbose_message(_("Will need up to %.2f GB (%.0f MB) of disk space"),
disk_space / 1024.0, disk_space);
if (er_flag) {
cseg_open(&r_h, seg_rows, seg_cols, num_open_segs);
cseg_read_cell(&r_h, ele_name, "");
}
/* read elevation input and mark NULL/masked cells */
/* scattered access: alt, watalt, bitflags, asp */
seg_open(&watalt, nrows, ncols, seg_rows, seg_cols, num_open_segs * 2, sizeof(WAT_ALT));
seg_open(&aspflag, nrows, ncols, seg_rows, seg_cols, num_open_segs * 4, sizeof(ASP_FLAG));
if (tci_flag)
dseg_open(&tci, seg_rows, seg_cols, num_open_segs);
/* open elevation input */
ele_fd = Rast_open_old(ele_name, "");
ele_map_type = Rast_get_map_type(ele_fd);
ele_size = Rast_cell_size(ele_map_type);
elebuf = Rast_allocate_buf(ele_map_type);
afbuf = G_malloc(ncols * sizeof(ASP_FLAG));
if (ele_map_type == FCELL_TYPE || ele_map_type == DCELL_TYPE)
ele_scale = 1000; /* should be enough to do the trick */
/* initial flow accumulation */
if (run_flag) {
wat_fd = Rast_open_old(run_name, "");
wat_map_type = Rast_get_map_type(ele_fd);
wat_size = Rast_cell_size(ele_map_type);
watbuf = Rast_allocate_buf(ele_map_type);
}
else {
watbuf = watptr = NULL;
wat_fd = wat_size = wat_map_type = -1;
}
wabuf = G_malloc(ncols * sizeof(WAT_ALT));
alt_value_buf = Rast_allocate_buf(CELL_TYPE);
/* read elevation input and mark NULL/masked cells */
G_message("SECTION 1a: Mark masked and NULL cells");
MASK_flag = 0;
do_points = (GW_LARGE_INT) nrows * ncols;
for (r = 0; r < nrows; r++) {
G_percent(r, nrows, 1);
Rast_get_row(ele_fd, elebuf, r, ele_map_type);
ptr = elebuf;
if (run_flag) {
Rast_get_row(wat_fd, watbuf, r, wat_map_type);
watptr = watbuf;
}
for (c = 0; c < ncols; c++) {
afbuf[c].flag = 0;
afbuf[c].asp = 0;
/* check for masked and NULL cells */
if (Rast_is_null_value(ptr, ele_map_type)) {
FLAG_SET(afbuf[c].flag, NULLFLAG);
FLAG_SET(afbuf[c].flag, INLISTFLAG);
FLAG_SET(afbuf[c].flag, WORKEDFLAG);
Rast_set_c_null_value(&alt_value, 1);
/* flow accumulation */
Rast_set_d_null_value(&wat_value, 1);
do_points--;
}
else {
if (ele_map_type == CELL_TYPE) {
alt_value = *((CELL *)ptr);
}
else if (ele_map_type == FCELL_TYPE) {
dvalue = *((FCELL *)ptr);
dvalue *= ele_scale;
alt_value = ele_round(dvalue);
}
else if (ele_map_type == DCELL_TYPE) {
dvalue = *((DCELL *)ptr);
dvalue *= ele_scale;
alt_value = ele_round(dvalue);
}
/* flow accumulation */
if (run_flag) {
if (Rast_is_null_value(watptr, wat_map_type)) {
wat_value = 0; /* ok ? */
}
else {
if (wat_map_type == CELL_TYPE) {
wat_value = *((CELL *)watptr);
}
else if (wat_map_type == FCELL_TYPE) {
wat_value = *((FCELL *)watptr);
}
else if (wat_map_type == DCELL_TYPE) {
wat_value = *((DCELL *)watptr);
}
}
}
else {
wat_value = 1;
}
}
wabuf[c].wat = wat_value;
wabuf[c].ele = alt_value;
alt_value_buf[c] = alt_value;
ptr = G_incr_void_ptr(ptr, ele_size);
if (run_flag) {
watptr = G_incr_void_ptr(watptr, wat_size);
}
}
seg_put_row(&watalt, (char *) wabuf, r);
seg_put_row(&aspflag, (char *)afbuf, r);
if (er_flag) {
cseg_put_row(&r_h, alt_value_buf, r);
}
}
G_percent(nrows, nrows, 1); /* finish it */
Rast_close(ele_fd);
G_free(wabuf);
G_free(afbuf);
if (run_flag) {
Rast_close(wat_fd);
G_free(watbuf);
}
MASK_flag = (do_points < nrows * ncols);
/* do RUSLE */
if (er_flag) {
if (ob_flag) {
fd = Rast_open_old(ob_name, "");
buf = Rast_allocate_c_buf();
for (r = 0; r < nrows; r++) {
G_percent(r, nrows, 1);
Rast_get_c_row(fd, buf, r);
for (c = 0; c < ncols; c++) {
block_value = buf[c];
if (!Rast_is_c_null_value(&block_value) && block_value) {
seg_get(&aspflag, (char *)&af, r, c);
FLAG_SET(af.flag, RUSLEBLOCKFLAG);
seg_put(&aspflag, (char *)&af, r, c);
}
}
}
G_percent(nrows, nrows, 1); /* finish it */
Rast_close(fd);
G_free(buf);
}
if (ril_flag) {
dseg_open(&ril, seg_rows, seg_cols, num_open_segs);
dseg_read_cell(&ril, ril_name, "");
}
/* dseg_open(&slp, SROW, SCOL, num_open_segs); */
dseg_open(&s_l, seg_rows, seg_cols, num_open_segs);
if (sg_flag)
dseg_open(&s_g, seg_rows, seg_cols, num_open_segs);
if (ls_flag)
dseg_open(&l_s, seg_rows, seg_cols, num_open_segs);
}
G_debug(1, "open segments for A* points");
/* columns per segment */
seg_cols = seg_rows * seg_rows;
num_cseg_total = do_points / seg_cols;
if (do_points % seg_cols > 0)
num_cseg_total++;
/* no need to have more segments open than exist */
num_open_array_segs = num_open_segs / 16.;
if (num_open_array_segs > num_cseg_total)
num_open_array_segs = num_cseg_total;
if (num_open_array_segs < 1)
num_open_array_segs = 1;
seg_open(&astar_pts, 1, do_points, 1, seg_cols, num_open_array_segs,
sizeof(POINT));
/* one-based d-ary search_heap with astar_pts */
G_debug(1, "open segments for A* search heap");
G_debug(1, "heap memory %.2f MB", heap_mem);
/* columns per segment */
/* larger is faster */
seg_cols = seg_rows * seg_rows;
num_cseg_total = do_points / seg_cols;
if (do_points % seg_cols > 0)
num_cseg_total++;
/* no need to have more segments open than exist */
num_open_array_segs = (1 << 20) * heap_mem / (seg_cols * sizeof(HEAP_PNT));
if (num_open_array_segs > num_cseg_total)
num_open_array_segs = num_cseg_total;
if (num_open_array_segs < 2)
num_open_array_segs = 2;
G_debug(1, "A* search heap open segments %d, total %d",
num_open_array_segs, num_cseg_total);
/* the search heap will not hold more than 5% of all points at any given time ? */
/* chances are good that the heap will fit into one large segment */
seg_open(&search_heap, 1, do_points + 1, 1, seg_cols,
num_open_array_segs, sizeof(HEAP_PNT));
G_message(_("SECTION 1b: Determining Offmap Flow."));
/* heap is empty */
heap_size = 0;
if (pit_flag) {
buf = Rast_allocate_c_buf();
fd = Rast_open_old(pit_name, "");
}
else
buf = NULL;
first_astar = first_cum = -1;
for (r = 0; r < nrows; r++) {
G_percent(r, nrows, 1);
if (pit_flag)
Rast_get_c_row(fd, buf, r);
for (c = 0; c < ncols; c++) {
seg_get(&aspflag, (char *)&af, r, c);
if (!FLAG_GET(af.flag, NULLFLAG)) {
if (er_flag)
dseg_put(&s_l, &half_res, r, c);
asp_value = af.asp;
if (r == 0 || c == 0 || r == nrows - 1 ||
c == ncols - 1) {
/* dseg_get(&wat, &wat_value, r, c); */
seg_get(&watalt, (char *)&wa, r, c);
wat_value = wa.wat;
if (wat_value > 0) {
wat_value = -wat_value;
/* dseg_put(&wat, &wat_value, r, c); */
wa.wat = wat_value;
seg_put(&watalt, (char *)&wa, r, c);
}
if (r == 0)
asp_value = -2;
else if (c == 0)
asp_value = -4;
else if (r == nrows - 1)
asp_value = -6;
else if (c == ncols - 1)
asp_value = -8;
/* cseg_get(&alt, &alt_value, r, c); */
alt_value = wa.ele;
add_pt(r, c, alt_value);
FLAG_SET(af.flag, INLISTFLAG);
FLAG_SET(af.flag, EDGEFLAG);
af.asp = asp_value;
seg_put(&aspflag, (char *)&af, r, c);
}
else {
seg_get(&watalt, (char *)&wa, r, c);
for (ct_dir = 0; ct_dir < sides; ct_dir++) {
/* get r, c (r_nbr, c_nbr) for neighbours */
r_nbr = r + nextdr[ct_dir];
c_nbr = c + nextdc[ct_dir];
seg_get(&aspflag, (char *)&af_nbr, r_nbr, c_nbr);
if (FLAG_GET(af_nbr.flag, NULLFLAG)) {
af.asp = -1 * drain[r - r_nbr + 1][c - c_nbr + 1];
add_pt(r, c, wa.ele);
FLAG_SET(af.flag, INLISTFLAG);
FLAG_SET(af.flag, EDGEFLAG);
seg_put(&aspflag, (char *)&af, r, c);
wat_value = wa.wat;
if (wat_value > 0) {
wa.wat = -wat_value;
seg_put(&watalt, (char *)&wa, r, c);
}
break;
}
}
}
/* real depression ? */
if (pit_flag && asp_value == 0) {
if (!Rast_is_c_null_value(&buf[c]) && buf[c] != 0) {
seg_get(&watalt, (char *)&wa, r, c);
add_pt(r, c, wa.ele);
FLAG_SET(af.flag, INLISTFLAG);
FLAG_SET(af.flag, EDGEFLAG);
seg_put(&aspflag, (char *)&af, r, c);
wat_value = wa.wat;
if (wat_value > 0) {
wa.wat = -wat_value;
seg_put(&watalt, (char *)&wa, r, c);
}
}
}
} /* end non-NULL cell */
} /* end column */
}
G_percent(r, nrows, 1); /* finish it */
return 0;
}
/* ************************************************************************* */
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 calculateF(int fd, area_des ad, struct Cell_head hd, double *result)
{
FCELL *buf;
FCELL *buf_sup;
FCELL corrCell;
FCELL precCell;
FCELL supCell;
int i, j;
int mask_fd = -1, *mask_buf;
int ris = 0;
int masked = FALSE;
long npatch = 0;
long tot = 0;
long zero = 0;
long uno = 1;
long idCorr = 0;
long lastId = 0;
long doppi = 0;
long *mask_patch_sup;
long *mask_patch_corr;
double indice = 0;
double area = 0; /*if all cells are null area=0 */
double areaCorrect = 0;
double EW_DIST1, EW_DIST2, NS_DIST1, NS_DIST2;
avlID_tree albero = NULL;
avlID_table *array;
/* open mask if needed */
if (ad->mask == 1) {
if ((mask_fd = open(ad->mask_name, O_RDONLY, 0755)) < 0)
return RLI_ERRORE;
mask_buf = G_malloc(ad->cl * sizeof(int));
if (mask_buf == NULL) {
G_fatal_error("malloc mask_buf failed");
return RLI_ERRORE;
}
masked = TRUE;
}
mask_patch_sup = G_malloc(ad->cl * sizeof(long));
if (mask_patch_sup == NULL) {
G_fatal_error("malloc mask_patch_sup failed");
return RLI_ERRORE;
}
mask_patch_corr = G_malloc(ad->cl * sizeof(long));
if (mask_patch_corr == NULL) {
G_fatal_error("malloc mask_patch_corr failed");
return RLI_ERRORE;
}
buf_sup = Rast_allocate_f_buf();
if (buf_sup == NULL) {
G_fatal_error("malloc buf_sup failed");
return RLI_ERRORE;
}
buf = Rast_allocate_f_buf();
if (buf == NULL) {
G_fatal_error("malloc buf failed");
return RLI_ERRORE;
}
Rast_set_f_null_value(buf_sup + ad->x, ad->cl); /*the first time buf_sup is all null */
for (i = 0; i < ad->cl; i++) {
mask_patch_sup[i] = 0;
mask_patch_corr[i] = 0;
}
/*for each raster row */
for (j = 0; j < ad->rl; j++) {
if (j > 0) {
buf_sup = RLI_get_fcell_raster_row(fd, j - 1 + ad->y, ad);
}
buf = RLI_get_fcell_raster_row(fd, j + ad->y, ad);
if (masked) {
if (read(mask_fd, mask_buf, (ad->cl * sizeof(int))) < 0) {
G_fatal_error("mask read failed");
return RLI_ERRORE;
}
}
Rast_set_f_null_value(&precCell, 1);
for (i = 0; i < ad->cl; i++) { /*for each cell in the row */
corrCell = buf[i + ad->x];
if (((masked) && (mask_buf[i + ad->x] == 0))) {
Rast_set_f_null_value(&corrCell, 1);
}
if (!(Rast_is_null_value(&corrCell, FCELL_TYPE))) {
area++;
if (i > 0)
precCell = buf[i - 1 + ad->x];
if (j == 0)
Rast_set_f_null_value(&supCell, 1);
else
supCell = buf_sup[i + ad->x];
if (corrCell != precCell) {
if (corrCell != supCell) {
/*new patch */
if (idCorr == 0) { /*first patch */
lastId = 1;
idCorr = 1;
mask_patch_corr[i] = idCorr;
}
else { /*not first patch */
/* put in the tree previous value */
if (albero == NULL) {
albero = avlID_make(idCorr, uno);
if (albero == NULL) {
G_fatal_error("avlID_make error");
return RLI_ERRORE;
}
npatch++;
}
else { /*tree not empty */
ris = avlID_add(&albero, idCorr, uno);
switch (ris) {
case AVL_ERR:
{
G_fatal_error("avlID_add error");
return RLI_ERRORE;
}
case AVL_ADD:
{
npatch++;
break;
}
case AVL_PRES:
{
break;
}
default:
{
G_fatal_error
("avlID_add unknown error");
return RLI_ERRORE;
}
}
}
lastId++;
idCorr = lastId;
mask_patch_corr[i] = idCorr;
}
}
else { /*current cell and upper cell are equal */
if ((corrCell == precCell) &&
(mask_patch_sup[i] != mask_patch_corr[i - 1])) {
long r = 0;
long del = mask_patch_sup[i];
r = avlID_sub(&albero, del);
if (r == 0) {
G_fatal_error("avlID_sub error");
return RLI_ERRORE;
}
/*Remove one patch because it makes part of a patch already found */
ris = avlID_add(&albero, idCorr, uno);
switch (ris) {
case AVL_ERR:
{
G_fatal_error("avlID_add error");
return RLI_ERRORE;
}
case AVL_ADD:
{
npatch++;
break;
}
case AVL_PRES:
{
break;
}
default:
{
G_fatal_error("avlID_add unknown error");
return RLI_ERRORE;
}
}
r = i;
while (i < ad->cl) {
if (mask_patch_sup[r] == del) {
mask_patch_sup[r] = idCorr;
}
else {
r = ad->cl + 1;
}
}
}
if (albero == NULL) {
albero = avlID_make(idCorr, uno);
if (albero == NULL) {
G_fatal_error("avlID_make error");
return RLI_ERRORE;
}
npatch++;
}
else { /*the tree (albero) isn't null */
ris = avlID_add(&albero, idCorr, uno);
switch (ris) {
case AVL_ERR:
{
G_fatal_error("avlID_add error");
return RLI_ERRORE;
}
case AVL_ADD:
{
npatch++;
break;
}
case AVL_PRES:
{
break;
}
default:
{
G_fatal_error("avlID_add unknown error");
return RLI_ERRORE;
}
}
}
idCorr = mask_patch_sup[i];
mask_patch_corr[i] = idCorr;
}
}
else { /*current cell and previous cell are equal */
if ((corrCell == supCell) &&
(mask_patch_sup[i] != mask_patch_corr[i - 1])) {
int l;
mask_patch_corr[i] = mask_patch_sup[i];
l = i - 1;
while (l >= 0) {
if (mask_patch_corr[l] == idCorr) {
mask_patch_corr[l] = mask_patch_sup[i];
l--;
}
else {
l = (-1);
}
}
lastId--;
idCorr = mask_patch_sup[i];
}
else {
mask_patch_corr[i] = idCorr;
}
}
}
else { /*null cell or cell not to consider */
mask_patch_corr[i] = 0;
}
}
mask_patch_sup = mask_patch_corr;
}
if (area != 0) {
if (albero == NULL) {
albero = avlID_make(idCorr, uno);
if (albero == NULL) {
G_fatal_error("avlID_make error");
return RLI_ERRORE;
}
npatch++;
}
else {
ris = avlID_add(&albero, idCorr, uno);
switch (ris) {
case AVL_ERR:
{
G_fatal_error("avlID_add error");
return RLI_ERRORE;
}
case AVL_ADD:
{
npatch++;
break;
}
case AVL_PRES:
{
break;
}
default:
{
G_fatal_error("avlID_add unknown error");
return RLI_ERRORE;
}
}
}
array = G_malloc(npatch * sizeof(avlID_tableRow));
if (array == NULL) {
G_fatal_error("malloc array failed");
return RLI_ERRORE;
}
tot = avlID_to_array(albero, zero, array);
if (tot != npatch) {
G_warning
("avlID_to_array unaspected value. the result could be wrong");
return RLI_ERRORE;
}
for (i = 0; i < npatch; i++) {
if (array[i]->tot == 0)
doppi++;
}
npatch = npatch - doppi;
/*calculate distance */
G_begin_distance_calculations();
/* EW Dist at North edge */
EW_DIST1 = G_distance(hd.east, hd.north, hd.west, hd.north);
/* EW Dist at South Edge */
EW_DIST2 = G_distance(hd.east, hd.south, hd.west, hd.south);
/* NS Dist at East edge */
NS_DIST1 = G_distance(hd.east, hd.north, hd.east, hd.south);
/* NS Dist at West edge */
NS_DIST2 = G_distance(hd.west, hd.north, hd.west, hd.south);
areaCorrect = (((EW_DIST1 + EW_DIST2) / 2) / hd.cols) *
(((NS_DIST1 + NS_DIST2) / 2) / hd.rows) * (area);
indice = areaCorrect / npatch;
G_free(array);
}
else
indice = (double)(0);
*result = indice;
if (masked)
G_free(mask_buf);
G_free(mask_patch_corr);
return RLI_OK;
}
int main(int argc, char *argv[])
{
struct History history;
struct GModule *module;
char *desc;
struct Cell_head cellhd, orig_cellhd;
void *inrast, *outrast;
int infd, outfd;
void *ptr;
int nrows, ncols, row, col;
RASTER_MAP_TYPE in_data_type;
struct Option *input_prefix, *output_prefix, *metfn, *sensor, *adate,
*pdate, *elev, *bgain, *metho, *perc, *dark, *atmo, *lsatmet, *oscale;
char *inputname, *met, *outputname, *sensorname;
struct Flag *frad, *print_meta, *named;
lsat_data lsat;
char band_in[GNAME_MAX], band_out[GNAME_MAX];
int i, j, q, method, pixel, dn_dark[MAX_BANDS], dn_mode[MAX_BANDS], dn_sat;
int overwrite;
double qcal, rad, ref, percent, ref_mode, rayleigh, scale;
unsigned long hist[QCALMAX], h_max;
struct Colors colors;
struct FPRange range;
double min, max;
/* initialize GIS environment */
G_gisinit(argv[0]);
/* initialize module */
module = G_define_module();
module->description =
_("Calculates top-of-atmosphere radiance or reflectance and temperature for Landsat MSS/TM/ETM+/OLI");
G_add_keyword(_("imagery"));
G_add_keyword(_("radiometric conversion"));
G_add_keyword(_("radiance"));
G_add_keyword(_("reflectance"));
G_add_keyword(_("brightness temperature"));
G_add_keyword(_("Landsat"));
G_add_keyword(_("atmospheric correction"));
module->overwrite = TRUE;
/* It defines the different parameters */
input_prefix = G_define_standard_option(G_OPT_R_BASENAME_INPUT);
input_prefix->label = _("Base name of input raster bands");
input_prefix->description = _("Example: 'B.' for B.1, B.2, ...");
output_prefix = G_define_standard_option(G_OPT_R_BASENAME_OUTPUT);
output_prefix->label = _("Prefix for output raster maps");
output_prefix->description =
_("Example: 'B.toar.' generates B.toar.1, B.toar.2, ...");
metfn = G_define_standard_option(G_OPT_F_INPUT);
metfn->key = "metfile";
metfn->required = NO;
metfn->description = _("Name of Landsat metadata file (.met or MTL.txt)");
metfn->guisection = _("Metadata");
sensor = G_define_option();
sensor->key = "sensor";
sensor->type = TYPE_STRING;
sensor->label = _("Spacecraft sensor");
sensor->description = _("Required only if 'metfile' not given (recommended for sanity)");
sensor->options = "mss1,mss2,mss3,mss4,mss5,tm4,tm5,tm7,oli8";
desc = NULL;
G_asprintf(&desc,
"mss1;%s;mss2;%s;mss3;%s;mss4;%s;mss5;%s;tm4;%s;tm5;%s;tm7;%s;oli8;%s",
_("Landsat-1 MSS"),
_("Landsat-2 MSS"),
_("Landsat-3 MSS"),
_("Landsat-4 MSS"),
_("Landsat-5 MSS"),
_("Landsat-4 TM"),
_("Landsat-5 TM"),
_("Landsat-7 ETM+"),
_("Landsat_8 OLI/TIRS"));
sensor->descriptions = desc;
sensor->required = NO; /* perhaps YES for clarity */
sensor->guisection = _("Metadata");
metho = G_define_option();
metho->key = "method";
metho->type = TYPE_STRING;
metho->required = NO;
metho->options = "uncorrected,dos1,dos2,dos2b,dos3,dos4";
metho->label = _("Atmospheric correction method");
metho->description = _("Atmospheric correction method");
metho->answer = "uncorrected";
metho->guisection = _("Metadata");
adate = G_define_option();
adate->key = "date";
adate->type = TYPE_STRING;
adate->required = NO;
adate->key_desc = "yyyy-mm-dd";
adate->label = _("Image acquisition date (yyyy-mm-dd)");
adate->description = _("Required only if 'metfile' not given");
adate->guisection = _("Metadata");
elev = G_define_option();
elev->key = "sun_elevation";
elev->type = TYPE_DOUBLE;
elev->required = NO;
elev->label = _("Sun elevation in degrees");
elev->description = _("Required only if 'metfile' not given");
elev->guisection = _("Metadata");
pdate = G_define_option();
pdate->key = "product_date";
pdate->type = TYPE_STRING;
pdate->required = NO;
pdate->key_desc = "yyyy-mm-dd";
pdate->label = _("Image creation date (yyyy-mm-dd)");
pdate->description = _("Required only if 'metfile' not given");
pdate->guisection = _("Metadata");
bgain = G_define_option();
bgain->key = "gain";
bgain->type = TYPE_STRING;
bgain->required = NO;
bgain->label = _("Gain (H/L) of all Landsat ETM+ bands (1-5,61,62,7,8)");
bgain->description = _("Required only if 'metfile' not given");
bgain->guisection = _("Settings");
perc = G_define_option();
perc->key = "percent";
perc->type = TYPE_DOUBLE;
perc->required = NO;
perc->label = _("Percent of solar radiance in path radiance");
perc->description = _("Required only if 'method' is any DOS");
perc->answer = "0.01";
perc->guisection = _("Settings");
dark = G_define_option();
dark->key = "pixel";
dark->type = TYPE_INTEGER;
dark->required = NO;
dark->label =
_("Minimum pixels to consider digital number as dark object");
dark->description = _("Required only if 'method' is any DOS");
dark->answer = "1000";
dark->guisection = _("Settings");
atmo = G_define_option();
atmo->key = "rayleigh";
atmo->type = TYPE_DOUBLE;
atmo->required = NO;
atmo->label = _("Rayleigh atmosphere (diffuse sky irradiance)"); /* scattering coefficient? */
atmo->description = _("Required only if 'method' is DOS3");
atmo->answer = "0.0";
atmo->guisection = _("Settings");
lsatmet = G_define_option();
lsatmet->key = "lsatmet";
lsatmet->type = TYPE_STRING;
lsatmet->required = NO;
lsatmet->multiple = YES;
lsatmet->label = _("return value stored for a given metadata");
lsatmet->description = _("Required only if 'metfile' and -p given");
lsatmet->options =
"number,creation,date,sun_elev,sensor,bands,sunaz,time";
desc = NULL;
G_asprintf(&desc,
"number;%s;creation;%s;date;%s;sun_elev;%s;sensor;%s;bands;%s;sunaz;%s;time;%s",
_("Landsat Number"),
_("Creation timestamp"),
_("Date"),
_("Sun Elevation"),
_("Sensor"),
_("Bands count"), _("Sun Azimuth Angle"), _("Time"));
lsatmet->descriptions = desc;
lsatmet->guisection = _("Settings");
oscale = G_define_option();
oscale->key = "scale";
oscale->type = TYPE_DOUBLE;
oscale->answer = "1.0";
oscale->required = NO;
oscale->description = _("Scale factor for output");
/* define the different flags */
frad = G_define_flag();
frad->key = 'r';
frad->description =
_("Output at-sensor radiance instead of reflectance for all bands");
named = G_define_flag();
named->key = 'n';
named->description =
_("Input raster maps use as extension the number of the band instead the code");
print_meta = G_define_flag();
print_meta->key = 'p';
print_meta->description = _("Print output metadata info");
/* options and afters parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/*****************************************
* ---------- START --------------------
* Stores options and flags to variables
*****************************************/
met = metfn->answer;
inputname = input_prefix->answer;
outputname = output_prefix->answer;
sensorname = sensor->answer ? sensor->answer : "";
overwrite = G_check_overwrite(argc, argv);
Rast_get_window(&orig_cellhd);
G_zero(&lsat, sizeof(lsat));
if (adate->answer != NULL) {
strncpy(lsat.date, adate->answer, 11);
lsat.date[10] = '\0';
if (strlen(lsat.date) != 10)
G_fatal_error(_("Illegal date format: [%s] (yyyy-mm-dd)"),
lsat.date);
}
if (pdate->answer != NULL) {
strncpy(lsat.creation, pdate->answer, 11);
lsat.creation[10] = '\0';
if (strlen(lsat.creation) != 10)
G_fatal_error(_("Illegal date format: [%s] (yyyy-mm-dd)"),
lsat.creation);
}
lsat.sun_elev = elev->answer == NULL ? 0. : atof(elev->answer);
percent = atof(perc->answer);
pixel = atoi(dark->answer);
rayleigh = atof(atmo->answer);
scale = atof(oscale->answer);
/*
* Data from metadata file
*/
lsat.flag = NOMETADATAFILE; /* Unnecessary because G_zero filled, but for sanity */
if (met != NULL) {
lsat.flag = METADATAFILE;
lsat_metadata(met, &lsat);
if (print_meta->answer) {
char *lsatmeta;
if (lsatmet->answer == NULL) {
G_fatal_error(_("Please use a metadata keyword with -p"));
}
for (i = 0; lsatmet->answers[i] != NULL; i++) {
lsatmeta = lsatmet->answers[i];
if (strcmp(lsatmeta, "number") == 0) {
fprintf(stdout, "number=%d\n", lsat.number);
}
if (strcmp(lsatmeta, "creation") == 0) {
fprintf(stdout, "creation=%s\n", lsat.creation);
}
if (strcmp(lsatmeta, "date") == 0) {
fprintf(stdout, "date=%s\n", lsat.date);
}
if (strcmp(lsatmeta, "sun_elev") == 0) {
fprintf(stdout, "sun_elev=%f\n", lsat.sun_elev);
}
if (strcmp(lsatmeta, "sunaz") == 0) {
fprintf(stdout, "sunaz=%f\n", lsat.sun_az);
}
if (strcmp(lsatmeta, "sensor") == 0) {
fprintf(stdout, "sensor=%s\n", lsat.sensor);
}
if (strcmp(lsatmeta, "bands") == 0) {
fprintf(stdout, "bands=%d\n", lsat.bands);
}
if (strcmp(lsatmet->answer, "time") == 0) {
fprintf(stdout, "%f\n", lsat.time);
}
}
exit(EXIT_SUCCESS);
}
G_debug(1, "lsat.number = %d, lsat.sensor = [%s]",
lsat.number, lsat.sensor);
if (!lsat.sensor || lsat.number > 8 || lsat.number < 1)
G_fatal_error(_("Failed to identify satellite"));
G_debug(1, "Landsat-%d %s with data set in metadata file [%s]",
lsat.number, lsat.sensor, met);
if (elev->answer != NULL) {
lsat.sun_elev = atof(elev->answer);
G_warning("Overwriting solar elevation of metadata file");
}
}
/*
* Data from command line
*/
else if (adate->answer == NULL || elev->answer == NULL) {
G_fatal_error(_("Lacking '%s' and/or '%s' for this satellite"),
adate->key, elev->key);
}
else {
if (strcmp(sensorname, "tm7") == 0) {
if (bgain->answer == NULL || strlen(bgain->answer) != 9)
G_fatal_error(_("Landsat-7 requires band gain with 9 (H/L) characters"));
set_ETM(&lsat, bgain->answer);
}
else if (strcmp(sensorname, "oli8") == 0)
set_OLI(&lsat);
else if (strcmp(sensorname, "tm5") == 0)
set_TM5(&lsat);
else if (strcmp(sensorname, "tm4") == 0)
set_TM4(&lsat);
else if (strcmp(sensorname, "mss5") == 0)
set_MSS5(&lsat);
else if (strcmp(sensorname, "mss4") == 0)
set_MSS4(&lsat);
else if (strcmp(sensorname, "mss3") == 0)
set_MSS3(&lsat);
else if (strcmp(sensorname, "mss2") == 0)
set_MSS2(&lsat);
else if (strcmp(sensorname, "mss1") == 0)
set_MSS1(&lsat);
else
G_fatal_error(_("Unknown satellite type (defined by '%s')"),
sensorname);
}
/*****************************************
* ------------ PREPARATION --------------
*****************************************/
if (strcasecmp(metho->answer, "corrected") == 0) /* deleted 2013 */
method = CORRECTED;
else if (strcasecmp(metho->answer, "dos1") == 0)
method = DOS1;
else if (strcasecmp(metho->answer, "dos2") == 0)
method = DOS2;
else if (strcasecmp(metho->answer, "dos2b") == 0)
method = DOS2b;
else if (strcasecmp(metho->answer, "dos3") == 0)
method = DOS3;
else if (strcasecmp(metho->answer, "dos4") == 0)
method = DOS4;
else
method = UNCORRECTED;
/*
if (metho->answer[3] == '2') method = (metho->answer[4] == '\0') ? DOS2 : DOS2b;
else if (metho->answer[3] == '1') method = DOS1;
else if (metho->answer[3] == '3') method = DOS3;
else if (metho->answer[3] == '4') method = DOS4;
else method = UNCORRECTED;
*/
for (i = 0; i < lsat.bands; i++) {
dn_mode[i] = 0;
dn_dark[i] = (int)lsat.band[i].qcalmin;
dn_sat = (int)(0.90 * lsat.band[i].qcalmax);
/* Begin: calculate dark pixel */
if (method > DOS && !lsat.band[i].thermal) {
for (q = 0; q <= lsat.band[i].qcalmax; q++)
hist[q] = 0L;
sprintf(band_in, "%s%d", inputname, lsat.band[i].code);
Rast_get_cellhd(band_in, "", &cellhd);
Rast_set_window(&cellhd);
if ((infd = Rast_open_old(band_in, "")) < 0)
G_fatal_error(_("Unable to open raster map <%s>"), band_in);
in_data_type = Rast_get_map_type(infd);
if (in_data_type < 0)
G_fatal_error(_("Unable to read data type of raster map <%s>"), band_in);
inrast = Rast_allocate_buf(in_data_type);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
G_message("Calculating dark pixel of <%s>... ", band_in);
for (row = 0; row < nrows; row++) {
Rast_get_row(infd, inrast, row, in_data_type);
for (col = 0; col < ncols; col++) {
switch (in_data_type) {
case CELL_TYPE:
ptr = (void *)((CELL *) inrast + col);
q = (int)*((CELL *) ptr);
break;
case FCELL_TYPE:
ptr = (void *)((FCELL *) inrast + col);
q = (int)*((FCELL *) ptr);
break;
case DCELL_TYPE:
ptr = (void *)((DCELL *) inrast + col);
q = (int)*((DCELL *) ptr);
break;
default:
ptr = NULL;
q = -1.;
}
if (!Rast_is_null_value(ptr, in_data_type) &&
q >= lsat.band[i].qcalmin &&
q <= lsat.band[i].qcalmax)
hist[q]++;
}
}
/* DN of dark object */
for (j = lsat.band[i].qcalmin; j <= lsat.band[i].qcalmax; j++) {
if (hist[j] >= (unsigned int)pixel) {
dn_dark[i] = j;
break;
}
}
/* Mode of DN (exclude potentially saturated) */
h_max = 0L;
for (j = lsat.band[i].qcalmin; j < dn_sat; j++) {
/* G_debug(5, "%d-%ld", j, hist[j]); */
if (hist[j] > h_max) {
h_max = hist[j];
dn_mode[i] = j;
}
}
G_verbose_message
("... DN = %.2d [%lu] : mode %.2d [%lu], excluding DN > %d",
dn_dark[i], hist[dn_dark[i]], dn_mode[i], hist[dn_mode[i]],
dn_sat);
G_free(inrast);
Rast_close(infd);
}
/* End: calculate dark pixel */
/* Calculate transformation constants */
lsat_bandctes(&lsat, i, method, percent, dn_dark[i], rayleigh);
}
/*
* unnecessary or necessary with more checking as acquisition date,...
* if (strlen(lsat.creation) == 0)
* G_fatal_error(_("Unknown production date (defined by '%s')"), pdate->key);
*/
if (G_verbose() > G_verbose_std()) {
fprintf(stderr, "\n LANDSAT: %d SENSOR: %s\n", lsat.number,
lsat.sensor);
fprintf(stderr, " ACQUISITION DATE %s [production date %s]\n",
lsat.date, lsat.creation);
fprintf(stderr, " Earth-sun distance = %.8lf\n", lsat.dist_es);
fprintf(stderr, " Solar elevation angle = %.8lf\n", lsat.sun_elev);
fprintf(stderr, " Atmospheric correction: %s\n",
(method == UNCORRECTED ? "UNCORRECTED" : metho->answer));
if (method > DOS) {
fprintf(stderr,
" Percent of solar irradiance in path radiance = %.4lf\n",
percent);
}
for (i = 0; i < lsat.bands; i++) {
fprintf(stderr, "-------------------\n");
fprintf(stderr, " BAND %d %s(code %d)\n", lsat.band[i].number,
(lsat.band[i].thermal ? "thermal " : ""),
lsat.band[i].code);
fprintf(stderr,
" calibrated digital number (DN): %.1lf to %.1lf\n",
lsat.band[i].qcalmin, lsat.band[i].qcalmax);
fprintf(stderr, " calibration constants (L): %.5lf to %.5lf\n",
lsat.band[i].lmin, lsat.band[i].lmax);
fprintf(stderr, " at-%s radiance = %.8lf * DN + %.5lf\n",
(method > DOS ? "surface" : "sensor"), lsat.band[i].gain,
lsat.band[i].bias);
if (lsat.band[i].thermal) {
fprintf(stderr,
" at-sensor temperature = %.5lf / log[(%.5lf / radiance) + 1.0]\n",
lsat.band[i].K2, lsat.band[i].K1);
}
else {
fprintf(stderr,
" mean solar exoatmospheric irradiance (ESUN): %.5lf\n",
lsat.band[i].esun);
fprintf(stderr, " at-%s reflectance = radiance / %.5lf\n",
(method > DOS ? "surface" : "sensor"),
lsat.band[i].K1);
if (method > DOS) {
fprintf(stderr,
" the darkness DN with a least %d pixels is %d\n",
pixel, dn_dark[i]);
fprintf(stderr, " the DN mode is %d\n", dn_mode[i]);
}
}
}
fprintf(stderr, "-------------------\n");
fflush(stderr);
}
/*****************************************
* ------------ CALCULUS -----------------
*****************************************/
G_message(_("Calculating..."));
for (i = 0; i < lsat.bands; i++) {
sprintf(band_in, "%s%d", inputname,
(named->answer ? lsat.band[i].number : lsat.band[i].code));
sprintf(band_out, "%s%d", outputname, lsat.band[i].code);
/* set same size as original band raster */
Rast_get_cellhd(band_in, "", &cellhd);
Rast_set_window(&cellhd);
if ((infd = Rast_open_old(band_in, "")) < 0)
G_fatal_error(_("Unable to open raster map <%s>"), band_in);
if (G_find_raster2(band_out, "")) {
if (overwrite) {
G_warning(_("Raster map <%s> already exists and will be overwritten"),
band_out);
}
else {
G_warning(_("Raster map <%s> exists. Skipping."), band_out);
continue;
}
}
in_data_type = Rast_get_map_type(infd);
if (in_data_type < 0)
G_fatal_error(_("Unable to read data type of raster map <%s>"), band_in);
/* controlling, if we can write the raster */
if (G_legal_filename(band_out) < 0)
G_fatal_error(_("<%s> is an illegal file name"), band_out);
if ((outfd = Rast_open_new(band_out, DCELL_TYPE)) < 0)
G_fatal_error(_("Unable to create raster map <%s>"), band_out);
/* allocate input and output buffer */
inrast = Rast_allocate_buf(in_data_type);
outrast = Rast_allocate_buf(DCELL_TYPE);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
G_important_message(_("Writing %s of <%s> to <%s>..."),
(frad->
answer ? _("radiance") : (lsat.band[i].
thermal) ?
_("temperature") : _("reflectance")), band_in,
band_out);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Rast_get_row(infd, inrast, row, in_data_type);
for (col = 0; col < ncols; col++) {
switch (in_data_type) {
case CELL_TYPE:
ptr = (void *)((CELL *) inrast + col);
qcal = (double)((CELL *) inrast)[col];
break;
case FCELL_TYPE:
ptr = (void *)((FCELL *) inrast + col);
qcal = (double)((FCELL *) inrast)[col];
break;
case DCELL_TYPE:
ptr = (void *)((DCELL *) inrast + col);
qcal = (double)((DCELL *) inrast)[col];
break;
default:
ptr = NULL;
qcal = -1.;
}
if (Rast_is_null_value(ptr, in_data_type) ||
qcal < lsat.band[i].qcalmin) {
Rast_set_d_null_value((DCELL *) outrast + col, 1);
}
else {
rad = lsat_qcal2rad(qcal, &lsat.band[i]);
if (frad->answer) {
ref = rad;
}
else {
if (lsat.band[i].thermal) {
ref = lsat_rad2temp(rad, &lsat.band[i]);
}
else {
ref = lsat_rad2ref(rad, &lsat.band[i]) * scale;
if (ref < 0. && method > DOS)
ref = 0.;
}
}
((DCELL *) outrast)[col] = ref;
}
}
Rast_put_row(outfd, outrast, DCELL_TYPE);
}
G_percent(1, 1, 1);
ref_mode = 0.;
if (method > DOS && !lsat.band[i].thermal) {
ref_mode = lsat_qcal2rad(dn_mode[i], &lsat.band[i]);
ref_mode = lsat_rad2ref(ref_mode, &lsat.band[i]);
}
G_free(inrast);
Rast_close(infd);
G_free(outrast);
Rast_close(outfd);
/*
* needed?
* if (out_type != CELL_TYPE)
* G_quantize_fp_map_range(band_out, G_mapset(), 0., 360., 0,
* 360);
*/
/* set grey255 colortable */
Rast_init_colors(&colors);
Rast_read_fp_range(band_out, G_mapset(), &range);
Rast_get_fp_range_min_max(&range, &min, &max);
Rast_make_grey_scale_fp_colors(&colors, min, max);
Rast_write_colors(band_out, G_mapset(), &colors);
/* Initialize the 'history' structure with basic info */
Rast_short_history(band_out, "raster", &history);
Rast_append_format_history(&history,
" %s of Landsat-%d %s (method %s)",
(frad->
answer ? "Radiance" : (lsat.band[i].
thermal ?
"Temperature" :
"Reflectance")),
lsat.number, lsat.sensor, metho->answer);
Rast_append_history(&history,
"-----------------------------------------------------------------");
Rast_append_format_history(&history,
" Acquisition date (and time) ........... %s (%.4lf h)",
lsat.date, lsat.time);
Rast_append_format_history(&history,
" Production date ....................... %s\n",
lsat.creation);
Rast_append_format_history(&history,
" Earth-sun distance (d) ................ %.7lf",
lsat.dist_es);
Rast_append_format_history(&history,
" Sun elevation (and azimuth) ........... %.5lf (%.5lf)",
lsat.sun_elev, lsat.sun_az);
Rast_append_format_history(&history,
" Digital number (DN) range ............. %.0lf to %.0lf",
lsat.band[i].qcalmin,
lsat.band[i].qcalmax);
Rast_append_format_history(&history,
" Calibration constants (Lmin to Lmax) .. %+.5lf to %+.5lf",
lsat.band[i].lmin, lsat.band[i].lmax);
Rast_append_format_history(&history,
" DN to Radiance (gain and bias) ........ %+.5lf and %+.5lf",
lsat.band[i].gain, lsat.band[i].bias);
if (lsat.band[i].thermal) {
Rast_append_format_history(&history,
" Temperature (K1 and K2) ............... %.3lf and %.3lf",
lsat.band[i].K1, lsat.band[i].K2);
}
else {
Rast_append_format_history(&history,
" Mean solar irradiance (ESUN) .......... %.3lf",
lsat.band[i].esun);
Rast_append_format_history(&history,
" Radiance to Reflectance (divide by) ... %+.5lf",
lsat.band[i].K1);
if (method > DOS) {
Rast_append_format_history(&history, " ");
Rast_append_format_history(&history,
" Dark object (%4d pixels) DN = ........ %d",
pixel, dn_dark[i]);
Rast_append_format_history(&history,
" Mode in reflectance histogram ......... %.5lf",
ref_mode);
}
}
Rast_append_history(&history,
"------------------------------------------------------------------");
Rast_command_history(&history);
Rast_write_history(band_out, &history);
if (lsat.band[i].thermal)
Rast_write_units(band_out, "Kelvin");
else if (frad->answer)
Rast_write_units(band_out, "W/(m^2 sr um)");
else
Rast_write_units(band_out, "unitless");
/* set raster timestamp from acq date? (see r.timestamp module) */
}
Rast_set_window(&orig_cellhd);
exit(EXIT_SUCCESS);
}
static int calc_covariance(int *fds, double **covar, double *mu, int bands)
{
int j, k;
int rows = Rast_window_rows();
int cols = Rast_window_cols();
int row, col;
for (j = 0; j < bands; j++) {
RASTER_MAP_TYPE maptype = Rast_get_map_type(fds[j]);
void *rowbuf1 = NULL;
void *rowbuf2 = NULL;
/* don't assume each image is of the same type */
if (rowbuf1)
G_free(rowbuf1);
if ((rowbuf1 = Rast_allocate_buf(maptype)) == NULL)
G_fatal_error(_("Unable allocate memory for row buffer"));
G_message(_("Computing row %d (of %d) of covariance matrix..."),
j + 1, bands);
for (row = 0; row < rows; row++) {
void *ptr1, *ptr2;
G_percent(row, rows - 1, 2);
Rast_get_row(fds[j], rowbuf1, row, maptype);
for (k = j; k < bands; k++) {
RASTER_MAP_TYPE maptype2 = Rast_get_map_type(fds[k]);
/* don't assume each image is of the same type */
if (rowbuf2)
G_free(rowbuf2);
if ((rowbuf2 = Rast_allocate_buf(maptype2)) == NULL)
G_fatal_error(_("Unable to allocate memory for row buffer"));
Rast_get_row(fds[k], rowbuf2, row, maptype2);
ptr1 = rowbuf1;
ptr2 = rowbuf2;
for (col = 0; col < cols; col++) {
/* skip null cells */
if (Rast_is_null_value(ptr1, maptype) ||
Rast_is_null_value(ptr2, maptype2)) {
ptr1 = G_incr_void_ptr(ptr1, Rast_cell_size(maptype));
ptr2 = G_incr_void_ptr(ptr2, Rast_cell_size(maptype2));
continue;
}
covar[j][k] +=
((double)Rast_get_d_value(ptr1, maptype) -
mu[j]) * ((double)Rast_get_d_value(ptr2,
maptype2) - mu[k]);
ptr1 = G_incr_void_ptr(ptr1, Rast_cell_size(maptype));
ptr2 = G_incr_void_ptr(ptr2, Rast_cell_size(maptype2));
}
covar[k][j] = covar[j][k];
}
}
}
return 0;
}
/*!
* \brief Get a raster category label
*
* This routine looks up category <i>rast</i> in the <i>pcats</i>
* structure and returns a pointer to a string which is the label for
* the category. A legal pointer is always returned. If the category
* does not exist in <i>pcats</i>, then a pointer to the empty string
* "" is returned.
*
* <b>Warning:</b> The pointer that is returned points to a hidden
* static buffer. Successive calls to Rast_get_c_cat() overwrite this
* buffer.
*
* \param rast cell value
* \param pcats pointer to Categories structure
* \param data_type map type (CELL, FCELL, DCELL)
*
* \return pointer to category label
* \return "" if category is not found
*/
char *Rast_get_cat(void *rast,
struct Categories *pcats, RASTER_MAP_TYPE data_type)
{
static char label[1024];
char *f, *l, *v;
CELL i;
DCELL val;
float a[2];
char fmt[30], value_str[30];
if (Rast_is_null_value(rast, data_type)) {
sprintf(label, "no data");
return label;
}
/* first search the list of labels */
*label = 0;
val = Rast_get_d_value(rast, data_type);
i = Rast_quant_get_cell_value(&pcats->q, val);
G_debug(5, "Rast_get_cat(): val %lf found i %d", val, i);
if (!Rast_is_c_null_value(&i) && i < pcats->ncats) {
if (pcats->labels[i] != NULL)
return pcats->labels[i];
return label;
}
/* generate the label */
if ((f = pcats->fmt) == NULL)
return label;
a[0] = (float)val *pcats->m1 + pcats->a1;
a[1] = (float)val *pcats->m2 + pcats->a2;
l = label;
while (*f) {
if (*f == '$') {
f++;
if (*f == '$')
*l++ = *f++;
else if (*f == '?') {
f++;
get_cond(&f, v = value_str, val);
while (*v)
*l++ = *v++;
}
else if (get_fmt(&f, fmt, &i)) {
sprintf(v = value_str, fmt, a[i]);
while (*v)
*l++ = *v++;
}
else
*l++ = '$';
}
else {
*l++ = *f++;
}
}
*l = 0;
return label;
}
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[])
{
void *raster, *ptr;
/*
char *null_row;
*/
RASTER_MAP_TYPE out_type, map_type;
char *outfile;
char null_str[80];
char cell_buf[300];
int fd;
int row, col;
int nrows, ncols, dp;
int do_stdout;
FILE *fp;
double cellsize;
struct GModule *module;
struct
{
struct Option *map;
struct Option *output;
struct Option *dp;
struct Option *null;
} parm;
struct
{
struct Flag *noheader;
struct Flag *singleline;
struct Flag *ccenter;
} flag;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("export"));
module->description =
_("Converts a raster map layer into an ESRI ARCGRID file.");
/* Define the different options */
parm.map = G_define_standard_option(G_OPT_R_INPUT);
parm.output = G_define_standard_option(G_OPT_R_OUTPUT);
parm.output->gisprompt = "new_file,file,output";
parm.output->description =
_("Name of an output ARC-GRID map (use out=- for stdout)");
parm.dp = G_define_option();
parm.dp->key = "dp";
parm.dp->type = TYPE_INTEGER;
parm.dp->required = NO;
parm.dp->answer = "8";
parm.dp->description = _("Number of decimal places");
flag.noheader = G_define_flag();
flag.noheader->key = 'h';
flag.noheader->description = _("Suppress printing of header information");
/* Added to optionally produce a single line output. -- emes -- 12.10.92 */
flag.singleline = G_define_flag();
flag.singleline->key = '1';
flag.singleline->description =
_("List one entry per line instead of full row");
/* use cell center in header instead of cell corner */
flag.ccenter = G_define_flag();
flag.ccenter->key = 'c';
flag.ccenter->description =
_("Use cell center reference in header instead of cell corner");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
sscanf(parm.dp->answer, "%d", &dp);
if (dp > 20 || dp < 0)
G_fatal_error("dp has to be from 0 to 20");
outfile = parm.output->answer;
if ((strcmp("-", outfile)) == 0)
do_stdout = 1;
else
do_stdout = 0;
sprintf(null_str, "-9999");
fd = Rast_open_old(parm.map->answer, "");
map_type = Rast_get_map_type(fd);
out_type = map_type;
/*
null_row = Rast_allocate_null_buf();
*/
raster = Rast_allocate_buf(out_type);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* open arc file for writing */
if (do_stdout)
fp = stdout;
else if (NULL == (fp = fopen(outfile, "w")))
G_fatal_error(_("Unable to open file <%s>"), outfile);
if (!flag.noheader->answer) {
struct Cell_head region;
char buf[128];
G_get_window(®ion);
fprintf(fp, "ncols %d\n", region.cols);
fprintf(fp, "nrows %d\n", region.rows);
cellsize = fabs(region.east - region.west) / region.cols;
if (G_projection() != PROJECTION_LL) { /* Is Projection != LL (3) */
if (!flag.ccenter->answer) {
G_format_easting(region.west, buf, region.proj);
fprintf(fp, "xllcorner %s\n", buf);
G_format_northing(region.south, buf, region.proj);
fprintf(fp, "yllcorner %s\n", buf);
}
else {
G_format_easting(region.west + cellsize / 2., buf, region.proj);
fprintf(fp, "xllcenter %s\n", buf);
G_format_northing(region.south + cellsize / 2., buf, region.proj);
fprintf(fp, "yllcenter %s\n", buf);
}
}
else { /* yes, lat/long */
fprintf(fp, "xllcorner %f\n", region.west);
fprintf(fp, "yllcorner %f\n", region.south);
}
fprintf(fp, "cellsize %f\n", cellsize);
fprintf(fp, "NODATA_value %s\n", null_str);
}
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Rast_get_row(fd, raster, row, out_type);
/*
Rast_get_null_value_row(fd, null_row, row);
*/
for (col = 0, ptr = raster; col < ncols; col++,
ptr = G_incr_void_ptr(ptr, Rast_cell_size(out_type))) {
if (!Rast_is_null_value(ptr, out_type)) {
if (out_type == CELL_TYPE)
fprintf(fp, "%d", *((CELL *) ptr));
else if (out_type == FCELL_TYPE) {
sprintf(cell_buf, "%.*f", dp, *((FCELL *) ptr));
G_trim_decimal(cell_buf);
fprintf(fp, "%s", cell_buf);
}
else if (out_type == DCELL_TYPE) {
sprintf(cell_buf, "%.*f", dp, *((DCELL *) ptr));
G_trim_decimal(cell_buf);
fprintf(fp, "%s", cell_buf);
}
}
else
fprintf(fp, "%s", null_str);
if (!flag.singleline->answer)
fprintf(fp, " ");
else
fprintf(fp, "\n");
}
if (!flag.singleline->answer)
fprintf(fp, "\n");
/*
for (col = 0; col < ncols; col++)
fprintf (fp,"%d ", null_row[col]);
fprintf (fp,"\n");
*/
}
/* make sure it got to 100% */
G_percent(1, 1, 2);
Rast_close(fd);
fclose(fp);
exit(EXIT_SUCCESS);
}
int zoom(struct Cell_head *window, const char *name, const char *mapset)
{
int fd;
void *raster, *rast_ptr;
RASTER_MAP_TYPE map_type;
int row, col;
int nrows, ncols;
int top, bottom, left, right, mark;
double north, south, east, west;
G_adjust_Cell_head3(window, 0, 0, 0);
Rast_set_window(window);
nrows = window->rows;
ncols = window->cols;
fd = Rast_open_old(name, mapset);
map_type = Rast_get_map_type(fd);
raster = Rast_allocate_buf(map_type);
/* find first non-null row */
top = nrows;
bottom = -1;
left = ncols;
right = -1;
for (row = 0; row < nrows; row++) {
Rast_get_row(fd, rast_ptr = raster, row, map_type);
for (col = 0; col < ncols; col++) {
if (!Rast_is_null_value(rast_ptr, map_type))
break;
rast_ptr = G_incr_void_ptr(rast_ptr, Rast_cell_size(map_type));
}
if (col == ncols)
continue;
if (row < top)
top = row;
if (row > bottom)
bottom = row;
if (col < left)
left = col;
for (mark = col; col < ncols; col++) {
if (!Rast_is_null_value(rast_ptr, map_type))
mark = col;
rast_ptr = G_incr_void_ptr(rast_ptr, Rast_cell_size(map_type));
}
if (mark > right)
right = mark;
}
Rast_close(fd);
G_free(raster);
/* no data everywhere? */
if (bottom < 0)
return 0;
north = window->north - top * window->ns_res;
south = window->north - (bottom + 1) * window->ns_res;
west = window->west + left * window->ew_res;
east = window->west + (right + 1) * window->ew_res;
window->north = north;
window->south = south;
window->east = east;
window->west = west;
return 1;
}
int main(int argc, char *argv[])
{
int i, row, col; /* counters */
unsigned long filesize;
int endianness; /* 0=little, 1=big */
int data_format; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int (ie text) */
int data_type; /* 0=numbers 1=text */
int format_block; /* combo of endianness, 0, data_format, and type */
int realflag = 0; /* 0=only real values used */
/* should type be specifically uint32 ??? */
char array_name[32]; /* variable names must start with a letter (case
sensitive) followed by letters, numbers, or
underscores. 31 chars max. */
int name_len;
int mrows, ncols; /* text/data/map array dimensions */
int val_i; /* for misc use */
float val_f; /* for misc use */
double val_d; /* for misc use */
char *infile, *outfile, *maptitle, *basename;
struct Cell_head region;
void *raster, *ptr;
RASTER_MAP_TYPE map_type;
struct Option *inputfile, *outputfile;
struct GModule *module;
int fd;
FILE *fp1;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("export"));
module->description = _("Exports a GRASS raster to a binary MAT-File.");
/* Define the different options */
inputfile = G_define_standard_option(G_OPT_R_INPUT);
outputfile = G_define_option();
outputfile->key = "output";
outputfile->type = TYPE_STRING;
outputfile->required = YES;
outputfile->gisprompt = "new_file,file,output";
outputfile->description = _("Name for the output binary MAT-File");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
infile = inputfile->answer;
basename = G_store(outputfile->answer);
G_basename(basename, "mat");
outfile = G_malloc(strlen(basename) + 5);
sprintf(outfile, "%s.mat", basename);
fd = Rast_open_old(infile, "");
map_type = Rast_get_map_type(fd);
/* open bin file for writing */
fp1 = fopen(outfile, "wb");
if (NULL == fp1)
G_fatal_error(_("Unable to open output file <%s>"), outfile);
/* Check Endian State of Host Computer */
if (G_is_little_endian())
endianness = 0; /* ie little endian */
else
endianness = 1; /* ie big endian */
G_debug(1, "Machine is %s endian.\n", endianness ? "big" : "little");
G_get_window(®ion);
/********** Write map **********/
/** write text element (map name) **/
strncpy(array_name, "map_name", 31);
mrows = 1;
ncols = strlen(infile);
data_format = 5; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int(text) */
data_type = 1; /* 0=numbers 1=text */
G_verbose_message(_("Exporting <%s>"), infile);
/* 4 byte data format */
format_block = endianness * 1000 + data_format * 10 + data_type;
fwrite(&format_block, sizeof(int), 1, fp1);
/* fprintf(stderr, "name data format is [%04ld]\n", format_block); */
/* 4 byte number of rows & columns */
fwrite(&mrows, sizeof(int), 1, fp1);
fwrite(&ncols, sizeof(int), 1, fp1);
/* 4 byte real/imag flag 0=real vals only */
fwrite(&realflag, sizeof(int), 1, fp1);
/* length of array_name+1 */
name_len = strlen(array_name) + 1;
fwrite(&name_len, sizeof(int), 1, fp1);
/* array name */
fprintf(fp1, "%s%c", array_name, '\0');
/* array data */
fprintf(fp1, "%s", infile);
/********** Write title (if there is one) **********/
maptitle = Rast_get_cell_title(infile, "");
if (strlen(maptitle) >= 1) {
/** write text element (map title) **/
strncpy(array_name, "map_title", 31);
mrows = 1;
ncols = strlen(maptitle);
data_format = 5; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int(text) */
data_type = 1; /* 0=numbers 1=text */
/* 4 byte data format */
format_block = endianness * 1000 + data_format * 10 + data_type;
fwrite(&format_block, sizeof(int), 1, fp1);
/* 4 byte number of rows & columns */
fwrite(&mrows, sizeof(int), 1, fp1);
fwrite(&ncols, sizeof(int), 1, fp1);
/* 4 byte real/imag flag 0=real vals only */
fwrite(&realflag, sizeof(int), 1, fp1);
/* length of array_name+1 */
name_len = strlen(array_name) + 1;
fwrite(&name_len, sizeof(int), 1, fp1);
/* array name */
fprintf(fp1, "%s%c", array_name, '\0');
/* array data */
fprintf(fp1, "%s", maptitle);
}
/***** Write bounds *****/
G_verbose_message("");
G_verbose_message(_("Using the Current Region settings:"));
G_verbose_message(_("northern edge=%f"), region.north);
G_verbose_message(_("southern edge=%f"), region.south);
G_verbose_message(_("eastern edge=%f"), region.east);
G_verbose_message(_("western edge=%f"), region.west);
G_verbose_message(_("nsres=%f"), region.ns_res);
G_verbose_message(_("ewres=%f"), region.ew_res);
G_verbose_message(_("rows=%d"), region.rows);
G_verbose_message(_("cols=%d"), region.cols);
G_verbose_message("");
for (i = 0; i < 4; i++) {
switch (i) {
case 0:
strncpy(array_name, "map_northern_edge", 31);
val_d = region.north;
break;
case 1:
strncpy(array_name, "map_southern_edge", 31);
val_d = region.south;
break;
case 2:
strncpy(array_name, "map_eastern_edge", 31);
val_d = region.east;
break;
case 3:
strncpy(array_name, "map_western_edge", 31);
val_d = region.west;
break;
default:
fclose(fp1);
G_fatal_error("please contact development team");
break;
}
/** write data element **/
data_format = 0; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int(text) */
data_type = 0; /* 0=numbers 1=text */
mrows = 1;
ncols = 1;
/* 4 byte data format */
format_block = endianness * 1000 + data_format * 10 + data_type;
fwrite(&format_block, sizeof(int), 1, fp1);
/* fprintf(stderr, "bounds data format is [%04ld]\n", format_block); */
/* 4 byte number of rows , 4 byte number of colums */
fwrite(&mrows, sizeof(int), 1, fp1);
fwrite(&ncols, sizeof(int), 1, fp1);
/* 4 byte real/imag flag 0=only real */
fwrite(&realflag, sizeof(int), 1, fp1);
/* length of array_name+1 */
name_len = strlen(array_name) + 1;
fwrite(&name_len, sizeof(int), 1, fp1);
/* array name */
fprintf(fp1, "%s%c", array_name, '\0');
/* write array data, by increasing column */
fwrite(&val_d, sizeof(double), 1, fp1);
/** end of data element **/
}
/***** Write map data *****/
strncpy(array_name, "map_data", 31);
switch (map_type) { /* data_format: 0=double 1=float 2=32bit signed int 5=8bit unsigned int (ie text) */
case CELL_TYPE:
data_format = 2;
G_verbose_message(_("Exporting raster as integer values"));
break;
case FCELL_TYPE:
data_format = 1;
G_verbose_message(_("Exporting raster as floating point values"));
break;
case DCELL_TYPE:
data_format = 0;
G_verbose_message(_("Exporting raster as double FP values"));
break;
default:
fclose(fp1);
G_fatal_error("Please contact development team");
break;
}
data_type = 0; /* 0=numbers 1=text */
mrows = region.rows;
ncols = region.cols;
/* 4 byte data format */
format_block = (endianness * 1000) + (data_format * 10) + data_type;
fwrite(&format_block, sizeof(int), 1, fp1);
G_debug(3, "map data format is [%04d]\n", format_block);
/* 4 byte number of rows & columns */
fwrite(&mrows, sizeof(int), 1, fp1);
fwrite(&ncols, sizeof(int), 1, fp1);
/* 4 byte real/imag flag 0=only real */
fwrite(&realflag, sizeof(int), 1, fp1);
/* length of array_name+1 */
name_len = strlen(array_name) + 1;
fwrite(&name_len, sizeof(int), 1, fp1);
/* array name */
fprintf(fp1, "%s%c", array_name, '\0');
/* data array, by increasing column */
raster =
G_calloc((Rast_window_rows() + 1) * (Rast_window_cols() + 1),
Rast_cell_size(map_type));
G_debug(1, "mem alloc is %d bytes\n", /* I think _cols()+1 is unneeded? */
Rast_cell_size(map_type) * (Rast_window_rows() +
1) * (Rast_window_cols() + 1));
G_verbose_message(_("Reading in map ... "));
/* load entire map into memory */
for (row = 0, ptr = raster; row < mrows; row++,
ptr =
G_incr_void_ptr(ptr,
(Rast_window_cols() + 1) * Rast_cell_size(map_type))) {
Rast_get_row(fd, ptr, row, map_type);
G_percent(row, mrows, 2);
}
G_percent(row, mrows, 2); /* finish it off */
G_verbose_message(_("Writing out map..."));
/* then write it to disk */
/* NoGood: fwrite(raster, Rast_cell_size(map_type), mrows*ncols, fp1); */
for (col = 0; col < ncols; col++) {
for (row = 0; row < mrows; row++) {
ptr = raster;
ptr =
G_incr_void_ptr(ptr,
(col +
row * (ncols +
1)) * Rast_cell_size(map_type));
if (!Rast_is_null_value(ptr, map_type)) {
if (map_type == CELL_TYPE) {
val_i = *((CELL *) ptr);
fwrite(&val_i, sizeof(int), 1, fp1);
}
else if (map_type == FCELL_TYPE) {
val_f = *((FCELL *) ptr);
fwrite(&val_f, sizeof(float), 1, fp1);
}
else if (map_type == DCELL_TYPE) {
val_d = *((DCELL *) ptr);
fwrite(&val_d, sizeof(double), 1, fp1);
}
}
else { /* ie if NULL cell -> write IEEE NaN value */
if (map_type == CELL_TYPE) {
val_i = *((CELL *) ptr); /* int has no NaN value, so use whatever GRASS uses */
fwrite(&val_i, sizeof(int), 1, fp1);
}
else if (map_type == FCELL_TYPE) {
if (endianness) /* ie big */
fprintf(fp1, "%c%c%c%c", 0xff, 0xf8, 0, 0);
else /* ie little */
fprintf(fp1, "%c%c%c%c", 0, 0, 0xf8, 0xff);
}
else if (map_type == DCELL_TYPE) {
if (endianness)
fprintf(fp1, "%c%c%c%c%c%c%c%c", 0xff, 0xf8, 0, 0, 0,
0, 0, 0);
else
fprintf(fp1, "%c%c%c%c%c%c%c%c", 0, 0, 0, 0, 0, 0,
0xf8, 0xff);
}
}
}
G_percent(col, ncols, 2);
}
G_percent(col, ncols, 2); /* finish it off */
/*** end of data element ***/
/* done! */
filesize = G_ftell(fp1);
fclose(fp1);
G_verbose_message(_("%ld bytes written to '%s'"), filesize, outfile);
G_done_msg("");
G_free(basename);
G_free(outfile);
exit(EXIT_SUCCESS);
}
int patch_density(int fd, char **par, area_des ad, double *result)
{
CELL *buf, *sup;
int count = 0, i, j, connected = 0, complete_line = 1, other_above = 0;
double area;
struct Cell_head hd;
CELL complete_value;
double EW_DIST1, EW_DIST2, NS_DIST1, NS_DIST2;
int mask_fd = -1, *mask_buf, *mask_sup, null_count = 0;
Rast_set_c_null_value(&complete_value, 1);
Rast_get_cellhd(ad->raster, "", &hd);
sup = Rast_allocate_c_buf();
/* open mask if needed */
if (ad->mask == 1) {
if ((mask_fd = open(ad->mask_name, O_RDONLY, 0755)) < 0)
return 0;
mask_buf = malloc(ad->cl * sizeof(int));
mask_sup = malloc(ad->cl * sizeof(int));
}
/*calculate distance */
G_begin_distance_calculations();
/* EW Dist at North edge */
EW_DIST1 = G_distance(hd.east, hd.north, hd.west, hd.north);
/* EW Dist at South Edge */
EW_DIST2 = G_distance(hd.east, hd.south, hd.west, hd.south);
/* NS Dist at East edge */
NS_DIST1 = G_distance(hd.east, hd.north, hd.east, hd.south);
/* NS Dist at West edge */
NS_DIST2 = G_distance(hd.west, hd.north, hd.west, hd.south);
/*calculate number of patch */
for (i = 0; i < ad->rl; i++) {
buf = RLI_get_cell_raster_row(fd, i + ad->y, ad);
if (i > 0) {
sup = RLI_get_cell_raster_row(fd, i - 1 + ad->y, ad);
}
/* mask values */
if (ad->mask == 1) {
int k;
if (i > 0) {
int *tmp;
tmp = mask_sup;
mask_buf = mask_sup;
}
if (read(mask_fd, mask_buf, (ad->cl * sizeof(int))) < 0)
return 0;
for (k = 0; k < ad->cl; k++) {
if (mask_buf[k] == 0) {
Rast_set_c_null_value(mask_buf + k, 1);
null_count++;
}
}
}
if (complete_line) {
if (!Rast_is_null_value(&(buf[ad->x]), CELL_TYPE) &&
buf[ad->x] != complete_value)
count++;
for (j = 0; j < ad->cl - 1; j++) {
if (buf[j + ad->x] != buf[j + 1 + ad->x]) {
complete_line = 0;
if (!Rast_is_null_value(&(buf[j + 1 + ad->x]), CELL_TYPE)
&& buf[j + 1 + ad->x] != complete_value)
count++;
}
}
if (complete_line) {
complete_value = buf[ad->x];
}
}
else {
complete_line = 1;
connected = 0;
other_above = 0;
for (j = 0; j < ad->cl; j++) {
if (sup[j + ad->x] == buf[j + ad->x]) {
connected = 1;
if (other_above) {
other_above = 0;
count--;
}
}
else {
if (connected &&
!Rast_is_null_value(&(buf[j + ad->x]), CELL_TYPE))
other_above = 1;
}
if (j < ad->cl - 1 && buf[j + ad->x] != buf[j + 1 + ad->x]) {
complete_line = 0;
if (!connected &&
!Rast_is_null_value(&(buf[j + ad->x]), CELL_TYPE)) {
count++;
connected = 0;
other_above = 0;
}
else {
connected = 0;
other_above = 0;
}
}
}
if (!connected &&
sup[ad->cl - 1 + ad->x] != buf[ad->cl - 1 + ad->x]) {
if (!Rast_is_null_value
(&(buf[ad->cl - 1 + ad->x]), CELL_TYPE)) {
count++;
complete_line = 0;
}
}
if (complete_line)
complete_value = buf[ad->x];
}
}
area = (((EW_DIST1 + EW_DIST2) / 2) / hd.cols) *
(((NS_DIST1 + NS_DIST2) / 2) / hd.rows) *
(ad->rl * ad->cl - null_count);
if (area != 0)
*result = (count / area) * 1000000;
else
*result = -1;
G_free(sup);
return RLI_OK;
}
