/*!
\brief Pack color table (floating-point map)
Passed a array of floats that will be converted from cell values
to packed colors (0xbbggrr) and float to int
Floating point data not freed here, use:
gsds_free_data_buff(id, ATTY_FLOAT)
\param filename raster map name
\param fbuf
\param ibuf
\param rows number of rows
\param cols number of cols
*/
void Gs_pack_colors_float(const char *filename, float *fbuf, int *ibuf,
int rows, int cols)
{
const char *mapset;
struct Colors colrules;
unsigned char *r, *g, *b, *set;
int i, j, *icur;
FCELL *fcur;
mapset = G_find_cell2(filename, "");
if (!mapset) {
G_warning(_("Raster map <%s> not found"), filename);
return;
}
r = (unsigned char *)G_malloc(cols);
g = (unsigned char *)G_malloc(cols);
b = (unsigned char *)G_malloc(cols);
set = (unsigned char *)G_malloc(cols);
G_read_colors(filename, mapset, &colrules);
fcur = fbuf;
icur = ibuf;
G_message(_("Translating colors from raster map <%s>..."),
G_fully_qualified_name(filename, mapset));
for (i = 0; i < rows; i++) {
G_lookup_f_raster_colors(fcur, r, g, b, set, cols, &colrules);
G_percent(i, rows, 2);
for (j = 0; j < cols; j++) {
if (set[j]) {
icur[j] =
(r[j] & 0xff) | ((g[j] & 0xff) << 8) | ((b[j] & 0xff) <<
16);
}
else {
icur[j] = NO_DATA_COL;
}
}
icur = &(icur[cols]);
fcur = &(fcur[cols]);
}
G_percent(1, 1, 1);
G_free_colors(&colrules);
G_free(r);
G_free(g);
G_free(b);
G_free(set);
return;
}
GRASSRasterBand::~GRASSRasterBand()
{
if( poCT != NULL ) {
G_free_colors( &sGrassColors );
delete poCT;
}
if( hCell >= 0 )
G_close_cell( hCell );
if ( pszCellName )
G_free ( pszCellName );
if ( pszMapset )
G_free ( pszMapset );
}
int display( char *name,
char *mapset,
RASTER_MAP_TYPE data_type )
{
struct Colors colors;
if ( G_read_colors( name, mapset, &colors ) == -1 )
G_fatal_error(( "Color file for <%s> not available" ), name );
//G_set_null_value_color(r, g, b, &colors);
/* Go draw the raster map */
cell_draw( name, mapset, &colors, data_type );
/* release the colors now */
G_free_colors( &colors );
return 0;
}
int
process(char *name, char *mapset, int change_null, RASTER_MAP_TYPE map_type)
{
struct Colors colr;
struct History hist;
struct Categories cats;
struct Quant quant;
int colr_ok;
int hist_ok;
int cats_ok;
int quant_ok;
G_suppress_warnings(1);
colr_ok = G_read_colors(name, mapset, &colr) > 0;
hist_ok = G_read_history(name, mapset, &hist) >= 0;
cats_ok = G_read_raster_cats(name, mapset, &cats) >= 0;
if (map_type != CELL_TYPE) {
G_quant_init(&quant);
quant_ok = G_read_quant(name, mapset, &quant);
G_suppress_warnings(0);
}
if (doit(name, mapset, change_null, map_type))
return 1;
if (colr_ok) {
G_write_colors(name, mapset, &colr);
G_free_colors(&colr);
}
if (hist_ok)
G_write_history(name, &hist);
if (cats_ok) {
cats.num = G_number_of_cats(name, mapset);
G_write_raster_cats(name, &cats);
G_free_cats(&cats);
}
if (map_type != CELL_TYPE && quant_ok)
G_write_quant(name, mapset, &quant);
return 0;
}
int read_rgb(char *key, char *data)
{
char names[3][100];
char fullname[100];
int i;
if (sscanf(data, "%s %s %s", names[0], names[1], names[2]) != 3) {
error(key, data, "illegal request (rgb)");
return 0;
}
PS.do_raster = 0;
PS.do_colortable = 0;
if (PS.cell_fd >= 0) {
G_close_cell(PS.cell_fd);
G_free(PS.cell_name);
G_free(PS.cell_mapset);
G_free_colors(&PS.colors);
PS.cell_fd = -1;
}
/* initialize group structure (for compatibility with PS_raster_plot()) */
I_init_group_ref(&grp.ref);
/*
* not relevant here
*
if (I_get_group_ref(grp.group_name, &grp.ref) == 0)
G_fatal_error(_("Can't get group information"));
*/
grp.group_name = "RGB Group";
/* get file names for R, G, & B */
for (i = 0; i < 3; i++) {
char *mapset, *name, *p;
name = names[i];
p = strchr(name, '@');
if (p) {
*p = '\0';
mapset = p + 1;
}
else {
mapset = G_find_file2("cell", name, "");
if (!mapset) {
error(name, "", "not found");
return 0;
}
}
grp.name[i] = G_store(name);
grp.mapset[i] = G_store(mapset);
/* read in colors */
if (G_read_colors(grp.name[i], grp.mapset[i], &(grp.colors[i])) == -1) {
sprintf(fullname, "%s in %s", grp.name[i], grp.mapset[i]);
error(fullname, "", "can't read color table");
return 0;
}
/* open raster maps for reading */
if ((grp.fd[i] = G_open_cell_old(grp.name[i], grp.mapset[i])) < 0) {
sprintf(fullname, "%s in %s", grp.name[i], grp.mapset[i]);
error(fullname, "", "can't open raster map");
G_free_colors(&(grp.colors[i]));
return 0;
}
}
strcpy(PS.celltitle, grp.group_name);
G_strip(PS.celltitle);
return 1;
}
int make_new_cell_layer(void)
{
struct History hist;
void *rast;
int cellfd;
int tmpfd;
int row;
/* open the new raster map to contain the edited version of
the original cell layer. open our temporary file for read
and copy its contents to the layer */
G_set_window(&real_window);
cellfd = G_open_raster_new(new_name, map_type);
tmpfd = open(tempfile, 0);
lseek(tmpfd, 0L, 0);
rast = G_allocate_raster_buf(map_type);
fprintf(stderr, "\n +-------------------------------------------+\n");
fprintf(stderr, " | Saving new cell layer |\n");
fprintf(stderr, " +---------------------------------------");
for (row = 0; row < real_nrows; row++) {
if (read(tmpfd, rast, real_ncols * cellsize) !=
(real_ncols * cellsize))
error(1, "error writing raster map during copy");
G_put_raster_row(cellfd, rast, map_type);
G_percent(row, real_nrows, 5);
}
G_percent(100, 100, 5);
fprintf(stderr, "\n");
close(tmpfd);
G_close_cell(cellfd);
unlink(tempfile);
/* create and write cat, colr, quant, and hist support files
for the newly created layer */
if (colr_ok) {
G_write_colors(new_name, user_mapset, &colr);
G_free_colors(&colr);
colr_ok = 0;
}
if (cats_ok) {
cats.num = G_number_of_cats(new_name, user_mapset);
G_write_cats(new_name, &cats);
G_free_cats(&cats);
cats_ok = 0;
}
if (quant_ok) {
G_write_quant(new_name, G_mapset(), &quant);
G_quant_free(&quant);
cats_ok = 0;
}
/* construct some history information */
sprintf(hist.mapid, "%s", G_date());
sprintf(hist.title, "%s", new_name);
sprintf(hist.mapset, "%s", user_mapset);
sprintf(hist.creator, "%s", G_whoami());
sprintf(hist.maptype, "cell");
sprintf(hist.edhist[0],
"Generated by d.rast.edit from original raster map");
sprintf(hist.edhist[1], " %s in mapset %s ", orig_name, orig_mapset);
hist.edlinecnt = 2;
/* write history */
if (G_write_history(new_name, &hist) == -1)
error(0, "could not write history");
return 0;
}
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 );
}
}
