/* checks if user-supplied parameters are valid */ int check_parms (char *map_answer, char *input_answer, char *output_answer, int all ) { if ( map_answer != NULL ) { if ((G_find_file ("fcell", map_answer, "") == NULL) && (G_find_file ("dcell", map_answer, "") == NULL) && (G_find_file ("cell", map_answer, "") == NULL)) { /* no coverage map found */ G_fatal_error ("No raster map exists with the given name."); } /* specifying all means to disregard the map! */ if ( all == 1 ) { G_warning ("Map was specified, but the -a flag disregards map values!\n Your results might not be what you expect."); } } /* check if sample sites exist */ if (G_find_file ("vector", input_answer, "") == NULL) { G_fatal_error ("No sample/sites list exists with the given name!"); } /* check if a legal file name was given for output map this just overwrites existing sites */ if (G_legal_filename (output_answer) == -1) { G_fatal_error ("Name chosen for result map is not a valid file name!"); } /* return raster mode to caller */ if ( map_answer != NULL ) { return (G_raster_map_type (map_answer,"")); } else return (-1); }
int G_write_quant(const char *name, const char *mapset, const struct Quant *quant) { CELL cell_min, cell_max; DCELL d_min, d_max; char buf[300]; if (G_raster_map_type(name, mapset) == CELL_TYPE) { sprintf(buf, _("Cannot write quant rules: map %s is integer"), name); G_warning(buf); return -1; } G_quant_get_limits(quant, &d_min, &d_max, &cell_min, &cell_max); /* first actually write the rules */ if (G__quant_export(name, mapset, quant) < 0) { sprintf(buf, _("Cannot write quant rules for map %s"), name); G_warning(buf); return -1; } return 1; }
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 ); }
GRASSRasterBand::GRASSRasterBand( GRASSDataset *poDS, int nBand, const char * pszMapset, const char * pszCellName ) { struct Cell_head sCellInfo; // Note: GISDBASE, LOCATION_NAME ans MAPSET was set in GRASSDataset::Open this->poDS = poDS; this->nBand = nBand; this->valid = false; this->pszCellName = G_store ( (char *) pszCellName ); this->pszMapset = G_store ( (char *) pszMapset ); G_get_cellhd( (char *) pszCellName, (char *) pszMapset, &sCellInfo ); nGRSType = G_raster_map_type( (char *) pszCellName, (char *) pszMapset ); /* -------------------------------------------------------------------- */ /* Get min/max values. */ /* -------------------------------------------------------------------- */ struct FPRange sRange; if( G_read_fp_range( (char *) pszCellName, (char *) pszMapset, &sRange ) == -1 ) { bHaveMinMax = FALSE; } else { bHaveMinMax = TRUE; G_get_fp_range_min_max( &sRange, &dfCellMin, &dfCellMax ); } /* -------------------------------------------------------------------- */ /* Setup band type, and preferred nodata value. */ /* -------------------------------------------------------------------- */ // Negative values are also (?) stored as 4 bytes (format = 3) // => raster with format < 3 has only positive values // GRASS modules usually do not waste space and only the format necessary to keep // full raster values range is used -> no checks if shorter type could be used if( nGRSType == CELL_TYPE ) { if ( sCellInfo.format == 0 ) { // 1 byte / cell -> possible range 0,255 if ( bHaveMinMax && dfCellMin > 0 ) { this->eDataType = GDT_Byte; dfNoData = 0.0; } else if ( bHaveMinMax && dfCellMax < 255 ) { this->eDataType = GDT_Byte; dfNoData = 255.0; } else { // maximum is not known or full range is used this->eDataType = GDT_UInt16; dfNoData = 256.0; } nativeNulls = false; } else if ( sCellInfo.format == 1 ) { // 2 bytes / cell -> possible range 0,65535 if ( bHaveMinMax && dfCellMin > 0 ) { this->eDataType = GDT_UInt16; dfNoData = 0.0; } else if ( bHaveMinMax && dfCellMax < 65535 ) { this->eDataType = GDT_UInt16; dfNoData = 65535; } else { // maximum is not known or full range is used CELL cval; this->eDataType = GDT_Int32; G_set_c_null_value ( &cval, 1); dfNoData = (double) cval; nativeNulls = true; } nativeNulls = false; } else { // 3-4 bytes CELL cval; this->eDataType = GDT_Int32; G_set_c_null_value ( &cval, 1); dfNoData = (double) cval; nativeNulls = true; } } else if( nGRSType == FCELL_TYPE ) { FCELL fval; this->eDataType = GDT_Float32; G_set_f_null_value ( &fval, 1); dfNoData = (double) fval; nativeNulls = true; } else if( nGRSType == DCELL_TYPE ) { DCELL dval; this->eDataType = GDT_Float64; G_set_d_null_value ( &dval, 1); dfNoData = (double) dval; nativeNulls = true; } nBlockXSize = poDS->nRasterXSize;; nBlockYSize = 1; G_set_window( &(((GRASSDataset *)poDS)->sCellInfo) ); if ( (hCell = G_open_cell_old((char *) pszCellName, (char *) pszMapset)) < 0 ) { CPLError( CE_Warning, CPLE_AppDefined, "GRASS: Cannot open raster '%s'", pszCellName ); return; } G_copy((void *) &sOpenWindow, (void *) &(((GRASSDataset *)poDS)->sCellInfo), sizeof(struct Cell_head)); /* -------------------------------------------------------------------- */ /* Do we have a color table? */ /* -------------------------------------------------------------------- */ poCT = NULL; if( G_read_colors( (char *) pszCellName, (char *) pszMapset, &sGrassColors ) == 1 ) { int maxcolor; CELL min, max; G_get_color_range ( &min, &max, &sGrassColors); if ( bHaveMinMax ) { if ( max < dfCellMax ) { maxcolor = max; } else { maxcolor = (int) ceil ( dfCellMax ); } if ( maxcolor > GRASS_MAX_COLORS ) { maxcolor = GRASS_MAX_COLORS; CPLDebug( "GRASS", "Too many values, color table cut to %d entries.", maxcolor ); } } else { if ( max < GRASS_MAX_COLORS ) { maxcolor = max; } else { maxcolor = GRASS_MAX_COLORS; CPLDebug( "GRASS", "Too many values, color table set to %d entries.", maxcolor ); } } poCT = new GDALColorTable(); for( int iColor = 0; iColor <= maxcolor; iColor++ ) { int nRed, nGreen, nBlue; GDALColorEntry sColor; #if GRASS_VERSION_MAJOR >= 7 if( Rast_get_c_color( &iColor, &nRed, &nGreen, &nBlue, &sGrassColors ) ) #else if( G_get_color( iColor, &nRed, &nGreen, &nBlue, &sGrassColors ) ) #endif { sColor.c1 = nRed; sColor.c2 = nGreen; sColor.c3 = nBlue; sColor.c4 = 255; poCT->SetColorEntry( iColor, &sColor ); } else { sColor.c1 = 0; sColor.c2 = 0; sColor.c3 = 0; sColor.c4 = 0; poCT->SetColorEntry( iColor, &sColor ); } } /* Create metadata enries for color table rules */ char key[200], value[200]; int rcount = G_colors_count ( &sGrassColors ); sprintf ( value, "%d", rcount ); this->SetMetadataItem( "COLOR_TABLE_RULES_COUNT", value ); /* Add the rules in reverse order */ for ( int i = rcount-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, &sGrassColors, i ); sprintf ( key, "COLOR_TABLE_RULE_RGB_%d", rcount-i-1 ); sprintf ( value, "%e %e %d %d %d %d %d %d", val1, val2, r1, g1, b1, r2, g2, b2 ); this->SetMetadataItem( key, value ); } } else { this->SetMetadataItem( "COLOR_TABLE_RULES_COUNT", "0" ); } this->valid = true; }
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 ); }
int main( int argc, char **argv ) { char *mapset; char *name; struct GModule *module; struct Option *map; struct Option *win; struct Option *format; struct Cell_head window; RASTER_MAP_TYPE raster_type; /* Initialize the GIS calls */ G_gisinit( argv[0] ); module = G_define_module(); module->keywords = ( "display, raster" ); module->description = ( "Output raster map layers in a format suitable for display in QGIS" ); map = G_define_standard_option( G_OPT_R_MAP ); map->description = ( "Raster map to be displayed" ); format = G_define_option(); format->key = "format"; format->type = TYPE_STRING; format->description = "format"; format->options = "color,value"; win = G_define_option(); win->key = "window"; win->type = TYPE_DOUBLE; win->multiple = YES; win->description = "xmin,ymin,xmax,ymax,ncols,nrows"; if ( G_parser( argc, argv ) ) exit( EXIT_FAILURE ); name = map->answer; /* Make sure map is available */ mapset = G_find_cell2( name, "" ); if ( mapset == NULL ) G_fatal_error(( "Raster map <%s> not found" ), name ); /* It can happen that GRASS data set is 'corrupted' and zone differs in WIND and * cellhd, and G_open_cell_old fails, so it is better to read window from map */ /* G_get_window( &window ); */ G_get_cellhd( name, mapset, &window ); window.west = atof( win->answers[0] ); window.south = atof( win->answers[1] ); window.east = atof( win->answers[2] ); window.north = atof( win->answers[3] ); window.cols = atoi( win->answers[4] ); window.rows = atoi( win->answers[5] ); G_adjust_Cell_head( &window, 1, 1 ); G_set_window( &window ); raster_type = G_raster_map_type( name, "" ); display( name, mapset, raster_type, format->answer ); exit( EXIT_SUCCESS ); }
void cell_clip_drv(int col0, int row0, int ncols, int nrows, double **value, int index, int cntwhole, float radius) { register int i, j; int cnt = 0, p; double *rich, *richtmp; char *name, *mapset; DCELL **buf; DCELL **null_buf; RASTER_MAP_TYPE data_type; /* col0 = starting column for area to be clipped row0 = starting row for area to be clipped ncols = number of columns in area to be clipped nrows = number of rows in area to be clipped value = index = number of the region to be clipped, if there's a region map buf = pointer to array containing the clipped area, a smaller area than the original raster map to be read from finput printf("h2\n"); pat = pointer to array containing the map of patch numbers cor = pointer to array containing the map of interior area */ name = choice->fn; mapset = G_mapset(); data_type = G_raster_map_type(name, mapset); /* dynamically allocate storage for the buffer that will hold the contents of the window */ buf = (DCELL **) G_calloc(nrows + 3, sizeof(DCELL *)); for (i = 0; i < nrows + 3; i++) { buf[i] = (DCELL *) G_calloc(ncols + 3, sizeof(DCELL)); } /* dynamically allocate storage for the buffer that will hold the null values for the clipped area */ null_buf = (DCELL **) G_calloc(nrows + 3, sizeof(DCELL *)); for (i = 0; i < nrows + 3; i++) null_buf[i] = (DCELL *) G_calloc(ncols + 3, sizeof(DCELL)); /* call the cell_clip routine */ cell_clip(buf, null_buf, row0, col0, nrows, ncols, index, radius); /* dynamically allocate memory for the richness array */ richtmp = (double *)G_calloc(MAX, sizeof(double)); /* go through the sampling area pixel by pixel */ for (i = 1; i < nrows + 1; i++) { for (j = 1; j < ncols + 1; j++) { /* if buf[i][j] is not a null value, call get_rich to tally up the number of different attributes in the sampling area and fill the richness array with those attributes */ if ((buf[i][j] || buf[i][j] == 0.0) && null_buf[i][j] == 0.0) { /*printf("buf[%d][%d] = %f\n",i,j,buf[i][j]); */ get_rich(buf[i][j], richtmp, &cnt); } } } if (cnt) { rich = (double *)G_calloc(cnt, sizeof(double)); for (i = 0; i < cnt; i++) { rich[i] = richtmp[i]; } G_free(richtmp); /* call ANSI C runtime library function qsort to sort the richness array into ascending order */ qsort(rich, cnt, sizeof(double), compar); /* moving window */ if (choice->wrum == 'm') { if (is_not_empty_buffer(buf, null_buf, nrows + 1, ncols + 1)) { if (center_is_not_null(buf, null_buf, nrows, ncols)) mv_texture(nrows, ncols, buf, null_buf, value, index, rich, cnt, cntwhole); else { for (p = 0; p < 17; p++) *(*(value + index) + p) = -BIG; } } } /* whole map, units, or regions */ else if (is_not_empty_buffer(buf, null_buf, nrows + 1, ncols + 1)) df_texture(nrows, ncols, buf, null_buf, rich, cnt, cntwhole); for (i = 0; i < nrows + 3; i++) G_free(*(buf + i)); G_free(buf); /* free memory allocated for null buffer */ for (i = 0; i < nrows + 3; i++) G_free(null_buf[i]); G_free(null_buf); G_free(rich); } else G_free(richtmp); return; }
void cell_clip(DCELL ** buf, DCELL ** null_buf, int row0, int col0, int nrows, int ncols, int index, float radius) { CELL *tmp, *tmp1; FCELL *ftmp; DCELL *dtmp; char *tmpname, *nulltmp; int fr; register int i, j; double center_row = 0.0, center_col = 0.0; double dist; RASTER_MAP_TYPE data_type; /* Variables: IN: buf = pointer to array containing only the pixels inside the area that was specified to be clipped, so a smaller array than the original raster map null_buf = pointer to array containing the corresponding null values row0 = starting row for the area to be clipped out of the raster map col0 = starting col for the area to be clipped out of the raster map nrows = total number of rows in the area to be clipped ncols = total number of cols in the area to be clipped index = number of the region to be clipped, if there's a region map INTERNAL: tmp = pointer to a temporary array to store a row of the raster map tmp1 = pointer to a temporary array to store a row of the region map fr = return value from attempting to open the region map i, j = indices to rows and cols of the arrays */ data_type = G_raster_map_type(choice->fn, G_mapset()); /* if sampling by region was chosen, check for the region map and make sure it is an integer (CELL_TYPE) map */ if (choice->wrum == 'r') { if (0 > (fr = G_open_cell_old(choice->reg, G_mapset()))) { fprintf(stderr, "\n"); fprintf(stderr, " *******************************************************\n"); fprintf(stderr, " You specified sam=r to request sampling by region, \n"); fprintf(stderr, " but the region map specified with the 'reg=' parameter\n"); fprintf(stderr, " cannot be found in the current mapset. \n"); fprintf(stderr, " *******************************************************\n"); exit(1); } if (G_raster_map_type(choice->reg, G_mapset()) > 0) { fprintf(stderr, "\n"); fprintf(stderr, " *******************************************************\n"); fprintf(stderr, " You specified sam=r to request sampling by region, \n"); fprintf(stderr, " but the region map specified with the 'reg=' parameter\n"); fprintf(stderr, " must be an integer map, and it is floating point or \n"); fprintf(stderr, " double instead. \n"); fprintf(stderr, " *******************************************************\n"); exit(1); } tmp1 = G_allocate_raster_buf(CELL_TYPE); G_zero_raster_buf(tmp1, CELL_TYPE); fprintf(stderr, "Analyzing region number %d...\n", index); } /* allocate memory to store a row of the raster map, depending on the type of input raster map; keep track of the name of the buffer for each raster type */ switch (data_type) { case CELL_TYPE: tmp = G_allocate_raster_buf(CELL_TYPE); tmpname = "tmp"; break; case FCELL_TYPE: ftmp = G_allocate_raster_buf(FCELL_TYPE); tmpname = "ftmp"; break; case DCELL_TYPE: dtmp = G_allocate_raster_buf(DCELL_TYPE); tmpname = "dtmp"; break; } /* allocate memory to store a row of the null values corresponding to the raster map */ nulltmp = G_allocate_null_buf(); /* if circles are used for sampling, then calculate the center of the area to be clipped, in pixels */ if ((int)radius) { center_row = ((double)row0 + ((double)nrows - 1) / 2); center_col = ((double)col0 + ((double)ncols - 1) / 2); } /* for each row of the area to be clipped */ for (i = row0; i < row0 + nrows; i++) { /* if region, read in the corresponding map row in the region file */ if (choice->wrum == 'r') G_get_raster_row_nomask(fr, tmp1, i, CELL_TYPE); /* initialize each element of the row buffer to 0; this row buffer will hold one row of the clipped raster map. Then read row i of the map and the corresponding null values into tmp and nulltmp buffers */ switch (data_type) { case CELL_TYPE: G_zero_raster_buf(tmp, data_type); G_get_raster_row(finput, tmp, i, CELL_TYPE); break; case FCELL_TYPE: G_zero_raster_buf(ftmp, data_type); G_get_raster_row(finput, ftmp, i, FCELL_TYPE); break; case DCELL_TYPE: G_zero_raster_buf(dtmp, data_type); G_get_raster_row(finput, dtmp, i, DCELL_TYPE); break; } G_get_null_value_row(finput, nulltmp, i); /* for all the columns one by one */ for (j = col0; j < col0 + ncols; j++) { /* if circles are used for sampling */ if ((int)radius) { dist = sqrt(((double)i - center_row) * ((double)i - center_row) + ((double)j - center_col) * ((double)j - center_col)); /* copy the contents of tmp into the appropriate cell in buf */ if (dist < radius) { switch (data_type) { case CELL_TYPE: *(*(buf + i + 1 - row0) + j + 1 - col0) = *(tmp + j); break; case FCELL_TYPE: *(*(buf + i + 1 - row0) + j + 1 - col0) = *(ftmp + j); break; case DCELL_TYPE: *(*(buf + i + 1 - row0) + j + 1 - col0) = *(dtmp + j); break; } *(*(null_buf + i + 1 - row0) + j + 1 - col0) = *(nulltmp + j); } } /* if circles are not used and if the choice is not "by region" or if this column is in region "index" */ else if (choice->wrum != 'r' || *(tmp1 + j) == index) { /* copy the contents of the correct tmp into the appropriate cell in the buf and the corresponding null values into the appropriate cell in null_buf */ switch (data_type) { case CELL_TYPE: *(*(buf + i + 1 - row0) + j + 1 - col0) = *(tmp + j); break; case FCELL_TYPE: *(*(buf + i + 1 - row0) + j + 1 - col0) = *(ftmp + j); break; case DCELL_TYPE: *(*(buf + i + 1 - row0) + j + 1 - col0) = *(dtmp + j); break; } *(*(null_buf + i + 1 - row0) + j + 1 - col0) = *(nulltmp + j); } } } switch (data_type) { case CELL_TYPE: G_free(tmp); break; case FCELL_TYPE: G_free(ftmp); break; case DCELL_TYPE: G_free(dtmp); break; } if (choice->wrum == 'r') { G_free(tmp1); G_close_cell(fr); } G_free(nulltmp); return; }
int main(int argc, char *argv[]) { char *name, *mapset; char rname[GNAME_MAX], rmapset[GMAPSET_MAX]; char path[GPATH_MAX]; int row, col, null_fd; unsigned char *null_bits; RASTER_MAP_TYPE map_type; int change_null = 0, create, remove, only_int, only_fp, only_null; int is_reclass; struct GModule *module; struct { struct Option *map; struct Option *setnull; struct Option *null; } parms; struct { struct Flag *f; struct Flag *n; struct Flag *i; struct Flag *c; struct Flag *r; } flags; G_gisinit(argv[0]); module = G_define_module(); module->keywords = _("raster, null data"); module->description = _("Manages NULL-values of given raster map."); parms.map = G_define_standard_option(G_OPT_R_MAP); parms.map->description = _("Name of raster map for which to edit null file"); parms.setnull = G_define_option(); parms.setnull->key = "setnull"; parms.setnull->key_desc = "val[-val]"; parms.setnull->type = TYPE_STRING; parms.setnull->required = NO; parms.setnull->multiple = YES; parms.setnull->description = _("List of cell values to be set to NULL"); parms.setnull->guisection = _("Modify"); parms.null = G_define_option(); parms.null->key = "null"; parms.null->type = TYPE_DOUBLE; parms.null->required = NO; parms.null->multiple = NO; parms.null->description = _("The value to replace the null value by"); parms.null->guisection = _("Modify"); flags.f = G_define_flag(); flags.f->key = 'f'; flags.f->description = _("Only do the work if the map is floating-point"); flags.f->guisection = _("Check"); flags.i = G_define_flag(); flags.i->key = 'i'; flags.i->description = _("Only do the work if the map is integer"); flags.i->guisection = _("Check"); flags.n = G_define_flag(); flags.n->key = 'n'; flags.n->description = _("Only do the work if the map doesn't have a NULL-value bitmap file"); flags.n->guisection = _("Check"); flags.c = G_define_flag(); flags.c->key = 'c'; flags.c->description = _("Create NULL-value bitmap file validating all data cells"); flags.r = G_define_flag(); flags.r->key = 'r'; flags.r->description = _("Remove NULL-value bitmap file"); flags.r->guisection = _("Remove"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); only_int = flags.i->answer; only_fp = flags.f->answer; only_null = flags.n->answer; create = flags.c->answer; remove = flags.r->answer; name = parms.map->answer; mapset = G_find_cell2(name, ""); if (mapset == NULL) G_fatal_error(_("Raster map <%s> not found"), name); is_reclass = (G_is_reclass(name, mapset, rname, rmapset) > 0); if (is_reclass) G_fatal_error(_("Raster map <%s> is a reclass of map <%s@%s>. " "Consider to generate a copy with r.mapcalc. Exiting."), name, rname, rmapset); if (strcmp(mapset, G_mapset()) != 0) G_fatal_error(_("Raster map <%s> is not in your mapset <%s>"), name, G_mapset()); if (parms.null->answer) { if (sscanf(parms.null->answer, "%lf", &new_null) == 1) change_null = 1; else G_fatal_error(_("%s is illegal entry for null"), parms.null->answer); } map_type = G_raster_map_type(name, mapset); if (only_null && G_find_file_misc("cell_misc", "null", name, mapset)) G_fatal_error(_("Raster map <%s> already has a null bitmap file"), name); if (map_type == CELL_TYPE) { if (only_fp) G_fatal_error(_("<%s> is integer raster map (CELL)"), name); if ((double)((int)new_null) != new_null) { G_warning(_("<%s> is integer raster map (CELL). Using null=%d."), name, (int)new_null); new_null = (double)((int)new_null); } } else if (only_int) G_fatal_error(_("<%s> is floating pointing raster map"), name); parse_vallist(parms.setnull->answers, &d_mask); if (G_get_cellhd(name, mapset, &cellhd) < 0) G_fatal_error(_("Unable to read header of raster map <%s>"), G_fully_qualified_name(name, mapset)); if (create) { /* write a file of no-nulls */ null_bits = (unsigned char *)G__allocate_null_bits(cellhd.cols); /* init all cells to 0's */ for (col = 0; col < G__null_bitstream_size(cellhd.cols); col++) null_bits[col] = 0; null_fd = G_open_new_misc("cell_misc", "null", name); G_verbose_message(_("Writing new null file for raster map <%s>..."), name); for (row = 0; row < cellhd.rows; row++) { G_percent(row, cellhd.rows, 1); if (G__write_null_bits(null_fd, null_bits, row, cellhd.cols, 0) < 0) G_fatal_error(_("Error writing null row %d"), row); } G_percent(row, cellhd.rows, 1); close(null_fd); G_done_msg(_("Raster map <%s> modified."), name); exit(EXIT_SUCCESS); } if (remove) { /* write a file of no-nulls */ G_verbose_message(_("Removing null file for raster map <%s>..."), name); null_fd = G_open_new_misc("cell_misc", "null", name); G__file_name_misc(path, "cell_misc", "null", name, mapset); unlink(path); G_done_msg(_("Raster map <%s> modified."), name); exit(EXIT_SUCCESS); } process(name, mapset, change_null, map_type); exit(EXIT_SUCCESS); }
GRASSRasterBand::GRASSRasterBand( GRASSDataset *poDS, int nBand, const char * pszMapset, const char * pszCellName ) { struct Cell_head sCellInfo; this->poDS = poDS; this->nBand = nBand; G_get_cellhd( (char *) pszCellName, (char *) pszMapset, &sCellInfo ); nGRSType = G_raster_map_type( (char *) pszCellName, (char *) pszMapset ); /* -------------------------------------------------------------------- */ /* Get min/max values. */ /* -------------------------------------------------------------------- */ struct FPRange sRange; if( G_read_fp_range( (char *) pszCellName, (char *) pszMapset, &sRange ) == -1 ) { bHaveMinMax = FALSE; } else { bHaveMinMax = TRUE; G_get_fp_range_min_max( &sRange, &dfCellMin, &dfCellMax ); } /* -------------------------------------------------------------------- */ /* Setup band type, and preferred nodata value. */ /* -------------------------------------------------------------------- */ dfNoData = 0.0; if( nGRSType == CELL_TYPE && sCellInfo.format == 0 ) { if( bHaveMinMax && dfCellMin < 1.0 && dfCellMax > 254.0 ) { this->eDataType = GDT_UInt16; dfNoData = 256.0; } else { this->eDataType = GDT_Byte; if( dfCellMax < 255.0 ) dfNoData = 255.0; else dfNoData = 0.0; } } else if( nGRSType == CELL_TYPE && sCellInfo.format == 1 ) { this->eDataType = GDT_UInt16; dfNoData = 65535.0; } else if( nGRSType == CELL_TYPE ) { this->eDataType = GDT_UInt32; dfNoData = 65535.0; } else if( nGRSType == FCELL_TYPE ) { this->eDataType = GDT_Float32; dfNoData = -12345.0; } else if( nGRSType == DCELL_TYPE ) { this->eDataType = GDT_Float64; dfNoData = -12345.0; } nBlockXSize = poDS->nRasterXSize;; nBlockYSize = 1; hCell = G_open_cell_old((char *) pszCellName, (char *) pszMapset); /* -------------------------------------------------------------------- */ /* Do we have a color table? */ /* -------------------------------------------------------------------- */ struct Colors sGrassColors; poCT = NULL; if( G_read_colors( (char *) pszCellName, (char *) pszMapset, &sGrassColors ) == 1 ) { poCT = new GDALColorTable(); for( int iColor = 0; iColor < 256; iColor++ ) { int nRed, nGreen, nBlue; GDALColorEntry sColor; if( G_get_color( iColor, &nRed, &nGreen, &nBlue, &sGrassColors ) ) { sColor.c1 = nRed; sColor.c2 = nGreen; sColor.c3 = nBlue; sColor.c4 = 255; poCT->SetColorEntry( iColor, &sColor ); } else { sColor.c1 = 0; sColor.c2 = 0; sColor.c3 = 0; sColor.c4 = 0; poCT->SetColorEntry( iColor, &sColor ); } } G_free_colors( &sGrassColors ); } }
void* raster2array(const char* name, struct Cell_head* header, int* rows, int* cols, RASTER_MAP_TYPE out_type) { // Open the raster map and load the dem // for simplicity sake, the dem will be an array of // doubles, converted from any possible GRASS CELL type. char* mapset = G_find_cell2(name, ""); if (mapset == NULL) G_fatal_error("Raster map <%s> not found", name); // Find out the cell type of the DEM RASTER_MAP_TYPE type = G_raster_map_type(name, mapset); // Get a file descriptor for the DEM raster map int infd; if ((infd = G_open_cell_old(name, mapset)) < 0) G_fatal_error("Unable to open raster map <%s>", name); // Get header info for the DEM raster map struct Cell_head cellhd; if (G_get_cellhd(name, mapset, &cellhd) < 0) G_fatal_error("Unable to open raster map <%s>", name); // Create a GRASS buffer for the DEM raster void* inrast = G_allocate_raster_buf(type); // Get the max rows and max cols from the window information, since the // header gives the values for the full raster const int maxr = G_window_rows(); const int maxc = G_window_cols(); // Read in the raster line by line, copying it into the double array // rast for return. void* rast; switch (out_type) { case CELL_TYPE: rast = (int*) calloc(maxr * maxc, sizeof(int)); break; case FCELL_TYPE: rast = (float*) calloc(maxr * maxc, sizeof(float)); break; case DCELL_TYPE: rast = (double*) calloc(maxr * maxc, sizeof(double)); break; } if (rast == NULL) { G_fatal_error("Unable to allocate memory for raster map <%s>", name); } int row, col; for (row = 0; row < maxr; ++row) { if (G_get_raster_row(infd, inrast, row, type) < 0) G_fatal_error("Unable to read raster map <%s> row %d", name, row); for (col = 0; col < maxc; ++col) { int index = col + row * maxc; if (out_type == CELL_TYPE) { switch (type) { case CELL_TYPE: ((int*) rast)[index] = ((int *) inrast)[col]; break; case FCELL_TYPE: ((int*) rast)[index] = (int) ((float *) inrast)[col]; break; case DCELL_TYPE: ((int*) rast)[index] = (int) ((double *) inrast)[col]; break; default: G_fatal_error("Unknown cell type"); break; } } if (out_type == FCELL_TYPE) { switch (type) { case CELL_TYPE: ((float*) rast)[index] = (float) ((int *) inrast)[col]; break; case FCELL_TYPE: ((float*) rast)[index] = ((float *) inrast)[col]; break; case DCELL_TYPE: ((float*) rast)[index] = (float) ((double *) inrast)[col]; break; default: G_fatal_error("Unknown cell type"); break; } } if (out_type == DCELL_TYPE) { switch (type) { case CELL_TYPE: ((double*) rast)[index] = (double) ((int *) inrast)[col]; break; case FCELL_TYPE: ((double*) rast)[index] = (double) ((float *) inrast)[col]; break; case DCELL_TYPE: ((double*) rast)[index] = ((double *) inrast)[col]; break; default: G_fatal_error("Unknown cell type"); break; } } } } // Return cellhd, maxr, and maxc by pointer if (header != NULL) *header = cellhd; if (rows != NULL) *rows = maxr; if (cols != NULL) *cols = maxc; return rast; }
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; }