static void read_rows(int infile, int row)
{
int end_row = cur_row + neighbors;
int first_row = row;
int last_row = row + neighbors;
int offset = first_row - cur_row;
int keep = end_row - first_row;
int i;
if (end_row >= last_row)
return;
if (keep > 0 && offset > 0)
for (i = 0; i < keep; i++) {
DCELL *tmp = bufs[i];
bufs[i] = bufs[i + offset];
bufs[i + offset] = tmp;
}
if (keep < 0)
keep = 0;
for (i = keep; i < neighbors; i++)
G_get_d_raster_row(infile, bufs[i], first_row + i);
cur_row = first_row;
}
CPLErr GRASSRasterBand::IReadBlock( int /*nBlockXOff*/, int nBlockYOff,
void *pImage )
{
if ( ! this->valid ) return CE_Failure;
// Reset window because IRasterIO could be previously called.
if ( ResetReading ( &(((GRASSDataset *)poDS)->sCellInfo) ) != CE_None ) {
return CE_Failure;
}
if ( eDataType == GDT_Byte || eDataType == GDT_UInt16 ) {
CELL *cbuf = G_allocate_c_raster_buf();
G_get_c_raster_row ( hCell, cbuf, nBlockYOff );
/* Reset NULLs */
for ( int col = 0; col < nBlockXSize; col++ ) {
if ( G_is_c_null_value(&(cbuf[col])) )
cbuf[col] = (CELL) dfNoData;
}
GDALCopyWords ( (void *) cbuf, GDT_Int32, sizeof(CELL),
pImage, eDataType, GDALGetDataTypeSize(eDataType)/8,
nBlockXSize );
G_free ( cbuf );
}
else if ( eDataType == GDT_Int32 )
{
G_get_c_raster_row ( hCell, (CELL *) pImage, nBlockYOff );
}
else if ( eDataType == GDT_Float32 )
{
G_get_f_raster_row ( hCell, (FCELL *) pImage, nBlockYOff );
}
else if ( eDataType == GDT_Float64 )
{
G_get_d_raster_row ( hCell, (DCELL *) pImage, nBlockYOff );
}
return CE_None;
}
int main( int argc, char **argv )
{
struct GModule *module;
struct Option *info_opt, *rast_opt, *vect_opt, *coor_opt;
struct Cell_head window;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->description = ( "Get info about locations,mapsets,maps" );
info_opt = G_define_option();
info_opt->key = "info";
info_opt->type = TYPE_STRING;
info_opt->description = "info key";
info_opt->options = "proj,window,query";
rast_opt = G_define_standard_option( G_OPT_R_INPUT );
rast_opt->key = "rast";
rast_opt->required = NO;
vect_opt = G_define_standard_option( G_OPT_V_INPUT );
vect_opt->key = "vect";
vect_opt->required = NO;
coor_opt = G_define_option();
coor_opt->key = "coor";
coor_opt->type = TYPE_DOUBLE;
coor_opt->multiple = YES;
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
if ( strcmp( "proj", info_opt->answer ) == 0 )
{
G_get_window( &window );
/* code from g.proj */
if ( window.proj != PROJECTION_XY )
{
struct Key_Value *projinfo, *projunits;
char *wkt;
projinfo = G_get_projinfo();
projunits = G_get_projunits();
wkt = GPJ_grass_to_wkt( projinfo, projunits, 0, 0 );
fprintf( stdout, "%s", wkt );
}
}
else if ( strcmp( "window", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%f,%f,%f,%f", window.west, window.south, window.east, window.north );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
else if ( strcmp( "query", info_opt->answer ) == 0 )
{
double x, y;
int row, col;
x = atof( coor_opt->answers[0] );
y = atof( coor_opt->answers[1] );
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
G_get_cellhd( rast_opt->answer, "", &window );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
col = ( int ) G_easting_to_col( x, &window );
row = ( int ) G_northing_to_row( y, &window );
if ( col == window.cols ) col--;
if ( row == window.rows ) row--;
if ( col < 0 || col > window.cols || row < 0 || row > window.rows )
{
fprintf( stdout, "value:null\n" );
}
else
{
void *ptr;
double val;
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = cell[col];
ptr = &( cell[col] );
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = dcell[col];
ptr = &( dcell[col] );
}
if ( G_is_null_value( ptr, rast_type ) )
{
fprintf( stdout, "value:null\n" );
}
else
{
fprintf( stdout, "value:%f\n", val );
}
}
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
exit( EXIT_SUCCESS );
}
int getmaprow(int fd, void *buf, int row, int len)
{
if (G_get_d_raster_row(fd, (DCELL *) buf, row) < 0)
G_fatal_error(_("Cannot read raster row %d"), row);
return 1;
}
CPLErr GRASSRasterBand::IRasterIO ( GDALRWFlag eRWFlag,
int nXOff, int nYOff, int nXSize, int nYSize,
void * pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
int nPixelSpace, int nLineSpace )
{
/* GRASS library does that, we have only calculate and reset the region in map units
* and if the region has changed, reopen the raster */
/* Calculate the region */
struct Cell_head sWindow;
struct Cell_head *psDsWindow;
if ( ! this->valid ) return CE_Failure;
psDsWindow = &(((GRASSDataset *)poDS)->sCellInfo);
sWindow.north = psDsWindow->north - nYOff * psDsWindow->ns_res;
sWindow.south = sWindow.north - nYSize * psDsWindow->ns_res;
sWindow.west = psDsWindow->west + nXOff * psDsWindow->ew_res;
sWindow.east = sWindow.west + nXSize * psDsWindow->ew_res;
sWindow.proj = psDsWindow->proj;
sWindow.zone = psDsWindow->zone;
sWindow.cols = nBufXSize;
sWindow.rows = nBufYSize;
/* Reset resolution */
G_adjust_Cell_head ( &sWindow, 1, 1);
if ( ResetReading ( &sWindow ) != CE_None )
{
return CE_Failure;
}
/* Read Data */
CELL *cbuf = NULL;
FCELL *fbuf = NULL;
DCELL *dbuf = NULL;
bool direct = false;
/* Reset space if default (0) */
if ( nPixelSpace == 0 )
nPixelSpace = GDALGetDataTypeSize ( eBufType ) / 8;
if ( nLineSpace == 0 )
nLineSpace = nBufXSize * nPixelSpace;
if ( nGRSType == CELL_TYPE && ( !nativeNulls || eBufType != GDT_Int32 || sizeof(CELL) != 4 ||
nPixelSpace != sizeof(CELL) ) )
{
cbuf = G_allocate_c_raster_buf();
} else if( nGRSType == FCELL_TYPE && ( eBufType != GDT_Float32 || nPixelSpace != sizeof(FCELL) ) ) {
fbuf = G_allocate_f_raster_buf();
} else if( nGRSType == DCELL_TYPE && ( eBufType != GDT_Float64 || nPixelSpace != sizeof(DCELL) ) ) {
dbuf = G_allocate_d_raster_buf();
} else {
direct = true;
}
for ( int row = 0; row < nBufYSize; row++ ) {
char *pnt = (char *)pData + row * nLineSpace;
if ( nGRSType == CELL_TYPE ) {
if ( direct ) {
G_get_c_raster_row ( hCell, (CELL *) pnt, row );
} else {
G_get_c_raster_row ( hCell, cbuf, row );
/* Reset NULLs */
for ( int col = 0; col < nBufXSize; col++ ) {
if ( G_is_c_null_value(&(cbuf[col])) )
cbuf[col] = (CELL) dfNoData;
}
GDALCopyWords ( (void *) cbuf, GDT_Int32, sizeof(CELL),
(void *) pnt, eBufType, nPixelSpace,
nBufXSize );
}
} else if( nGRSType == FCELL_TYPE ) {
if ( direct ) {
G_get_f_raster_row ( hCell, (FCELL *) pnt, row );
} else {
G_get_f_raster_row ( hCell, fbuf, row );
GDALCopyWords ( (void *) fbuf, GDT_Float32, sizeof(FCELL),
(void *) pnt, eBufType, nPixelSpace,
nBufXSize );
}
} else if( nGRSType == DCELL_TYPE ) {
if ( direct ) {
G_get_d_raster_row ( hCell, (DCELL *) pnt, row );
} else {
G_get_d_raster_row ( hCell, dbuf, row );
GDALCopyWords ( (void *) dbuf, GDT_Float64, sizeof(DCELL),
(void *) pnt, eBufType, nPixelSpace,
nBufXSize );
}
}
}
if ( cbuf ) G_free ( cbuf );
if ( fbuf ) G_free ( fbuf );
if ( dbuf ) G_free ( dbuf );
return CE_None;
}
int main( int argc, char **argv )
{
struct GModule *module;
struct Option *info_opt, *rast_opt, *vect_opt, *coor_opt, *north_opt, *south_opt, *east_opt, *west_opt, *rows_opt, *cols_opt;
struct Cell_head window;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->description = ( "Get info about locations,mapsets,maps" );
info_opt = G_define_option();
info_opt->key = "info";
info_opt->type = TYPE_STRING;
info_opt->description = "info key";
info_opt->options = "proj,window,size,query,info,colors,stats";
rast_opt = G_define_standard_option( G_OPT_R_INPUT );
rast_opt->key = "rast";
rast_opt->required = NO;
vect_opt = G_define_standard_option( G_OPT_V_INPUT );
vect_opt->key = "vect";
vect_opt->required = NO;
coor_opt = G_define_option();
coor_opt->key = "coor";
coor_opt->type = TYPE_DOUBLE;
coor_opt->multiple = YES;
north_opt = G_define_option();
north_opt->key = "north";
north_opt->type = TYPE_STRING;
south_opt = G_define_option();
south_opt->key = "south";
south_opt->type = TYPE_STRING;
east_opt = G_define_option();
east_opt->key = "east";
east_opt->type = TYPE_STRING;
west_opt = G_define_option();
west_opt->key = "west";
west_opt->type = TYPE_STRING;
rows_opt = G_define_option();
rows_opt->key = "rows";
rows_opt->type = TYPE_INTEGER;
cols_opt = G_define_option();
cols_opt->key = "cols";
cols_opt->type = TYPE_INTEGER;
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
if ( strcmp( "proj", info_opt->answer ) == 0 )
{
G_get_window( &window );
/* code from g.proj */
if ( window.proj != PROJECTION_XY )
{
struct Key_Value *projinfo, *projunits;
char *wkt;
projinfo = G_get_projinfo();
projunits = G_get_projunits();
wkt = GPJ_grass_to_wkt( projinfo, projunits, 0, 0 );
fprintf( stdout, "%s", wkt );
}
}
else if ( strcmp( "window", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%f,%f,%f,%f", window.west, window.south, window.east, window.north );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
// raster width and height
else if ( strcmp( "size", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%d,%d", window.cols, window.rows );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
// raster informations
else if ( strcmp( "info", info_opt->answer ) == 0 )
{
struct FPRange range;
double zmin, zmax;
// Data type
RASTER_MAP_TYPE raster_type = G_raster_map_type( rast_opt->answer, "" );
fprintf( stdout, "TYPE:%d\n", raster_type );
// Statistics
if ( G_read_fp_range( rast_opt->answer, "", &range ) < 0 )
{
G_fatal_error(( "Unable to read range file" ) );
}
G_get_fp_range_min_max( &range, &zmin, &zmax );
fprintf( stdout, "MIN_VALUE:%.17e\n", zmin );
fprintf( stdout, "MAX_VALUE:%.17e\n", zmax );
}
else if ( strcmp( "colors", info_opt->answer ) == 0 )
{
// Color table
struct Colors colors;
int i, ccount;
if ( G_read_colors( rast_opt->answer, "", &colors ) == 1 )
{
//int maxcolor;
//CELL min, max;
//G_get_color_range ( &min, &max, &colors);
ccount = G_colors_count( &colors );
for ( i = ccount - 1; i >= 0; i-- )
{
DCELL val1, val2;
unsigned char r1, g1, b1, r2, g2, b2;
G_get_f_color_rule( &val1, &r1, &g1, &b1, &val2, &r2, &g2, &b2, &colors, i );
fprintf( stdout, "%.17e %.17e %d %d %d %d %d %d\n", val1, val2, r1, g1, b1, r2, g2, b2 );
}
}
}
else if ( strcmp( "query", info_opt->answer ) == 0 )
{
double x, y;
int row, col;
//x = atof( coor_opt->answers[0] );
//y = atof( coor_opt->answers[1] );
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
char buff[101];
G_get_cellhd( rast_opt->answer, "", &window );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
// wait for coors from stdin
while ( fgets( buff, 100, stdin ) != 0 )
{
if ( sscanf( buff, "%lf%lf", &x, &y ) != 2 )
{
fprintf( stdout, "value:error\n" );
}
else
{
col = ( int ) G_easting_to_col( x, &window );
row = ( int ) G_northing_to_row( y, &window );
if ( col == window.cols )
col--;
if ( row == window.rows )
row--;
if ( col < 0 || col > window.cols || row < 0 || row > window.rows )
{
fprintf( stdout, "value:out\n" );
}
else
{
void *ptr;
double val;
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = cell[col];
ptr = &( cell[col] );
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = dcell[col];
ptr = &( dcell[col] );
}
if ( G_is_null_value( ptr, rast_type ) )
{
fprintf( stdout, "value:null\n" );
}
else
{
fprintf( stdout, "value:%f\n", val );
}
}
}
fflush( stdout );
}
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
else if ( strcmp( "stats", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
int ncols, nrows;
int row, col;
void *ptr;
double val;
double min = DBL_MAX;
double max = -DBL_MAX;
double sum = 0; // sum of values
int count = 0; // count of non null values
double mean = 0;
double squares_sum = 0; // sum of squares
double stdev = 0; // standard deviation
G_get_cellhd( rast_opt->answer, "", &window );
window.north = atof( north_opt->answer );
window.south = atof( south_opt->answer );
window.east = atof( east_opt->answer );
window.west = atof( west_opt->answer );
window.rows = ( int ) atoi( rows_opt->answer );
window.cols = ( int ) atoi( cols_opt->answer );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
ncols = G_window_cols();
nrows = G_window_rows();
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
// Calc stats is very slow for large rasters -> prefer optimization for speed over
// code length and readability (which is not currently true)
for ( row = 0; row < nrows; row++ )
{
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
}
for ( col = 0; col < ncols; col++ )
{
if ( rast_type == CELL_TYPE )
{
val = cell[col];
ptr = &( cell[col] );
}
else
{
val = dcell[col];
ptr = &( dcell[col] );
}
if ( ! G_is_null_value( ptr, rast_type ) )
{
if ( val < min ) min = val;
if ( val > max ) max = val;
sum += val;
count++;
squares_sum += pow( val, 2 );
}
}
}
mean = sum / count;
squares_sum -= count * pow( mean, 2 );
stdev = sqrt( squares_sum / ( count - 1 ) );
fprintf( stdout, "MIN:%.17e\n", min );
fprintf( stdout, "MAX:%.17e\n", max );
fprintf( stdout, "SUM:%.17e\n", sum );
fprintf( stdout, "MEAN:%.17e\n", mean );
fprintf( stdout, "COUNT:%d\n", count );
fprintf( stdout, "STDEV:%.17e\n", stdev );
fprintf( stdout, "SQSUM:%.17e\n", squares_sum );
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
exit( EXIT_SUCCESS );
}
/*!
\brief Get categories/labels
Formats label as in d.what.rast -> (catval) catlabel
\param filename raster map name
\param drow
\param dcol
\param catstr category string
\return 1 on success
\return 0 on failure
*/
int Gs_get_cat_label(const char *filename, int drow, int dcol, char *catstr)
{
struct Categories cats;
const char *mapset;
CELL *buf;
DCELL *dbuf;
RASTER_MAP_TYPE map_type;
int fd;
if ((mapset = G_find_cell2(filename, "")) == NULL) {
G_warning(_("Raster map <%s> not found"), filename);
return 0;
}
if (-1 != G_read_cats(filename, mapset, &cats)) {
fd = G_open_cell_old(filename, mapset);
map_type = G_get_raster_map_type(fd);
if (map_type == CELL_TYPE) {
buf = G_allocate_c_raster_buf();
if (G_get_c_raster_row(fd, buf, drow) < 0) {
sprintf(catstr, "error");
}
else if (G_is_c_null_value(&buf[dcol])) {
sprintf(catstr, "(NULL) %s",
G_get_c_raster_cat(&buf[dcol], &cats));
}
else {
sprintf(catstr, "(%d) %s", buf[dcol],
G_get_c_raster_cat(&buf[dcol], &cats));
}
G_free(buf);
}
else {
/* fp map */
dbuf = G_allocate_d_raster_buf();
if (G_get_d_raster_row(fd, dbuf, drow) < 0) {
sprintf(catstr, "error");
}
else if (G_is_d_null_value(&dbuf[dcol])) {
sprintf(catstr, "(NULL) %s",
G_get_d_raster_cat(&dbuf[dcol], &cats));
}
else {
sprintf(catstr, "(%g) %s", dbuf[dcol],
G_get_d_raster_cat(&dbuf[dcol], &cats));
}
G_free(dbuf);
}
}
else {
strcpy(catstr, "no category label");
}
/* TODO: may want to keep these around for multiple queries */
G_free_cats(&cats);
G_close_cell(fd);
return (1);
}
int main(int argc, char *argv[])
{
struct Cell_head cellhd;
struct Range range;
char *name; /* input raster name */
char *result; /* output raster name */
char *mapset; /* mapset name */
DCELL *inrast; /* input buffer */
DCELL *outrast; /* output buffer */
int row,col;
int infd, outfd; /* file descriptor */
int verbose;
double *weights; /* array of weights */
DCELL **D_rows;
DCELL *tmp;
int nrows;
int ncols;
double min, max; /* raster map range */
RASTER_MAP_TYPE data_type; /* type of the map */
void *values; /* neighborhood values */
int n,i; /* number of neighborhood cells */
int size; /* matrix size */
double ssigma; /* sigma of the spatial part */
double csigma; /* sigma of the color part */
char title[1024]; /* map title */
struct GModule *module; /* GRASS module for parsing arguments */
struct
{
struct Option *input, *output;
struct Option *sigma_s, *sigma_c, *size;
struct Option *title;
} parm;
struct
{
struct Flag *quiet;
struct Flag *print_sigmas;
} flag;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env,
stores program name to
G_program_name
*/
/* initialize module */
module = G_define_module();
module->description = ("Gaussian filter for raster maps.");
/* Define the different options */
parm.input = G_define_option() ;
parm.input->key = "input";
parm.input->type = TYPE_STRING;
parm.input->required = YES;
parm.input->description= ("Name of an input layer" );
parm.output = G_define_option() ;
parm.output->key = "output";
parm.output->type = TYPE_STRING;
parm.output->required = YES;
parm.output->description= ("Name of an output layer");
parm.sigma_s = G_define_option() ;
parm.sigma_s->key = "ssigma";
parm.sigma_s->type = TYPE_DOUBLE;
parm.sigma_s->required = NO;
parm.sigma_s->description= ("Sigma for space part of the filter\n\t(default: 0.465*((size-1)/2)");
parm.sigma_c = G_define_option() ;
parm.sigma_c->key = "csigma";
parm.sigma_c->type = TYPE_DOUBLE;
parm.sigma_c->required = NO;
parm.sigma_c->description= ("Sigma for color part of the filter\n(default: 0.465*((color_range)/2)");
parm.size = G_define_option() ;
parm.size->key = "size";
parm.size->type = TYPE_INTEGER;
parm.size->required = YES;
parm.size->description= ("Size of the matrix (odd number)");
flag.print_sigmas = G_define_flag() ;
flag.print_sigmas->key = 's' ;
flag.print_sigmas->description = "Print calculated values for sigmas" ;
flag.quiet = G_define_flag() ;
flag.quiet->key = 'q' ;
flag.quiet->description = "Quiet" ;
/* options and flags pareser */
if (G_parser(argc, argv))
exit (-1);
/* stores options and flags to variables */
name = parm.input->answer;
result = parm.output->answer;
verbose = (! flag.quiet->answer);
sscanf(parm.size->answer, "%d", &size);
if (!parm.sigma_s->answer)
ssigma = 0.465*((size-1)/2);
else
sscanf(parm.sigma_s->answer, "%lf", &ssigma);
/* controlling the input values */
if (size%2 == 0)
G_fatal_error("Size <%d> is not odd number", size);
/* returs NULL if the map was not found in any mapset,
* mapset name otherwise*/
mapset = G_find_cell2 (name, "");
if (mapset == NULL)
G_fatal_error ("cell file [%s] not found", name);
/* color sigma next */
if (!parm.sigma_c->answer) {
if (G_read_range(name, mapset, &range) < 0)
G_fatal_error("Could not read the raster map range");
/* for raster maps with range from 0-255 the result
* should be around 60
*/
min = (double)range.min;
max = (double)range.max;
csigma = 0.456*(max - min)/2;
}
else
sscanf(parm.sigma_c->answer, "%lf", &csigma);
/* print if appropriate */
if (flag.print_sigmas->answer)
printf("Space sigma: %f\nColor sigma: %f\n", ssigma, csigma);
if (G_legal_filename (result) < 0)
G_fatal_error ("[%s] is an illegal name", result);
/* count weights */
weights = (double *)malloc(size * size * sizeof(double));
/* stores values of gauss. bell into 'weigts'*/
count_weights(weights, size, ssigma);
/* determine the inputmap type (CELL/FCELL/DCELL) */
data_type = G_raster_map_type(name, mapset);
/* G_open_cell_old - returns file destriptor (>0) */
if ( (infd = G_open_cell_old (name, mapset)) < 0)
G_fatal_error ("Cannot open cell file [%s]", name);
/* controlling, if we can open input raster */
if (G_get_cellhd (name, mapset, &cellhd) < 0)
G_fatal_error ("Cannot read file header of [%s]", name);
/* Allocate input buffer */
inrast = G_allocate_raster_buf(data_type);
/* Allocate output buffer, use input map data_type */
nrows = G_window_rows();
ncols = G_window_cols();
outrast = G_allocate_d_raster_buf();
/* Allocate values buffers */
values = (DCELL *) malloc(size * size * sizeof(DCELL));
/* allocating memory for rows */
D_rows = (DCELL **)malloc(size * sizeof(DCELL));
for (i = 0; i < size; i++) {
D_rows[i] = G_allocate_raster_buf(DCELL_TYPE);
}
if (values == NULL)
G_fatal_error("Cannot allocate memory");
/* controlling, if we can write the raster */
if ( (outfd = G_open_raster_new (result, data_type)) < 0)
G_fatal_error ("Could not open <%s>",result);
/* write first rows as NULL values */
for (row = 0; row < size/2; row++) {
G_set_d_null_value(outrast, ncols);
if (G_put_d_raster_row (outfd, outrast) < 0)
G_fatal_error ("Cannot write to <%s>",result);
}
/* allocate first size/2 rows */
for (row = 0; row < size; row++)
if (G_get_d_raster_row(infd, D_rows[row], row) < 0)
G_fatal_error ("Could not open <%s>",result);
/****************************************************************/
/* for each row inside the region */
for ( row = size/2; row < nrows - size/2; row++) {
if (verbose)
G_percent (row, nrows, 2);
/* allocate new last row */
G_get_d_raster_row(infd, D_rows[size-1], row+(size/2));
/*process the data */
for (col=0; col < ncols; col++){
/* skip the outside columns */
if ( (col - size/2) < 0 || ncols <= (col + size/2)) {
G_set_d_null_value(outrast, 1);
}
/* work only with columns, which are inside */
else {
/* store values of the matrix into arry 'values', 'n' is
* number of elements of the matrix */
n = D_gather(infd, values, D_rows, col, row,size);
((DCELL *)outrast)[col] = D_bilateral(values, ssigma, csigma, size, weights);
}
} /* for each column */
/* write raster row to output raster file */
G_put_d_raster_row (outfd, outrast);
/* switch rows */
tmp = D_rows[0];
for (i = 0; i < size; i++){
D_rows[i] = D_rows[i + 1];
}
D_rows[size-1] = tmp;
} /* for each row */
/* write last rows as NULL values */
for (i = 0; i < size/2; i++) {
G_set_d_null_value(outrast, ncols);
G_put_d_raster_row (outfd, outrast);
}
/* memory cleaning */
G_free(outrast);
G_free(inrast);
G_free(values);
for (i = 0; i < size; i++) {
G_free(D_rows[i]);
}
free((void *) D_rows);
/* closing rastr files */
G_close_cell (infd);
G_close_cell (outfd);
/* set the map title */
sprintf(title, "Bilateral filter of %s with %dx%d matrix: ssigma %.3f, csigma %.3f", name, size, size, ssigma, csigma );
G_put_cell_title (result, title );
return 0;
}