/*!
* \brief Get category description
*
* Returns i-th description and i-th data range from the list of
* category descriptions with corresponding data ranges. end points of
* data interval in <i>rast1</i> and <i>rast2</i>.
*
* \param pcats pointer to Categories structure
* \param i index
* \param rast1, rast2 raster values (range)
* \param data_type map type
*
* \return "" on error
* \return pointer to category description
*/
char *Rast_get_ith_cat(const struct Categories *pcats, int i, void *rast1,
void *rast2, RASTER_MAP_TYPE data_type)
{
char *tmp;
DCELL val1, val2;
tmp = Rast_get_ith_d_cat(pcats, i, &val1, &val2);
Rast_set_d_value(rast1, val1, data_type);
Rast_set_d_value(rast2, val2, data_type);
return tmp;
}
/*!
\brief Get next marked raster categories
\param pcats pointer to Categories structure
\param rast1, rast2 cell values (raster range)
\param[out] count count
\param data_type map type
\return NULL if not found
\return description if found
*/
char *Rast_get_next_marked_cat(struct Categories *pcats,
void *rast1, void *rast2,
long *count, RASTER_MAP_TYPE data_type)
{
DCELL val1, val2;
char *lab;
lab = Rast_get_next_marked_d_cat(pcats, &val1, &val2, count);
Rast_set_d_value(rast1, val1, data_type);
Rast_set_d_value(rast2, val2, data_type);
return lab;
}
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 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_sumsq(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;
old_val = Rast_get_d_value(ptr, map_type);
Rast_set_d_value(ptr, (value * value) + old_val, map_type);
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;
}
void p_bilinear(struct cache *ibuffer, /* input buffer */
void *obufptr, /* ptr in output buffer */
int cell_type, /* raster map type of obufptr */
double *row_idx, /* row index */
double *col_idx, /* column index */
struct Cell_head *cellhd /* information of output map */
)
{
int row; /* row indices for interp */
int col; /* column indices for interp */
int i, j;
DCELL t, u; /* intermediate slope */
DCELL result; /* result of interpolation */
DCELL c[2][2];
/* cut indices to integer */
row = (int)floor(*row_idx - 0.5);
col = (int)floor(*col_idx - 0.5);
/* check for out of bounds - if out of bounds set NULL value and return */
if (row < 0 || row + 1 >= cellhd->rows || col < 0 || col + 1 >= cellhd->cols) {
Rast_set_null_value(obufptr, 1, cell_type);
return;
}
for (i = 0; i < 2; i++)
for (j = 0; j < 2; j++) {
const DCELL *cellp = CPTR(ibuffer, row + i, col + j);
if (Rast_is_d_null_value(cellp)) {
Rast_set_null_value(obufptr, 1, cell_type);
return;
}
c[i][j] = *cellp;
}
/* do the interpolation */
t = *col_idx - 0.5 - col;
u = *row_idx - 0.5 - row;
result = Rast_interp_bilinear(t, u, c[0][0], c[0][1], c[1][0], c[1][1]);
Rast_set_d_value(obufptr, result, cell_type);
}
void p_cubic_f(struct cache *ibuffer, /* input buffer */
void *obufptr, /* ptr in output buffer */
int cell_type, /* raster map type of obufptr */
double *row_idx, /* row index */
double *col_idx, /* column index */
struct Cell_head *cellhd /* cell header of input layer */
)
{
/* start nearest neighbor to do some basic tests */
int row, col; /* row/col of nearest neighbor */
DCELL *cellp, cell;
/* cut indices to integer */
row = (int)floor(*row_idx);
col = (int)floor(*col_idx);
/* check for out of bounds - if out of bounds set NULL value */
if (row < 0 || row >= cellhd->rows || col < 0 || col >= cellhd->cols) {
Rast_set_null_value(obufptr, 1, cell_type);
return;
}
cellp = CPTR(ibuffer, row, col);
/* if nearest is null, all the other interps will be null */
if (Rast_is_d_null_value(cellp)) {
Rast_set_null_value(obufptr, 1, cell_type);
return;
}
cell = *cellp;
p_cubic(ibuffer, obufptr, cell_type, row_idx, col_idx, cellhd);
/* fallback to bilinear if cubic is null */
if (Rast_is_d_null_value(obufptr)) {
p_bilinear(ibuffer, obufptr, cell_type, row_idx, col_idx, cellhd);
/* fallback to nearest if bilinear is null */
if (Rast_is_d_null_value(obufptr))
Rast_set_d_value(obufptr, cell, cell_type);
}
}
/*---------------------------------------------------------------------------------------*/
void P_Aux_to_Raster(double **matrix, int fd)
{
int ncols, col, nrows, row;
void *ptr, *raster;
nrows = Rast_window_rows();
ncols = Rast_window_cols();
raster = Rast_allocate_buf(DCELL_TYPE);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Rast_set_d_null_value(raster, ncols);
for (col = 0, ptr = raster; col < ncols;
col++, ptr = G_incr_void_ptr(ptr, Rast_cell_size(DCELL_TYPE))) {
Rast_set_d_value(ptr, (DCELL) (matrix[row][col]), DCELL_TYPE);
}
Rast_put_d_row(fd, raster);
}
G_percent(row, nrows, 2);
}
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 );
}
static int
write_pca(double **eigmat, int *inp_fd, char *out_basename,
int bands, int scale, int scale_min, int scale_max)
{
int i, j;
void *outbuf, *outptr;
double min = 0.;
double max = 0.;
double old_range = 0.;
double new_range = 0.;
int rows = Rast_window_rows();
int cols = Rast_window_cols();
int cell_mapsiz = Rast_cell_size(CELL_TYPE);
int dcell_mapsiz = Rast_cell_size(DCELL_TYPE);
DCELL *d_buf;
/* 2 passes for rescale. 1 pass for no rescale */
int PASSES = (scale) ? 2 : 1;
/* temporary row storage */
d_buf = (DCELL *) G_malloc(cols * sizeof(double));
/* allocate memory for output row buffer */
outbuf = (scale) ? Rast_allocate_buf(CELL_TYPE) :
Rast_allocate_buf(DCELL_TYPE);
if (!outbuf)
G_fatal_error(_("Unable to allocate memory for raster row"));
for (i = 0; i < bands; i++) {
char name[100];
int out_fd;
int pass;
sprintf(name, "%s.%d", out_basename, i + 1);
G_message(_("Transforming <%s>..."), name);
/* open a new file for output */
if (scale)
out_fd = Rast_open_c_new(name);
else {
out_fd = Rast_open_fp_new(name);
Rast_set_fp_type(DCELL_TYPE);
}
for (pass = 1; pass <= PASSES; pass++) {
void *rowbuf = NULL;
int row, col;
if (scale && (pass == PASSES)) {
G_message(_("Rescaling <%s> to range %d,%d..."),
name, scale_min, scale_max);
old_range = max - min;
new_range = (double)(scale_max - scale_min);
}
for (row = 0; row < rows; row++) {
void *rowptr;
G_percent(row, rows, 2);
/* reset d_buf */
for (col = 0; col < cols; col++)
d_buf[col] = 0.;
for (j = 0; j < bands; j++) {
RASTER_MAP_TYPE maptype =
Rast_get_map_type(inp_fd[j]);
/* don't assume each image is of the same type */
if (rowbuf)
G_free(rowbuf);
if (!(rowbuf = Rast_allocate_buf(maptype)))
G_fatal_error(_("Unable allocate memory for row buffer"));
Rast_get_row(inp_fd[j], rowbuf, row, maptype);
rowptr = rowbuf;
outptr = outbuf;
/* add into the output cell eigmat[i][j] * corresp cell
* of j-th band for current j */
for (col = 0; col < cols; col++) {
/* handle null cells */
if (Rast_is_null_value(rowptr, maptype)) {
if (scale) {
Rast_set_null_value(outptr, 1, CELL_TYPE);
outptr = G_incr_void_ptr(outptr, cell_mapsiz);
}
else {
Rast_set_null_value(outptr, 1, DCELL_TYPE);
outptr =
G_incr_void_ptr(outptr, dcell_mapsiz);
}
rowptr =
G_incr_void_ptr(rowptr,
Rast_cell_size(maptype));
continue;
}
/* corresp. cell of j-th band */
d_buf[col] +=
eigmat[i][j] * Rast_get_d_value(rowptr,
maptype);
/* the cell entry is complete */
if (j == (bands - 1)) {
if (scale && (pass == 1)) {
if ((row == 0) && (col == 0))
min = max = d_buf[0];
if (d_buf[col] < min)
min = d_buf[col];
if (d_buf[col] > max)
max = d_buf[col];
}
else if (scale) {
if (min == max) {
Rast_set_c_value(outptr, 1,
CELL_TYPE);
}
else {
/* map data to 0, (new_range-1) and then adding new_min */
CELL tmpcell =
round_c((new_range *
(d_buf[col] -
min) / old_range) +
scale_min);
Rast_set_c_value(outptr, tmpcell,
CELL_TYPE);
}
}
else { /* (!scale) */
Rast_set_d_value(outptr, d_buf[col],
DCELL_TYPE);
}
}
outptr = (scale) ?
G_incr_void_ptr(outptr, cell_mapsiz) :
G_incr_void_ptr(outptr, dcell_mapsiz);
rowptr =
G_incr_void_ptr(rowptr, Rast_cell_size(maptype));
}
} /* for j = 0 to bands */
if (pass == PASSES) {
if (scale)
Rast_put_row(out_fd, outbuf, CELL_TYPE);
else
Rast_put_row(out_fd, outbuf, DCELL_TYPE);
}
}
G_percent(row, rows, 2);
/* close output file */
if (pass == PASSES)
Rast_close(out_fd);
}
}
if (d_buf)
G_free(d_buf);
if (outbuf)
G_free(outbuf);
return 0;
}
int main(int argc, char *argv[])
{
char *input;
char *output;
char *title;
char *temp;
FILE *fd, *ft;
int cf, direction, sz;
struct Cell_head cellhd;
struct History history;
void *rast, *rast_ptr;
int row, col;
int nrows, ncols;
double x;
char y[128];
struct GModule *module;
struct
{
struct Option *input, *output, *title, *mult, *nv, *type;
} parm;
struct
{
struct Flag *s;
} flag;
char *null_val_str;
DCELL mult;
RASTER_MAP_TYPE data_type;
double atof();
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("import"));
G_add_keyword(_("conversion"));
G_add_keyword("ASCII");
module->description =
_("Converts a GRASS ASCII raster file to binary raster map.");
parm.input = G_define_standard_option(G_OPT_F_INPUT);
parm.input->label =
_("Name of input file to be imported");
parm.input->description = _("'-' for standard input");
parm.output = G_define_standard_option(G_OPT_R_OUTPUT);
parm.type = G_define_option();
parm.type->key = "type";
parm.type->type = TYPE_STRING;
parm.type->required = NO;
parm.type->options = "CELL,FCELL,DCELL";
parm.type->label = _("Storage type for resultant raster map");
parm.type->description = _("Default: CELL for integer values, DCELL for floating-point values");
parm.title = G_define_option();
parm.title->key = "title";
parm.title->key_desc = "phrase";
parm.title->type = TYPE_STRING;
parm.title->required = NO;
parm.title->description = _("Title for resultant raster map");
parm.mult = G_define_option();
parm.mult->key = "multiplier";
parm.mult->type = TYPE_DOUBLE;
parm.mult->description = _("Default: read from header");
parm.mult->required = NO;
parm.mult->label = _("Multiplier for ASCII data");
parm.nv = G_define_standard_option(G_OPT_M_NULL_VALUE);
parm.nv->description = _("Default: read from header");
parm.nv->label = _("String representing NULL value data cell");
parm.nv->guisection = _("NULL data");
flag.s = G_define_flag();
flag.s->key = 's';
flag.s->description =
_("SURFER (Golden Software) ASCII file will be imported");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
input = parm.input->answer;
output = parm.output->answer;
temp = G_tempfile();
ft = fopen(temp, "w+");
if (ft == NULL)
G_fatal_error(_("Unable to open temporary file <%s>"), temp);
if ((title = parm.title->answer))
G_strip(title);
if (!parm.mult->answer)
Rast_set_d_null_value(&mult, 1);
else if ((sscanf(parm.mult->answer, "%lf", &mult)) != 1)
G_fatal_error(_("Wrong entry for multiplier: %s"), parm.mult->answer);
null_val_str = parm.nv->answer;
data_type = -1;
if (parm.type->answer) {
switch(parm.type->answer[0]) {
case 'C':
data_type = CELL_TYPE;
break;
case 'F':
data_type = FCELL_TYPE;
break;
case 'D':
data_type = DCELL_TYPE;
break;
}
}
if (strcmp(input, "-") == 0) {
Tmp_file = G_tempfile();
if (NULL == (Tmp_fd = fopen(Tmp_file, "w+")))
G_fatal_error(_("Unable to open temporary file <%s>"), Tmp_file);
unlink(Tmp_file);
if (0 > file_cpy(stdin, Tmp_fd))
G_fatal_error(_("Unable to read input from stdin"));
fd = Tmp_fd;
}
else
fd = fopen(input, "r");
if (fd == NULL) {
G_fatal_error(_("Unable to read input from <%s>"), input);
}
direction = 1;
sz = 0;
if (flag.s->answer) {
sz = getgrdhead(fd, &cellhd);
/* for Surfer files, the data type is always FCELL_TYPE,
the multiplier and the null_val_str are never used */
data_type = FCELL_TYPE;
mult = 1.;
null_val_str = "";
/* rows in surfer files are ordered from bottom to top,
opposite of normal GRASS ordering */
direction = -1;
}
else
sz = gethead(fd, &cellhd, &data_type, &mult, &null_val_str);
if (!sz)
G_fatal_error(_("Can't get cell header"));
nrows = cellhd.rows;
ncols = cellhd.cols;
Rast_set_window(&cellhd);
if (nrows != Rast_window_rows())
G_fatal_error(_("OOPS: rows changed from %d to %d"), nrows,
Rast_window_rows());
if (ncols != Rast_window_cols())
G_fatal_error(_("OOPS: cols changed from %d to %d"), ncols,
Rast_window_cols());
rast_ptr = Rast_allocate_buf(data_type);
rast = rast_ptr;
cf = Rast_open_new(output, data_type);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
for (col = 0; col < ncols; col++) {
if (fscanf(fd, "%s", y) != 1) {
Rast_unopen(cf);
G_fatal_error(_("Data conversion failed at row %d, col %d"),
row + 1, col + 1);
}
if (strcmp(y, null_val_str)) {
x = atof(y);
if ((float)x == GS_BLANK) {
Rast_set_null_value(rast_ptr, 1, data_type);
}
else {
Rast_set_d_value(rast_ptr,
(DCELL) (x * mult), data_type);
}
}
else {
Rast_set_null_value(rast_ptr, 1, data_type);
}
rast_ptr = G_incr_void_ptr(rast_ptr, Rast_cell_size(data_type));
}
fwrite(rast, Rast_cell_size(data_type), ncols, ft);
rast_ptr = rast;
}
G_percent(nrows, nrows, 2);
G_debug(1, "Creating support files for %s", output);
sz = 0;
if (direction < 0) {
sz = -ncols * Rast_cell_size(data_type);
G_fseek(ft, sz, SEEK_END);
sz *= 2;
}
else {
G_fseek(ft, 0L, SEEK_SET);
}
for (row = 0; row < nrows; row += 1) {
fread(rast, Rast_cell_size(data_type), ncols, ft);
Rast_put_row(cf, rast, data_type);
G_fseek(ft, sz, SEEK_CUR);
}
fclose(ft);
unlink(temp);
Rast_close(cf);
if (title)
Rast_put_cell_title(output, title);
Rast_short_history(output, "raster", &history);
Rast_command_history(&history);
Rast_write_history(output, &history);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int out_fd;
CELL *result, *rp;
int nrows, ncols;
int row, col, count_sum;
int field;
struct GModule *module;
struct Option *in_opt, *out_opt, *field_opt;
struct Option *method_opt, *size_opt;
struct Map_info In;
double radius;
struct boxlist *List;
struct Cell_head region;
struct bound_box box;
struct line_pnts *Points;
struct line_cats *Cats;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("algebra"));
G_add_keyword(_("statistics"));
G_add_keyword(_("raster"));
G_add_keyword(_("aggregation"));
module->label = _("Neighborhood analysis tool for vector point maps.");
module->description = _("Makes each cell value a "
"function of the attribute values assigned to the vector points or centroids "
"around it, and stores new cell values in an output raster map.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
out_opt = G_define_standard_option(G_OPT_R_OUTPUT);
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->options = "count";
method_opt->answer = "count";
method_opt->description = _("Neighborhood operation");
size_opt = G_define_option();
size_opt->key = "size";
size_opt->type = TYPE_DOUBLE;
size_opt->required = YES;
size_opt->description = _("Neighborhood diameter in map units");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
radius = atof(size_opt->answer) / 2;
/* open input vector */
Vect_set_open_level(2);
if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
field = Vect_get_field_number(&In, field_opt->answer);
G_get_set_window(®ion);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
result = Rast_allocate_buf(CELL_TYPE);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
List = Vect_new_boxlist(0);
/*open the new cellfile */
out_fd = Rast_open_new(out_opt->answer, CELL_TYPE);
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
count_sum = 0;
for (row = 0; row < nrows; row++) {
double x, y;
G_percent(row, nrows, 2);
y = Rast_row_to_northing(row + 0.5, ®ion);
box.N = y + radius;
box.S = y - radius;
Rast_set_null_value(result, ncols, CELL_TYPE);
rp = result;
for (col = 0; col < ncols; col++) {
int i, count;
CELL value;
x = Rast_col_to_easting(col + 0.5, ®ion);
box.E = x + radius;
box.W = x - radius;
Vect_select_lines_by_box(&In, &box, GV_POINTS, List);
G_debug(3, " %d lines in box", List->n_values);
count = 0;
for (i = 0; i < List->n_values; i++) {
Vect_read_line(&In, Points, Cats, List->id[i]);
if (field != -1 && Vect_cat_get(Cats, field, NULL) == 0)
continue;
if (Vect_points_distance(x, y, 0.0, Points->x[0],
Points->y[0], 0.0, 0) <= radius)
count++;
}
if (count > 0) {
value = count;
Rast_set_d_value(rp, value, CELL_TYPE);
}
rp = G_incr_void_ptr(rp, Rast_cell_size(CELL_TYPE));
count_sum += count;
}
Rast_put_row(out_fd, result, CELL_TYPE);
}
G_percent(1, 1, 1);
Vect_close(&In);
Rast_close(out_fd);
if (count_sum < 1)
G_warning(_("No points found"));
exit(EXIT_SUCCESS);
}