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;
}
/*!
* \brief Writes the null value to the N_array_2d struct at position col, row
*
* The null value will be automatically set to the array data type (CELL, FCELL or DCELL).
*
* \param data N_array_2d *
* \param col int
* \param row int
* \return void
* */
void N_put_array_2d_value_null(N_array_2d * data, int col, int row)
{
G_debug(6,
"N_put_array_2d_value_null: put null value to array pos [%i][%i]",
col, row);
if (data->offset == 0) {
if (data->type == CELL_TYPE && data->cell_array != NULL) {
Rast_set_c_null_value((void *)
&(data->
cell_array[row * data->cols_intern + col]),
1);
}
else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
Rast_set_f_null_value((void *)
&(data->
fcell_array[row * data->cols_intern + col]),
1);
}
else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
Rast_set_d_null_value((void *)
&(data->
dcell_array[row * data->cols_intern + col]),
1);
}
}
else {
if (data->type == CELL_TYPE && data->cell_array != NULL) {
Rast_set_c_null_value((void *)
&(data->
cell_array[(row +
data->offset) *
data->cols_intern + col +
data->offset]), 1);
}
else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
Rast_set_f_null_value((void *)
&(data->
fcell_array[(row +
data->offset) *
data->cols_intern + col +
data->offset]), 1);
}
else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
Rast_set_d_null_value((void *)
&(data->
dcell_array[(row +
data->offset) *
data->cols_intern + col +
data->offset]), 1);
}
}
return;
}
static int input_data(struct interp_params *params,
int first_row, int last_row,
struct fcell_triple *points,
int fdsmooth, int fdinp,
int inp_rows, int inp_cols,
double zmin, double inp_ns_res, double inp_ew_res)
{
double x, y, sm; /* input data and smoothing */
int m1, m2; /* loop counters */
static FCELL *cellinp = NULL; /* cell buffer for input data */
static FCELL *cellsmooth = NULL; /* cell buffer for smoothing */
if (!cellinp)
cellinp = Rast_allocate_f_buf();
if (!cellsmooth)
cellsmooth = Rast_allocate_f_buf();
for (m1 = 0; m1 <= last_row - first_row; m1++) {
Rast_get_f_row(fdinp, cellinp, inp_rows - m1 - first_row);
if (fdsmooth >= 0)
Rast_get_f_row(fdsmooth, cellsmooth, inp_rows - m1 - first_row);
y = params->y_orig + (m1 + first_row - 1 + 0.5) * inp_ns_res;
for (m2 = 0; m2 < inp_cols; m2++) {
x = params->x_orig + (m2 + 0.5) * inp_ew_res;
/*
* z = cellinp[m2]*params->zmult;
*/
if (fdsmooth >= 0)
sm = (double)cellsmooth[m2];
else
sm = 0.01;
points[m1 * inp_cols + m2].x = x - params->x_orig;
points[m1 * inp_cols + m2].y = y - params->y_orig;
if (!Rast_is_f_null_value(cellinp + m2)) {
points[m1 * inp_cols + m2].z =
cellinp[m2] * params->zmult - zmin;
}
else {
Rast_set_f_null_value(&(points[m1 * inp_cols + m2].z), 1);
}
/* fprintf (stdout,"sm: %f\n",sm); */
points[m1 * inp_cols + m2].smooth = sm;
}
}
return 1;
}
static void set_to_null(struct RASTER_MAP_PTR *buf, int col)
{
switch (buf->type) {
case CELL_TYPE:
Rast_set_c_null_value(&(buf->data.c[col]), 1);
break;
case FCELL_TYPE:
Rast_set_f_null_value(&(buf->data.f[col]), 1);
break;
case DCELL_TYPE:
Rast_set_d_null_value(&(buf->data.d[col]), 1);
break;
}
}
static void convert_and_write_df(int fd, const void *vbuf)
{
const DCELL *buf = vbuf;
struct fileinfo *fcb = &R__.fileinfo[fd];
FCELL *p = (FCELL *) fcb->data;
int i;
for (i = 0; i < fcb->cellhd.cols; i++)
if (Rast_is_d_null_value(&buf[i]))
Rast_set_f_null_value(&p[i], 1);
else
p[i] = (FCELL) buf[i];
Rast_put_f_row(fd, p);
}
/* Saves map file from 2d array. NULL must be 0. Also meanwhile calculates area and volume. */
void save_map(FCELL ** out, int out_fd, int rows, int cols, int flag,
FCELL * min_depth, FCELL * max_depth, double *area,
double *volume)
{
int row, col;
double cellsize = -1;
G_debug(1, "Saving new map");
if (G_begin_cell_area_calculations() == 0 || G_begin_cell_area_calculations() == 1) { /* All cells have constant size... */
cellsize = G_area_of_cell_at_row(0);
}
G_debug(1, "Cell area: %f", cellsize);
for (row = 0; row < rows; row++) {
if (cellsize == -1) /* Get LatLon current rows cell size */
cellsize = G_area_of_cell_at_row(row);
for (col = 0; col < cols; col++) {
if (flag == 1) /* Create negative map */
out[row][col] = 0 - out[row][col];
if (out[row][col] == 0) {
Rast_set_f_null_value(&out[row][col], 1);
}
if (out[row][col] > 0 || out[row][col] < 0) {
G_debug(5, "volume %f += cellsize %f * value %f [%d,%d]",
*volume, cellsize, out[row][col], row, col);
*area += cellsize;
*volume += cellsize * out[row][col];
}
/* Get min/max depth. Can be usefull ;) */
if (out[row][col] > *max_depth)
*max_depth = out[row][col];
if (out[row][col] < *min_depth)
*min_depth = out[row][col];
}
Rast_put_f_row(out_fd, out[row]);
G_percent(row + 1, rows, 5);
}
}
static void write_row_float(png_bytep p)
{
unsigned int x, c;
channel *ch;
for (x = 0; x < width; x++)
for (c = 0; c < 6; c++)
{
ch = &channels[c];
if (ch->active)
ch->fbuf[x] = (FCELL) get_png_val(&p, bit_depth)
/ ch->maxval;
}
if (t_gamma != 1.0)
for (c = 0; c < 6; c++)
{
ch = &channels[c];
if (c != C_A && ch->active)
for (x = 0; x < width; x++)
ch->fbuf[x] = gamma_correct(ch->fbuf[x]);
}
if (channels[C_A].active && ialpha > 0)
for (c = 0; c < 6; c++)
{
ch = &channels[c];
if (c != C_A && ch->active)
for (x = 0; x < width; x++)
if (channels[C_A].fbuf[x] <= alpha)
Rast_set_f_null_value(&ch->fbuf[x], 1);
}
for (c = 0; c < 6; c++)
{
ch = &channels[c];
if (ch->active)
Rast_put_f_row(ch->fd, ch->fbuf);
}
}
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 calculateF(int fd, struct area_entry *ad, double *result)
{
FCELL *buf, *buf_sup, *buf_null;
FCELL corrCell, precCell, supCell;
long npatch, area;
long pid, old_pid, new_pid, *pid_corr, *pid_sup, *ltmp;
struct pst *pst;
long nalloc, incr;
int i, j, k;
int connected;
int mask_fd, *mask_buf, *mask_sup, *mask_tmp, masked;
struct Cell_head hd;
Rast_get_window(&hd);
buf_null = Rast_allocate_f_buf();
Rast_set_f_null_value(buf_null, Rast_window_cols());
buf_sup = buf_null;
/* initialize patch ids */
pid_corr = G_malloc(Rast_window_cols() * sizeof(long));
pid_sup = G_malloc(Rast_window_cols() * sizeof(long));
for (j = 0; j < Rast_window_cols(); j++) {
pid_corr[j] = 0;
pid_sup[j] = 0;
}
/* open mask if needed */
mask_fd = -1;
mask_buf = mask_sup = NULL;
masked = FALSE;
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;
}
mask_sup = G_malloc(ad->cl * sizeof(int));
if (mask_sup == NULL) {
G_fatal_error("malloc mask_buf failed");
return RLI_ERRORE;
}
for (j = 0; j < ad->cl; j++)
mask_buf[j] = 0;
masked = TRUE;
}
/* calculate number of patches */
npatch = 0;
area = 0;
pid = 0;
/* patch size and type */
incr = 1024;
if (incr > ad->rl)
incr = ad->rl;
if (incr > ad->cl)
incr = ad->cl;
if (incr < 2)
incr = 2;
nalloc = incr;
pst = G_malloc(nalloc * sizeof(struct pst));
for (k = 0; k < nalloc; k++) {
pst[k].count = 0;
}
for (i = 0; i < ad->rl; i++) {
buf = RLI_get_fcell_raster_row(fd, i + ad->y, ad);
if (i > 0) {
buf_sup = RLI_get_fcell_raster_row(fd, i - 1 + ad->y, ad);
}
if (masked) {
mask_tmp = mask_sup;
mask_sup = mask_buf;
mask_buf = mask_tmp;
if (read(mask_fd, mask_buf, (ad->cl * sizeof(int))) < 0)
return 0;
}
ltmp = pid_sup;
pid_sup = pid_corr;
pid_corr = ltmp;
Rast_set_f_null_value(&precCell, 1);
connected = 0;
for (j = 0; j < ad->cl; j++) {
pid_corr[j + ad->x] = 0;
corrCell = buf[j + ad->x];
if (masked && (mask_buf[j] == 0)) {
Rast_set_f_null_value(&corrCell, 1);
}
if (Rast_is_f_null_value(&corrCell)) {
connected = 0;
precCell = corrCell;
continue;
}
area++;
supCell = buf_sup[j + ad->x];
if (masked && (mask_sup[j] == 0)) {
Rast_set_f_null_value(&supCell, 1);
}
if (!Rast_is_f_null_value(&precCell) && corrCell == precCell) {
pid_corr[j + ad->x] = pid_corr[j - 1 + ad->x];
connected = 1;
pst[pid_corr[j + ad->x]].count++;
}
else {
connected = 0;
}
if (!Rast_is_f_null_value(&supCell) && corrCell == supCell) {
if (pid_corr[j + ad->x] != pid_sup[j + ad->x]) {
/* connect or merge */
/* after r.clump */
if (connected) {
npatch--;
if (npatch == 0) {
G_fatal_error("npatch == 0 at row %d, col %d", i, j);
}
}
old_pid = pid_corr[j + ad->x];
new_pid = pid_sup[j + ad->x];
pid_corr[j + ad->x] = new_pid;
if (old_pid > 0) {
/* merge */
/* update left side of the current row */
for (k = 0; k < j; k++) {
if (pid_corr[k + ad->x] == old_pid)
pid_corr[k + ad->x] = new_pid;
}
/* update right side of the previous row */
for (k = j + 1; k < ad->cl; k++) {
if (pid_sup[k + ad->x] == old_pid)
pid_sup[k + ad->x] = new_pid;
}
pst[new_pid].count += pst[old_pid].count;
pst[old_pid].count = 0;
if (old_pid == pid)
pid--;
}
else {
pst[new_pid].count++;
}
}
connected = 1;
}
if (!connected) {
/* start new patch */
npatch++;
pid++;
pid_corr[j + ad->x] = pid;
if (pid >= nalloc) {
pst = (struct pst *)G_realloc(pst, (pid + incr) * sizeof(struct pst));
for (k = nalloc; k < pid + incr; k++)
pst[k].count = 0;
nalloc = pid + incr;
}
pst[pid].count = 1;
pst[pid].type.t = CELL_TYPE;
pst[pid].type.val.c = corrCell;
}
precCell = corrCell;
}
}
if (npatch > 0) {
double EW_DIST1, EW_DIST2, NS_DIST1, NS_DIST2;
double area_p;
double cell_size_m;
double min, max;
/* 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);
cell_size_m = (((EW_DIST1 + EW_DIST2) / 2) / hd.cols) *
(((NS_DIST1 + NS_DIST2) / 2) / hd.rows);
/* get min and max patch size */
min = 1.0 / 0.0; /* inf */
max = -1.0 / 0.0; /* -inf */
for (old_pid = 1; old_pid <= pid; old_pid++) {
if (pst[old_pid].count > 0) {
area_p = cell_size_m * pst[old_pid].count / 10000;
if (min > area_p)
min = area_p;
if (max < area_p)
max = area_p;
}
}
*result = max - min;
}
else
Rast_set_d_null_value(result, 1);
if (masked) {
close(mask_fd);
G_free(mask_buf);
G_free(mask_sup);
}
G_free(buf_null);
G_free(pid_corr);
G_free(pid_sup);
G_free(pst);
return RLI_OK;
}
int main( int argc, char **argv )
{
char *name = nullptr;
struct Option *map;
struct Cell_head window;
G_gisinit( argv[0] );
G_define_module();
map = G_define_standard_option( G_OPT_R_OUTPUT );
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
name = map->answer;
#ifdef Q_OS_WIN
_setmode( _fileno( stdin ), _O_BINARY );
_setmode( _fileno( stdout ), _O_BINARY );
//setvbuf( stdin, NULL, _IONBF, BUFSIZ );
// setting _IONBF on stdout works on windows correctly, data written immediately even without fflush(stdout)
//setvbuf( stdout, NULL, _IONBF, BUFSIZ );
#endif
QgsGrassDataFile stdinFile;
stdinFile.open( stdin );
QDataStream stdinStream( &stdinFile );
QFile stdoutFile;
stdoutFile.open( stdout, QIODevice::WriteOnly | QIODevice::Unbuffered );
QDataStream stdoutStream( &stdoutFile );
qint32 proj, zone;
stdinStream >> proj >> zone;
QgsRectangle extent;
qint32 rows, cols;
stdinStream >> extent >> cols >> rows;
checkStream( stdinStream );
QString err = QgsGrass::setRegion( &window, extent, rows, cols );
if ( !err.isEmpty() )
{
G_fatal_error( "Cannot set region: %s", err.toUtf8().constData() );
}
window.proj = ( int ) proj;
window.zone = ( int ) zone;
G_set_window( &window );
Qgis::DataType qgis_type;
qint32 type;
stdinStream >> type;
checkStream( stdinStream );
qgis_type = ( Qgis::DataType )type;
RASTER_MAP_TYPE grass_type;
switch ( qgis_type )
{
case Qgis::Int32:
grass_type = CELL_TYPE;
break;
case Qgis::Float32:
grass_type = FCELL_TYPE;
break;
case Qgis::Float64:
grass_type = DCELL_TYPE;
break;
default:
G_fatal_error( "QGIS data type %d not supported", qgis_type );
return 1;
}
cf = Rast_open_new( name, grass_type );
if ( cf < 0 )
{
G_fatal_error( "Unable to create raster map <%s>", name );
return 1;
}
void *buf = Rast_allocate_buf( grass_type );
int expectedSize = cols * QgsRasterBlock::typeSize( qgis_type );
bool isCanceled = false;
QByteArray byteArray;
for ( int row = 0; row < rows; row++ )
{
stdinStream >> isCanceled;
checkStream( stdinStream );
if ( isCanceled )
{
break;
}
double noDataValue;
stdinStream >> noDataValue;
stdinStream >> byteArray;
checkStream( stdinStream );
if ( byteArray.size() != expectedSize )
{
G_fatal_error( "Wrong byte array size, expected %d bytes, got %d, row %d / %d", expectedSize, byteArray.size(), row, rows );
return 1;
}
qint32 *cell = nullptr;
float *fcell = nullptr;
double *dcell = nullptr;
if ( grass_type == CELL_TYPE )
cell = ( qint32 * ) byteArray.data();
else if ( grass_type == FCELL_TYPE )
fcell = ( float * ) byteArray.data();
else if ( grass_type == DCELL_TYPE )
dcell = ( double * ) byteArray.data();
void *ptr = buf;
for ( int col = 0; col < cols; col++ )
{
if ( grass_type == CELL_TYPE )
{
if ( ( CELL )cell[col] == ( CELL )noDataValue )
{
Rast_set_c_null_value( ( CELL * )ptr, 1 );
}
else
{
Rast_set_c_value( ptr, ( CELL )( cell[col] ), grass_type );
}
}
else if ( grass_type == FCELL_TYPE )
{
if ( ( FCELL )fcell[col] == ( FCELL )noDataValue )
{
Rast_set_f_null_value( ( FCELL * )ptr, 1 );
}
else
{
Rast_set_f_value( ptr, ( FCELL )( fcell[col] ), grass_type );
}
}
else if ( grass_type == DCELL_TYPE )
{
if ( ( DCELL )dcell[col] == ( DCELL )noDataValue )
{
Rast_set_d_null_value( ( DCELL * )ptr, 1 );
}
else
{
Rast_set_d_value( ptr, ( DCELL )dcell[col], grass_type );
}
}
ptr = G_incr_void_ptr( ptr, Rast_cell_size( grass_type ) );
}
Rast_put_row( cf, buf, grass_type );
#ifndef Q_OS_WIN
// Because stdin is somewhere buffered on Windows (not clear if in QProcess or by Windows)
// we cannot in QgsGrassImport wait for this because it hangs. Setting _IONBF on stdin does not help
// and there is no flush() on QProcess.
// OTOH, smaller stdin buffer is probably blocking QgsGrassImport so that the import can be canceled immediately.
stdoutStream << ( bool )true; // row written
stdoutFile.flush();
#endif
}
if ( isCanceled )
{
Rast_unopen( cf );
}
else
{
Rast_close( cf );
struct History history;
Rast_short_history( name, "raster", &history );
Rast_command_history( &history );
Rast_write_history( name, &history );
}
exit( EXIT_SUCCESS );
}
/* Process the raster and do atmospheric corrections.
Params:
* INPUT FILE
ifd: input file descriptor
iref: input file has radiance values (default is reflectance) ?
iscale: input file's range (default is min = 0, max = 255)
ialt_fd: height map file descriptor, negative if global value is used
ivis_fd: visibility map file descriptor, negative if global value is used
* OUTPUT FILE
ofd: output file descriptor
oflt: if true use FCELL_TYPE for output
oscale: output file's range (default is min = 0, max = 255)
*/
static void process_raster(int ifd, InputMask imask, ScaleRange iscale,
int ialt_fd, int ivis_fd, int ofd, bool oint,
ScaleRange oscale)
{
FCELL *buf; /* buffer for the input values */
FCELL *alt = NULL; /* buffer for the elevation values */
FCELL *vis = NULL; /* buffer for the visibility values */
FCELL prev_alt = -1.f;
FCELL prev_vis = -1.f;
int row, col, nrows, ncols;
/* switch on optimization automatically if elevation and/or visibility map is given */
bool optimize = (ialt_fd >= 0 || ivis_fd >= 0);
#ifdef _NO_OPTIMIZE_
optimize = false;
#endif
/* do initial computation with global elevation and visibility values */
TransformInput ti;
ti = compute();
/* use a cache to increase computation speed when an elevation map
* and/or a visibility map is given */
TICache ticache;
/* allocate memory for buffers */
buf = (FCELL *) Rast_allocate_buf(FCELL_TYPE);
if (ialt_fd >= 0)
alt = (FCELL *) Rast_allocate_buf(FCELL_TYPE);
if (ivis_fd >= 0)
vis = (FCELL *) Rast_allocate_buf(FCELL_TYPE);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 1); /* keep the user informed of our progress */
/* read the next row */
Rast_get_row(ifd, buf, row, FCELL_TYPE);
/* read the next row of elevation values */
if (ialt_fd >= 0)
Rast_get_row(ialt_fd, alt, row, FCELL_TYPE);
/* read the next row of elevation values */
if (ivis_fd >= 0)
Rast_get_row(ivis_fd, vis, row, FCELL_TYPE);
/* loop over all the values in the row */
for (col = 0; col < ncols; col++) {
if ((vis && Rast_is_f_null_value(&vis[col])) ||
(alt && Rast_is_f_null_value(&alt[col])) ||
Rast_is_f_null_value(&buf[col])) {
Rast_set_f_null_value(&buf[col], 1);
continue;
}
if (ialt_fd >= 0) {
if (alt[col] < 0)
alt[col] = 0; /* on or below sea level, all the same for 6S */
else
alt[col] /= 1000.0f; /* converting to km from input which should be in meter */
/* round to nearest altitude bin */
/* rounding result: watch out for fp representation error */
alt[col] = ((int) (alt[col] * BIN_ALT + 0.5)) / BIN_ALT;
}
if (ivis_fd >= 0) {
if (vis[col] < 0)
vis[col] = 0; /* negative visibility is invalid, print a WARNING ? */
/* round to nearest visibility bin */
/* rounding result: watch out for fp representation error */
vis[col] = ((int) (vis[col] + 0.5));
}
/* check if both maps are active and if whether any value has changed */
if ((ialt_fd >= 0) && (ivis_fd >= 0) &&
((prev_vis != vis[col]) || (prev_alt != alt[col]))) {
prev_alt = alt[col]; /* update new values */
prev_vis = vis[col];
if (optimize) {
int in_cache = ticache.search(alt[col], vis[col], &ti);
if (!in_cache) {
pre_compute_hv(alt[col], vis[col]); /* re-compute transformation inputs */
ti = compute(); /* ... */
ticache.add(ti, alt[col], vis[col]);
}
}
else {
pre_compute_hv(alt[col], vis[col]); /* re-compute transformation inputs */
ti = compute(); /* ... */
}
}
else { /* only one of the maps is being used */
if ((ivis_fd >= 0) && (prev_vis != vis[col])) {
prev_vis = vis[col]; /* keep track of previous visibility */
if (optimize) {
int in_cache = ticache.search(0, vis[col], &ti);
if (!in_cache) {
pre_compute_v(vis[col]); /* re-compute transformation inputs */
ti = compute(); /* ... */
ticache.add(ti, 0, vis[col]);
}
}
else {
pre_compute_v(vis[col]); /* re-compute transformation inputs */
ti = compute(); /* ... */
}
}
if ((ialt_fd >= 0) && (prev_alt != alt[col])) {
prev_alt = alt[col]; /* keep track of previous altitude */
if (optimize) {
int in_cache = ticache.search(alt[col], 0, &ti);
if (!in_cache) {
pre_compute_h(alt[col]); /* re-compute transformation inputs */
ti = compute(); /* ... */
ticache.add(ti, alt[col], 0);
}
}
else {
pre_compute_h(alt[col]); /* re-compute transformation inputs */
ti = compute(); /* ... */
}
}
}
G_debug(3, "Computed r%d (%d), c%d (%d)", row, nrows, col, ncols);
/* transform from iscale.[min,max] to [0,1] */
buf[col] =
(buf[col] - iscale.min) / ((float)iscale.max -
(float)iscale.min);
buf[col] = transform(ti, imask, buf[col]);
/* transform from [0,1] to oscale.[min,max] */
buf[col] =
buf[col] * ((float)oscale.max - (float)oscale.min) +
oscale.min;
if (oint && (buf[col] > (float)oscale.max))
G_warning(_("The output data will overflow. Reflectance > 100%%"));
}
/* write output */
if (oint)
write_fp_to_cell(ofd, buf);
else
Rast_put_row(ofd, buf, FCELL_TYPE);
}
G_percent(1, 1, 1);
/* free allocated memory */
G_free(buf);
if (ialt_fd >= 0)
G_free(alt);
if (ivis_fd >= 0)
G_free(vis);
}
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)
{
IO rasters[] = { /* rasters stores output buffers */
{"dem",YES,"Input dem","input",UNKNOWN,-1,NULL}, /* WARNING: this one map is input */
{"forms",NO,"Most common geomorphic forms","patterns",CELL_TYPE,-1,NULL},
{"ternary",NO,"code of ternary patterns","patterns",CELL_TYPE,-1,NULL},
{"positive",NO,"code of binary positive patterns","patterns",CELL_TYPE,-1,NULL},
{"negative",NO,"code of binary negative patterns","patterns",CELL_TYPE,-1,NULL},
{"intensity",NO,"rasters containing mean relative elevation of the form","geometry",FCELL_TYPE,-1,NULL},
{"exposition",NO,"rasters containing maximum difference between extend and central cell","geometry",FCELL_TYPE,-1,NULL},
{"range",NO,"rasters containing difference between max and min elevation of the form extend","geometry",FCELL_TYPE,-1,NULL},
{"variance",NO,"rasters containing variance of form boundary","geometry",FCELL_TYPE,-1,NULL},
{"elongation",NO,"rasters containing local elongation","geometry",FCELL_TYPE,-1,NULL},
{"azimuth",NO,"rasters containing local azimuth of the elongation","geometry",FCELL_TYPE,-1,NULL},
{"extend",NO,"rasters containing local extend (area) of the form","geometry",FCELL_TYPE,-1,NULL},
{"width",NO,"rasters containing local width of the form","geometry",FCELL_TYPE,-1,NULL}
}; /* adding more maps change IOSIZE macro */
CATCOLORS ccolors[CNT]={ /* colors and cats for forms */
{ZERO, 0, 0, 0, "forms"},
{FL, 220, 220, 220, "flat"},
{PK, 56, 0, 0, "summit"},
{RI, 200, 0, 0, "ridge"},
{SH, 255, 80, 20, "shoulder"},
{CV, 250, 210, 60, "spur"},
{SL, 255, 255, 60, "slope"},
{CN, 180, 230, 20, "hollow"},
{FS, 60, 250, 150, "footslope"},
{VL, 0, 0, 255, "valley"},
{PT, 0, 0, 56, "depression"},
{__, 255, 0, 255, "ERROR"}};
struct GModule *module;
struct Option
*opt_input,
*opt_output[io_size],
*par_search_radius,
*par_skip_radius,
*par_flat_treshold,
*par_flat_distance;
struct Flag *flag_units,
*flag_extended;
struct History history;
int i,j, n;
int meters=0, multires=0, extended=0; /* flags */
int row,cur_row,col,radius;
int pattern_size;
double max_resolution;
char prefix[20];
G_gisinit(argv[0]);
{ /* interface parameters */
module = G_define_module();
module->description =
_("Calculate geomorphons (terrain forms)and associated geometry using machine vision approach");
G_add_keyword("Geomorphons");
G_add_keyword("Terrain patterns");
G_add_keyword("Machine vision geomorphometry");
opt_input = G_define_standard_option(G_OPT_R_INPUT);
opt_input->key = rasters[0].name;
opt_input->required = rasters[0].required;
opt_input->description = _(rasters[0].description);
for (i=1;i<io_size;++i) { /* WARNING: loop starts from one, zero is for input */
opt_output[i] = G_define_standard_option(G_OPT_R_OUTPUT);
opt_output[i]->key = rasters[i].name;
opt_output[i]->required = NO;
opt_output[i]->description = _(rasters[i].description);
opt_output[i]->guisection = _(rasters[i].gui);
}
par_search_radius = G_define_option();
par_search_radius->key = "search";
par_search_radius->type = TYPE_INTEGER;
par_search_radius->answer = "3";
par_search_radius->required = YES;
par_search_radius->description = _("Outer search radius");
par_skip_radius = G_define_option();
par_skip_radius->key = "skip";
par_skip_radius->type = TYPE_INTEGER;
par_skip_radius->answer = "0";
par_skip_radius->required = YES;
par_skip_radius->description = _("Inner search radius");
par_flat_treshold = G_define_option();
par_flat_treshold->key = "flat";
par_flat_treshold->type = TYPE_DOUBLE;
par_flat_treshold->answer = "1";
par_flat_treshold->required = YES;
par_flat_treshold->description = _("Flatenss treshold (degrees)");
par_flat_distance = G_define_option();
par_flat_distance->key = "dist";
par_flat_distance->type = TYPE_DOUBLE;
par_flat_distance->answer = "0";
par_flat_distance->required = YES;
par_flat_distance->description = _("Flatenss distance, zero for none");
flag_units = G_define_flag();
flag_units->key = 'm';
flag_units->description = _("Use meters to define search units (default is cells)");
flag_extended = G_define_flag();
flag_extended->key = 'e';
flag_extended->description = _("Use extended form correction");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
}
{ /* calculate parameters */
int num_outputs=0;
double search_radius, skip_radius, start_radius, step_radius;
double ns_resolution;
for (i=1;i<io_size;++i) /* check for outputs */
if(opt_output[i]->answer) {
if (G_legal_filename(opt_output[i]->answer) < 0)
G_fatal_error(_("<%s> is an illegal file name"), opt_output[i]->answer);
num_outputs++;
}
if(!num_outputs && !multires)
G_fatal_error(_("At least one output is required"));
meters=(flag_units->answer != 0);
extended=(flag_extended->answer != 0);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
Rast_get_window(&window);
G_begin_distance_calculations();
if(G_projection()==PROJECTION_LL) { /* for LL max_res should be NS */
ns_resolution=G_distance(0,Rast_row_to_northing(0, &window),0,Rast_row_to_northing(1, &window));
max_resolution=ns_resolution;
} else {
max_resolution=MAX(window.ns_res,window.ew_res); /* max_resolution MORE meters per cell */
}
G_message("NSRES, %f", ns_resolution);
cell_res=max_resolution; /* this parameter is global */
/* search distance */
search_radius=atof(par_search_radius->answer);
search_cells=meters?(int)(search_radius/max_resolution):search_radius;
if(search_cells<1)
G_fatal_error(_("Search radius size must cover at least 1 cell"));
row_radius_size=meters?ceil(search_radius/max_resolution):search_radius;
row_buffer_size=row_radius_size*2+1;
search_distance=(meters)?search_radius:max_resolution*search_cells;
/* skip distance */
skip_radius=atof(par_skip_radius->answer);
skip_cells=meters?(int)(skip_radius/max_resolution):skip_radius;
if(skip_cells>=search_cells)
G_fatal_error(_("Skip radius size must be at least 1 cell lower than radius"));
skip_distance=(meters)?skip_radius:ns_resolution*skip_cells;
/* flatness parameters */
flat_threshold=atof(par_flat_treshold->answer);
if(flat_threshold<=0.)
G_fatal_error(_("Flatenss treshold must be grater than 0"));
flat_threshold=DEGREE2RAD(flat_threshold);
flat_distance=atof(par_flat_distance->answer);
flat_distance=(meters)?flat_distance:ns_resolution*flat_distance;
flat_threshold_height=tan(flat_threshold)*flat_distance;
if((flat_distance>0&&flat_distance<=skip_distance)||flat_distance>=search_distance) {
G_warning(_("Flatenss distance should be between skip and search radius. Otherwise ignored"));
flat_distance=0;
}
if (search_distance<10*cell_res)
extended=0;
/* print information about distances */
G_message("Search distance m: %f, cells: %d", search_distance, search_cells);
G_message("Skip distance m: %f, cells: %d", skip_distance, skip_cells);
G_message("Flat threshold distance m: %f, height: %f",flat_distance, flat_threshold_height);
G_message("%s version",(extended)?"extended":"basic");
}
/* generate global ternary codes */
for(i=0;i<6561;++i)
global_ternary_codes[i]=ternary_rotate(i);
/* open DEM */
strcpy(elevation.elevname,opt_input->answer);
open_map(&elevation);
PATTERN* pattern;
PATTERN patterns[4];
void* pointer_buf;
int formA, formB, formC;
double search_dist=search_distance;
double skip_dist=skip_distance;
double flat_dist=flat_distance;
double area_of_octagon=4*(search_distance*search_distance)*sin(DEGREE2RAD(45.));
cell_step=1;
/* prepare outputs */
for (i=1;i<io_size;++i)
if(opt_output[i]->answer) {
rasters[i].fd=Rast_open_new(opt_output[i]->answer,rasters[i].out_data_type);
rasters[i].buffer=Rast_allocate_buf(rasters[i].out_data_type);
}
/* main loop */
for(row=0;row<nrows;++row) {
G_percent(row, nrows, 2);
cur_row = (row < row_radius_size)?row:
((row >= nrows-row_radius_size-1) ? row_buffer_size - (nrows-row-1) : row_radius_size);
if(row>(row_radius_size) && row<nrows-(row_radius_size+1))
shift_buffers(row);
for (col=0;col<ncols;++col) {
/* on borders forms ussualy are innatural. */
if(row<(skip_cells+1) || row>nrows-(skip_cells+2) ||
col<(skip_cells+1) || col>ncols-(skip_cells+2) ||
Rast_is_f_null_value(&elevation.elev[cur_row][col])) {
/* set outputs to NULL and do nothing if source value is null or border*/
for (i=1;i<io_size;++i)
if(opt_output[i]->answer) {
pointer_buf=rasters[i].buffer;
switch (rasters[i].out_data_type) {
case CELL_TYPE:
Rast_set_c_null_value(&((CELL*)pointer_buf)[col],1);
break;
case FCELL_TYPE:
Rast_set_f_null_value(&((FCELL*)pointer_buf)[col],1);
break;
case DCELL_TYPE:
Rast_set_d_null_value(&((DCELL*)pointer_buf)[col],1);
break;
default:
G_fatal_error(_("Unknown output data type"));
}
}
continue;
} /* end null value */
{
int cur_form, small_form;
search_distance=search_dist;
skip_distance=skip_dist;
flat_distance=flat_dist;
pattern_size=calc_pattern(&patterns[0],row,cur_row,col);
pattern=&patterns[0];
cur_form=determine_form(pattern->num_negatives,pattern->num_positives);
/* correction of forms */
if(extended) {
/* 1) remove extensive innatural forms: ridges, peaks, shoulders and footslopes */
if((cur_form==4||cur_form==8||cur_form==2||cur_form==3)) {
search_distance=(search_dist/4.<4*max_resolution)? 4*max_resolution : search_dist/4.;
skip_distance=0;
flat_distance=0;
pattern_size=calc_pattern(&patterns[1],row,cur_row,col);
pattern=&patterns[1];
small_form=determine_form(pattern->num_negatives,pattern->num_positives);
if(cur_form==4||cur_form==8)
cur_form=(small_form==1)? 1 : cur_form;
if(cur_form==2||cur_form==3)
cur_form=small_form;
}
} /* end of correction */
pattern=&patterns[0];
if(opt_output[o_forms]->answer)
((CELL*)rasters[o_forms].buffer)[col]=cur_form;
}
if(opt_output[o_ternary]->answer)
((CELL*)rasters[o_ternary].buffer)[col]=determine_ternary(pattern->pattern);
if(opt_output[o_positive]->answer)
((CELL*)rasters[o_positive].buffer)[col]=pattern->num_positives;//rotate(pattern->positives);
if(opt_output[o_negative]->answer)
((CELL*)rasters[o_negative].buffer)[col]=pattern->num_negatives;//rotate(pattern->negatives);
if(opt_output[o_intensity]->answer)
((FCELL*)rasters[o_intensity].buffer)[col]=intensity(pattern->elevation,pattern_size);
if(opt_output[o_exposition]->answer)
((FCELL*)rasters[o_exposition].buffer)[col]=exposition(pattern->elevation);
if(opt_output[o_range]->answer)
((FCELL*)rasters[o_range].buffer)[col]=range(pattern->elevation);
if(opt_output[o_variance]->answer)
((FCELL*)rasters[o_variance].buffer)[col]=variance(pattern->elevation, pattern_size);
// used only for next four shape functions
if(opt_output[o_elongation]->answer ||opt_output[o_azimuth]->answer||
opt_output[o_extend]->answer || opt_output[o_width]->answer) {
float azimuth,elongation,width;
radial2cartesian(pattern);
shape(pattern, pattern_size,&azimuth,&elongation,&width);
if(opt_output[o_azimuth]->answer)
((FCELL*)rasters[o_azimuth].buffer)[col]=azimuth;
if(opt_output[o_elongation]->answer)
((FCELL*)rasters[o_elongation].buffer)[col]=elongation;
if(opt_output[o_width]->answer)
((FCELL*)rasters[o_width].buffer)[col]=width;
}
if(opt_output[o_extend]->answer)
((FCELL*)rasters[o_extend].buffer)[col]=extends(pattern, pattern_size)/area_of_octagon;
} /* end for col */
/* write existing outputs */
for (i=1;i<io_size;++i)
if(opt_output[i]->answer)
Rast_put_row(rasters[i].fd, rasters[i].buffer, rasters[i].out_data_type);
}
G_percent(row, nrows, 2); /* end main loop */
/* finish and close */
free_map(elevation.elev, row_buffer_size+1);
for (i=1;i<io_size;++i)
if(opt_output[i]->answer) {
G_free(rasters[i].buffer);
Rast_close(rasters[i].fd);
Rast_short_history(opt_output[i]->answer, "raster", &history);
Rast_command_history(&history);
Rast_write_history(opt_output[i]->answer, &history);
}
if(opt_output[o_forms]->answer)
write_form_cat_colors(opt_output[o_forms]->answer,ccolors);
if(opt_output[o_intensity]->answer)
write_contrast_colors(opt_output[o_intensity]->answer);
if(opt_output[o_exposition]->answer)
write_contrast_colors(opt_output[o_exposition]->answer);
if(opt_output[o_range]->answer)
write_contrast_colors(opt_output[o_range]->answer);
G_message("Done!");
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Cell_head cellhd;
char *name, *result;
char **mapname;
FCELL **fbuf;
int n_measures, n_outputs, *measure_idx;
int nrows, ncols;
int row, col, first_row, last_row, first_col, last_col;
int i, j;
CELL **data; /* Data structure containing image */
DCELL *dcell_row;
struct FPRange range;
DCELL min, max, inscale;
FCELL measure; /* Containing measure done */
int dist, size; /* dist = value of distance, size = s. of moving window */
int offset;
int have_px, have_py, have_sentr, have_pxpys, have_pxpyd;
int infd, *outfd;
RASTER_MAP_TYPE data_type, out_data_type;
struct GModule *module;
struct Option *opt_input, *opt_output, *opt_size, *opt_dist, *opt_measure;
struct Flag *flag_ind, *flag_all;
struct History history;
char p[1024];
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("algebra"));
G_add_keyword(_("statistics"));
G_add_keyword(_("texture"));
module->description =
_("Generate images with textural features from a raster map.");
module->overwrite = 1;
/* Define the different options */
opt_input = G_define_standard_option(G_OPT_R_INPUT);
opt_output = G_define_standard_option(G_OPT_R_BASENAME_OUTPUT);
opt_size = G_define_option();
opt_size->key = "size";
opt_size->key_desc = "value";
opt_size->type = TYPE_INTEGER;
opt_size->required = NO;
opt_size->description = _("The size of moving window (odd and >= 3)");
opt_size->answer = "3";
/* Textural character is in direct relation of the spatial size of the texture primitives. */
opt_dist = G_define_option();
opt_dist->key = "distance";
opt_dist->key_desc = "value";
opt_dist->type = TYPE_INTEGER;
opt_dist->required = NO;
opt_dist->description = _("The distance between two samples (>= 1)");
opt_dist->answer = "1";
for (i = 0; menu[i].name; i++) {
if (i)
strcat(p, ",");
else
*p = 0;
strcat(p, menu[i].name);
}
opt_measure = G_define_option();
opt_measure->key = "method";
opt_measure->type = TYPE_STRING;
opt_measure->required = NO;
opt_measure->multiple = YES;
opt_measure->options = p;
opt_measure->description = _("Textural measurement method");
flag_ind = G_define_flag();
flag_ind->key = 's';
flag_ind->description = _("Separate output for each angle (0, 45, 90, 135)");
flag_all = G_define_flag();
flag_all->key = 'a';
flag_all->description = _("Calculate all textural measurements");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
name = opt_input->answer;
result = opt_output->answer;
size = atoi(opt_size->answer);
if (size <= 0)
G_fatal_error(_("Size of the moving window must be > 0"));
if (size % 2 != 1)
G_fatal_error(_("Size of the moving window must be odd"));
dist = atoi(opt_dist->answer);
if (dist <= 0)
G_fatal_error(_("The distance between two samples must be > 0"));
n_measures = 0;
if (flag_all->answer) {
for (i = 0; menu[i].name; i++) {
menu[i].useme = 1;
}
n_measures = i;
}
else {
for (i = 0; opt_measure->answers[i]; i++) {
if (opt_measure->answers[i]) {
const char *measure_name = opt_measure->answers[i];
int n = find_measure(measure_name);
menu[n].useme = 1;
n_measures++;
}
}
}
if (!n_measures)
G_fatal_error(_("Nothing to compute. Use at least one textural measure."));
measure_idx = G_malloc(n_measures * sizeof(int));
j = 0;
for (i = 0; menu[i].name; i++) {
if (menu[i].useme == 1) {
measure_idx[j] = menu[i].idx;
j++;
}
}
/* variables needed */
if (menu[2].useme || menu[11].useme || menu[12].useme)
have_px = 1;
else
have_px = 0;
if (menu[11].useme || menu[12].useme)
have_py = 1;
else
have_py = 0;
if (menu[6].useme || menu[7].useme)
have_sentr = 1;
else
have_sentr = 0;
if (menu[5].useme || menu[6].useme || menu[7].useme)
have_pxpys = 1;
else
have_pxpys = 0;
if (menu[9].useme || menu[10].useme)
have_pxpyd = 1;
else
have_pxpyd = 0;
infd = Rast_open_old(name, "");
/* determine the inputmap type (CELL/FCELL/DCELL) */
data_type = Rast_get_map_type(infd);
Rast_get_cellhd(name, "", &cellhd);
out_data_type = FCELL_TYPE;
/* Allocate output buffers, use FCELL data_type */
n_outputs = n_measures;
if (flag_ind->answer) {
n_outputs = n_measures * 4;
}
fbuf = G_malloc(n_outputs * sizeof(FCELL *));
mapname = G_malloc(n_outputs * sizeof(char *));
for (i = 0; i < n_outputs; i++) {
mapname[i] = G_malloc(GNAME_MAX * sizeof(char));
fbuf[i] = Rast_allocate_buf(out_data_type);
}
/* open output maps */
outfd = G_malloc(n_outputs * sizeof(int));
for (i = 0; i < n_measures; i++) {
if (flag_ind->answer) {
for (j = 0; j < 4; j++) {
sprintf(mapname[i * 4 + j], "%s%s_%d", result,
menu[measure_idx[i]].suffix, j * 45);
outfd[i * 4 + j] = Rast_open_new(mapname[i * 4 + j], out_data_type);
}
}
else {
sprintf(mapname[i], "%s%s", result,
menu[measure_idx[i]].suffix);
outfd[i] = Rast_open_new(mapname[i], out_data_type);
}
}
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* Load raster map. */
/* allocate the space for one row of cell map data *A* */
dcell_row = Rast_allocate_d_buf();
/* Allocate appropriate memory for the structure containing the image */
data = (int **)G_malloc(nrows * sizeof(int *));
for (i = 0; i < nrows; i++) {
data[i] = (int *)G_malloc(ncols * sizeof(int));
}
/* read input range */
Rast_init_fp_range(&range);
Rast_read_fp_range(name, "", &range);
Rast_get_fp_range_min_max(&range, &min, &max);
inscale = 0;
if (min < 0 || max > 255) {
inscale = 255. / (max - min);
}
/* input has 0 - 1 range */
else if (max <= 1.) {
inscale = 255. / (max - min);
}
/* Read in cell map values */
/* TODO: use r.proj cache */
G_important_message(_("Reading raster map..."));
for (j = 0; j < nrows; j++) {
Rast_get_row(infd, dcell_row, j, DCELL_TYPE);
for (i = 0; i < ncols; i++) {
if (Rast_is_d_null_value(&(dcell_row[i])))
data[j][i] = -1;
else if (inscale) {
data[j][i] = (CELL)((dcell_row[i] - min) * inscale);
}
else
data[j][i] = (CELL)dcell_row[i];
}
}
/* close input cell map and release the row buffer */
Rast_close(infd);
G_free(dcell_row);
/* Now raster map is loaded to memory. */
/* *************************************************************************************************
*
* Compute of the matrix S.G.L.D. (Spatial Gray-Level Dependence Matrices) or co-occurrence matrix.
* The image is analized for piece, every piece is naming moving window (s.w.). The s.w. must be
* square with number of size's samples odd, that because we want the sample at the center of matrix.
*
***************************************************************************************************/
offset = size / 2;
first_row = first_col = offset;
last_row = nrows - offset;
last_col = ncols - offset;
Rast_set_f_null_value(fbuf[0], ncols);
for (row = 0; row < first_row; row++) {
for (i = 0; i < n_outputs; i++) {
Rast_put_row(outfd[i], fbuf[0], out_data_type);
}
}
if (n_measures > 1)
G_message(n_("Calculating %d texture measure",
"Calculating %d texture measures", n_measures), n_measures);
else
G_message(_("Calculating %s"), menu[measure_idx[0]].desc);
alloc_vars(size, dist);
for (row = first_row; row < last_row; row++) {
G_percent(row, nrows, 2);
for (i = 0; i < n_outputs; i++)
Rast_set_f_null_value(fbuf[i], ncols);
/*process the data */
for (col = first_col; col < last_col; col++) {
if (!set_vars(data, row, col, size, offset, dist)) {
for (i = 0; i < n_outputs; i++)
Rast_set_f_null_value(&(fbuf[i][col]), 1);
continue;
}
/* for all angles (0, 45, 90, 135) */
for (i = 0; i < 4; i++) {
set_angle_vars(i, have_px, have_py, have_sentr, have_pxpys, have_pxpyd);
/* for all requested textural measures */
for (j = 0; j < n_measures; j++) {
measure = (FCELL) h_measure(measure_idx[j]);
if (flag_ind->answer) {
/* output for each angle separately */
fbuf[j * 4 + i][col] = measure;
}
else {
/* use average over all angles for each measure */
if (i == 0)
fbuf[j][col] = measure;
else if (i < 3)
fbuf[j][col] += measure;
else
fbuf[j][col] = (fbuf[j][col] + measure) / 4.0;
}
}
}
}
for (i = 0; i < n_outputs; i++) {
Rast_put_row(outfd[i], fbuf[i], out_data_type);
}
}
Rast_set_f_null_value(fbuf[0], ncols);
for (row = last_row; row < nrows; row++) {
for (i = 0; i < n_outputs; i++) {
Rast_put_row(outfd[i], fbuf[0], out_data_type);
}
}
G_percent(nrows, nrows, 1);
for (i = 0; i < n_outputs; i++) {
Rast_close(outfd[i]);
Rast_short_history(mapname[i], "raster", &history);
Rast_command_history(&history);
Rast_write_history(mapname[i], &history);
G_free(fbuf[i]);
}
G_free(fbuf);
G_free(data);
exit(EXIT_SUCCESS);
}