• Main Page
  • Related Pages
  • Data Structures
  • Files
  • File List
  • Globals

opencell.c

Go to the documentation of this file.
00001 
00015 #include <rpc/types.h>
00016 #include <rpc/xdr.h>
00017 #include <unistd.h>
00018 #include <string.h>
00019 #include <sys/types.h>
00020 #include <sys/stat.h>
00021 #include <fcntl.h>
00022 #include <grass/config.h>
00023 #include "G.h"
00024 #include <grass/gis.h>
00025 #include <grass/glocale.h>
00026 
00027 static int allocate_compress_buf(int);
00028 
00029 static struct fileinfo *new_fileinfo(int fd)
00030 {
00031     int oldsize = G__.fileinfo_count;
00032     int newsize = oldsize;
00033     int i;
00034 
00035     if (fd < oldsize)
00036         return &G__.fileinfo[fd];
00037 
00038     newsize *= 2;
00039     if (newsize <= fd)
00040         newsize = fd + 20;
00041 
00042     G__.fileinfo = G_realloc(G__.fileinfo, newsize * sizeof(struct fileinfo));
00043 
00044     /* Mark all cell files as closed */
00045     for (i = oldsize; i < newsize; i++) {
00046         memset(&G__.fileinfo[i], 0, sizeof(struct fileinfo));
00047         G__.fileinfo[i].open_mode = -1;
00048     }
00049 
00050     G__.fileinfo_count = newsize;
00051 
00052     return &G__.fileinfo[fd];
00053 }
00054 
00055 
00072 static int G__open_raster_new(const char *name, int open_mode);
00073 
00100 int G_open_cell_old(const char *name, const char *mapset)
00101 {
00102     int fd;
00103 
00104     if ((fd = G__open_cell_old(name, mapset)) < 0) {
00105         G_warning(_("Unable to open raster map <%s@%s>"), name, mapset);
00106         return fd;
00107     }
00108 
00109     /* turn on auto masking, if not already on */
00110     G__check_for_auto_masking();
00111     /*
00112        if(G__.auto_mask <= 0)
00113        G__.mask_buf = G_allocate_cell_buf();
00114        now we don't ever free it!, so no need to allocate it  (Olga)
00115      */
00116     /* mask_buf is used for reading MASK file when mask is set and
00117        for reading map rows when the null file doesn't exist */
00118 
00119     return fd;
00120 }
00121 
00149 int G__open_cell_old(const char *name, const char *mapset)
00150 {
00151     struct fileinfo *fcb;
00152     int fd;
00153     char cell_dir[100];
00154     const char *r_name;
00155     const char *r_mapset;
00156     struct Cell_head cellhd;
00157     int CELL_nbytes = 0;        /* bytes per cell in CELL map */
00158     int INTERN_SIZE;
00159     int reclass_flag, i;
00160     int MAP_NBYTES;
00161     RASTER_MAP_TYPE MAP_TYPE;
00162     struct Reclass reclass;
00163     const char *xmapset;
00164     struct GDAL_link *gdal;
00165 
00166     /* make sure window is set    */
00167     G__init_window();
00168 
00169     xmapset = G_find_cell2(name, mapset);
00170     if (!xmapset) {
00171         G_warning(_("Unable to find <%s@%s>"), name, mapset);
00172         return -1;
00173     }
00174     mapset = xmapset;
00175 
00176     /* Check for reclassification */
00177     reclass_flag = G_get_reclass(name, mapset, &reclass);
00178 
00179     switch (reclass_flag) {
00180     case 0:
00181         r_name = name;
00182         r_mapset = mapset;
00183         break;
00184     case 1:
00185         r_name = reclass.name;
00186         r_mapset = reclass.mapset;
00187         if (G_find_cell2(r_name, r_mapset) == NULL) {
00188             G_warning(_("Unable to open raster map <%s@%s> since it is a reclass "
00189                         "of raster map <%s@%s> which does not exist"),
00190                       name, mapset, r_name, r_mapset);
00191             return -1;
00192         }
00193         break;
00194     default:                    /* Error reading cellhd/reclass file */
00195         return -1;
00196     }
00197 
00198     /* read the cell header */
00199     if (G_get_cellhd(r_name, r_mapset, &cellhd) < 0)
00200         return -1;
00201 
00202     /* now check the type */
00203     MAP_TYPE = G_raster_map_type(r_name, r_mapset);
00204     if (MAP_TYPE < 0)
00205         return -1;
00206 
00207     if (MAP_TYPE == CELL_TYPE)
00208         /* set the number of bytes for CELL map */
00209     {
00210         CELL_nbytes = cellhd.format + 1;
00211         if (CELL_nbytes < 1) {
00212             G_warning(_("Raster map <%s@%s>: format field in header file invalid"),
00213                       r_name, r_mapset);
00214             return -1;
00215         }
00216     }
00217 
00218     if (cellhd.proj != G__.window.proj) {
00219         G_warning(_("Raster map <%s@%s> is in different projection than current region. "
00220                     "Found raster map <%s@%s>, should be <%s>."),
00221                   name, mapset, name, G__projection_name(cellhd.proj),
00222                   G__projection_name(G__.window.proj));
00223         return -1;
00224     }
00225     if (cellhd.zone != G__.window.zone) {
00226         G_warning(_("Raster map <%s@%s> is in different zone (%d) than current region (%d)"),
00227                   name, mapset, cellhd.zone, G__.window.zone);
00228         return -1;
00229     }
00230 
00231     /* when map is int warn if too large cell size */
00232     if (MAP_TYPE == CELL_TYPE && (unsigned int) CELL_nbytes > sizeof(CELL)) {
00233         G_warning(_("Raster map <%s@%s>: bytes per cell (%d) too large"),
00234                   name, mapset, CELL_nbytes);
00235         return -1;
00236     }
00237 
00238     /* record number of bytes per cell */
00239     if (MAP_TYPE == FCELL_TYPE) {
00240         strcpy(cell_dir, "fcell");
00241         INTERN_SIZE = sizeof(FCELL);
00242         MAP_NBYTES = XDR_FLOAT_NBYTES;
00243     }
00244     else if (MAP_TYPE == DCELL_TYPE) {
00245         strcpy(cell_dir, "fcell");
00246         INTERN_SIZE = sizeof(DCELL);
00247         MAP_NBYTES = XDR_DOUBLE_NBYTES;
00248     }
00249     else {                      /* integer */
00250 
00251         strcpy(cell_dir, "cell");
00252         INTERN_SIZE = sizeof(CELL);
00253         MAP_NBYTES = CELL_nbytes;
00254     }
00255 
00256     gdal = G_get_gdal_link(r_name, r_mapset);
00257     if (gdal) {
00258 #ifdef HAVE_GDAL
00259         /* dummy descriptor to reserve the fileinfo slot */
00260         fd = open(G_DEV_NULL, O_RDONLY);
00261 #else
00262         G_warning(_("map <%s@%s> is a GDAL link but GRASS is compiled without GDAL support"),
00263                   r_name, r_mapset);
00264         return -1;
00265 #endif
00266     }
00267     else
00268         /* now actually open file for reading */
00269         fd = G_open_old(cell_dir, r_name, r_mapset);
00270 
00271     if (fd < 0)
00272         return -1;
00273 
00274     fcb = new_fileinfo(fd);
00275 
00276     fcb->map_type = MAP_TYPE;
00277 
00278     /* Save cell header */
00279     G_copy((char *)&fcb->cellhd, (char *)&cellhd, sizeof(cellhd));
00280 
00281     /* allocate null bitstream buffers for reading null rows */
00282     for (i = 0; i < NULL_ROWS_INMEM; i++)
00283         fcb->NULL_ROWS[i] = G__allocate_null_bits(G__.window.cols);
00284     fcb->null_work_buf = G__allocate_null_bits(fcb->cellhd.cols);
00285     /* initialize : no NULL rows in memory */
00286     fcb->min_null_row = (-1) * NULL_ROWS_INMEM;
00287 
00288     /* mark closed */
00289     fcb->open_mode = -1;
00290 
00291     /* save name and mapset */
00292     {
00293         char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
00294 
00295         if (G__name_is_fully_qualified(name, xname, xmapset))
00296             fcb->name = G_store(xname);
00297         else
00298             fcb->name = G_store(name);
00299     }
00300     fcb->mapset = G_store(mapset);
00301 
00302     /* mark no data row in memory  */
00303     fcb->cur_row = -1;
00304     /* fcb->null_cur_row is not used for reading, only for writing */
00305     fcb->null_cur_row = -1;
00306 
00307     /* if reclass, copy reclass structure */
00308     if ((fcb->reclass_flag = reclass_flag))
00309         G_copy(&fcb->reclass, &reclass, sizeof(reclass));
00310 
00311     fcb->gdal = gdal;
00312     if (!gdal)
00313         /* check for compressed data format, making initial reads if necessary */
00314         if (G__check_format(fd) < 0) {
00315             close(fd);          /* warning issued by check_format() */
00316             return -1;
00317         }
00318 
00319     /* create the mapping from cell file to window */
00320     G__create_window_mapping(fd);
00321 
00322     /*
00323      * allocate the data buffer
00324      * number of bytes per cell is cellhd.format+1
00325      */
00326 
00327     /* for reading fcb->data is allocated to be fcb->cellhd.cols * fcb->nbytes 
00328        (= XDR_FLOAT/DOUBLE_NBYTES) and G__.work_buf to be G__.window.cols * 
00329        sizeof(CELL or DCELL or FCELL) */
00330     fcb->data = (unsigned char *)G_calloc(fcb->cellhd.cols, MAP_NBYTES);
00331 
00332     G__reallocate_work_buf(INTERN_SIZE);
00333     G__reallocate_mask_buf();
00334     G__reallocate_null_buf();
00335     G__reallocate_temp_buf();
00336     /* work_buf is used as intermediate buf for conversions */
00337     /*
00338      * allocate/enlarge the compressed data buffer needed by get_map_row()
00339      */
00340     allocate_compress_buf(fd);
00341 
00342     /* initialize/read in quant rules for float point maps */
00343     if (fcb->map_type != CELL_TYPE) {
00344         if (fcb->reclass_flag)
00345             G_read_quant(fcb->reclass.name, fcb->reclass.mapset,
00346                          &(fcb->quant));
00347         else
00348             G_read_quant(fcb->name, fcb->mapset, &(fcb->quant));
00349     }
00350 
00351     /* now mark open for read: this must follow create_window_mapping() */
00352     fcb->open_mode = OPEN_OLD;
00353     fcb->io_error = 0;
00354     fcb->map_type = MAP_TYPE;
00355     fcb->nbytes = MAP_NBYTES;
00356     fcb->null_file_exists = -1;
00357 
00358     if (fcb->map_type != CELL_TYPE)
00359         xdrmem_create(&fcb->xdrstream, (caddr_t) fcb->data,
00360                       (u_int) (fcb->nbytes * fcb->cellhd.cols), XDR_DECODE);
00361 
00362     return fd;
00363 }
00364 
00365 /*****************************************************************/
00366 
00367 static int WRITE_NBYTES = sizeof(CELL);
00368 
00369 /* bytes per cell for current map */
00370 
00371 static int NBYTES = sizeof(CELL);
00372 
00373 /* bytes per cell for writing integer maps */
00374 
00375 static RASTER_MAP_TYPE WRITE_MAP_TYPE = CELL_TYPE;
00376 
00377 /* a type of current map */
00378 
00379 static int COMPRESSION_TYPE = 0;
00380 
00381 #define FP_NBYTES G__.fp_nbytes
00382 /* bytes per cell for writing floating point maps */
00383 #define FP_TYPE  G__.fp_type
00384 /* a type of floating maps to be open */
00385 static int FP_TYPE_SET = 0;     /* wether or not the f.p. type was set explicitly
00386                                    by calling G_set_fp_type() */
00387 
00388 static char cell_dir[100];
00389 
00417 int G_open_cell_new(const char *name)
00418 {
00419     WRITE_MAP_TYPE = CELL_TYPE;
00420     strcpy(cell_dir, "cell");
00421     /* bytes per cell for current map */
00422     WRITE_NBYTES = NBYTES;
00423     return G__open_raster_new(name, OPEN_NEW_COMPRESSED);
00424 }
00425 
00438 int G_open_cell_new_random(const char *name)
00439 {
00440     WRITE_MAP_TYPE = CELL_TYPE;
00441     /* bytes per cell for current map */
00442     WRITE_NBYTES = NBYTES;
00443     strcpy(cell_dir, "cell");
00444     return G__open_raster_new(name, OPEN_NEW_RANDOM);
00445 }
00446 
00457 int G_open_cell_new_uncompressed(const char *name)
00458 {
00459     WRITE_MAP_TYPE = CELL_TYPE; /* a type of current map */
00460     strcpy(cell_dir, "cell");
00461     /* bytes per cell for current map */
00462     WRITE_NBYTES = NBYTES;
00463     return G__open_raster_new(name, OPEN_NEW_UNCOMPRESSED);
00464 }
00465 
00476 int G_want_histogram(int flag)
00477 {
00478     G__.want_histogram = flag;
00479 
00480     return 0;
00481 }
00482 
00497 int G_set_cell_format(int n)
00498 /* sets the format for integer raster map */
00499 {
00500     if (WRITE_MAP_TYPE == CELL_TYPE) {
00501         NBYTES = n + 1;
00502         if (NBYTES <= 0)
00503             NBYTES = 1;
00504         if ((unsigned int) NBYTES > sizeof(CELL))
00505             NBYTES = sizeof(CELL);
00506     }
00507 
00508     return 0;
00509 }
00510 
00518 int G_cellvalue_format(CELL v)
00519 {
00520     unsigned int i;
00521 
00522     if (v >= 0)
00523         for (i = 0; i < sizeof(CELL); i++)
00524             if (!(v /= 256))
00525                 return i;
00526     return sizeof(CELL) - 1;
00527 }
00528 
00546 int G_open_fp_cell_new(const char *name)
00547 {
00548     /* use current float. type for writing float point maps */
00549     /* if the FP type was NOT explicitly set by G_set_fp_type()
00550        use environment variable */
00551     if (!FP_TYPE_SET) {
00552         if (getenv("GRASS_FP_DOUBLE")) {
00553             FP_TYPE = DCELL_TYPE;
00554             FP_NBYTES = XDR_DOUBLE_NBYTES;
00555         }
00556         else {
00557             FP_TYPE = FCELL_TYPE;
00558             FP_NBYTES = XDR_FLOAT_NBYTES;
00559         }
00560     }
00561     WRITE_MAP_TYPE = FP_TYPE;
00562     WRITE_NBYTES = FP_NBYTES;
00563 
00564     strcpy(cell_dir, "fcell");
00565     return G__open_raster_new(name, OPEN_NEW_COMPRESSED);
00566 }
00567 
00578 int G_open_fp_cell_new_uncompressed(const char *name)
00579 {
00580     /* use current float. type for writing float point maps */
00581     if (!FP_TYPE_SET) {
00582         if (getenv("GRASS_FP_DOUBLE")) {
00583             FP_TYPE = DCELL_TYPE;
00584             FP_NBYTES = XDR_DOUBLE_NBYTES;
00585         }
00586         else {
00587             FP_TYPE = FCELL_TYPE;
00588             FP_NBYTES = XDR_FLOAT_NBYTES;
00589         }
00590     }
00591     WRITE_MAP_TYPE = FP_TYPE;
00592     WRITE_NBYTES = FP_NBYTES;
00593 
00594     strcpy(cell_dir, "fcell");
00595     return G__open_raster_new(name, OPEN_NEW_UNCOMPRESSED);
00596 }
00597 
00598 static int
00599 clean_check_raster_name(const char *inmap, char **outmap, char **outmapset)
00600 {
00601     /* Remove mapset part of name if exists.  Also, if mapset
00602      * part exists, make sure it matches current mapset.
00603      */
00604     int status = 0;
00605     char *ptr;
00606     char *buf;
00607 
00608     buf = G_store(inmap);
00609     if ((ptr = strpbrk(buf, "@")) != NULL) {
00610         *ptr = '\0';
00611         ptr++;
00612         *outmapset = G_store(G_mapset());
00613         if ((status = strcmp(ptr, *outmapset))) {
00614             G_free(buf);
00615             G_free(*outmapset);
00616         }
00617         else {
00618             *outmap = G_store(buf);
00619             G_free(buf);
00620         }
00621     }
00622     else {
00623         *outmap = buf;
00624         *outmapset = G_store(G_mapset());
00625     }
00626     return status;
00627 }
00628 
00629 /* opens a f-cell or cell file depending on WRITE_MAP_TYPE */
00630 static int G__open_raster_new(const char *name, int open_mode)
00631 {
00632     char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
00633     struct fileinfo *fcb;
00634     int i, null_fd, fd;
00635     char *tempname;
00636     char *map;
00637     char *mapset;
00638 
00639     /* check for fully-qualfied name */
00640     if (G__name_is_fully_qualified(name, xname, xmapset)) {
00641         if (strcmp(xmapset, G_mapset()) != 0)
00642             G_fatal_error(_("Raster map <%s> is not in the current mapset (%s)"),
00643                             name, G_mapset());
00644         name = xname;
00645     }
00646 
00647     /* check for legal grass name */
00648     if (G_legal_filename(name) < 0) {
00649         G_warning(_("<%s> is an illegal file name"),
00650                   name);
00651         return -1;
00652     }
00653 
00654     if (clean_check_raster_name(name, &map, &mapset) != 0) {
00655         G_warning(_("<%s>: bad mapset"), name);
00656         return -1;
00657     }
00658 
00659     /* make sure window is set */
00660     G__init_window();
00661 
00662     /* open a tempfile name */
00663     tempname = G_tempfile();
00664     fd = creat(tempname, 0666);
00665     if (fd < 0) {
00666         G_warning(_("G__open_raster_new(): no temp files available"));
00667         G_free(tempname);
00668         G_free(map);
00669         G_free(mapset);
00670         return -1;
00671     }
00672 
00673     fcb = new_fileinfo(fd);
00674     /*
00675      * since we are bypassing the normal open logic
00676      * must create the cell element 
00677      */
00678     G__make_mapset_element(cell_dir);
00679 
00680     /* mark closed */
00681     fcb->map_type = WRITE_MAP_TYPE;
00682     fcb->open_mode = -1;
00683 
00684     /* for writing fcb->data is allocated to be G__.window.cols * 
00685        sizeof(CELL or DCELL or FCELL) and G__.work_buf to be G__.window.cols *
00686        fcb->nbytes (= XDR_FLOAT/DOUBLE_NBYTES) */
00687     fcb->data = (unsigned char *)G_calloc(G__.window.cols,
00688                                           G_raster_size(fcb->map_type));
00689 
00690     G__reallocate_null_buf();
00691     /* we need null buffer to automatically write embeded nulls in put_row */
00692 
00693     if (open_mode == OPEN_NEW_COMPRESSED && !COMPRESSION_TYPE)
00694         COMPRESSION_TYPE = getenv("GRASS_INT_ZLIB") ? 2 : 1;
00695 
00696     /*
00697      * copy current window into cell header
00698      * set format to cell/supercell
00699      * for compressed writing
00700      *   allocate space to hold the row address array
00701      *   allocate/enlarge both the compress_buf and the work_buf
00702      */
00703     G_copy((char *)&fcb->cellhd, (char *)&G__.window, sizeof(fcb->cellhd));
00704 
00705     if (open_mode == OPEN_NEW_COMPRESSED && fcb->map_type == CELL_TYPE) {
00706         fcb->row_ptr = G_calloc(fcb->cellhd.rows + 1, sizeof(off_t));
00707         G_zero(fcb->row_ptr, (fcb->cellhd.rows + 1) * sizeof(off_t));
00708         G__write_row_ptrs(fd);
00709         fcb->cellhd.compressed = COMPRESSION_TYPE;
00710 
00711         allocate_compress_buf(fd);
00712         fcb->nbytes = 1;        /* to the minimum */
00713         G__reallocate_work_buf(sizeof(CELL));
00714         G__reallocate_mask_buf();
00715         G__reallocate_temp_buf();
00716     }
00717     else {
00718         fcb->nbytes = WRITE_NBYTES;
00719         if (open_mode == OPEN_NEW_COMPRESSED) {
00720             fcb->row_ptr = G_calloc(fcb->cellhd.rows + 1, sizeof(off_t));
00721             G_zero(fcb->row_ptr, (fcb->cellhd.rows + 1) * sizeof(off_t));
00722             G__write_row_ptrs(fd);
00723             fcb->cellhd.compressed = COMPRESSION_TYPE;
00724         }
00725         else
00726             fcb->cellhd.compressed = 0;
00727         G__reallocate_work_buf(fcb->nbytes);
00728         G__reallocate_mask_buf();
00729         G__reallocate_temp_buf();
00730 
00731         if (fcb->map_type != CELL_TYPE) {
00732             G_quant_init(&(fcb->quant));
00733         }
00734 
00735         if (open_mode == OPEN_NEW_RANDOM) {
00736             G_warning(_("Unable to write embedded null values "
00737                         "for raster map open for random access"));
00738             if (fcb->map_type == CELL_TYPE)
00739                 G_write_zeros(fd,
00740                               (long)WRITE_NBYTES * fcb->cellhd.cols *
00741                               fcb->cellhd.rows);
00742             else if (fcb->map_type == FCELL_TYPE) {
00743                 if (G__random_f_initialize_0
00744                     (fd, fcb->cellhd.rows, fcb->cellhd.cols) < 0)
00745                     return -1;
00746             }
00747             else {
00748                 if (G__random_d_initialize_0
00749                     (fd, fcb->cellhd.rows, fcb->cellhd.cols) < 0)
00750                     return -1;
00751             }
00752         }
00753     }
00754 
00755     /* save name and mapset, and tempfile name */
00756     fcb->name = map;
00757     fcb->mapset = mapset;
00758     fcb->temp_name = tempname;
00759 
00760     /* next row to be written (in order) is zero */
00761     fcb->cur_row = 0;
00762 
00763     /* open a null tempfile name */
00764     tempname = G_tempfile();
00765     null_fd = creat(tempname, 0666);
00766     if (null_fd < 0) {
00767         G_warning(_("G__open_raster_new(): no temp files available"));
00768         G_free(tempname);
00769         G_free(fcb->name);
00770         G_free(fcb->mapset);
00771         G_free(fcb->temp_name);
00772         close(fd);
00773         return -1;
00774     }
00775 
00776     fcb->null_temp_name = tempname;
00777     close(null_fd);
00778 
00779     /* next row to be written (in order) is zero */
00780     fcb->null_cur_row = 0;
00781 
00782     /* allocate null bitstream buffers for writing */
00783     for (i = 0; i < NULL_ROWS_INMEM; i++)
00784         fcb->NULL_ROWS[i] = G__allocate_null_bits(fcb->cellhd.cols);
00785     fcb->min_null_row = (-1) * NULL_ROWS_INMEM;
00786     fcb->null_work_buf = G__allocate_null_bits(fcb->cellhd.cols);
00787 
00788     /* init cell stats */
00789     /* now works only for int maps */
00790     if (fcb->map_type == CELL_TYPE)
00791         if ((fcb->want_histogram = G__.want_histogram))
00792             G_init_cell_stats(&fcb->statf);
00793 
00794     /* init range and if map is double/float init d/f_range */
00795     G_init_range(&fcb->range);
00796 
00797     if (fcb->map_type != CELL_TYPE)
00798         G_init_fp_range(&fcb->fp_range);
00799 
00800     /* mark file as open for write */
00801     fcb->open_mode = open_mode;
00802     fcb->io_error = 0;
00803 
00804     return fd;
00805 }
00806 
00816 static int allocate_compress_buf(int fd)
00817 {
00818     struct fileinfo *fcb = &G__.fileinfo[fd];
00819     int n;
00820 
00821     n = fcb->cellhd.cols * (sizeof(CELL) + 1) + 1;
00822     if (fcb->cellhd.compressed && fcb->map_type == CELL_TYPE &&
00823         (n > G__.compressed_buf_size)) {
00824         if (G__.compressed_buf_size <= 0)
00825             G__.compressed_buf = (unsigned char *)G_malloc(n);
00826         else
00827             G__.compressed_buf =
00828                 (unsigned char *)G_realloc((char *)G__.compressed_buf, n);
00829         G__.compressed_buf_size = n;
00830     }
00831 
00832     return 0;
00833 }
00834 
00842 int G__reallocate_work_buf(int bytes_per_cell)
00843 {
00844     int n;
00845 
00846     n = G__.window.cols * (bytes_per_cell + 1) + 1;
00847     if (n > G__.work_buf_size) {
00848         if (G__.work_buf_size <= 0)
00849             G__.work_buf = (unsigned char *)G_malloc(n);
00850         else
00851             G__.work_buf =
00852                 (unsigned char *)G_realloc((char *)G__.work_buf, n);
00853         G__.work_buf_size = n;
00854     }
00855 
00856     return 0;
00857 }
00858 
00865 int G__reallocate_null_buf(void)
00866 {
00867     int n;
00868     n = (G__.window.cols + 1) * sizeof(char);
00869     if (n > G__.null_buf_size) {
00870         if (G__.null_buf_size <= 0)
00871             G__.null_buf = (char *)G_malloc(n);
00872         else
00873             G__.null_buf = (char *)G_realloc(G__.null_buf, n);
00874         G__.null_buf_size = n;
00875     }
00876 
00877     return 0;
00878 }
00879 
00885 int G__reallocate_mask_buf(void)
00886 {
00887     int n;
00888 
00889     n = (G__.window.cols + 1) * sizeof(CELL);
00890     if (n > G__.mask_buf_size) {
00891         if (G__.mask_buf_size <= 0)
00892             G__.mask_buf = (CELL *) G_malloc(n);
00893         else
00894             G__.mask_buf = (CELL *) G_realloc((char *)G__.mask_buf, n);
00895         G__.mask_buf_size = n;
00896     }
00897 
00898     return 0;
00899 }
00900 
00906 int G__reallocate_temp_buf(void)
00907 {
00908     int n;
00909 
00910     n = (G__.window.cols + 1) * sizeof(CELL);
00911     if (n > G__.temp_buf_size) {
00912         if (G__.temp_buf_size <= 0)
00913             G__.temp_buf = (CELL *) G_malloc(n);
00914         else
00915             G__.temp_buf = (CELL *) G_realloc((char *)G__.temp_buf, n);
00916         G__.temp_buf_size = n;
00917     }
00918 
00919     return 0;
00920 }
00921 
00922 
00937 int G_set_fp_type(RASTER_MAP_TYPE map_type)
00938 {
00939     FP_TYPE_SET = 1;
00940     if (map_type != FCELL_TYPE && map_type != DCELL_TYPE) {
00941         G_warning(_("G_set_fp_type(): can only be called with FCELL_TYPE or DCELL_TYPE"));
00942         return -1;
00943     }
00944     FP_TYPE = map_type;
00945     if (map_type == DCELL_TYPE)
00946         FP_NBYTES = XDR_DOUBLE_NBYTES;
00947     else
00948         FP_NBYTES = XDR_FLOAT_NBYTES;
00949 
00950     return 1;
00951 }
00952 
00953 
00954 #define FORMAT_FILE "f_format"
00955 
00956 
00969 int G_raster_map_is_fp(const char *name, const char *mapset)
00970 {
00971     char path[GPATH_MAX];
00972     const char *xmapset;
00973 
00974     xmapset = G_find_cell2(name, mapset);
00975     if (!xmapset) {
00976         G_warning(_("Unable to find '%s' in '%s'"), name, mapset);
00977         return -1;
00978     }
00979     G__file_name(path, "fcell", name, xmapset);
00980     if (access(path, 0) == 0)
00981         return 1;
00982     G__file_name(path, "g3dcell", name, xmapset);
00983     if (access(path, 0) == 0)
00984         return 1;
00985     
00986     return 0;
00987 }
00988 
01001 RASTER_MAP_TYPE G_raster_map_type(const char *name, const char *mapset)
01002 {
01003     char path[GPATH_MAX];
01004     const char *xmapset;
01005 
01006     xmapset = G_find_cell2(name, mapset);
01007     if (!xmapset) {
01008         if (mapset && *mapset)
01009             G_warning(_("Raster map <%s> not found in mapset <%s>"), name, mapset);
01010         else
01011             G_warning(_("Raster map <%s> not found"), name);
01012         return -1;
01013     }
01014     G__file_name(path, "fcell", name, xmapset);
01015 
01016     if (access(path, 0) == 0)
01017         return G__check_fp_type(name, xmapset);
01018 
01019     G__file_name(path, "g3dcell", name, xmapset);
01020 
01021     if (access(path, 0) == 0)
01022         return DCELL_TYPE;
01023 
01024     return CELL_TYPE;
01025 }
01026 
01038 RASTER_MAP_TYPE G_get_raster_map_type(int fd)
01039 {
01040     struct fileinfo *fcb = &G__.fileinfo[fd];
01041 
01042     return fcb->map_type;
01043 }
01044 
01053 RASTER_MAP_TYPE G__check_fp_type(const char *name, const char *mapset)
01054 {
01055     char path[GPATH_MAX];
01056     struct Key_Value *format_keys;
01057     int in_stat;
01058     char *str, *str1;
01059     RASTER_MAP_TYPE map_type;
01060     const char *xmapset;
01061 
01062     xmapset = G_find_cell2(name, mapset);
01063     if (!xmapset) {
01064         G_warning(_("Unable to find '%s' in '%s'"), name, mapset);
01065         return -1;
01066     }
01067     G__file_name_misc(path, "cell_misc", FORMAT_FILE, name, xmapset);
01068 
01069     if (access(path, 0) != 0) {
01070         G_warning(_("Unable to find '%s'"), path);
01071         return -1;
01072     }
01073     format_keys = G_read_key_value_file(path, &in_stat);
01074     if (in_stat != 0) {
01075         G_warning(_("Unable to open '%s'"), path);
01076         return -1;
01077     }
01078     if ((str = G_find_key_value("type", format_keys)) != NULL) {
01079         G_strip(str);
01080         if (strcmp(str, "double") == 0)
01081             map_type = DCELL_TYPE;
01082         else if (strcmp(str, "float") == 0)
01083             map_type = FCELL_TYPE;
01084         else {
01085             G_warning(_("Invalid type: field '%s' in file '%s'"),
01086                       str, path);
01087             G_free_key_value(format_keys);
01088             return -1;
01089         }
01090     }
01091     else {
01092         G_free_key_value(format_keys);
01093         return -1;
01094     }
01095 
01096     if ((str1 = G_find_key_value("byte_order", format_keys)) != NULL) {
01097         G_strip(str1);
01098         if (strcmp(str1, "xdr") != 0)
01099             G_warning(_("Raster map <%s> is not xdr: byte_order: %s"),
01100                         name, str);
01101         /* here read and translate  byte order if not using xdr */
01102     }
01103     G_free_key_value(format_keys);
01104     return map_type;
01105 }
01106 
01127 int G_open_raster_new(const char *name, RASTER_MAP_TYPE wr_type)
01128 {
01129     if (wr_type == CELL_TYPE)
01130         return G_open_cell_new(name);
01131 
01132     G_set_fp_type(wr_type);
01133     return G_open_fp_cell_new(name);
01134 }
01135 
01147 int G_open_raster_new_uncompressed(const char *name, RASTER_MAP_TYPE wr_type)
01148 {
01149     if (wr_type == CELL_TYPE)
01150         return G_open_cell_new_uncompressed(name);
01151 
01152     G_set_fp_type(wr_type);
01153     return G_open_fp_cell_new_uncompressed(name);
01154 }
01155 
01171 int G_set_quant_rules(int fd, struct Quant *q)
01172 {
01173     struct fileinfo *fcb = &G__.fileinfo[fd];
01174     CELL cell;
01175     DCELL dcell;
01176     struct Quant_table *p;
01177 
01178     if (fcb->open_mode != OPEN_OLD) {
01179         G_warning(_("G_set_quant_rules() can be called only for "
01180                     "raster maps opened for reading"));
01181         return -1;
01182     }
01183     /* copy all info from q to fcb->quant) */
01184     G_quant_init(&fcb->quant);
01185     if (q->truncate_only) {
01186         G_quant_truncate(&fcb->quant);
01187         return 0;
01188     }
01189     for (p = &(q->table[q->nofRules - 1]); p >= q->table; p--)
01190         G_quant_add_rule(&fcb->quant, p->dLow, p->dHigh, p->cLow, p->cHigh);
01191     if (G_quant_get_neg_infinite_rule(q, &dcell, &cell) > 0)
01192         G_quant_set_neg_infinite_rule(&fcb->quant, dcell, cell);
01193     if (G_quant_get_pos_infinite_rule(q, &dcell, &cell) > 0)
01194         G_quant_set_pos_infinite_rule(&fcb->quant, dcell, cell);
01195 
01196     return 0;
01197 }

Generated on Thu Dec 9 2010 20:46:05 for GRASS Programmer's Manual by  doxygen 1.7.2