CPLErr GRASSRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff, void * pImage ) { char *pachNullBuf; pachNullBuf = (char *) CPLMalloc(nBlockXSize); G_get_null_value_row( hCell, pachNullBuf, nBlockYOff ); if( eDataType == GDT_Float32 || eDataType == GDT_Float64 || eDataType == GDT_UInt32 ) { G_get_raster_row( hCell, pImage, nBlockYOff, nGRSType ); for( int i = 0; i < nBlockXSize; i++ ) { if( pachNullBuf[i] != 0 ) { if( eDataType == GDT_UInt32 ) ((GUInt32 *) pImage)[i] = (GUInt32) dfNoData; else if( eDataType == GDT_Float32 ) ((float *) pImage)[i] = dfNoData; else ((double *) pImage)[i] = dfNoData; } } } else { GUInt32 *panRow = (GUInt32 *) CPLMalloc(4 * nBlockXSize); G_get_raster_row( hCell, panRow, nBlockYOff, nGRSType ); for( int i = 0; i < nBlockXSize; i++ ) { if( pachNullBuf[i] != 0 ) panRow[i] = (GUInt32) dfNoData; } GDALCopyWords( panRow, GDT_UInt32, 4, pImage, eDataType, GDALGetDataTypeSize(eDataType)/8, nBlockXSize ); CPLFree( panRow ); } CPLFree( pachNullBuf ); return CE_None; }
/* * Loads raster data to host memory and returns a pointer to it. * The operation is performed within the current context. * * CONTEXT *ctx ........... an active OpenCL context. * int nrows .............. the number of rows in the DEM. * int ncols .............. the number of columns in the DEM. * int infd ............... file descriptor to read from the DEM. * RASTER_MAP_TYPE rtype .. DEM element data type. * */ FCELL* load_raster (CONTEXT *ctx, const int nrows, const int ncols, const int infd, RASTER_MAP_TYPE rtype) { int row, col; if (rtype != FCELL_TYPE) { G_fatal_error ("Wrong element data type in 'load_raster'"); return NULL; } else { FCELL *rastbuf = malloc (ncols * G_raster_size (rtype)); G_message ("Loading raster data into memory ..."); /* allocate raster DEM data */ FCELL *dem_device = (FCELL *) clmalloc (ctx, nrows * ncols * G_raster_size (rtype), 0); /* Load input map in device memory row by row */ for (row = 0; row < nrows; row++) { /* display completion percentage */ G_percent (row, nrows, 2); /* read input map */ if (G_get_raster_row (infd, rastbuf, row, rtype) < 0) G_fatal_error ("Unable to read from raster map"); /* copy this row to the device buffer */ FCELL *offset = dem_device + row * ncols; if (offset != memcpy (offset, rastbuf, ncols * G_raster_size (rtype))) G_fatal_error ("Error while copying memory!"); } /* free buffers */ free (rastbuf); /* Return a pointer to the allocated resources */ return dem_device; } }
int read_row(void *buf) { void *p; if (last_read) return (0); if (first_read) { blank_line(buf); first_read = 0; } else { if (row_count >= n_rows) { last_read = 1; blank_line(buf); } else { /* The buf variable is a void pointer and thus */ /* points to anything. Therefore, it's size is */ /* unknown and thus, it cannot be used for pointer */ /* arithmetic (some compilers treat this as an error */ /* - SGI MIPSPro compiler for one). Make the */ /* assumption that data_size is the proper number of */ /* bytes and cast the buf variable to char * before */ /* incrementing */ p = ((char *)buf) + data_size; G_get_raster_row(input_fd, p, row_count++, data_type); p = buf; G_set_null_value(p, 1, data_type); /* Again we need to cast p to char * under the */ /* assumption that the increment is the proper */ /* number of bytes. */ p = ((char *)p) + (row_length + 1) * data_size; G_set_null_value(p, 1, data_type); } } return (row_length + 2); }
int GRASS_LIB_EXPORT G_get_d_raster_row( int fd, DCELL * buf, int row ) { return G_get_raster_row( fd, ( void* )buf, row, DCELL_TYPE ); }
int GRASS_LIB_EXPORT G_get_raster_row_nomask( int fd, void * buf, int row, RASTER_MAP_TYPE data_type ) { return G_get_raster_row( fd, buf, row, data_type ); }
static int cell_draw( char *name, char *mapset, struct Colors *colors, RASTER_MAP_TYPE data_type, char *format ) { int cellfile; void *xarray; int row; int ncols, nrows; static unsigned char *red, *grn, *blu, *set; int i; void *ptr; int big_endian; long one = 1; FILE *fo; int raster_size; big_endian = !( *(( char * )( &one ) ) ); ncols = G_window_cols(); nrows = G_window_rows(); /* Make sure map is available */ if (( cellfile = G_open_cell_old( name, mapset ) ) == -1 ) G_fatal_error(( "Unable to open raster map <%s>" ), name ); /* Allocate space for cell buffer */ xarray = G_allocate_raster_buf( data_type ); red = G_malloc( ncols ); grn = G_malloc( ncols ); blu = G_malloc( ncols ); set = G_malloc( ncols ); /* some buggy C libraries require BOTH setmode() and fdopen(bin) */ #ifdef WIN32 if ( _setmode( _fileno( stdout ), _O_BINARY ) == -1 ) G_fatal_error( "Cannot set stdout mode" ); #endif // Unfortunately this is not sufficient on Windows to switch stdout to binary mode fo = fdopen( fileno( stdout ), "wb" ); raster_size = G_raster_size( data_type ); //fprintf( fo, "%d %d", data_type, raster_size ); //exit(0); /* loop for array rows */ for ( row = 0; row < nrows; row++ ) { G_get_raster_row( cellfile, xarray, row, data_type ); ptr = xarray; G_lookup_raster_colors( xarray, red, grn, blu, set, ncols, colors, data_type ); for ( i = 0; i < ncols; i++ ) { unsigned char alpha = 255; //G_debug ( 0, "row = %d col = %d", row, i ); if ( G_is_null_value( ptr, data_type ) ) { alpha = 0; } if ( strcmp( format, "color" ) == 0 ) { // We need data suitable for QImage 32-bpp // the data are stored in QImage as QRgb which is unsigned int. // Because it depends on byte order of the platform we have to // consider byte order (well, middle endian ignored) if ( big_endian ) { // I have never tested this fprintf( fo, "%c%c%c%c", alpha, red[i], grn[i], blu[i] ); } else { fprintf( fo, "%c%c%c%c", blu[i], grn[i], red[i], alpha ); } } else { if ( data_type == CELL_TYPE ) { //G_debug ( 0, "valx = %d", *((CELL *) ptr)); } if ( G_is_null_value( ptr, data_type ) ) { if ( data_type == CELL_TYPE ) { int nul = -2147483647; fwrite( &nul , 4, 1, fo ); } else if ( data_type == DCELL_TYPE ) { double nul = 2.2250738585072014e-308; fwrite( &nul , 8, 1, fo ); } else if ( data_type == FCELL_TYPE ) { double nul = 1.17549435e-38F; fwrite( &nul , 4, 1, fo ); } } else { fwrite( ptr, raster_size, 1, fo ); } } ptr = G_incr_void_ptr( ptr, raster_size ); } } G_close_cell( cellfile ); return ( 0 ); }
/* * main function */ int main(int argc, char *argv[]) { /* struct Cell_head window; database window */ struct Cell_head cellhd; /* it stores region information, and header information of rasters */ char *name, *name2; /* input raster name */ char *result; /* output raster name */ char *mapset; /* mapset name */ void *inrast; /* input buffer */ unsigned char *outrast; /* output buffer */ int nrows, ncols; int row, col; int infd, outfd; /* file descriptor */ int verbose; struct History history; /* holds meta-data (title, comments,..) */ struct GModule *module; /* GRASS module for parsing arguments */ struct Option *input, *output, *input2; /* options */ FILE *in; /*file for Path loss factors*/ struct Flag *flag1; /* flags */ char buffer_out[1000]; strcpy(buffer_out,getenv("GISBASE")); strcat(buffer_out,"/etc/radio_coverage/lossfactors_new.txt"); /*G_message(_("1!! Pot1: %s, Pot2: %s"), buffer_path, buffer_path1); buffer_out=strcat(buffer_path,buffer_path1); G_message(_("Pot1: %s, Pot2: %s"), buffer_path, buffer_path1);*/ /* initialize GIS environment */ G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */ /* initialize module */ module = G_define_module(); module->keywords = _("raster, clutter"); module->description = _("Clutter convert module"); /* Define the different options as defined in gis.h */ input = G_define_standard_option(G_OPT_R_INPUT); input2 = G_define_standard_option(G_OPT_F_INPUT); input2->key = "Path_loss_values"; input2->type = TYPE_STRING; input2->required = YES; input2->answer = buffer_out;//getenv("GISBASE"); //strcat(buffer_path1,(char *)getenv("GISBASE"));//,"/etc/radio_coverage"); input2->gisprompt = "old_file,file,input"; input2->description = _("Path loss factors for land usage"); /* Define the different flags */ flag1 = G_define_flag(); flag1->key = 'o'; flag1->description = _("Old_Cipher"); output = G_define_standard_option(G_OPT_R_OUTPUT); /* options and flags parser */ if (G_parser(argc, argv)) { exit(EXIT_FAILURE); } /*G_message(_("1!! Pot1: %s, Pot2: %s"), buffer_path, buffer_path1); strcat(buffer_path,buffer_path1); G_message(_("Pot1: %s, Pot2: %s"), buffer_path, buffer_path1); input2->answer = buffer_path;//getenv("GISBASE"); //strcat(buffer_path1,(char *)getenv("GISBASE"));//,"/etc/radio_coverage");*/ /* stores options and flags to variables */ name = input->answer; name2 = input2->answer; result = output->answer; verbose = (flag1->answer); G_message(_("Verbose: %d"),verbose); /* returns NULL if the map was not found in any mapset, * mapset name otherwise */ //G_message(_("3_START")); mapset = G_find_cell2(name, ""); if (mapset == NULL) G_fatal_error(_("Raster map <%s> not found"), name); if (G_legal_filename(result) < 0) G_fatal_error(_("<%s> is an illegal file name"), result); /* G_open_cell_old - returns file destriptor (>0) */ if ((infd = G_open_cell_old(name, mapset)) < 0) G_fatal_error(_("Unable to open raster map <%s>"), name); /* controlling, if we can open input raster */ if (G_get_cellhd(name, mapset, &cellhd) < 0) G_fatal_error(_("Unable to read file header of <%s>"), name); G_debug(3, "number of rows %d", cellhd.rows); G_set_window(&cellhd); G_get_set_window(&cellhd); /* Allocate input buffer */ inrast = G_allocate_raster_buf(FCELL_TYPE); /* Allocate output buffer, use input map data_type */ nrows = G_window_rows(); ncols = G_window_cols(); outrast = G_allocate_raster_buf(FCELL_TYPE); G_message(_("nrows %d and ncols %d"),nrows,ncols); /* controlling, if we can write the raster */ if ((outfd = G_open_raster_new(result, FCELL_TYPE)) < 0) G_fatal_error(_("Unable to create raster map <%s>"), result); /* do Clutter Convert */ /* open file for model tuning parameters*/ char fileName[150]; strcpy (fileName, name2); //G_message(_("Path: %s"),name2); if( (in = fopen(fileName,"r")) == NULL ) G_fatal_error(_("Unable to open file <%s>"), fileName); char buffer[256]; double terr_path_loss[100]; int counter=0; fgets (buffer, 250, in); while(fgets(buffer,250,in)!=NULL){ sscanf(buffer,"%lf %lf", &terr_path_loss[counter]); counter++; } int cipher_cont=0; /* old or new clutter */ if (verbose == 1) { cipher_cont=1; G_message(_("Parameter UR: %f, GP: %f, RP: %f, GI: %f, GL: %f, GM: %f, GR: %f, VO: %f, KM: %f, OD: %f"), terr_path_loss[0], terr_path_loss[1], terr_path_loss[2], terr_path_loss[3], terr_path_loss[4], terr_path_loss[5], terr_path_loss[6], terr_path_loss[7], terr_path_loss[8], terr_path_loss[9]); } else if (verbose == 0) { cipher_cont=11; G_message(_("Parameter UR1: %f, UR2: %f, UR3: %f, UR4: %f, UR5: %f, GI: %f, GL: %f, GM: %f, GR: %f, VO: %f, KM: %f, OD: %f"), terr_path_loss[0], terr_path_loss[1], terr_path_loss[2], terr_path_loss[3], terr_path_loss[4], terr_path_loss[5], terr_path_loss[6], terr_path_loss[7], terr_path_loss[8], terr_path_loss[9], terr_path_loss[10], terr_path_loss[11]); } G_message(_("Counter: %d"),counter); G_message(_("cipher_cont: %d"),cipher_cont); G_message(_("START")); /* for each row */ for (row = 0; row < nrows; row++) { FCELL f_in, f_out; /* read input map */ if (G_get_raster_row(infd, inrast, row, FCELL_TYPE) < 0) G_fatal_error(_("Unable to read raster map <%s> row %d"), name, row); /* process the data */ for (col = 0; col < ncols; col++) { f_in = ((FCELL *) inrast)[col]; //G_message(_("Input data: %d"),(int)f_in); f_out = terr_path_loss[(int)f_in-cipher_cont]; //G_message(_("Output data: %f"),(double)f_out); ((FCELL *) outrast)[col] = f_out; } /* write raster row to output raster map */ if (G_put_raster_row(outfd, outrast, FCELL_TYPE) < 0) G_fatal_error(_("Failed writing raster map <%s>"), result); } //G_message(_("END_clutconvert_test")); G_message(_("END")); /* memory cleanup */ G_free(inrast); G_free(outrast); /* closing raster maps */ G_close_cell(infd); G_close_cell(outfd); /* add command line incantation to history file */ G_short_history(result, "raster", &history); G_command_history(&history); G_write_history(result, &history); exit(EXIT_SUCCESS); }
static int cell_draw( char *name, char *mapset, struct Colors *colors, RASTER_MAP_TYPE data_type, char *format ) { int cellfile; void *xarray = 0; int row; int ncols, nrows; static unsigned char *red, *grn, *blu, *set; int i; void *ptr = 0; int big_endian; long one = 1; FILE *fo = 0; size_t raster_size; #ifdef NAN double dnul = NAN; float fnul = ( float )( NAN ); #else double dnul = strtod( "NAN", 0 ); float fnul = strtof( "NAN", 0 ); // another possibility would be nan()/nanf() - C99 // and 0./0. if all fails #endif assert( dnul != dnul ); assert( fnul != fnul ); big_endian = !( *( ( char * )( &one ) ) ); ncols = G_window_cols(); nrows = G_window_rows(); /* Make sure map is available */ if ( ( cellfile = G_open_cell_old( name, mapset ) ) == -1 ) G_fatal_error( ( "Unable to open raster map <%s>" ), name ); /* Allocate space for cell buffer */ xarray = G_allocate_raster_buf( data_type ); red = G_malloc( ncols ); grn = G_malloc( ncols ); blu = G_malloc( ncols ); set = G_malloc( ncols ); /* some buggy C libraries require BOTH setmode() and fdopen(bin) */ // Do not use Q_OS_WIN, we are in C file, no Qt headers #ifdef WIN32 if ( _setmode( _fileno( stdout ), _O_BINARY ) == -1 ) G_fatal_error( "Cannot set stdout mode" ); #endif // Unfortunately this is not sufficient on Windows to switch stdout to binary mode fo = fdopen( fileno( stdout ), "wb" ); raster_size = G_raster_size( data_type ); //fprintf( fo, "%d %d", data_type, raster_size ); //exit(0); /* loop for array rows */ for ( row = 0; row < nrows; row++ ) { G_get_raster_row( cellfile, xarray, row, data_type ); ptr = xarray; G_lookup_raster_colors( xarray, red, grn, blu, set, ncols, colors, data_type ); for ( i = 0; i < ncols; i++ ) { unsigned char alpha = 255; //G_debug ( 0, "row = %d col = %d", row, i ); if ( G_is_null_value( ptr, data_type ) ) { alpha = 0; } if ( strcmp( format, "color" ) == 0 ) { // We need data suitable for QImage 32-bpp // the data are stored in QImage as QRgb which is unsigned int. // Because it depends on byte order of the platform we have to // consider byte order (well, middle endian ignored) if ( big_endian ) { // I have never tested this fprintf( fo, "%c%c%c%c", alpha, red[i], grn[i], blu[i] ); } else { fprintf( fo, "%c%c%c%c", blu[i], grn[i], red[i], alpha ); } } else { if ( data_type == CELL_TYPE ) { //G_debug ( 0, "valx = %d", *((CELL *) ptr)); } if ( G_is_null_value( ptr, data_type ) ) { // see comments in QgsGrassRasterProvider::noDataValue() if ( data_type == CELL_TYPE ) { //int nul = -2000000000; int nul = INT_MIN; fwrite( &nul, 4, 1, fo ); } else if ( data_type == DCELL_TYPE ) { //double nul = -1e+300; fwrite( &dnul, 8, 1, fo ); } else if ( data_type == FCELL_TYPE ) { //double nul = -1e+30; fwrite( &fnul, 4, 1, fo ); } } else { fwrite( ptr, raster_size, 1, fo ); } } ptr = G_incr_void_ptr( ptr, raster_size ); } } G_close_cell( cellfile ); fclose( fo ); return ( 0 ); }
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; }
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; }