G3d_ -> Rast3d_

git-svn-id: https://svn.osgeo.org/grass/grass/trunk@47537 15284696-431f-4ddb-bdfa-cd5b030d7da7

general/g.region/main.c

@@ -488,11 +488,11 @@ int main(int argc, char *argv[])
 	if ((mapset = G_find_grid3(name, "")) == NULL)
 	    G_fatal_error(_("3D raster map <%s> not found"), name);
 
-	if (G3d_readRegionMap(name, mapset, &win) < 0)
+	if (Rast3d_readRegionMap(name, mapset, &win) < 0)
 	    G_fatal_error(_("Unable to read header of 3D raster map <%s@%s>"),
 			  name, mapset);
 
-	G3d_regionToCellHead(&win, &window);
+	Rast3d_regionToCellHead(&win, &window);
     }
 
     /* vect= */

include/raster3d.h

@@ -231,7 +231,7 @@ typedef struct
     int lastIndex;
     int lastIndexActive;
 
-} G3d_cache_hash;
+} Rast3d_cache_hash;
 
 /*---------------------------------------------------------------------------*/
 

include/raster3ddefs.h

@@ -2,48 +2,48 @@
 #define GRASS_RASTER3DDEFS_H
 
 /* cache.c */
-void G3d_cache_reset(RASTER3D_cache *);
-void G3d_cache_dispose(RASTER3D_cache *);
-void *G3d_cache_new(int, int, int, write_fn *, void *, read_fn *, void *);
-void G3d_cache_set_removeFun(RASTER3D_cache *, write_fn *, void *);
-void G3d_cache_set_loadFun(RASTER3D_cache *, read_fn *, void *);
-void *G3d_cache_new_read(int, int, int, read_fn *, void *);
-int G3d_cache_lock(RASTER3D_cache *, int);
-void G3d_cache_lock_intern(RASTER3D_cache *, int);
-int G3d_cache_unlock(RASTER3D_cache *, int);
-int G3d_cache_unlock_all(RASTER3D_cache *);
-int G3d_cache_lock_all(RASTER3D_cache *);
-void G3d_cache_autolock_on(RASTER3D_cache *);
-void G3d_cache_autolock_off(RASTER3D_cache *);
-void G3d_cache_set_minUnlock(RASTER3D_cache *, int);
-int G3d_cache_remove_elt(RASTER3D_cache *, int);
-int G3d_cache_flush(RASTER3D_cache *, int);
-int G3d_cache_remove_all(RASTER3D_cache *);
-int G3d_cache_flush_all(RASTER3D_cache *);
-void *G3d_cache_elt_ptr(RASTER3D_cache *, int);
-int G3d_cache_load(RASTER3D_cache *, int);
-int G3d_cache_get_elt(RASTER3D_cache *, int, void *);
-int G3d_cache_put_elt(RASTER3D_cache *, int, const void *);
+void Rast3d_cache_reset(RASTER3D_cache *);
+void Rast3d_cache_dispose(RASTER3D_cache *);
+void *Rast3d_cache_new(int, int, int, write_fn *, void *, read_fn *, void *);
+void Rast3d_cache_set_removeFun(RASTER3D_cache *, write_fn *, void *);
+void Rast3d_cache_set_loadFun(RASTER3D_cache *, read_fn *, void *);
+void *Rast3d_cache_new_read(int, int, int, read_fn *, void *);
+int Rast3d_cache_lock(RASTER3D_cache *, int);
+void Rast3d_cache_lock_intern(RASTER3D_cache *, int);
+int Rast3d_cache_unlock(RASTER3D_cache *, int);
+int Rast3d_cache_unlock_all(RASTER3D_cache *);
+int Rast3d_cache_lock_all(RASTER3D_cache *);
+void Rast3d_cache_autolock_on(RASTER3D_cache *);
+void Rast3d_cache_autolock_off(RASTER3D_cache *);
+void Rast3d_cache_set_minUnlock(RASTER3D_cache *, int);
+int Rast3d_cache_remove_elt(RASTER3D_cache *, int);
+int Rast3d_cache_flush(RASTER3D_cache *, int);
+int Rast3d_cache_remove_all(RASTER3D_cache *);
+int Rast3d_cache_flush_all(RASTER3D_cache *);
+void *Rast3d_cache_elt_ptr(RASTER3D_cache *, int);
+int Rast3d_cache_load(RASTER3D_cache *, int);
+int Rast3d_cache_get_elt(RASTER3D_cache *, int, void *);
+int Rast3d_cache_put_elt(RASTER3D_cache *, int, const void *);
 
 /* cachehash.c */
-void G3d_cache_hash_reset(G3d_cache_hash *);
-void G3d_cache_hash_dispose(G3d_cache_hash *);
-void *G3d_cache_hash_new(int);
-void G3d_cache_hash_remove_name(G3d_cache_hash *, int);
-void G3d_cache_hash_load_name(G3d_cache_hash *, int, int);
-int G3d_cache_hash_name2index(G3d_cache_hash *, int);
+void Rast3d_cache_hash_reset(Rast3d_cache_hash *);
+void Rast3d_cache_hash_dispose(Rast3d_cache_hash *);
+void *Rast3d_cache_hash_new(int);
+void Rast3d_cache_hash_remove_name(Rast3d_cache_hash *, int);
+void Rast3d_cache_hash_load_name(Rast3d_cache_hash *, int, int);
+int Rast3d_cache_hash_name2index(Rast3d_cache_hash *, int);
 
 /* changeprecision.c */
-void G3d_changePrecision(void *, int, const char *);
+void Rast3d_changePrecision(void *, int, const char *);
 
 /* changetype.c */
-void G3d_changeType(void *, const char *);
+void Rast3d_changeType(void *, const char *);
 
 /* filecompare.c */
-void G3d_compareFiles(const char *, const char *, const char *, const char *);
+void Rast3d_compareFiles(const char *, const char *, const char *, const char *);
 
 /* filename.c */
-void G3d_filename(char *, const char *, const char *, const char *);
+void Rast3d_filename(char *, const char *, const char *, const char *);
 
 /* find_grid3.c */
 char *G_find_grid3(const char *, const char *);
@@ -59,239 +59,239 @@ int G_fpcompress_readXdrFloats(int, char *, int, int, int, char *);
 int G_fpcompress_readXdrDoubles(int, char *, int, int, int, char *);
 
 /* g3dalloc.c */
-void *G3d_malloc(int);
-void *G3d_realloc(void *, int);
-void G3d_free(void *);
+void *Rast3d_malloc(int);
+void *Rast3d_realloc(void *, int);
+void Rast3d_free(void *);
 
 /* g3dcache.c */
-int G3d_initCache(RASTER3D_Map *, int);
-int G3d_disposeCache(RASTER3D_Map *);
-int G3d_flushAllTiles(RASTER3D_Map *);
+int Rast3d_initCache(RASTER3D_Map *, int);
+int Rast3d_disposeCache(RASTER3D_Map *);
+int Rast3d_flushAllTiles(RASTER3D_Map *);
 
 /* g3dcats.c */
-int G3d_writeCats(const char *, struct Categories *);
-int G3d_readCats(const char *, const char *, struct Categories *);
+int Rast3d_writeCats(const char *, struct Categories *);
+int Rast3d_readCats(const char *, const char *, struct Categories *);
 
 /* g3dclose.c */
-int G3d_closeCell(RASTER3D_Map *);
+int Rast3d_closeCell(RASTER3D_Map *);
 
 /* g3dcolor.c */
-int G3d_removeColor(const char *);
-int G3d_readColors(const char *, const char *, struct Colors *);
-int G3d_writeColors(const char *, const char *, struct Colors *);
+int Rast3d_removeColor(const char *);
+int Rast3d_readColors(const char *, const char *, struct Colors *);
+int Rast3d_writeColors(const char *, const char *, struct Colors *);
 
 /* g3ddefaults.c */
-void G3d_setCompressionMode(int, int, int, int);
-void G3d_getCompressionMode(int *, int *, int *, int *);
-void G3d_setCacheSize(int);
-int G3d_getCacheSize(void);
-void G3d_setCacheLimit(int);
-int G3d_getCacheLimit(void);
-void G3d_setFileType(int);
-int G3d_getFileType(void);
-void G3d_setTileDimension(int, int, int);
-void G3d_getTileDimension(int *, int *, int *);
-void G3d_setErrorFun(void (*)(const char *));
-void G3d_setUnit(const char *);
-void G3d_initDefaults(void);
+void Rast3d_setCompressionMode(int, int, int, int);
+void Rast3d_getCompressionMode(int *, int *, int *, int *);
+void Rast3d_setCacheSize(int);
+int Rast3d_getCacheSize(void);
+void Rast3d_setCacheLimit(int);
+int Rast3d_getCacheLimit(void);
+void Rast3d_setFileType(int);
+int Rast3d_getFileType(void);
+void Rast3d_setTileDimension(int, int, int);
+void Rast3d_getTileDimension(int *, int *, int *);
+void Rast3d_setErrorFun(void (*)(const char *));
+void Rast3d_setUnit(const char *);
+void Rast3d_initDefaults(void);
 
 /* g3ddoubleio.c */
-int G3d_writeDoubles(int, int, const double *, int);
-int G3d_readDoubles(int, int, double *, int);
+int Rast3d_writeDoubles(int, int, const double *, int);
+int Rast3d_readDoubles(int, int, double *, int);
 
 /* g3derror.c */
-void G3d_skipError(const char *);
-void G3d_printError(const char *);
-void G3d_fatalError(const char *, ...) __attribute__ ((format(printf, 1, 2)))
+void Rast3d_skipError(const char *);
+void Rast3d_printError(const char *);
+void Rast3d_fatalError(const char *, ...) __attribute__ ((format(printf, 1, 2)))
     __attribute__ ((noreturn));
-void G3d_fatalError_noargs(const char *) __attribute__ ((noreturn));
-void G3d_error(const char *, ...) __attribute__ ((format(printf, 1, 2)));
+void Rast3d_fatalError_noargs(const char *) __attribute__ ((noreturn));
+void Rast3d_error(const char *, ...) __attribute__ ((format(printf, 1, 2)));
 
 /* g3dfpxdr.c */
-int G3d_isXdrNullNum(const void *, int);
-int G3d_isXdrNullFloat(const float *);
-int G3d_isXdrNullDouble(const double *);
-void G3d_setXdrNullNum(void *, int);
-void G3d_setXdrNullDouble(double *);
-void G3d_setXdrNullFloat(float *);
-int G3d_initFpXdr(RASTER3D_Map *, int);
-int G3d_initCopyToXdr(RASTER3D_Map *, int);
-int G3d_copyToXdr(const void *, int);
-int G3d_initCopyFromXdr(RASTER3D_Map *, int);
-int G3d_copyFromXdr(int, void *);
+int Rast3d_isXdrNullNum(const void *, int);
+int Rast3d_isXdrNullFloat(const float *);
+int Rast3d_isXdrNullDouble(const double *);
+void Rast3d_setXdrNullNum(void *, int);
+void Rast3d_setXdrNullDouble(double *);
+void Rast3d_setXdrNullFloat(float *);
+int Rast3d_initFpXdr(RASTER3D_Map *, int);
+int Rast3d_initCopyToXdr(RASTER3D_Map *, int);
+int Rast3d_copyToXdr(const void *, int);
+int Rast3d_initCopyFromXdr(RASTER3D_Map *, int);
+int Rast3d_copyFromXdr(int, void *);
 
 /* g3dhistory.c */
-int G3d_writeHistory(const char *, struct History *);
-int G3d_readHistory(const char *, const char *, struct History *);
+int Rast3d_writeHistory(const char *, struct History *);
+int Rast3d_readHistory(const char *, const char *, struct History *);
 
 /* g3dintio.c */
-int G3d_writeInts(int, int, const int *, int);
-int G3d_readInts(int, int, int *, int);
+int Rast3d_writeInts(int, int, const int *, int);
+int Rast3d_readInts(int, int, int *, int);
 
 /* g3dkeys.c */
-int G3d_keyGetInt(struct Key_Value *, const char *, int *);
-int G3d_keyGetDouble(struct Key_Value *, const char *, double *);
-int G3d_keyGetString(struct Key_Value *, const char *, char **);
-int G3d_keyGetValue(struct Key_Value *, const char *, char *, char *, int,
+int Rast3d_keyGetInt(struct Key_Value *, const char *, int *);
+int Rast3d_keyGetDouble(struct Key_Value *, const char *, double *);
+int Rast3d_keyGetString(struct Key_Value *, const char *, char **);
+int Rast3d_keyGetValue(struct Key_Value *, const char *, char *, char *, int,
 		    int, int *);
-int G3d_keySetInt(struct Key_Value *, const char *, const int *);
-int G3d_keySetDouble(struct Key_Value *, const char *, const double *);
-int G3d_keySetString(struct Key_Value *, const char *, char *const *);
-int G3d_keySetValue(struct Key_Value *, const char *, const char *,
+int Rast3d_keySetInt(struct Key_Value *, const char *, const int *);
+int Rast3d_keySetDouble(struct Key_Value *, const char *, const double *);
+int Rast3d_keySetString(struct Key_Value *, const char *, char *const *);
+int Rast3d_keySetValue(struct Key_Value *, const char *, const char *,
 		    const char *, int, int, const int *);
 /* g3dlong.c */
-int G3d_longEncode(long *, unsigned char *, int);
-void G3d_longDecode(unsigned char *, long *, int, int);
+int Rast3d_longEncode(long *, unsigned char *, int);
+void Rast3d_longDecode(unsigned char *, long *, int, int);
 
 /* g3dmapset.c */
-void G3d_makeMapsetMapDirectory(const char *);
+void Rast3d_makeMapsetMapDirectory(const char *);
 
 /* g3dmask.c */
-int G3d_maskClose(void);
-int G3d_maskFileExists(void);
-int G3d_maskOpenOld(void);
-int G3d_maskReopen(int);
-int G3d_isMasked(RASTER3D_Map *, int, int, int);
-void G3d_maskNum(RASTER3D_Map *, int, int, int, void *, int);
-void G3d_maskFloat(RASTER3D_Map *, int, int, int, float *);
-void G3d_maskDouble(RASTER3D_Map *, int, int, int, double *);
-void G3d_maskTile(RASTER3D_Map *, int, void *, int);
-void G3d_maskOn(RASTER3D_Map *);
-void G3d_maskOff(RASTER3D_Map *);
-int G3d_maskIsOn(RASTER3D_Map *);
-int G3d_maskIsOff(RASTER3D_Map *);
-const char *G3d_maskFile(void);
-int G3d_maskMapExists(void);
+int Rast3d_maskClose(void);
+int Rast3d_maskFileExists(void);
+int Rast3d_maskOpenOld(void);
+int Rast3d_maskReopen(int);
+int Rast3d_isMasked(RASTER3D_Map *, int, int, int);
+void Rast3d_maskNum(RASTER3D_Map *, int, int, int, void *, int);
+void Rast3d_maskFloat(RASTER3D_Map *, int, int, int, float *);
+void Rast3d_maskDouble(RASTER3D_Map *, int, int, int, double *);
+void Rast3d_maskTile(RASTER3D_Map *, int, void *, int);
+void Rast3d_maskOn(RASTER3D_Map *);
+void Rast3d_maskOff(RASTER3D_Map *);
+int Rast3d_maskIsOn(RASTER3D_Map *);
+int Rast3d_maskIsOff(RASTER3D_Map *);
+const char *Rast3d_maskFile(void);
+int Rast3d_maskMapExists(void);
 
 /* maskfn.c */
-int G3d_mask_d_select(DCELL *, d_Mask *);
-DCELL G3d_mask_match_d_interval(DCELL, d_Interval *);
-void G3d_parse_vallist(char **, d_Mask **);
+int Rast3d_mask_d_select(DCELL *, d_Mask *);
+DCELL Rast3d_mask_match_d_interval(DCELL, d_Interval *);
+void Rast3d_parse_vallist(char **, d_Mask **);
 
 /* g3dmisc.c */
-int G3d_g3dType2cellType(int);
-void G3d_copyFloat2Double(const float *, int, double *, int, int);
-void G3d_copyDouble2Float(const double *, int, float *, int, int);
-void G3d_copyValues(const void *, int, int, void *, int, int, int);
-int G3d_length(int);
-int G3d_externLength(int);
+int Rast3d_g3dType2cellType(int);
+void Rast3d_copyFloat2Double(const float *, int, double *, int, int);
+void Rast3d_copyDouble2Float(const double *, int, float *, int, int);
+void Rast3d_copyValues(const void *, int, int, void *, int, int, int);
+int Rast3d_length(int);
+int Rast3d_externLength(int);
 
 /* g3dnull.c */
-int G3d_isNullValueNum(const void *, int);
-void G3d_setNullValue(void *, int, int);
+int Rast3d_isNullValueNum(const void *, int);
+void Rast3d_setNullValue(void *, int, int);
 
 /* g3dopen2.c */
-void *G3d_openNewParam(const char *, int , int, RASTER3D_Region *, int, int, int, int, int, int, int);
+void *Rast3d_openNewParam(const char *, int , int, RASTER3D_Region *, int, int, int, int, int, int, int);
 /* g3dopen.c */
-void *G3d_openCellOldNoHeader(const char *, const char *);
-void *G3d_openCellOld(const char *, const char *, RASTER3D_Region *, int, int);
-void *G3d_openCellNew(const char *, int, int, RASTER3D_Region *);
-void *G3d_openNewOptTileSize(const char *, int , RASTER3D_Region * , int , int );
+void *Rast3d_openCellOldNoHeader(const char *, const char *);
+void *Rast3d_openCellOld(const char *, const char *, RASTER3D_Region *, int, int);
+void *Rast3d_openCellNew(const char *, int, int, RASTER3D_Region *);
+void *Rast3d_openNewOptTileSize(const char *, int , RASTER3D_Region * , int , int );
 
 /* g3dparam.c */
-void G3d_setStandard3dInputParams(void);
-int G3d_getStandard3dParams(int *, int *, int *, int *, int *, int *, int *,
+void Rast3d_setStandard3dInputParams(void);
+int Rast3d_getStandard3dParams(int *, int *, int *, int *, int *, int *, int *,
 			    int *, int *, int *, int *, int *);
-void G3d_setWindowParams(void);
-char *G3d_getWindowParams(void);
+void Rast3d_setWindowParams(void);
+char *Rast3d_getWindowParams(void);
 
 /* g3drange.c */
-void G3d_range_updateFromTile(RASTER3D_Map *, const void *, int, int, int, int,
+void Rast3d_range_updateFromTile(RASTER3D_Map *, const void *, int, int, int, int,
 			      int, int, int, int);
-int G3d_readRange(const char *, const char *, struct FPRange *);
-int G3d_range_load(RASTER3D_Map *);
-void G3d_range_min_max(RASTER3D_Map *, double *, double *);
-int G3d_range_write(RASTER3D_Map *);
-int G3d_range_init(RASTER3D_Map *);
+int Rast3d_readRange(const char *, const char *, struct FPRange *);
+int Rast3d_range_load(RASTER3D_Map *);
+void Rast3d_range_min_max(RASTER3D_Map *, double *, double *);
+int Rast3d_range_write(RASTER3D_Map *);
+int Rast3d_range_init(RASTER3D_Map *);
 
 /* g3dregion.c */
-void G3d_getRegionValue(RASTER3D_Map *, double, double, double, void *, int);
-void G3d_adjustRegion(RASTER3D_Region *);
-void G3d_regionCopy(RASTER3D_Region *, RASTER3D_Region *);
-void G3d_incorporate2dRegion(struct Cell_head *, RASTER3D_Region *);
-void G3d_regionFromToCellHead(struct Cell_head *, RASTER3D_Region *);
-void G3d_adjustRegionRes(RASTER3D_Region *);
-void G3d_extract2dRegion(RASTER3D_Region *, struct Cell_head *);
-void G3d_regionToCellHead(RASTER3D_Region *, struct Cell_head *);
-int G3d_readRegionMap(const char *, const char *, RASTER3D_Region *);
-int G3d_isValidLocation(RASTER3D_Region *, double, double, double);
-void G3d_location2coord(RASTER3D_Region *, double, double, double, int *, int *, int *);
-void G3d_location2coord2(RASTER3D_Region *, double, double, double, int *, int *, int *);
-void G3d_coord2location(RASTER3D_Region *, double, double, double, double *, double *, double *);
+void Rast3d_getRegionValue(RASTER3D_Map *, double, double, double, void *, int);
+void Rast3d_adjustRegion(RASTER3D_Region *);
+void Rast3d_regionCopy(RASTER3D_Region *, RASTER3D_Region *);
+void Rast3d_incorporate2dRegion(struct Cell_head *, RASTER3D_Region *);
+void Rast3d_regionFromToCellHead(struct Cell_head *, RASTER3D_Region *);
+void Rast3d_adjustRegionRes(RASTER3D_Region *);
+void Rast3d_extract2dRegion(RASTER3D_Region *, struct Cell_head *);
+void Rast3d_regionToCellHead(RASTER3D_Region *, struct Cell_head *);
+int Rast3d_readRegionMap(const char *, const char *, RASTER3D_Region *);
+int Rast3d_isValidLocation(RASTER3D_Region *, double, double, double);
+void Rast3d_location2coord(RASTER3D_Region *, double, double, double, int *, int *, int *);
+void Rast3d_location2coord2(RASTER3D_Region *, double, double, double, int *, int *, int *);
+void Rast3d_coord2location(RASTER3D_Region *, double, double, double, double *, double *, double *);
 /* g3dresample.c */
-void G3d_nearestNeighbor(RASTER3D_Map *, int, int, int, void *, int);
-void G3d_setResamplingFun(RASTER3D_Map *, void (*)());
-void G3d_getResamplingFun(RASTER3D_Map *, void (**)());
-void G3d_getNearestNeighborFunPtr(void (**)());
+void Rast3d_nearestNeighbor(RASTER3D_Map *, int, int, int, void *, int);
+void Rast3d_setResamplingFun(RASTER3D_Map *, void (*)());
+void Rast3d_getResamplingFun(RASTER3D_Map *, void (**)());
+void Rast3d_getNearestNeighborFunPtr(void (**)());
 
 /* g3dvolume.c */
-void G3d_getVolumeA(void *, double[2][2][2][3], int, int, int, void *, int);
-void G3d_getVolume(void *, double, double, double, double, double, double,
+void Rast3d_getVolumeA(void *, double[2][2][2][3], int, int, int, void *, int);
+void Rast3d_getVolume(void *, double, double, double, double, double, double,
 		   double, double, double, double, double, double, int, int,
 		   int, void *, int);
-void G3d_getAlignedVolume(void *, double, double, double, double, double,
+void Rast3d_getAlignedVolume(void *, double, double, double, double, double,
 			  double, int, int, int, void *, int);
-void G3d_makeAlignedVolumeFile(void *, const char *, double, double, double,
+void Rast3d_makeAlignedVolumeFile(void *, const char *, double, double, double,
 			       double, double, double, int, int, int);
 /* g3dwindow.c */
-void G3d_getValue(RASTER3D_Map *, int, int, int, void *, int);
-float G3d_getFloat(RASTER3D_Map *, int, int, int);
-double G3d_getDouble(RASTER3D_Map *, int, int, int);
-void G3d_getWindowValue(RASTER3D_Map *, double, double, double, void *, int);
+void Rast3d_getValue(RASTER3D_Map *, int, int, int, void *, int);
+float Rast3d_getFloat(RASTER3D_Map *, int, int, int);
+double Rast3d_getDouble(RASTER3D_Map *, int, int, int);
+void Rast3d_getWindowValue(RASTER3D_Map *, double, double, double, void *, int);
 
 
-RASTER3D_Region *G3d_windowPtr(void);
-void G3d_setWindow(RASTER3D_Region *);
-void G3d_setWindowMap(RASTER3D_Map *, RASTER3D_Region *);
-void G3d_getWindow(RASTER3D_Region *);
+RASTER3D_Region *Rast3d_windowPtr(void);
+void Rast3d_setWindow(RASTER3D_Region *);
+void Rast3d_setWindowMap(RASTER3D_Map *, RASTER3D_Region *);
+void Rast3d_getWindow(RASTER3D_Region *);
 
 /* g3dwindowio.c */
-void G3d_useWindowParams(void);
-int G3d_readWindow(RASTER3D_Region *, const char *);
+void Rast3d_useWindowParams(void);
+int Rast3d_readWindow(RASTER3D_Region *, const char *);
 
-/* int G3d_writeWindow (RASTER3D_Region *, char *); */
+/* int Rast3d_writeWindow (RASTER3D_Region *, char *); */
 /* getblock.c */
-void G3d_getBlockNocache(RASTER3D_Map *, int, int, int, int, int, int, void *,
+void Rast3d_getBlockNocache(RASTER3D_Map *, int, int, int, int, int, int, void *,
 			 int);
-void G3d_getBlock(RASTER3D_Map *, int, int, int, int, int, int, void *, int);
+void Rast3d_getBlock(RASTER3D_Map *, int, int, int, int, int, int, void *, int);
 
 /* header.c */
-int G3d_readHeader(RASTER3D_Map *, int *, int *, double *, double *, double *,
+int Rast3d_readHeader(RASTER3D_Map *, int *, int *, double *, double *, double *,
 		   double *, double *, double *, int *, int *, int *,
 		   double *, double *, double *, int *, int *, int *, int *,
 		   int *, int *, int *, int *, int *, int *, int *, char **);
-int G3d_writeHeader(RASTER3D_Map *, int, int, double, double, double, double,
+int Rast3d_writeHeader(RASTER3D_Map *, int, int, double, double, double, double,
 		    double, double, int, int, int, double, double, double,
 		    int, int, int, int, int, int, int, int, int, int, int,
 		    char *);
-int G3d_cacheSizeEncode(int, int);
-int G3d__computeCacheSize(RASTER3D_Map *, int);
-int G3d_fillHeader(RASTER3D_Map *, int, int, int, int, int, int, int, int, int,
+int Rast3d_cacheSizeEncode(int, int);
+int Rast3d__computeCacheSize(RASTER3D_Map *, int);
+int Rast3d_fillHeader(RASTER3D_Map *, int, int, int, int, int, int, int, int, int,
 		   int, int, int, int, int, int, int, double, double, double,
 		   double, double, double, int, int, int, double, double,
 		   double, char *);
 /* headerinfo.c */
-void G3d_getCoordsMap(RASTER3D_Map *, int *, int *, int *);
-void G3d_getCoordsMapWindow(RASTER3D_Map *, int *, int *, int *);
-void G3d_getNofTilesMap(RASTER3D_Map *, int *, int *, int *);
-void G3d_getRegionMap(RASTER3D_Map *, double *, double *, double *, double *,
+void Rast3d_getCoordsMap(RASTER3D_Map *, int *, int *, int *);
+void Rast3d_getCoordsMapWindow(RASTER3D_Map *, int *, int *, int *);
+void Rast3d_getNofTilesMap(RASTER3D_Map *, int *, int *, int *);
+void Rast3d_getRegionMap(RASTER3D_Map *, double *, double *, double *, double *,
 		      double *, double *);
-void G3d_getWindowMap(RASTER3D_Map *, double *, double *, double *, double *,
+void Rast3d_getWindowMap(RASTER3D_Map *, double *, double *, double *, double *,
 		      double *, double *);
-void G3d_getTileDimensionsMap(RASTER3D_Map *, int *, int *, int *);
-int G3d_tileTypeMap(RASTER3D_Map *);
-int G3d_fileTypeMap(RASTER3D_Map *);
-int G3d_tilePrecisionMap(RASTER3D_Map *);
-int G3d_tileUseCacheMap(RASTER3D_Map *);
-void G3d_printHeader(RASTER3D_Map *);
-void G3d_getRegionStructMap(RASTER3D_Map *, RASTER3D_Region *);
+void Rast3d_getTileDimensionsMap(RASTER3D_Map *, int *, int *, int *);
+int Rast3d_tileTypeMap(RASTER3D_Map *);
+int Rast3d_fileTypeMap(RASTER3D_Map *);
+int Rast3d_tilePrecisionMap(RASTER3D_Map *);
+int Rast3d_tileUseCacheMap(RASTER3D_Map *);
+void Rast3d_printHeader(RASTER3D_Map *);
+void Rast3d_getRegionStructMap(RASTER3D_Map *, RASTER3D_Region *);
 
 /* index.c */
-int G3d_flushIndex(RASTER3D_Map *);
-int G3d_initIndex(RASTER3D_Map *, int);
+int Rast3d_flushIndex(RASTER3D_Map *);
+int Rast3d_initIndex(RASTER3D_Map *, int);
 
 /* retile.c */
-void G3d_retile(void *, const char *, int, int, int);
+void Rast3d_retile(void *, const char *, int, int, int);
 
 /* rle.c */
 int G_rle_count_only(char *, int, int);
@@ -299,62 +299,62 @@ void G_rle_encode(char *, char *, int, int);
 void G_rle_decode(char *, char *, int, int, int *, int *);
 
 /* tilealloc.c */
-void *G3d_allocTilesType(RASTER3D_Map *, int, int);
-void *G3d_allocTiles(RASTER3D_Map *, int);
-void G3d_freeTiles(void *);
+void *Rast3d_allocTilesType(RASTER3D_Map *, int, int);
+void *Rast3d_allocTiles(RASTER3D_Map *, int);
+void Rast3d_freeTiles(void *);
 
 /* tileio.c */
-void *G3d_getTilePtr(RASTER3D_Map *, int);
-int G3d_tileLoad(RASTER3D_Map *, int);
-int G3d__removeTile(RASTER3D_Map *, int);
-float G3d_getFloatRegion(RASTER3D_Map *, int, int, int);
-double G3d_getDoubleRegion(RASTER3D_Map *, int, int, int);
-void G3d_getValueRegion(RASTER3D_Map *, int, int, int, void *, int);
+void *Rast3d_getTilePtr(RASTER3D_Map *, int);
+int Rast3d_tileLoad(RASTER3D_Map *, int);
+int Rast3d__removeTile(RASTER3D_Map *, int);
+float Rast3d_getFloatRegion(RASTER3D_Map *, int, int, int);
+double Rast3d_getDoubleRegion(RASTER3D_Map *, int, int, int);
+void Rast3d_getValueRegion(RASTER3D_Map *, int, int, int, void *, int);
 
 /* tilemath.c */
-void G3d_computeOptimalTileDimension(RASTER3D_Region *, int, int *, int *, int *, int);
-void G3d_tileIndex2tile(RASTER3D_Map *, int, int *, int *, int *);
-int G3d_tile2tileIndex(RASTER3D_Map *, int, int, int);
-void G3d_tileCoordOrigin(RASTER3D_Map *, int, int, int, int *, int *, int *);
-void G3d_tileIndexOrigin(RASTER3D_Map *, int, int *, int *, int *);
-void G3d_coord2tileCoord(RASTER3D_Map *, int, int, int, int *, int *, int *, int *,
+void Rast3d_computeOptimalTileDimension(RASTER3D_Region *, int, int *, int *, int *, int);
+void Rast3d_tileIndex2tile(RASTER3D_Map *, int, int *, int *, int *);
+int Rast3d_tile2tileIndex(RASTER3D_Map *, int, int, int);
+void Rast3d_tileCoordOrigin(RASTER3D_Map *, int, int, int, int *, int *, int *);
+void Rast3d_tileIndexOrigin(RASTER3D_Map *, int, int *, int *, int *);
+void Rast3d_coord2tileCoord(RASTER3D_Map *, int, int, int, int *, int *, int *, int *,
 			 int *, int *);
-void G3d_coord2tileIndex(RASTER3D_Map *, int, int, int, int *, int *);
-int G3d_coordInRange(RASTER3D_Map *, int, int, int);
-int G3d_tileIndexInRange(RASTER3D_Map *, int);
-int G3d_tileInRange(RASTER3D_Map *, int, int, int);
-int G3d_computeClippedTileDimensions(RASTER3D_Map *, int, int *, int *, int *,
+void Rast3d_coord2tileIndex(RASTER3D_Map *, int, int, int, int *, int *);
+int Rast3d_coordInRange(RASTER3D_Map *, int, int, int);
+int Rast3d_tileIndexInRange(RASTER3D_Map *, int);
+int Rast3d_tileInRange(RASTER3D_Map *, int, int, int);
+int Rast3d_computeClippedTileDimensions(RASTER3D_Map *, int, int *, int *, int *,
 				     int *, int *, int *);
 
 /* tilenull.c */
-void G3d_setNullTileType(RASTER3D_Map *, void *, int);
-void G3d_setNullTile(RASTER3D_Map *, void *);
+void Rast3d_setNullTileType(RASTER3D_Map *, void *, int);
+void Rast3d_setNullTile(RASTER3D_Map *, void *);
 
 /* tileread.c */
-int G3d_readTile(RASTER3D_Map *, int, void *, int);
-int G3d_readTileFloat(RASTER3D_Map *, int, void *);
-int G3d_readTileDouble(RASTER3D_Map *, int, void *);
-int G3d_lockTile(RASTER3D_Map *, int);
-int G3d_unlockTile(RASTER3D_Map *, int);
-int G3d_unlockAll(RASTER3D_Map *);
-void G3d_autolockOn(RASTER3D_Map *);
-void G3d_autolockOff(RASTER3D_Map *);
-void G3d_minUnlocked(RASTER3D_Map *, int);
-int G3d_beginCycle(RASTER3D_Map *);
-int G3d_endCycle(RASTER3D_Map *);
+int Rast3d_readTile(RASTER3D_Map *, int, void *, int);
+int Rast3d_readTileFloat(RASTER3D_Map *, int, void *);
+int Rast3d_readTileDouble(RASTER3D_Map *, int, void *);
+int Rast3d_lockTile(RASTER3D_Map *, int);
+int Rast3d_unlockTile(RASTER3D_Map *, int);
+int Rast3d_unlockAll(RASTER3D_Map *);
+void Rast3d_autolockOn(RASTER3D_Map *);
+void Rast3d_autolockOff(RASTER3D_Map *);
+void Rast3d_minUnlocked(RASTER3D_Map *, int);
+int Rast3d_beginCycle(RASTER3D_Map *);
+int Rast3d_endCycle(RASTER3D_Map *);
 
 /* tilewrite.c */
-int G3d_writeTile(RASTER3D_Map *, int, const void *, int);
-int G3d_writeTileFloat(RASTER3D_Map *, int, const void *);
-int G3d_writeTileDouble(RASTER3D_Map *, int, const void *);
-int G3d_flushTile(RASTER3D_Map *, int);
-int G3d_flushTileCube(RASTER3D_Map *, int, int, int, int, int, int);
-int G3d_flushTilesInCube(RASTER3D_Map *, int, int, int, int, int, int);
-int G3d_putFloat(RASTER3D_Map *, int, int, int, float);
-int G3d_putDouble(RASTER3D_Map *, int, int, int, double);
-int G3d_putValue(RASTER3D_Map *, int, int, int, const void *, int);
+int Rast3d_writeTile(RASTER3D_Map *, int, const void *, int);
+int Rast3d_writeTileFloat(RASTER3D_Map *, int, const void *);
+int Rast3d_writeTileDouble(RASTER3D_Map *, int, const void *);
+int Rast3d_flushTile(RASTER3D_Map *, int);
+int Rast3d_flushTileCube(RASTER3D_Map *, int, int, int, int, int, int);
+int Rast3d_flushTilesInCube(RASTER3D_Map *, int, int, int, int, int, int);
+int Rast3d_putFloat(RASTER3D_Map *, int, int, int, float);
+int Rast3d_putDouble(RASTER3D_Map *, int, int, int, double);
+int Rast3d_putValue(RASTER3D_Map *, int, int, int, const void *, int);
 
 /* writeascii.c */
-void G3d_writeAscii(void *, const char *);
+void Rast3d_writeAscii(void *, const char *);
 
 #endif /* RASTER3DDEFS */

lib/gpde/N_arrays.c

@@ -886,7 +886,7 @@ int N_is_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
 	    G_debug(6,
 		    "N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
 		    depth, row, col);
-	    return G3d_isNullValueNum((void *)
+	    return Rast3d_isNullValueNum((void *)
 				      &(data->
 					fcell_array[depth *
 						    (data->rows_intern *
@@ -898,7 +898,7 @@ int N_is_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
 	    G_debug(6,
 		    "N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
 		    depth, row, col);
-	    return G3d_isNullValueNum((void *)
+	    return Rast3d_isNullValueNum((void *)
 				      &(data->
 					dcell_array[depth *
 						    (data->rows_intern *
@@ -912,7 +912,7 @@ int N_is_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
 	    G_debug(6,
 		    "N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
 		    depth, row, col);
-	    return G3d_isNullValueNum((void *)
+	    return Rast3d_isNullValueNum((void *)
 				      &(data->
 					fcell_array[(depth +
 						     data->offset) *
@@ -928,7 +928,7 @@ int N_is_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
 	    G_debug(6,
 		    "N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
 		    depth, row, col);
-	    return G3d_isNullValueNum((void *)
+	    return Rast3d_isNullValueNum((void *)
 				      &(data->
 					dcell_array[(depth +
 						     data->offset) *
@@ -1082,7 +1082,7 @@ void N_put_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
 
     if (data->offset == 0) {
 	if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
-	    G3d_setNullValue((void *)
+	    Rast3d_setNullValue((void *)
 			     &(data->
 			       fcell_array[depth *
 					   (data->rows_intern *
@@ -1091,7 +1091,7 @@ void N_put_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
 			     FCELL_TYPE);
 	}
 	else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
-	    G3d_setNullValue((void *)
+	    Rast3d_setNullValue((void *)
 			     &(data->
 			       dcell_array[depth *
 					   (data->rows_intern *
@@ -1102,7 +1102,7 @@ void N_put_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
     }
     else {
 	if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
-	    G3d_setNullValue((void *)
+	    Rast3d_setNullValue((void *)
 			     &(data->
 			       fcell_array[(depth +
 					    data->offset) *
@@ -1116,7 +1116,7 @@ void N_put_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
 			     FCELL_TYPE);
 	}
 	else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
-	    G3d_setNullValue((void *)
+	    Rast3d_setNullValue((void *)
 			     &(data->
 			       dcell_array[(depth +
 					    data->offset) *

lib/gpde/N_arrays_calc.c

@@ -522,7 +522,7 @@ void N_copy_array_3d(N_array_3d * source, N_array_3d * target)
 	 i++) {
 	null = 0;
 	if (source->type == FCELL_TYPE) {
-	    if (G3d_isNullValueNum
+	    if (Rast3d_isNullValueNum
 		((void *)&(source->fcell_array[i]), FCELL_TYPE))
 		null = 1;
 
@@ -531,7 +531,7 @@ void N_copy_array_3d(N_array_3d * source, N_array_3d * target)
 	    }
 	    if (target->type == DCELL_TYPE) {
 		if (null)
-		    G3d_setNullValue((void *)&(target->dcell_array[i]), 1,
+		    Rast3d_setNullValue((void *)&(target->dcell_array[i]), 1,
 				     DCELL_TYPE);
 		else
 		    target->dcell_array[i] = (double)source->fcell_array[i];
@@ -539,13 +539,13 @@ void N_copy_array_3d(N_array_3d * source, N_array_3d * target)
 
 	}
 	if (source->type == DCELL_TYPE) {
-	    if (G3d_isNullValueNum
+	    if (Rast3d_isNullValueNum
 		((void *)&(source->dcell_array[i]), DCELL_TYPE))
 		null = 1;
 
 	    if (target->type == FCELL_TYPE) {
 		if (null)
-		    G3d_setNullValue((void *)&(target->fcell_array[i]), 1,
+		    Rast3d_setNullValue((void *)&(target->fcell_array[i]), 1,
 				     FCELL_TYPE);
 		else
 		    target->fcell_array[i] = (float)source->dcell_array[i];
@@ -596,19 +596,19 @@ double N_norm_array_3d(N_array_3d * a, N_array_3d * b, int type)
 	v2 = 0.0;
 
 	if (a->type == FCELL_TYPE) {
-	    if (!G3d_isNullValueNum((void *)&(a->fcell_array[i]), FCELL_TYPE))
+	    if (!Rast3d_isNullValueNum((void *)&(a->fcell_array[i]), FCELL_TYPE))
 		v1 = (double)a->fcell_array[i];
 	}
 	if (a->type == DCELL_TYPE) {
-	    if (!G3d_isNullValueNum((void *)&(a->dcell_array[i]), DCELL_TYPE))
+	    if (!Rast3d_isNullValueNum((void *)&(a->dcell_array[i]), DCELL_TYPE))
 		v1 = (double)a->dcell_array[i];
 	}
 	if (b->type == FCELL_TYPE) {
-	    if (!G3d_isNullValueNum((void *)&(b->fcell_array[i]), FCELL_TYPE))
+	    if (!Rast3d_isNullValueNum((void *)&(b->fcell_array[i]), FCELL_TYPE))
 		v2 = (double)b->fcell_array[i];
 	}
 	if (b->type == DCELL_TYPE) {
-	    if (!G3d_isNullValueNum((void *)&(b->dcell_array[i]), DCELL_TYPE))
+	    if (!Rast3d_isNullValueNum((void *)&(b->dcell_array[i]), DCELL_TYPE))
 		v2 = (double)b->dcell_array[i];
 	}
 
@@ -859,7 +859,7 @@ int N_convert_array_3d_null_to_zero(N_array_3d * a)
     if (a->type == FCELL_TYPE)
 	for (i = 0; i < a->cols_intern * a->rows_intern * a->depths_intern;
 	     i++) {
-	    if (G3d_isNullValueNum((void *)&(a->fcell_array[i]), FCELL_TYPE)) {
+	    if (Rast3d_isNullValueNum((void *)&(a->fcell_array[i]), FCELL_TYPE)) {
 		a->fcell_array[i] = 0.0;
 		count++;
 	    }
@@ -868,7 +868,7 @@ int N_convert_array_3d_null_to_zero(N_array_3d * a)
     if (a->type == DCELL_TYPE)
 	for (i = 0; i < a->cols_intern * a->rows_intern * a->depths_intern;
 	     i++) {
-	    if (G3d_isNullValueNum((void *)&(a->dcell_array[i]), DCELL_TYPE)) {
+	    if (Rast3d_isNullValueNum((void *)&(a->dcell_array[i]), DCELL_TYPE)) {
 		a->dcell_array[i] = 0.0;
 		count++;
 	    }

lib/gpde/N_arrays_io.c

@@ -242,7 +242,7 @@ void N_write_array_2d_to_rast(N_array_2d * array, char *name)
  * <br><br>
  *
  * The new created or the provided array is returned.
- * If the reading of the volume map fails, G3d_fatalError() will
+ * If the reading of the volume map fails, Rast3d_fatalError() will
  * be invoked.
  *
  * \param name * char - the name of an existing volume map
@@ -262,7 +262,7 @@ N_array_3d *N_read_rast3d_to_array_3d(char *name, N_array_3d * array,
 
 
     /*get the current region */
-    G3d_getWindow(&region);
+    Rast3d_getWindow(&region);
 
     cols = region.cols;
     rows = region.rows;
@@ -270,17 +270,17 @@ N_array_3d *N_read_rast3d_to_array_3d(char *name, N_array_3d * array,
 
 
     if (NULL == G_find_grid3(name, ""))
-	G3d_fatalError(_("Requested g3d map <%s> not found"), name);
+	Rast3d_fatalError(_("Requested g3d map <%s> not found"), name);
 
     /*Open all maps with default region */
     map =
-	G3d_openCellOld(name, G_find_grid3(name, ""), RASTER3D_DEFAULT_WINDOW,
+	Rast3d_openCellOld(name, G_find_grid3(name, ""), RASTER3D_DEFAULT_WINDOW,
 			RASTER3D_TILE_SAME_AS_FILE, RASTER3D_USE_CACHE_DEFAULT);
 
     if (map == NULL)
-	G3d_fatalError(_("Error opening g3d map <%s>"), name);
+	Rast3d_fatalError(_("Error opening g3d map <%s>"), name);
 
-    type = G3d_tileTypeMap(map);
+    type = Rast3d_tileTypeMap(map);
 
     /*if the array is NULL create a new one with the data type of the volume map */
     /*the offset is 0 by default */
@@ -310,10 +310,10 @@ N_array_3d *N_read_rast3d_to_array_3d(char *name, N_array_3d * array,
 
     /*if requested set the Mask on */
     if (mask) {
-	if (G3d_maskFileExists()) {
+	if (Rast3d_maskFileExists()) {
 	    changemask = 0;
-	    if (G3d_maskIsOff(map)) {
-		G3d_maskOn(map);
+	    if (Rast3d_maskIsOff(map)) {
+		Rast3d_maskOn(map);
 		changemask = 1;
 	    }
 	}
@@ -324,7 +324,7 @@ N_array_3d *N_read_rast3d_to_array_3d(char *name, N_array_3d * array,
 	for (y = 0; y < rows; y++) {
 	    for (x = 0; x < cols; x++) {
 		if (type == FCELL_TYPE) {
-		    G3d_getValue(map, x, y, z, &f1, type);
+		    Rast3d_getValue(map, x, y, z, &f1, type);
 		    if (Rast_is_f_null_value((void *)&f1)) {
 			N_put_array_3d_value_null(data, x, y, z);
 		    }
@@ -336,7 +336,7 @@ N_array_3d *N_read_rast3d_to_array_3d(char *name, N_array_3d * array,
 		    }
 		}
 		else {
-		    G3d_getValue(map, x, y, z, &d1, type);
+		    Rast3d_getValue(map, x, y, z, &d1, type);
 		    if (Rast_is_d_null_value((void *)&d1)) {
 			N_put_array_3d_value_null(data, x, y, z);
 		    }
@@ -354,14 +354,14 @@ N_array_3d *N_read_rast3d_to_array_3d(char *name, N_array_3d * array,
 
     /*We set the Mask off, if it was off before */
     if (mask) {
-	if (G3d_maskFileExists())
-	    if (G3d_maskIsOn(map) && changemask)
-		G3d_maskOff(map);
+	if (Rast3d_maskFileExists())
+	    if (Rast3d_maskIsOn(map) && changemask)
+		Rast3d_maskOff(map);
     }
 
     /* Close files and exit */
-    if (!G3d_closeCell(map))
-	G3d_fatalError(map, NULL, 0, _("Error closing g3d file"));
+    if (!Rast3d_closeCell(map))
+	Rast3d_fatalError(map, NULL, 0, _("Error closing g3d file"));
 
     return data;
 }
@@ -372,7 +372,7 @@ N_array_3d *N_read_rast3d_to_array_3d(char *name, N_array_3d * array,
  * A new volume map is created with the same type as the N_array_3d.
  * The current region is used to open the volume map.
  * The N_array_3d must have the same size as the current region.
- * If the writing of the volume map fails, G3d_fatalError() will
+ * If the writing of the volume map fails, Rast3d_fatalError() will
  * be invoked.
  *
  *
@@ -392,7 +392,7 @@ void N_write_array_3d_to_rast3d(N_array_3d * array, char *name, int mask)
     RASTER3D_Region region;
 
     /*get the current region */
-    G3d_getWindow(&region);
+    Rast3d_getWindow(&region);
 
     cols = region.cols;
     rows = region.rows;
@@ -412,21 +412,21 @@ void N_write_array_3d_to_rast3d(N_array_3d * array, char *name, int mask)
 
     /*Open the new map */
     if (type == DCELL_TYPE)
-        map = G3d_openNewOptTileSize(name, RASTER3D_USE_CACHE_XY, &region, DCELL_TYPE, 32);
+        map = Rast3d_openNewOptTileSize(name, RASTER3D_USE_CACHE_XY, &region, DCELL_TYPE, 32);
     else if (type == FCELL_TYPE)
-        map = G3d_openNewOptTileSize(name, RASTER3D_USE_CACHE_XY, &region, FCELL_TYPE, 32);
+        map = Rast3d_openNewOptTileSize(name, RASTER3D_USE_CACHE_XY, &region, FCELL_TYPE, 32);
 
     if (map == NULL)
-	G3d_fatalError(_("Error opening g3d map <%s>"), name);
+	Rast3d_fatalError(_("Error opening g3d map <%s>"), name);
 
     G_message(_("Write 3d array to g3d map <%s>"), name);
 
     /*if requested set the Mask on */
     if (mask) {
-	if (G3d_maskFileExists()) {
+	if (Rast3d_maskFileExists()) {
 	    changemask = 0;
-	    if (G3d_maskIsOff(map)) {
-		G3d_maskOn(map);
+	    if (Rast3d_maskIsOff(map)) {
+		Rast3d_maskOn(map);
 		changemask = 1;
 	    }
 	}
@@ -439,11 +439,11 @@ void N_write_array_3d_to_rast3d(N_array_3d * array, char *name, int mask)
 	    for (x = 0; x < cols; x++) {
 		if (type == FCELL_TYPE) {
 		    f1 = N_get_array_3d_f_value(data, x, y, z);
-		    G3d_putFloat(map, x, y, z, f1);
+		    Rast3d_putFloat(map, x, y, z, f1);
 		}
 		else if (type == DCELL_TYPE) {
 		    d1 = N_get_array_3d_d_value(data, x, y, z);
-		    G3d_putDouble(map, x, y, z, d1);
+		    Rast3d_putDouble(map, x, y, z, d1);
 		}
 	    }
 	}
@@ -451,17 +451,17 @@ void N_write_array_3d_to_rast3d(N_array_3d * array, char *name, int mask)
 
     /*We set the Mask off, if it was off before */
     if (mask) {
-	if (G3d_maskFileExists())
-	    if (G3d_maskIsOn(map) && changemask)
-		G3d_maskOff(map);
+	if (Rast3d_maskFileExists())
+	    if (Rast3d_maskIsOn(map) && changemask)
+		Rast3d_maskOff(map);
     }
 
     /* Flush all tile */
-    if (!G3d_flushAllTiles(map))
-	G3d_fatalError("Error flushing tiles with G3d_flushAllTiles");
+    if (!Rast3d_flushAllTiles(map))
+	Rast3d_fatalError("Error flushing tiles with Rast3d_flushAllTiles");
     /* Close files and exit */
-    if (!G3d_closeCell(map))
-	G3d_fatalError(map, NULL, 0, _("Error closing g3d file"));
+    if (!Rast3d_closeCell(map))
+	Rast3d_fatalError(map, NULL, 0, _("Error closing g3d file"));
 
     return;
 }

lib/gpde/N_geom.c

@@ -90,7 +90,7 @@ N_geom_data *N_init_geom_data_3d(RASTER3D_Region * region3d, N_geom_data * geoda
 
 	/*convert the 3d into a 2d region and begin the area calculation */
 	G_get_set_window(&region2d);	/*this function is not thread safe */
-	G3d_regionToCellHead(region3d, &region2d);
+	Rast3d_regionToCellHead(region3d, &region2d);
     }
 
     return N_init_geom_data_2d(&region2d, geom);

lib/gpde/test/test_arrays.c

@@ -834,8 +834,8 @@ int test_array_3d(void)
     N_free_array_3d(data2);
 
     /*Set the defaults */
-    G3d_initDefaults();
-    G3d_getWindow(&region);
+    Rast3d_initDefaults();
+    Rast3d_getWindow(&region);
 
     data1 =
 	N_alloc_array_3d(region.cols, region.rows, region.depths, 0,

lib/gpde/test/test_geom.c

@@ -60,10 +60,10 @@ int test_geom_data(void)
     G_get_set_window(&region2d);
 
     /*Set the defaults */
-    G3d_initDefaults();
+    Rast3d_initDefaults();
 
     /*get the current region */
-    G3d_getWindow(&region3d);
+    Rast3d_getWindow(&region3d);
 
     geom = N_alloc_geom_data();
     if (!geom) {

lib/ogsf/GVL2.c

@@ -36,8 +36,8 @@ static double Region[6];
  */
 void GVL_libinit(void)
 {
-    G3d_initDefaults();
-    G3d_getWindow(&wind3);
+    Rast3d_initDefaults();
+    Rast3d_getWindow(&wind3);
 
     Region[0] = wind3.north;
     Region[1] = wind3.south;

lib/ogsf/Gvl3.c

@@ -44,7 +44,7 @@ int Gvl_load_colors_data(void **color_data, const char *name)
     if (NULL == (colors = (struct Colors *)G_malloc(sizeof(struct Colors))))
 	return (-1);
 
-    if (0 > G3d_readColors(name, mapset, colors)) {
+    if (0 > Rast3d_readColors(name, mapset, colors)) {
 	G_free(colors);
 	return (-1);
     }

lib/ogsf/gvl_file.c

@@ -431,7 +431,7 @@ void *open_g3d_file(const char *filename, IFLAG * type, double *min,
 
     /* open g3d file */
     map =
-	G3d_openCellOld(filename, mapset, RASTER3D_DEFAULT_WINDOW,
+	Rast3d_openCellOld(filename, mapset, RASTER3D_DEFAULT_WINDOW,
 			RASTER3D_TILE_SAME_AS_FILE, RASTER3D_USE_CACHE_DEFAULT);
     if (!map) {
 	G_warning(_("Unable to open 3D raster map <%s>"), filename);
@@ -439,15 +439,15 @@ void *open_g3d_file(const char *filename, IFLAG * type, double *min,
     }
 
     /* load range into range structure of map */
-    if (!G3d_range_load(map)) {
+    if (!Rast3d_range_load(map)) {
 	G_warning(_("Unable to read range of 3D raster map <%s>"), filename);
 	return (NULL);
     }
 
-    G3d_range_min_max(map, min, max);
+    Rast3d_range_min_max(map, min, max);
 
     /* get file data type */
-    itype = G3d_fileTypeMap(map);
+    itype = Rast3d_fileTypeMap(map);
     if (itype == FCELL_TYPE)
 	*type = VOL_DTYPE_FLOAT;
     if (itype == DCELL_TYPE)
@@ -467,7 +467,7 @@ void *open_g3d_file(const char *filename, IFLAG * type, double *min,
 int close_g3d_file(void *map)
 {
     /* close opened g3d file */
-    if (G3d_closeCell((RASTER3D_Map *) map) != 1) {
+    if (Rast3d_closeCell((RASTER3D_Map *) map) != 1) {
 	G_warning(_("Unable to close 3D raster map <%s>"),
 		  ((RASTER3D_Map *) map)->fileName);
 	return (-1);
@@ -492,12 +492,12 @@ int read_g3d_value(IFLAG type, void *map, int x, int y, int z, void *value)
     switch (type) {
 	/* float data type */
     case (VOL_DTYPE_FLOAT):
-	*((float *)value) = G3d_getFloat(map, x, y, z);
+	*((float *)value) = Rast3d_getFloat(map, x, y, z);
 	break;
 
 	/* double data type */
     case (VOL_DTYPE_DOUBLE):
-	*((double *)value) = G3d_getDouble(map, x, y, z);
+	*((double *)value) = Rast3d_getDouble(map, x, y, z);
 	break;
 
 	/* unsupported data type */
@@ -529,7 +529,7 @@ int read_g3d_slice(IFLAG type, void *map, int level, void *data)
 	for (x = 0; x < Cols; x++) {
 	    for (y = 0; y < Rows; y++) {
 		((float *)data)[x + y * Cols] =
-		    G3d_getFloat(map, x, y, level);
+		    Rast3d_getFloat(map, x, y, level);
 	    }
 	}
 
@@ -540,7 +540,7 @@ int read_g3d_slice(IFLAG type, void *map, int level, void *data)
 	for (x = 0; x < Cols; x++) {
 	    for (y = 0; y < Rows; y++) {
 		((double *)data)[x + y * Cols] =
-		    G3d_getDouble(map, x, y, level);
+		    Rast3d_getDouble(map, x, y, level);
 	    }
 	}
 
@@ -575,7 +575,7 @@ int read_g3d_vol(IFLAG type, void *map, void *data)
 	    for (y = 0; y < Rows; y++) {
 		for (z = 0; z < Depths; z++) {
 		    ((float *)data)[x + y * Cols + z * Rows * Cols] =
-			G3d_getFloat(map, x, y, z);
+			Rast3d_getFloat(map, x, y, z);
 		}
 	    }
 	}
@@ -588,7 +588,7 @@ int read_g3d_vol(IFLAG type, void *map, void *data)
 	    for (y = 0; y < Rows; y++) {
 		for (z = 0; z < Depths; z++) {
 		    ((double *)data)[x + y * Cols + z * Rows * Cols] =
-			G3d_getDouble(map, x, y, z);
+			Rast3d_getDouble(map, x, y, z);
 		}
 	    }
 	}
@@ -618,12 +618,12 @@ int is_null_g3d_value(IFLAG type, void *value)
     switch (type) {
 	/* float data type */
     case (VOL_DTYPE_FLOAT):
-	return G3d_isNullValueNum(value, FCELL_TYPE);
+	return Rast3d_isNullValueNum(value, FCELL_TYPE);
 	break;
 
 	/* double data type */
     case (VOL_DTYPE_DOUBLE):
-	return G3d_isNullValueNum(value, DCELL_TYPE);
+	return Rast3d_isNullValueNum(value, DCELL_TYPE);
 	break;
 
 	/* unsupported data type */

lib/raster3d/G3d.h_unused

@@ -58,39 +58,39 @@ typedef struct {
 
 /*---------------------------------------------------------------------------*/
 
-extern void *G3d_openCellOldNoHeader (/* name */);
+extern void *Rast3d_openCellOldNoHeader (/* name */);
 
-extern void *G3d_openCellOld (/* name, cache */);
-extern void *G3d_openCellOld_NEW (/* name, cache */);
-extern void *G3d_openCellNew (/* name, cache, compression, type,
+extern void *Rast3d_openCellOld (/* name, cache */);
+extern void *Rast3d_openCellOld_NEW (/* name, cache */);
+extern void *Rast3d_openCellNew (/* name, cache, compression, type,
                                  tileX, tileY, tileZ,
                                  xMin, yMin, zMin, xMax, yMax, zMax */);
-extern void *G3d_openGrid3File (/* name, x, y, z */);
-extern void *G3d_malloc (/* nBytes */);
-extern void *G3d_realloc (/* ptr, nBytes */);
-extern char *G3d_allocTiles (/* map, nofTiles */);
-extern char *G3d_allocTilesType (/* map, nofTiles, type */);
-extern char *G3d_getTilePtr (/* map, tileIndex */);
-
-extern float G3d_getFloat (/* map, x, y, z */);
-extern double G3d_getDouble (/* map, x, y, z */);
-extern float G3d_getFloatRegion (/* map, x, y, z */);
-extern double G3d_getDoubleRegion (/* map, x, y, z */);
-
-extern void *G3d_cache_new ();
-extern void *G3d_cache_new_read ();
-extern char *G3d_cache_elt_ptr (/* c, name */);
-
-extern void *G3d_cache_hash_new (/* nofNames */);
-
-extern void G3d_skipError (/* msg */);
-extern void G3d_printError (/* msg */);
-/*extern void *G3d_maskFile ();
+extern void *Rast3d_openGrid3File (/* name, x, y, z */);
+extern void *Rast3d_malloc (/* nBytes */);
+extern void *Rast3d_realloc (/* ptr, nBytes */);
+extern char *Rast3d_allocTiles (/* map, nofTiles */);
+extern char *Rast3d_allocTilesType (/* map, nofTiles, type */);
+extern char *Rast3d_getTilePtr (/* map, tileIndex */);
+
+extern float Rast3d_getFloat (/* map, x, y, z */);
+extern double Rast3d_getDouble (/* map, x, y, z */);
+extern float Rast3d_getFloatRegion (/* map, x, y, z */);
+extern double Rast3d_getDoubleRegion (/* map, x, y, z */);
+
+extern void *Rast3d_cache_new ();
+extern void *Rast3d_cache_new_read ();
+extern char *Rast3d_cache_elt_ptr (/* c, name */);
+
+extern void *Rast3d_cache_hash_new (/* nofNames */);
+
+extern void Rast3d_skipError (/* msg */);
+extern void Rast3d_printError (/* msg */);
+/*extern void *Rast3d_maskFile ();
 */
 
-extern void G3d_setWindow (/* window */);
-/*extern void G3d_getWindow ();*/
-extern RASTER3D_Region *G3d_windowPtr ();
+extern void Rast3d_setWindow (/* window */);
+/*extern void Rast3d_getWindow ();*/
+extern RASTER3D_Region *Rast3d_windowPtr ();
 
 /*---------------------------------------------------------------------------*/
 

lib/raster3d/alloc.c

@@ -13,7 +13,7 @@
  * \brief 
  *
  *  Same as <em>malloc (nBytes)</em>, except that in case of error
- * <tt>G3d_error()</tt> is invoked.
+ * <tt>Rast3d_error()</tt> is invoked.
  *
  *  \param nBytes
  *  \return void *: a pointer ... if successful,
@@ -21,7 +21,7 @@
 
  */
 
-void *G3d_malloc(int nBytes)
+void *Rast3d_malloc(int nBytes)
 {
     void *buf;
 
@@ -30,7 +30,7 @@ void *G3d_malloc(int nBytes)
     if ((buf = malloc(nBytes)) != NULL)
 	return buf;
 
-    G3d_error("G3d_malloc: out of memory");
+    Rast3d_error("Rast3d_malloc: out of memory");
     return (void *)NULL;
 }
 
@@ -39,7 +39,7 @@ void *G3d_malloc(int nBytes)
  * \brief 
  *
  *  Same as <em>realloc (ptr, nBytes)</em>, except that in case of error
- *  <tt>G3d_error()</tt> is invoked. 
+ *  <tt>Rast3d_error()</tt> is invoked. 
  *
  *  \param ptr
  *  \param nBytes
@@ -47,14 +47,14 @@ void *G3d_malloc(int nBytes)
  *         NULL ... otherwise.
  */
 
-void *G3d_realloc(void *ptr, int nBytes)
+void *Rast3d_realloc(void *ptr, int nBytes)
 {
     if (nBytes <= 0)
 	nBytes = 1;
     if ((ptr = realloc(ptr, nBytes)) != NULL)
 	return ptr;
 
-    G3d_error("G3d_realloc: out of memory");
+    Rast3d_error("Rast3d_realloc: out of memory");
     return (void *)NULL;
 }
 
@@ -68,7 +68,7 @@ void *G3d_realloc(void *ptr, int nBytes)
  *  \return void
  */
 
-void G3d_free(void *buf)
+void Rast3d_free(void *buf)
 {
     free(buf);
 }

lib/raster3d/cache.c

@@ -11,8 +11,8 @@ static int cacheRead_readFun(int tileIndex, void *tileBuf, void *closure)
 {
     RASTER3D_Map *map = closure;
 
-    if (!G3d_readTile(map, tileIndex, tileBuf, map->typeIntern)) {
-	G3d_error("cacheRead_readFun: error in G3d_readTile");
+    if (!Rast3d_readTile(map, tileIndex, tileBuf, map->typeIntern)) {
+	Rast3d_error("cacheRead_readFun: error in Rast3d_readTile");
 	return 0;
     }
     return 1;
@@ -22,11 +22,11 @@ static int cacheRead_readFun(int tileIndex, void *tileBuf, void *closure)
 
 static int initCacheRead(RASTER3D_Map * map, int nCached)
 {
-    map->cache = G3d_cache_new_read(nCached,
+    map->cache = Rast3d_cache_new_read(nCached,
 				    map->tileSize * map->numLengthIntern,
 				    map->nTiles, cacheRead_readFun, map);
     if (map->cache == NULL) {
-	G3d_error("initCacheRead: error in G3d_cache_new_read");
+	Rast3d_error("initCacheRead: error in Rast3d_cache_new_read");
 	return 0;
     }
 
@@ -62,8 +62,8 @@ static int cacheWrite_readFun(int tileIndex, void *tileBuf, void *closure)
     pos = map->index[tileIndex];
 
     /* tile has already been flushed onto output file or does not exist yet */
-    if (pos >= -1) {		/* note, G3d_readTile takes care of the case pos == -1 */
-	G3d_readTile(map, tileIndex, tileBuf, map->typeIntern);
+    if (pos >= -1) {		/* note, Rast3d_readTile takes care of the case pos == -1 */
+	Rast3d_readTile(map, tileIndex, tileBuf, map->typeIntern);
 	return 1;
     }
 
@@ -77,11 +77,11 @@ static int cacheWrite_readFun(int tileIndex, void *tileBuf, void *closure)
     /* seek tile and read it into buffer */
 
     if (lseek(map->cacheFD, offs, SEEK_SET) == -1) {
-	G3d_error("cacheWrite_readFun: can't position file");
+	Rast3d_error("cacheWrite_readFun: can't position file");
 	return 0;
     }
     if (read(map->cacheFD, tileBuf, nBytes) != nBytes) {
-	G3d_error("cacheWrite_readFun: can't read file");
+	Rast3d_error("cacheWrite_readFun: can't read file");
 	return 0;
     }
 
@@ -103,21 +103,21 @@ static int cacheWrite_readFun(int tileIndex, void *tileBuf, void *closure)
     offsLast = map->cachePosLast * (nBytes + sizeof(int));
 
     if (lseek(map->cacheFD, offsLast, SEEK_SET) == -1) {
-	G3d_error("cacheWrite_readFun: can't position file");
+	Rast3d_error("cacheWrite_readFun: can't position file");
 	return 0;
     }
     if (read(map->cacheFD, xdr, nBytes + sizeof(int)) != nBytes + sizeof(int)) {
-	G3d_error("cacheWrite_readFun: can't read file");
+	Rast3d_error("cacheWrite_readFun: can't read file");
 	return 0;
     }
 
     if (lseek(map->cacheFD, offs, SEEK_SET) == -1) {
-	G3d_error("cacheWrite_readFun: can't position file");
+	Rast3d_error("cacheWrite_readFun: can't position file");
 	return 0;
     }
     if (write(map->cacheFD, xdr, nBytes + sizeof(int)) !=
 	nBytes + sizeof(int)) {
-	G3d_error("cacheWrite_readFun: can't write file");
+	Rast3d_error("cacheWrite_readFun: can't write file");
 	return 0;
     }
 
@@ -146,15 +146,15 @@ cacheWrite_writeFun(int tileIndex, const void *tileBuf, void *closure)
     offs = map->cachePosLast * (nBytes + sizeof(int));
 
     if (lseek(map->cacheFD, offs, SEEK_SET) == -1) {
-	G3d_error("cacheWrite_writeFun: can't position file");
+	Rast3d_error("cacheWrite_writeFun: can't position file");
 	return 0;
     }
     if (write(map->cacheFD, tileBuf, nBytes) != nBytes) {
-	G3d_error("cacheWrite_writeFun: can't write file");
+	Rast3d_error("cacheWrite_writeFun: can't write file");
 	return 0;
     }
     if (write(map->cacheFD, &tileIndex, sizeof(int)) != sizeof(int)) {
-	G3d_error("cacheWrite_writeFun: can't write file");
+	Rast3d_error("cacheWrite_writeFun: can't write file");
 	return 0;
     }
 
@@ -169,14 +169,14 @@ static int disposeCacheWrite(RASTER3D_Map * map)
 {
     if (map->cacheFD >= 0) {
 	if (close(map->cacheFD) != 0) {
-	    G3d_error("disposeCacheWrite: could not close file");
+	    Rast3d_error("disposeCacheWrite: could not close file");
 	    return 0;
 	}
 	remove(map->cacheFileName);
-	G3d_free(map->cacheFileName);
+	Rast3d_free(map->cacheFileName);
     }
 
-    G3d_cache_dispose(map->cache);
+    Rast3d_cache_dispose(map->cache);
 
     return 1;
 }
@@ -189,13 +189,13 @@ static int initCacheWrite(RASTER3D_Map * map, int nCached)
     map->cacheFD = open(map->cacheFileName, O_RDWR | O_CREAT | O_TRUNC, 0666);
 
     if (map->cacheFD < 0) {
-	G3d_error("initCacheWrite: could not open file");
+	Rast3d_error("initCacheWrite: could not open file");
 	return 0;
     }
 
     map->cachePosLast = -1;
 
-    map->cache = G3d_cache_new(nCached,
+    map->cache = Rast3d_cache_new(nCached,
 			       map->tileSize * map->numLengthIntern,
 			       map->nTiles,
 			       cacheWrite_writeFun, map,
@@ -203,7 +203,7 @@ static int initCacheWrite(RASTER3D_Map * map, int nCached)
 
     if (map->cache == NULL) {
 	disposeCacheWrite(map);
-	G3d_error("initCacheWrite: error in G3d_cache_new");
+	Rast3d_error("initCacheWrite: error in Rast3d_cache_new");
 	return 0;
     }
 
@@ -212,18 +212,18 @@ static int initCacheWrite(RASTER3D_Map * map, int nCached)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_initCache(RASTER3D_Map * map, int nCached)
+int Rast3d_initCache(RASTER3D_Map * map, int nCached)
 {
     if (map->operation == RASTER3D_READ_DATA) {
 	if (!initCacheRead(map, nCached)) {
-	    G3d_error("G3d_initCache: error in initCacheRead");
+	    Rast3d_error("Rast3d_initCache: error in initCacheRead");
 	    return 0;
 	}
 	return 1;
     }
 
     if (!initCacheWrite(map, nCached)) {
-	G3d_error("G3d_initCache: error in initCacheWrite");
+	Rast3d_error("Rast3d_initCache: error in initCacheWrite");
 	return 0;
     }
 
@@ -234,24 +234,24 @@ int G3d_initCache(RASTER3D_Map * map, int nCached)
 
 static int disposeCacheRead(RASTER3D_Map * map)
 {
-    G3d_cache_dispose(map->cache);
+    Rast3d_cache_dispose(map->cache);
     return 1;
 }
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_disposeCache(RASTER3D_Map * map)
+int Rast3d_disposeCache(RASTER3D_Map * map)
 {
     if (map->operation == RASTER3D_READ_DATA) {
 	if (!disposeCacheRead(map)) {
-	    G3d_error("G3d_disposeCache: error in disposeCacheRead");
+	    Rast3d_error("Rast3d_disposeCache: error in disposeCacheRead");
 	    return 0;
 	}
 	return 1;
     }
 
     if (!disposeCacheWrite(map)) {
-	G3d_error("G3d_disposeCache: error in disposeCacheWrite");
+	Rast3d_error("Rast3d_disposeCache: error in disposeCacheWrite");
 	return 0;
     }
 
@@ -265,8 +265,8 @@ static int cacheFlushFun(int tileIndex, const void *tileBuf, void *closure)
 {
     RASTER3D_Map *map = closure;
 
-    if (!G3d_writeTile(map, tileIndex, tileBuf, map->typeIntern)) {
-	G3d_error("cacheFlushFun: error in G3d_writeTile");
+    if (!Rast3d_writeTile(map, tileIndex, tileBuf, map->typeIntern)) {
+	Rast3d_error("cacheFlushFun: error in Rast3d_writeTile");
 	return 0;
     }
 
@@ -275,21 +275,21 @@ static int cacheFlushFun(int tileIndex, const void *tileBuf, void *closure)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_flushAllTiles(RASTER3D_Map * map)
+int Rast3d_flushAllTiles(RASTER3D_Map * map)
 {
     int tileIndex, nBytes;
     long offs;
 
     if (map->operation == RASTER3D_READ_DATA) {
-	if (!G3d_cache_remove_all(map->cache)) {
-	    G3d_error("G3d_flushAllTiles: error in G3d_cache_remove_all");
+	if (!Rast3d_cache_remove_all(map->cache)) {
+	    Rast3d_error("Rast3d_flushAllTiles: error in Rast3d_cache_remove_all");
 	    return 0;
 	}
 	return 1;
     }
 
     /* make cache write into output file instead of cache file */
-    G3d_cache_set_removeFun(map->cache, cacheFlushFun, map);
+    Rast3d_cache_set_removeFun(map->cache, cacheFlushFun, map);
 
     /* first flush all the tiles which are in the file cache */
 
@@ -299,32 +299,32 @@ int G3d_flushAllTiles(RASTER3D_Map * map)
 	offs = map->cachePosLast * (nBytes + sizeof(int)) + nBytes;
 
 	if (lseek(map->cacheFD, offs, SEEK_SET) == -1) {
-	    G3d_error("G3d_flushAllTiles: can't position file");
+	    Rast3d_error("Rast3d_flushAllTiles: can't position file");
 	    return 0;
 	}
 	if (read(map->cacheFD, &tileIndex, sizeof(int)) != sizeof(int)) {
-	    G3d_error("G3d_flushAllTiles: can't read file");
+	    Rast3d_error("Rast3d_flushAllTiles: can't read file");
 	    return 0;
 	}
 
-	if (!G3d_cache_load(map->cache, tileIndex)) {
-	    G3d_error("G3d_flushAllTiles: error in G3d_cache_load");
+	if (!Rast3d_cache_load(map->cache, tileIndex)) {
+	    Rast3d_error("Rast3d_flushAllTiles: error in Rast3d_cache_load");
 	    return 0;
 	}
-	if (!G3d_cache_flush(map->cache, tileIndex)) {
-	    G3d_error("G3d_flushAllTiles: error in G3d_cache_flush");
+	if (!Rast3d_cache_flush(map->cache, tileIndex)) {
+	    Rast3d_error("Rast3d_flushAllTiles: error in Rast3d_cache_flush");
 	    return 0;
 	}
     }
 
     /* then flush all the tiles which remain in the non-file cache */
-    if (!G3d_cache_flush_all(map->cache)) {
-	G3d_error("G3d_flushAllTiles: error in G3d_cache_flush_all");
+    if (!Rast3d_cache_flush_all(map->cache)) {
+	Rast3d_error("Rast3d_flushAllTiles: error in Rast3d_cache_flush_all");
 	return 0;
     }
 
     /* now the cache should write into the cache file again */
-    G3d_cache_set_removeFun(map->cache, cacheWrite_writeFun, map);
+    Rast3d_cache_set_removeFun(map->cache, cacheWrite_writeFun, map);
 
     return 1;
 }

lib/raster3d/cache1.c

@@ -31,7 +31,7 @@
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_cache_reset(RASTER3D_cache * c)
+void Rast3d_cache_reset(RASTER3D_cache * c)
 {
     int i;
 
@@ -50,7 +50,7 @@ void G3d_cache_reset(RASTER3D_cache * c)
     c->nofUnlocked = c->nofElts;
     c->minUnlocked = 1;
 
-    G3d_cache_hash_reset(c->hash);
+    Rast3d_cache_hash_reset(c->hash);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -62,38 +62,38 @@ static int cache_dummy_fun(int tileIndex, const void *tileBuf, void *map)
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_cache_dispose(RASTER3D_cache * c)
+void Rast3d_cache_dispose(RASTER3D_cache * c)
 {
     if (c == NULL)
 	return;
 
-    G3d_cache_hash_dispose(c->hash);
+    Rast3d_cache_hash_dispose(c->hash);
 
     if (c->elts != NULL)
-	G3d_free(c->elts);
+	Rast3d_free(c->elts);
     if (c->names != NULL)
-	G3d_free(c->names);
+	Rast3d_free(c->names);
     if (c->locks != NULL)
-	G3d_free(c->locks);
+	Rast3d_free(c->locks);
     if (c->next != NULL)
-	G3d_free(c->next);
+	Rast3d_free(c->next);
     if (c->prev != NULL)
-	G3d_free(c->prev);
+	Rast3d_free(c->prev);
 
-    G3d_free(c);
+    Rast3d_free(c);
 }
 
 /*---------------------------------------------------------------------------*/
 
-void *G3d_cache_new(int nofElts, int sizeOfElts, int nofNames,
+void *Rast3d_cache_new(int nofElts, int sizeOfElts, int nofNames,
 		    int (*eltRemoveFun) (), void *eltRemoveFunData,
 		    int (*eltLoadFun) (), void *eltLoadFunData)
 {
     RASTER3D_cache *tmp;
 
-    tmp = G3d_malloc(sizeof(RASTER3D_cache));
+    tmp = Rast3d_malloc(sizeof(RASTER3D_cache));
     if (tmp == NULL) {
-	G3d_error("G3d_cache_new: error in G3d_malloc");
+	Rast3d_error("Rast3d_cache_new: error in Rast3d_malloc");
 	return (void *)NULL;
     }
 
@@ -101,17 +101,17 @@ void *G3d_cache_new(int nofElts, int sizeOfElts, int nofNames,
 
     tmp->nofElts = nofElts;
     tmp->eltSize = sizeOfElts;
-    tmp->elts = G3d_malloc(tmp->eltSize * tmp->nofElts);
-    tmp->names = G3d_malloc(sizeof(int) * tmp->nofElts);
-    tmp->locks = G3d_malloc(tmp->nofElts);
-    tmp->next = G3d_malloc(sizeof(int) * tmp->nofElts);
-    tmp->prev = G3d_malloc(sizeof(int) * tmp->nofElts);
+    tmp->elts = Rast3d_malloc(tmp->eltSize * tmp->nofElts);
+    tmp->names = Rast3d_malloc(sizeof(int) * tmp->nofElts);
+    tmp->locks = Rast3d_malloc(tmp->nofElts);
+    tmp->next = Rast3d_malloc(sizeof(int) * tmp->nofElts);
+    tmp->prev = Rast3d_malloc(sizeof(int) * tmp->nofElts);
 
     if ((tmp->elts == NULL) || (tmp->names == NULL) || (tmp->locks == NULL) ||
 	(tmp->next == NULL) || (tmp->prev == NULL)) {
 
-	G3d_cache_dispose(tmp);
-	G3d_error("G3d_cache_new: error in G3d_malloc");
+	Rast3d_cache_dispose(tmp);
+	Rast3d_error("Rast3d_cache_new: error in Rast3d_malloc");
 	return (void *)NULL;
     }
 
@@ -120,14 +120,14 @@ void *G3d_cache_new(int nofElts, int sizeOfElts, int nofNames,
     tmp->eltLoadFun = eltLoadFun;
     tmp->eltLoadFunData = eltLoadFunData;
 
-    tmp->hash = G3d_cache_hash_new(nofNames);
+    tmp->hash = Rast3d_cache_hash_new(nofNames);
     if (tmp->hash == NULL) {
-	G3d_cache_dispose(tmp);
-	G3d_error("G3d_cache_new: error in G3d_cache_hash_new");
+	Rast3d_cache_dispose(tmp);
+	Rast3d_error("Rast3d_cache_new: error in Rast3d_cache_hash_new");
 	return (void *)NULL;
     }
 
-    G3d_cache_reset(tmp);
+    Rast3d_cache_reset(tmp);
 
     return tmp;
 }
@@ -135,7 +135,7 @@ void *G3d_cache_new(int nofElts, int sizeOfElts, int nofNames,
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_cache_set_removeFun(RASTER3D_cache * c, int (*eltRemoveFun) (),
+Rast3d_cache_set_removeFun(RASTER3D_cache * c, int (*eltRemoveFun) (),
 			void *eltRemoveFunData)
 {
     c->eltRemoveFun = eltRemoveFun;
@@ -145,7 +145,7 @@ G3d_cache_set_removeFun(RASTER3D_cache * c, int (*eltRemoveFun) (),
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_cache_set_loadFun(RASTER3D_cache * c, int (*eltLoadFun) (),
+Rast3d_cache_set_loadFun(RASTER3D_cache * c, int (*eltLoadFun) (),
 		      void *eltLoadFunData)
 {
     c->eltLoadFun = eltLoadFun;
@@ -154,10 +154,10 @@ G3d_cache_set_loadFun(RASTER3D_cache * c, int (*eltLoadFun) (),
 
 /*---------------------------------------------------------------------------*/
 
-void *G3d_cache_new_read(int nofElts, int sizeOfElts, int nofNames,
+void *Rast3d_cache_new_read(int nofElts, int sizeOfElts, int nofNames,
 			 read_fn * eltLoadFun, void *eltLoadFunData)
 {
-    return G3d_cache_new(nofElts, sizeOfElts, nofNames,
+    return Rast3d_cache_new(nofElts, sizeOfElts, nofNames,
 			 cache_dummy_fun, NULL, eltLoadFun, eltLoadFunData);
 }
 
@@ -166,7 +166,7 @@ void *G3d_cache_new_read(int nofElts, int sizeOfElts, int nofNames,
 static void cache_queue_dequeue(RASTER3D_cache * c, int index)
 {
     if (IS_NOT_IN_QUEUE_ELT(index))
-	G3d_fatalError("cache_queue_dequeue: index not in queue");
+	Rast3d_fatalError("cache_queue_dequeue: index not in queue");
 
     if (index == c->first)
 	c->first = c->next[index];
@@ -186,18 +186,18 @@ static void cache_queue_dequeue(RASTER3D_cache * c, int index)
 static void cache_queue_enqueue(RASTER3D_cache * c, int left, int index)
 {
     if (IS_IN_QUEUE_ELT(index))
-	G3d_fatalError("cache_queue_enqueue: index already in queue");
+	Rast3d_fatalError("cache_queue_enqueue: index already in queue");
 
     if (c->first == -1) {
 	if (left != c->last)
-	    G3d_fatalError("cache_queue_enqueue: position out of range");
+	    Rast3d_fatalError("cache_queue_enqueue: position out of range");
 
 	c->first = c->last = index;
 	return;
     }
 
     if (IS_NOT_IN_QUEUE_ELT(left))
-	G3d_fatalError("cache_queue_enqueue: position not in queue");
+	Rast3d_fatalError("cache_queue_enqueue: position not in queue");
 
 
     if (left == -1) {
@@ -259,13 +259,13 @@ static void cache_queue_preppend(RASTER3D_cache * c, int index)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_cache_lock(RASTER3D_cache * c, int name)
+int Rast3d_cache_lock(RASTER3D_cache * c, int name)
 {
     int index;
 
-    index = G3d_cache_hash_name2index(c->hash, name);
+    index = Rast3d_cache_hash_name2index(c->hash, name);
     if (index == -1) {
-	G3d_error("G3d_cache_lock: name not in cache");
+	Rast3d_error("Rast3d_cache_lock: name not in cache");
 	return 0;
     }
 
@@ -284,7 +284,7 @@ int G3d_cache_lock(RASTER3D_cache * c, int name)
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_cache_lock_intern(RASTER3D_cache * c, int index)
+void Rast3d_cache_lock_intern(RASTER3D_cache * c, int index)
 {
     if (IS_LOCKED_ELT(index))
 	return;
@@ -295,13 +295,13 @@ void G3d_cache_lock_intern(RASTER3D_cache * c, int index)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_cache_unlock(RASTER3D_cache * c, int name)
+int Rast3d_cache_unlock(RASTER3D_cache * c, int name)
 {
     int index;
 
-    index = G3d_cache_hash_name2index(c->hash, name);
+    index = Rast3d_cache_hash_name2index(c->hash, name);
     if (index == -1) {
-	G3d_error("G3d_cache_unlock: name not in cache");
+	Rast3d_error("Rast3d_cache_unlock: name not in cache");
 	return 0;
     }
 
@@ -316,14 +316,14 @@ int G3d_cache_unlock(RASTER3D_cache * c, int name)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_cache_unlock_all(RASTER3D_cache * c)
+int Rast3d_cache_unlock_all(RASTER3D_cache * c)
 {
     int index;
 
     for (index = 0; index < c->nofElts; index++)
 	if (IS_LOCKED_ELT(index))
-	    if (!G3d_cache_unlock(c, c->names[index])) {
-		G3d_error("G3d_cache_unlock_all: error in G3d_cache_unlock");
+	    if (!Rast3d_cache_unlock(c, c->names[index])) {
+		Rast3d_error("Rast3d_cache_unlock_all: error in Rast3d_cache_unlock");
 		return 0;
 	    }
 
@@ -332,34 +332,34 @@ int G3d_cache_unlock_all(RASTER3D_cache * c)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_cache_lock_all(RASTER3D_cache * c)
+int Rast3d_cache_lock_all(RASTER3D_cache * c)
 {
     int index;
 
     for (index = 0; index < c->nofElts; index++)
 	if (IS_UNLOCKED_ELT(index))
-	    G3d_cache_lock_intern(c, index);
+	    Rast3d_cache_lock_intern(c, index);
 
     return 1;
 }
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_cache_autolock_on(RASTER3D_cache * c)
+void Rast3d_cache_autolock_on(RASTER3D_cache * c)
 {
     c->autoLock = 1;
 }
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_cache_autolock_off(RASTER3D_cache * c)
+void Rast3d_cache_autolock_off(RASTER3D_cache * c)
 {
     c->autoLock = 0;
 }
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_cache_set_minUnlock(RASTER3D_cache * c, int nofMinUnLocked)
+void Rast3d_cache_set_minUnlock(RASTER3D_cache * c, int nofMinUnLocked)
 {
     c->minUnlocked = nofMinUnLocked;
 }
@@ -370,9 +370,9 @@ static int cache_remove_elt(RASTER3D_cache * c, int name, int doFlush)
 {
     int index;
 
-    index = G3d_cache_hash_name2index(c->hash, name);
+    index = Rast3d_cache_hash_name2index(c->hash, name);
     if (index == -1) {
-	G3d_error("G3d_cache_deactivate_elt : name not in cache");
+	Rast3d_error("Rast3d_cache_deactivate_elt : name not in cache");
 	return 0;
     }
 
@@ -387,24 +387,24 @@ static int cache_remove_elt(RASTER3D_cache * c, int name, int doFlush)
     if (doFlush)
 	if (!c->eltRemoveFun(name, c->elts + c->eltSize * index,
 			     c->eltRemoveFunData)) {
-	    G3d_error("cache_remove_elt: error in c->eltRemoveFun");
+	    Rast3d_error("cache_remove_elt: error in c->eltRemoveFun");
 	    return 0;
 	}
 
     cache_queue_preppend(c, index);
     DEACTIVATE_ELT(index);
 
-    G3d_cache_hash_remove_name(c->hash, name);
+    Rast3d_cache_hash_remove_name(c->hash, name);
 
     return 1;
 }
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_cache_remove_elt(RASTER3D_cache * c, int name)
+int Rast3d_cache_remove_elt(RASTER3D_cache * c, int name)
 {
     if (!cache_remove_elt(c, name, 0)) {
-	G3d_error("G3d_cache_remove_elt: error in cache_remove_elt");
+	Rast3d_error("Rast3d_cache_remove_elt: error in cache_remove_elt");
 	return 0;
     }
 
@@ -413,10 +413,10 @@ int G3d_cache_remove_elt(RASTER3D_cache * c, int name)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_cache_flush(RASTER3D_cache * c, int name)
+int Rast3d_cache_flush(RASTER3D_cache * c, int name)
 {
     if (!cache_remove_elt(c, name, 1)) {
-	G3d_error("G3d_cache_flush: error in cache_remove_elt");
+	Rast3d_error("Rast3d_cache_flush: error in cache_remove_elt");
 	return 0;
     }
 
@@ -425,15 +425,15 @@ int G3d_cache_flush(RASTER3D_cache * c, int name)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_cache_remove_all(RASTER3D_cache * c)
+int Rast3d_cache_remove_all(RASTER3D_cache * c)
 {
     int index;
 
     for (index = 0; index < c->nofElts; index++)
 	if (IS_ACTIVE_ELT(index))
-	    if (!G3d_cache_remove_elt(c, c->names[index])) {
-		G3d_error
-		    ("G3d_cache_remove_all: error in G3d_cache_remove_elt");
+	    if (!Rast3d_cache_remove_elt(c, c->names[index])) {
+		Rast3d_error
+		    ("Rast3d_cache_remove_all: error in Rast3d_cache_remove_elt");
 		return 0;
 	    }
 
@@ -442,14 +442,14 @@ int G3d_cache_remove_all(RASTER3D_cache * c)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_cache_flush_all(RASTER3D_cache * c)
+int Rast3d_cache_flush_all(RASTER3D_cache * c)
 {
     int index;
 
     for (index = 0; index < c->nofElts; index++)
 	if (IS_ACTIVE_ELT(index))
-	    if (!G3d_cache_flush(c, c->names[index])) {
-		G3d_error("G3d_cache_flush_all: error in G3d_cache_flush");
+	    if (!Rast3d_cache_flush(c, c->names[index])) {
+		Rast3d_error("Rast3d_cache_flush_all: error in Rast3d_cache_flush");
 		return 0;
 	    }
 
@@ -458,17 +458,17 @@ int G3d_cache_flush_all(RASTER3D_cache * c)
 
 /*---------------------------------------------------------------------------*/
 
-void *G3d_cache_elt_ptr(RASTER3D_cache * c, int name)
+void *Rast3d_cache_elt_ptr(RASTER3D_cache * c, int name)
 {
     int index, oldName, doUnlock;
 
-    index = G3d_cache_hash_name2index(c->hash, name);
+    index = Rast3d_cache_hash_name2index(c->hash, name);
 
     if (index != -1) {
 	if (c->autoLock)
 	    if (IS_UNLOCKED_ELT(index) && (!ONE_UNLOCKED_ELT_ONLY) &&
 		(!ARE_MIN_UNLOCKED))
-		G3d_cache_lock_intern(c, index);
+		Rast3d_cache_lock_intern(c, index);
 
 	return c->elts + c->eltSize * index;
     }
@@ -476,30 +476,30 @@ void *G3d_cache_elt_ptr(RASTER3D_cache * c, int name)
     index = c->first;
     if (IS_ACTIVE_ELT(index)) {
 	oldName = c->names[index];
-	G3d_cache_hash_remove_name(c->hash, oldName);
+	Rast3d_cache_hash_remove_name(c->hash, oldName);
 	if (!c->eltRemoveFun(oldName, c->elts + c->eltSize * index,
 			     c->eltRemoveFunData)) {
-	    G3d_error("G3d_cache_elt_ptr: error in c->eltRemoveFun");
+	    Rast3d_error("Rast3d_cache_elt_ptr: error in c->eltRemoveFun");
 	    return NULL;
 	}
     }
 
-    G3d_cache_hash_load_name(c->hash, name, index);
+    Rast3d_cache_hash_load_name(c->hash, name, index);
 
     doUnlock = ((!c->autoLock) || ONE_UNLOCKED_ELT_ONLY || ARE_MIN_UNLOCKED);
 
     UNLOCK_ELT(index);
     c->names[index] = name;
-    G3d_cache_lock_intern(c, index);
+    Rast3d_cache_lock_intern(c, index);
 
     if (doUnlock)
-	if (!G3d_cache_unlock(c, name)) {
-	    G3d_error("G3d_cache_elt_ptr: error in G3d_cache_unlock");
+	if (!Rast3d_cache_unlock(c, name)) {
+	    Rast3d_error("Rast3d_cache_elt_ptr: error in Rast3d_cache_unlock");
 	    return NULL;
 	}
 
     if (!c->eltLoadFun(name, c->elts + c->eltSize * index, c->eltLoadFunData)) {
-	G3d_error("G3d_cache_elt_ptr: error in c->eltLoadFun");
+	Rast3d_error("Rast3d_cache_elt_ptr: error in c->eltLoadFun");
 	return NULL;
     }
 
@@ -508,10 +508,10 @@ void *G3d_cache_elt_ptr(RASTER3D_cache * c, int name)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_cache_load(RASTER3D_cache * c, int name)
+int Rast3d_cache_load(RASTER3D_cache * c, int name)
 {
-    if (G3d_cache_elt_ptr(c, name) == NULL) {
-	G3d_error("G3d_cache_load: error in G3d_cache_elt_ptr");
+    if (Rast3d_cache_elt_ptr(c, name) == NULL) {
+	Rast3d_error("Rast3d_cache_load: error in Rast3d_cache_elt_ptr");
 	return 0;
     }
 
@@ -520,13 +520,13 @@ int G3d_cache_load(RASTER3D_cache * c, int name)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_cache_get_elt(RASTER3D_cache * c, int name, void *dst)
+int Rast3d_cache_get_elt(RASTER3D_cache * c, int name, void *dst)
 {
     const void *elt;
 
-    elt = G3d_cache_elt_ptr(c, name);
+    elt = Rast3d_cache_elt_ptr(c, name);
     if (elt == NULL) {
-	G3d_error("G3d_cache_get_elt: error in G3d_cache_elt_ptr");
+	Rast3d_error("Rast3d_cache_get_elt: error in Rast3d_cache_elt_ptr");
 	return 0;
     }
 
@@ -537,13 +537,13 @@ int G3d_cache_get_elt(RASTER3D_cache * c, int name, void *dst)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_cache_put_elt(RASTER3D_cache * c, int name, const void *src)
+int Rast3d_cache_put_elt(RASTER3D_cache * c, int name, const void *src)
 {
     void *elt;
 
-    elt = G3d_cache_elt_ptr(c, name);
+    elt = Rast3d_cache_elt_ptr(c, name);
     if (elt == NULL) {
-	G3d_error("G3d_cache_put_elt: error in G3d_cache_elt_ptr");
+	Rast3d_error("Rast3d_cache_put_elt: error in Rast3d_cache_elt_ptr");
 	return 0;
     }
 
@@ -568,7 +568,7 @@ static void cache_test_print(RASTER3D_cache * c)
     int *a;
 
     al = c->autoLock;
-    G3d_cache_autolock_off(c);
+    Rast3d_cache_autolock_off(c);
 
     printf("\n--------------------------------\n");
     for (i = 0; i < c->nofElts; i++) {
@@ -578,8 +578,8 @@ static void cache_test_print(RASTER3D_cache * c)
 	    continue;
 	}
 
-	a = (int *)G3d_cache_elt_ptr(c, c->names[i]);
-	/*G3d_cache_get_elt (c, c->names[i], a); */
+	a = (int *)Rast3d_cache_elt_ptr(c, c->names[i]);
+	/*Rast3d_cache_get_elt (c, c->names[i], a); */
 	printf("name %d val %d %s\n", c->names[i], a[17],
 	       (IS_LOCKED_ELT(i) ? "locked" :
 		IS_UNLOCKED_ELT(i) ? "unlocked" : ""));
@@ -587,7 +587,7 @@ static void cache_test_print(RASTER3D_cache * c)
     printf("\n--------------------------------\n");
 
     if (al)
-	G3d_cache_autolock_on(c);
+	Rast3d_cache_autolock_on(c);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -630,14 +630,14 @@ static void cache_test_add(void *c, int name, int val)
     static int firstTime = 1;
 
     if (firstTime) {
-	ctd.value = G3d_malloc(((RASTER3D_cache *) c)->eltSize * sizeof(int));
+	ctd.value = Rast3d_malloc(((RASTER3D_cache *) c)->eltSize * sizeof(int));
 	firstTime = 0;
     }
 
     ctd.value[17] = val;
     ctd.size = ((RASTER3D_cache *) c)->eltSize;
 
-    G3d_cache_load(c, name);
+    Rast3d_cache_load(c, name);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -646,10 +646,10 @@ int MAIN()
 {
     void *c;
 
-    c = G3d_cache_new(3, 76 * sizeof(int), 100000,
+    c = Rast3d_cache_new(3, 76 * sizeof(int), 100000,
 		      cache_test_flush_fun, NULL, cache_test_load_fun, &ctd);
 
-    G3d_cache_autolock_on(c);
+    Rast3d_cache_autolock_on(c);
     cache_test_print(c);
     cache_test_add(c, 1111, -11);
     cache_test_print(c);
@@ -659,9 +659,9 @@ int MAIN()
     cache_test_print(c);
     cache_test_add(c, 4444, -44);
     cache_test_print(c);
-    G3d_cache_unlock_all(c);
+    Rast3d_cache_unlock_all(c);
     cache_test_print(c);
-    G3d_cache_load(c, 2222);
+    Rast3d_cache_load(c, 2222);
     cache_test_print(c);
     cache_test_add(c, 5555, -55);
     cache_test_print(c);
@@ -673,9 +673,9 @@ int MAIN()
     cache_test_print(c);
     cache_test_add(c, 9999, -99);
     cache_test_print(c);
-    G3d_cache_flush(c, 9999);
+    Rast3d_cache_flush(c, 9999);
     cache_test_print(c);
-    G3d_cache_flush_all(c);
+    Rast3d_cache_flush_all(c);
     cache_test_print(c);
     cache_test_add(c, 1111, -11);
     cache_test_print(c);
@@ -683,7 +683,7 @@ int MAIN()
     cache_test_print(c);
     cache_test_add(c, 3333, -33);
     cache_test_print(c);
-    G3d_cache_reset(c);
+    Rast3d_cache_reset(c);
     cache_test_print(c);
     cache_test_add(c, 1111, -11);
     cache_test_print(c);

lib/raster3d/cachehash.c

@@ -17,12 +17,12 @@ typedef struct
     int lastIndex;
     int lastIndexActive;
 
-} G3d_cache_hash;
+} Rast3d_cache_hash;
 #endif
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_cache_hash_reset(G3d_cache_hash * h)
+void Rast3d_cache_hash_reset(Rast3d_cache_hash * h)
 {
     int i;
 
@@ -34,53 +34,53 @@ void G3d_cache_hash_reset(G3d_cache_hash * h)
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_cache_hash_dispose(G3d_cache_hash * h)
+void Rast3d_cache_hash_dispose(Rast3d_cache_hash * h)
 {
     if (h == NULL)
 	return;
 
     if (h->index != NULL)
-	G3d_free(h->index);
+	Rast3d_free(h->index);
     if (h->active != NULL)
-	G3d_free(h->active);
-    G3d_free(h);
+	Rast3d_free(h->active);
+    Rast3d_free(h);
 }
 
 /*---------------------------------------------------------------------------*/
 
-void *G3d_cache_hash_new(int nofNames)
+void *Rast3d_cache_hash_new(int nofNames)
 {
-    G3d_cache_hash *tmp;
+    Rast3d_cache_hash *tmp;
 
-    tmp = G3d_malloc(sizeof(G3d_cache_hash));
+    tmp = Rast3d_malloc(sizeof(Rast3d_cache_hash));
     if (tmp == NULL) {
-	G3d_error("G3d_cache_hash_new: error in G3d_malloc");
+	Rast3d_error("Rast3d_cache_hash_new: error in Rast3d_malloc");
 	return (void *)NULL;
     }
 
     tmp->nofNames = nofNames;
-    tmp->index = G3d_malloc(sizeof(int) * tmp->nofNames);
-    tmp->active = G3d_malloc(sizeof(char) * tmp->nofNames);
+    tmp->index = Rast3d_malloc(sizeof(int) * tmp->nofNames);
+    tmp->active = Rast3d_malloc(sizeof(char) * tmp->nofNames);
     if ((tmp->index == NULL) || (tmp->active == NULL)) {
-	G3d_cache_hash_dispose(tmp);
-	G3d_error("G3d_cache_hash_new: error in G3d_malloc");
+	Rast3d_cache_hash_dispose(tmp);
+	Rast3d_error("Rast3d_cache_hash_new: error in Rast3d_malloc");
 	return (void *)NULL;
     }
 
-    G3d_cache_hash_reset(tmp);
+    Rast3d_cache_hash_reset(tmp);
 
     return tmp;
 }
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_cache_hash_remove_name(G3d_cache_hash * h, int name)
+void Rast3d_cache_hash_remove_name(Rast3d_cache_hash * h, int name)
 {
     if (name >= h->nofNames)
-	G3d_fatalError("G3d_cache_hash_remove_name: name out of range");
+	Rast3d_fatalError("Rast3d_cache_hash_remove_name: name out of range");
 
     if (h->active[name] == 0)
-	G3d_fatalError("G3d_cache_hash_remove_name: name not in hashtable");
+	Rast3d_fatalError("Rast3d_cache_hash_remove_name: name not in hashtable");
 
     h->active[name] = 0;
     if (name == h->lastName)
@@ -89,13 +89,13 @@ void G3d_cache_hash_remove_name(G3d_cache_hash * h, int name)
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_cache_hash_load_name(G3d_cache_hash * h, int name, int index)
+void Rast3d_cache_hash_load_name(Rast3d_cache_hash * h, int name, int index)
 {
     if (name >= h->nofNames)
-	G3d_fatalError("G3d_cache_hash_load_name: name out of range");
+	Rast3d_fatalError("Rast3d_cache_hash_load_name: name out of range");
 
     if (h->active[name] != 0)
-	G3d_fatalError("G3d_cache_hash_load_name: name already in hashtable");
+	Rast3d_fatalError("Rast3d_cache_hash_load_name: name already in hashtable");
 
     h->index[name] = index;
     h->active[name] = 1;
@@ -103,7 +103,7 @@ void G3d_cache_hash_load_name(G3d_cache_hash * h, int name, int index)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_cache_hash_name2index(G3d_cache_hash * h, int name)
+int Rast3d_cache_hash_name2index(Rast3d_cache_hash * h, int name)
 {
     int index;
 

lib/raster3d/cachehash.h

@@ -1 +1 @@
-extern void *G3d_cache_hash_new( /* nofElts */ );
+extern void *Rast3d_cache_hash_new( /* nofElts */ );

lib/raster3d/cats.c

@@ -26,7 +26,7 @@
  *  \return int
  */
 
-int G3d_writeCats(const char *name, struct Categories *cats)
+int Rast3d_writeCats(const char *name, struct Categories *cats)
  /* adapted from Rast_write_cats */
 {
     FILE *fd;
@@ -176,7 +176,7 @@ read_cats(const char *name, const char *mapset, struct Categories *pcats)
  */
 
 int
-G3d_readCats(const char *name, const char *mapset, struct Categories *pcats)
+Rast3d_readCats(const char *name, const char *mapset, struct Categories *pcats)
  /* adapted from Rast_read_cats */
 {
     const char *type;

lib/raster3d/changeprecision.c

@@ -20,7 +20,7 @@
  *  \return void
  */
 
-void G3d_changePrecision(void *map, int precision, const char *nameOut)
+void Rast3d_changePrecision(void *map, int precision, const char *nameOut)
 {
     void *map2;
     int x, y, z, savePrecision, saveCompression, saveLzw, saveRle;
@@ -30,47 +30,47 @@ void G3d_changePrecision(void *map, int precision, const char *nameOut)
     int nx, ny, nz;
     int tileXsave, tileYsave, tileZsave, tileX, tileY, tileZ, saveType;
 
-    saveType = G3d_getFileType();
-    /*   G3d_setFileType (G3d_fileTypeMap (map)); */
-    G3d_getCompressionMode(&saveCompression, &saveLzw, &saveRle,
+    saveType = Rast3d_getFileType();
+    /*   Rast3d_setFileType (Rast3d_fileTypeMap (map)); */
+    Rast3d_getCompressionMode(&saveCompression, &saveLzw, &saveRle,
 			   &savePrecision);
-    G3d_setCompressionMode(RASTER3D_COMPRESSION, saveLzw, saveRle, precision);
-    G3d_getTileDimension(&tileXsave, &tileYsave, &tileZsave);
-    G3d_getTileDimensionsMap(map, &tileX, &tileY, &tileZ);
-    G3d_setTileDimension(tileX, tileY, tileZ);
+    Rast3d_setCompressionMode(RASTER3D_COMPRESSION, saveLzw, saveRle, precision);
+    Rast3d_getTileDimension(&tileXsave, &tileYsave, &tileZsave);
+    Rast3d_getTileDimensionsMap(map, &tileX, &tileY, &tileZ);
+    Rast3d_setTileDimension(tileX, tileY, tileZ);
 
-    typeIntern = G3d_tileTypeMap(map);
-    G3d_getRegionStructMap(map, &region);
+    typeIntern = Rast3d_tileTypeMap(map);
+    Rast3d_getRegionStructMap(map, &region);
 
     map2 =
-	G3d_openCellNew(nameOut, typeIntern, RASTER3D_USE_CACHE_DEFAULT, &region);
+	Rast3d_openCellNew(nameOut, typeIntern, RASTER3D_USE_CACHE_DEFAULT, &region);
     if (map2 == NULL)
-	G3d_fatalError("G3d_changePrecision: error in G3d_openCellNew");
+	Rast3d_fatalError("Rast3d_changePrecision: error in Rast3d_openCellNew");
 
-    G3d_setFileType(saveType);
-    G3d_setCompressionMode(saveCompression, saveLzw, saveRle, savePrecision);
-    G3d_setTileDimension(tileXsave, tileYsave, tileZsave);
+    Rast3d_setFileType(saveType);
+    Rast3d_setCompressionMode(saveCompression, saveLzw, saveRle, savePrecision);
+    Rast3d_setTileDimension(tileXsave, tileYsave, tileZsave);
 
-    data = G3d_allocTiles(map, 1);
+    data = Rast3d_allocTiles(map, 1);
     if (data == NULL)
-	G3d_fatalError("G3d_changePrecision: error in G3d_allocTiles");
-    G3d_getNofTilesMap(map2, &nx, &ny, &nz);
+	Rast3d_fatalError("Rast3d_changePrecision: error in Rast3d_allocTiles");
+    Rast3d_getNofTilesMap(map2, &nx, &ny, &nz);
 
     for (z = 0; z < nz; z++)
 	for (y = 0; y < ny; y++)
 	    for (x = 0; x < nx; x++) {
-		if (!G3d_readTile(map, G3d_tile2tileIndex(map, x, y, z), data,
+		if (!Rast3d_readTile(map, Rast3d_tile2tileIndex(map, x, y, z), data,
 				  typeIntern))
-		    G3d_fatalError
-			("G3d_changePrecision: error in G3d_readTile");
-		if (!G3d_writeTile
-		    (map2, G3d_tile2tileIndex(map2, x, y, z), data,
+		    Rast3d_fatalError
+			("Rast3d_changePrecision: error in Rast3d_readTile");
+		if (!Rast3d_writeTile
+		    (map2, Rast3d_tile2tileIndex(map2, x, y, z), data,
 		     typeIntern))
-		    G3d_fatalError
-			("G3d_changePrecision: error in G3d_writeTile");
+		    Rast3d_fatalError
+			("Rast3d_changePrecision: error in Rast3d_writeTile");
 	    }
 
-    G3d_freeTiles(data);
-    if (!G3d_closeCell(map2))
-	G3d_fatalError("G3d_changePrecision: error in G3d_closeCell");
+    Rast3d_freeTiles(data);
+    if (!Rast3d_closeCell(map2))
+	Rast3d_fatalError("Rast3d_changePrecision: error in Rast3d_closeCell");
 }

lib/raster3d/changetype.c

@@ -21,7 +21,7 @@
  *  \return void
  */
 
-void G3d_changeType(void *map, const char *nameOut)
+void Rast3d_changeType(void *map, const char *nameOut)
 {
     void *map2;
     int x, y, z, saveType;
@@ -31,51 +31,51 @@ void G3d_changeType(void *map, const char *nameOut)
     int tileX, tileY, tileZ, typeIntern, typeIntern2;
     int tileXsave, tileYsave, tileZsave, nx, ny, nz;
 
-    saveType = G3d_getFileType();
-    G3d_setFileType(G3d_fileTypeMap(map) == FCELL_TYPE ?
+    saveType = Rast3d_getFileType();
+    Rast3d_setFileType(Rast3d_fileTypeMap(map) == FCELL_TYPE ?
 		    DCELL_TYPE : FCELL_TYPE);
-    G3d_getTileDimension(&tileXsave, &tileYsave, &tileZsave);
-    G3d_getTileDimensionsMap(map, &tileX, &tileY, &tileZ);
-    G3d_setTileDimension(tileX, tileY, tileZ);
+    Rast3d_getTileDimension(&tileXsave, &tileYsave, &tileZsave);
+    Rast3d_getTileDimensionsMap(map, &tileX, &tileY, &tileZ);
+    Rast3d_setTileDimension(tileX, tileY, tileZ);
 
-    G3d_getRegionStructMap(map, &region);
+    Rast3d_getRegionStructMap(map, &region);
     map2 =
-	G3d_openCellNew(nameOut, FCELL_TYPE, RASTER3D_USE_CACHE_DEFAULT, &region);
+	Rast3d_openCellNew(nameOut, FCELL_TYPE, RASTER3D_USE_CACHE_DEFAULT, &region);
 
     if (map2 == NULL)
-	G3d_fatalError("G3d_changeType: error in G3d_openCellNew");
+	Rast3d_fatalError("Rast3d_changeType: error in Rast3d_openCellNew");
 
-    G3d_setFileType(saveType);
-    G3d_setTileDimension(tileXsave, tileYsave, tileZsave);
+    Rast3d_setFileType(saveType);
+    Rast3d_setTileDimension(tileXsave, tileYsave, tileZsave);
 
-    data = G3d_allocTiles(map, 1);
+    data = Rast3d_allocTiles(map, 1);
     if (data == NULL)
-	G3d_fatalError("G3d_changeType: error in G3d_allocTiles");
-    data2 = G3d_allocTiles(map2, 1);
+	Rast3d_fatalError("Rast3d_changeType: error in Rast3d_allocTiles");
+    data2 = Rast3d_allocTiles(map2, 1);
     if (data2 == NULL)
-	G3d_fatalError("G3d_changeType: error in G3d_allocTiles");
+	Rast3d_fatalError("Rast3d_changeType: error in Rast3d_allocTiles");
 
-    G3d_getNofTilesMap(map2, &nx, &ny, &nz);
-    typeIntern = G3d_tileTypeMap(map);
-    typeIntern2 = G3d_tileTypeMap(map2);
+    Rast3d_getNofTilesMap(map2, &nx, &ny, &nz);
+    typeIntern = Rast3d_tileTypeMap(map);
+    typeIntern2 = Rast3d_tileTypeMap(map2);
     tileSize = tileX * tileY * tileZ;
 
     for (z = 0; z < nz; z++)
 	for (y = 0; y < ny; y++)
 	    for (x = 0; x < nx; x++) {
-		if (!G3d_readTile(map, G3d_tile2tileIndex(map, x, y, z), data,
+		if (!Rast3d_readTile(map, Rast3d_tile2tileIndex(map, x, y, z), data,
 				  typeIntern))
-		    G3d_fatalError("G3d_changeType: error in G3d_readTile");
-		G3d_copyValues(data, 0, typeIntern, data2, 0, typeIntern2,
+		    Rast3d_fatalError("Rast3d_changeType: error in Rast3d_readTile");
+		Rast3d_copyValues(data, 0, typeIntern, data2, 0, typeIntern2,
 			       tileSize);
-		if (!G3d_writeTile
-		    (map2, G3d_tile2tileIndex(map2, x, y, z), data2,
+		if (!Rast3d_writeTile
+		    (map2, Rast3d_tile2tileIndex(map2, x, y, z), data2,
 		     typeIntern2))
-		    G3d_fatalError("G3d_changeType: error in G3d_writeTile");
+		    Rast3d_fatalError("Rast3d_changeType: error in Rast3d_writeTile");
 	    }
 
-    G3d_freeTiles(data);
-    G3d_freeTiles(data2);
-    if (!G3d_closeCell(map2))
-	G3d_fatalError("G3d_changeType: error in G3d_closeCell");
+    Rast3d_freeTiles(data);
+    Rast3d_freeTiles(data2);
+    if (!Rast3d_closeCell(map2))
+	Rast3d_fatalError("Rast3d_changeType: error in Rast3d_closeCell");
 }

lib/raster3d/close.c

@@ -12,17 +12,17 @@
 
 /*---------------------------------------------------------------------------*/
 
-static int G3d_closeNew(RASTER3D_Map * map)
+static int Rast3d_closeNew(RASTER3D_Map * map)
 {
     char path[GPATH_MAX];
     struct Categories cats;
     struct History hist;
 
-    G3d_removeColor(map->fileName);
+    Rast3d_removeColor(map->fileName);
 
     /* create empty cats file */
     Rast_init_cats(NULL, &cats);
-    G3d_writeCats(map->fileName, &cats);
+    Rast3d_writeCats(map->fileName, &cats);
     Rast_free_cats(&cats);
 
     /*genrate the history file, use the normal G_ functions */
@@ -30,25 +30,25 @@ static int G3d_closeNew(RASTER3D_Map * map)
     Rast_command_history(&hist);
     /*Use the G3d function to write the history file,
      * otherwise the path is wrong */
-    if (!G3d_writeHistory(map->fileName, &hist)) {
-	G3d_error("G3d_closeNew: can't write raster3d history");
+    if (!Rast3d_writeHistory(map->fileName, &hist)) {
+	Rast3d_error("Rast3d_closeNew: can't write raster3d history");
     }
 
 
-    G3d_range_write(map);
+    Rast3d_range_write(map);
 
     close(map->data_fd);
 
     /* finally move tempfile to data file */
-    G3d_filename(path, RASTER3D_CELL_ELEMENT, map->fileName, map->mapset);
+    Rast3d_filename(path, RASTER3D_CELL_ELEMENT, map->fileName, map->mapset);
 #ifdef __MINGW32__
     if (CopyFile(map->tempName, path, FALSE) == 0) {
 #else
     if (link(map->tempName, path) < 0) {
 #endif
 	if (rename(map->tempName, path)) {
-	    G3d_error
-		("G3d_closeNew: can't move temp raster map %s\nto 3d data file %s",
+	    Rast3d_error
+		("Rast3d_closeNew: can't move temp raster map %s\nto 3d data file %s",
 		 map->tempName, path);
 	    return 0;
 	}
@@ -61,18 +61,18 @@ static int G3d_closeNew(RASTER3D_Map * map)
 
 /*---------------------------------------------------------------------------*/
 
-static int G3d_closeCellNew(RASTER3D_Map * map)
+static int Rast3d_closeCellNew(RASTER3D_Map * map)
 {
     long ltmp;
 
     if (map->useCache)
-	if (!G3d_flushAllTiles(map)) {
-	    G3d_error("G3d_closeCellNew: error in G3d_flushAllTiles");
+	if (!Rast3d_flushAllTiles(map)) {
+	    Rast3d_error("Rast3d_closeCellNew: error in Rast3d_flushAllTiles");
 	    return 0;
 	}
 
-    if (!G3d_flushIndex(map)) {
-	G3d_error("G3d_closeCellNew: error in G3d_flushIndex");
+    if (!Rast3d_flushIndex(map)) {
+	Rast3d_error("Rast3d_closeCellNew: error in Rast3d_flushIndex");
 	return 0;
     }
 
@@ -82,23 +82,23 @@ static int G3d_closeCellNew(RASTER3D_Map * map)
     if (lseek(map->data_fd,
 	      (long)(map->offset - sizeof(int) - sizeof(long)),
 	      SEEK_SET) == -1) {
-	G3d_error("G3d_closeCellNew: can't position file");
+	Rast3d_error("Rast3d_closeCellNew: can't position file");
 	return 0;
     }
 
-    if (!G3d_writeInts(map->data_fd, map->useXdr, &(map->indexNbytesUsed), 1)) {
-	G3d_error("G3d_closeCellNew: can't write header");
+    if (!Rast3d_writeInts(map->data_fd, map->useXdr, &(map->indexNbytesUsed), 1)) {
+	Rast3d_error("Rast3d_closeCellNew: can't write header");
 	return 0;
     }
 
-    G3d_longEncode(&(map->indexOffset), (unsigned char *)&ltmp, 1);
+    Rast3d_longEncode(&(map->indexOffset), (unsigned char *)&ltmp, 1);
     if (write(map->data_fd, &ltmp, sizeof(long)) != sizeof(long)) {
-	G3d_error("G3d_closeCellNew: can't write header");
+	Rast3d_error("Rast3d_closeCellNew: can't write header");
 	return 0;
     }
 
-    if (!G3d_closeNew(map) != 0) {
-	G3d_error("G3d_closeCellNew: error in G3d_closeNew");
+    if (!Rast3d_closeNew(map) != 0) {
+	Rast3d_error("Rast3d_closeCellNew: error in Rast3d_closeNew");
 	return 0;
     }
 
@@ -107,10 +107,10 @@ static int G3d_closeCellNew(RASTER3D_Map * map)
 
 /*---------------------------------------------------------------------------*/
 
-static int G3d_closeOld(RASTER3D_Map * map)
+static int Rast3d_closeOld(RASTER3D_Map * map)
 {
     if (close(map->data_fd) != 0) {
-	G3d_error("G3d_closeOld: could not close file");
+	Rast3d_error("Rast3d_closeOld: could not close file");
 	return 0;
     }
 
@@ -119,10 +119,10 @@ static int G3d_closeOld(RASTER3D_Map * map)
 
 /*---------------------------------------------------------------------------*/
 
-static int G3d_closeCellOld(RASTER3D_Map * map)
+static int Rast3d_closeCellOld(RASTER3D_Map * map)
 {
-    if (!G3d_closeOld(map) != 0) {
-	G3d_error("G3d_closeCellOld: error in G3d_closeOld");
+    if (!Rast3d_closeOld(map) != 0) {
+	Rast3d_error("Rast3d_closeCellOld: error in Rast3d_closeOld");
 	return 0;
     }
 
@@ -144,35 +144,35 @@ static int G3d_closeCellOld(RASTER3D_Map * map)
  *          0 ...  otherwise.
  */
 
-int G3d_closeCell(RASTER3D_Map * map)
+int Rast3d_closeCell(RASTER3D_Map * map)
 {
     if (map->operation == RASTER3D_WRITE_DATA) {
-	if (!G3d_closeCellNew(map)) {
-	    G3d_error("G3d_closeCell: error in G3d_closeCellNew");
+	if (!Rast3d_closeCellNew(map)) {
+	    Rast3d_error("Rast3d_closeCell: error in Rast3d_closeCellNew");
 	    return 0;
 	}
     }
     else {
-	if (!G3d_closeCellOld(map) != 0) {
-	    G3d_error("G3d_closeCell: error in G3d_closeCellOld");
+	if (!Rast3d_closeCellOld(map) != 0) {
+	    Rast3d_error("Rast3d_closeCell: error in Rast3d_closeCellOld");
 	    return 0;
 	}
     }
 
-    G3d_free(map->index);
-    G3d_free(map->tileLength);
+    Rast3d_free(map->index);
+    Rast3d_free(map->tileLength);
 
     if (map->useCache) {
-	if (!G3d_disposeCache(map)) {
-	    G3d_error("G3d_closeCell: error in G3d_disposeCache");
+	if (!Rast3d_disposeCache(map)) {
+	    Rast3d_error("Rast3d_closeCell: error in Rast3d_disposeCache");
 	    return 0;
 	}
     }
     else
-	G3d_free(map->data);
+	Rast3d_free(map->data);
 
     if (map->operation == RASTER3D_WRITE_DATA)
-	if (!G3d_writeHeader(map,
+	if (!Rast3d_writeHeader(map,
 			     map->region.proj, map->region.zone,
 			     map->region.north, map->region.south,
 			     map->region.east, map->region.west,
@@ -186,11 +186,11 @@ int G3d_closeCell(RASTER3D_Map * map)
 			     map->compression, map->useRle, map->useLzw,
 			     map->precision, map->offset, map->useXdr,
 			     map->hasIndex, map->unit)) {
-	    G3d_error("G3d_closeCell: error in G3d_writeHeader");
+	    Rast3d_error("Rast3d_closeCell: error in Rast3d_writeHeader");
 	    return 0;
 	}
 
-    G3d_free(map->unit);
-    G3d_free(map);
+    Rast3d_free(map->unit);
+    Rast3d_free(map);
     return 1;
 }

lib/raster3d/color.c

@@ -19,7 +19,7 @@ static int read_old_colors(FILE *, struct Colors *);
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_removeColor(const char *name)
+int Rast3d_removeColor(const char *name)
  /* adapted from G_remove_colr */
 {
     return G_remove_misc(RASTER3D_DIRECTORY, RASTER3D_COLOR_ELEMENT, name);
@@ -28,7 +28,7 @@ int G3d_removeColor(const char *name)
 /*---------------------------------------------------------------------------*/
 
 int
-G3d_readColors(const char *name, const char *mapset, struct Colors *colors)
+Rast3d_readColors(const char *name, const char *mapset, struct Colors *colors)
  /* adapted from Rast_read_colors */
 {
     const char *err;
@@ -41,7 +41,7 @@ G3d_readColors(const char *name, const char *mapset, struct Colors *colors)
 
     switch (read_colors(name, mapset, colors)) {
     case -2:
-	if (G3d_readRange(name, mapset, &drange) >= 0) {
+	if (Rast3d_readRange(name, mapset, &drange) >= 0) {
 	    Rast_get_fp_range_min_max(&drange, &dmin, &dmax);
 	    if (!Rast_is_d_null_value(&dmin) && !Rast_is_d_null_value(&dmax))
 		Rast_make_rainbow_fp_colors(colors, dmin, dmax);
@@ -324,7 +324,7 @@ static int read_old_colors(FILE * fd, struct Colors *colors)
 /*---------------------------------------------------------------------------*/
 
 int
-G3d_writeColors(const char *name, const char *mapset, struct Colors *colors)
+Rast3d_writeColors(const char *name, const char *mapset, struct Colors *colors)
  /* adapted from Rast_write_colors */
 {
     FILE *fd;

lib/raster3d/defaults.c

@@ -17,7 +17,7 @@
 #define RASTER3D_TILE_X_DEFAULT 16
 #define RASTER3D_TILE_Y_DEFAULT 16
 #define RASTER3D_TILE_Z_DEFAULT 8
-#define RASTER3D_ERROR_FUN_DEFAULT G3d_skipError
+#define RASTER3D_ERROR_FUN_DEFAULT Rast3d_skipError
 #define RASTER3D_UNIT_DEFAULT "none"
 
 /*---------------------------------------------------------------------------*/
@@ -82,10 +82,10 @@ char *g3d_unit_default = NULL;
  */
 
 void
-G3d_setCompressionMode(int doCompress, int doLzw, int doRle, int precision)
+Rast3d_setCompressionMode(int doCompress, int doLzw, int doRle, int precision)
 {
     if ((doCompress != RASTER3D_NO_COMPRESSION) && (doCompress != RASTER3D_COMPRESSION))
-	G3d_fatalError("G3d_setCompressionMode: wrong value for doCompress.");
+	Rast3d_fatalError("Rast3d_setCompressionMode: wrong value for doCompress.");
 
     g3d_do_compression = doCompress;
 
@@ -93,13 +93,13 @@ G3d_setCompressionMode(int doCompress, int doLzw, int doRle, int precision)
 	return;
 
     if ((doLzw != RASTER3D_NO_LZW) && (doLzw != RASTER3D_USE_LZW))
-	G3d_fatalError("G3d_setCompressionMode: wrong value for doLzw.");
+	Rast3d_fatalError("Rast3d_setCompressionMode: wrong value for doLzw.");
 
     if ((doRle != RASTER3D_NO_RLE) && (doRle != RASTER3D_USE_RLE))
-	G3d_fatalError("G3d_setCompressionMode: wrong value for doRle.");
+	Rast3d_fatalError("Rast3d_setCompressionMode: wrong value for doRle.");
 
     if (precision < -1)
-	G3d_fatalError("G3d_setCompressionMode: wrong value for precision.");
+	Rast3d_fatalError("Rast3d_setCompressionMode: wrong value for precision.");
 
     g3d_do_lzw_compression = doLzw;
     g3d_do_rle_compression = doRle;
@@ -122,7 +122,7 @@ G3d_setCompressionMode(int doCompress, int doLzw, int doRle, int precision)
  */
 
 void
-G3d_getCompressionMode(int *doCompress, int *doLzw, int *doRle,
+Rast3d_getCompressionMode(int *doCompress, int *doLzw, int *doRle,
 		       int *precision)
 {
     if (doCompress != NULL)
@@ -147,10 +147,10 @@ G3d_getCompressionMode(int *doCompress, int *doLzw, int *doRle,
  *  \return void
  */
 
-void G3d_setCacheSize(int nTiles)
+void Rast3d_setCacheSize(int nTiles)
 {
     if (nTiles < 0)
-	G3d_fatalError("G3d_setCacheSize: size out of range.");
+	Rast3d_fatalError("Rast3d_setCacheSize: size out of range.");
 
     g3d_cache_default = nTiles;
 }
@@ -166,7 +166,7 @@ void G3d_setCacheSize(int nTiles)
  *  \return int
  */
 
-int G3d_getCacheSize()
+int Rast3d_getCacheSize()
 {
     return g3d_cache_default;
 }
@@ -183,10 +183,10 @@ int G3d_getCacheSize()
  *  \return void
  */
 
-void G3d_setCacheLimit(int nBytes)
+void Rast3d_setCacheLimit(int nBytes)
 {
     if (nBytes <= 0)
-	G3d_fatalError("G3d_setCacheLimit: size out of range.");
+	Rast3d_fatalError("Rast3d_setCacheLimit: size out of range.");
 
     g3d_cache_max = nBytes;
 }
@@ -203,7 +203,7 @@ void G3d_setCacheLimit(int nBytes)
  *  \return int
  */
 
-int G3d_getCacheLimit()
+int Rast3d_getCacheLimit()
 {
     return g3d_cache_max;
 }
@@ -220,10 +220,10 @@ int G3d_getCacheLimit()
  *  \return void
  */
 
-void G3d_setFileType(int type)
+void Rast3d_setFileType(int type)
 {
     if ((type != FCELL_TYPE) && (type != DCELL_TYPE))
-	G3d_fatalError("G3d_setFileTypeDefault: invalid type");
+	Rast3d_fatalError("Rast3d_setFileTypeDefault: invalid type");
 
     g3d_file_type = type;
 }
@@ -240,7 +240,7 @@ void G3d_setFileType(int type)
  *  \return int
  */
 
-int G3d_getFileType()
+int Rast3d_getFileType()
 {
     return g3d_file_type;
 }
@@ -259,19 +259,19 @@ int G3d_getFileType()
  *  \return void
  */
 
-void G3d_setTileDimension(int tileX, int tileY, int tileZ)
+void Rast3d_setTileDimension(int tileX, int tileY, int tileZ)
 {
     if ((g3d_tile_dimension[0] = tileX) <= 0)
-	G3d_fatalError
-	    ("G3d_setTileDimension: value for tile x environment variable out of range");
+	Rast3d_fatalError
+	    ("Rast3d_setTileDimension: value for tile x environment variable out of range");
 
     if ((g3d_tile_dimension[1] = tileY) <= 0)
-	G3d_fatalError
-	    ("G3d_setTileDimension: value for tile y environment variable out of range");
+	Rast3d_fatalError
+	    ("Rast3d_setTileDimension: value for tile y environment variable out of range");
 
     if ((g3d_tile_dimension[2] = tileZ) <= 0)
-	G3d_fatalError
-	    ("G3d_setTileDimension: value for tile z environment variable out of range");
+	Rast3d_fatalError
+	    ("Rast3d_setTileDimension: value for tile z environment variable out of range");
 }
 
 /*---------------------------------------------------------------------------*/
@@ -288,7 +288,7 @@ void G3d_setTileDimension(int tileX, int tileY, int tileZ)
  *  \return void
  */
 
-void G3d_getTileDimension(int *tileX, int *tileY, int *tileZ)
+void Rast3d_getTileDimension(int *tileX, int *tileY, int *tileZ)
 {
     *tileX = g3d_tile_dimension[0];
     *tileY = g3d_tile_dimension[1];
@@ -307,7 +307,7 @@ void G3d_getTileDimension(int *tileX, int *tileY, int *tileZ)
  *  \return void
  */
 
-void G3d_setErrorFun(void (*fun) (const char *))
+void Rast3d_setErrorFun(void (*fun) (const char *))
 {
     g3d_error_fun = fun;
 }
@@ -324,9 +324,9 @@ void G3d_setErrorFun(void (*fun) (const char *))
  *  \return void
  */
 
-void G3d_setUnit(const char *unit)
+void Rast3d_setUnit(const char *unit)
 {
-    G3d_free(g3d_unit_default);
+    Rast3d_free(g3d_unit_default);
     g3d_unit_default = G_store(unit);
 }
 
@@ -344,7 +344,7 @@ void G3d_setUnit(const char *unit)
  *  \return void
  */
 
-void G3d_initDefaults(void)
+void Rast3d_initDefaults(void)
 {
     static int firstTime = 1;
     const char *value, *windowName;
@@ -407,13 +407,13 @@ void G3d_initDefaults(void)
 	    }
 	    else {
 		if (sscanf(value, "%d", &g3d_precision) != 1) {
-		    G3d_fatalError
-			("G3d_initDefaults: precision environment variable has invalid value");
+		    Rast3d_fatalError
+			("Rast3d_initDefaults: precision environment variable has invalid value");
 		}
 		else {
 		    if (g3d_precision < -1) {
-			G3d_fatalError
-			    ("G3d_initDefaults: value for cache environment variable out of range");
+			Rast3d_fatalError
+			    ("Rast3d_initDefaults: value for cache environment variable out of range");
 		    }
 		}
 	    }
@@ -442,12 +442,12 @@ void G3d_initDefaults(void)
 	}
 	else {
 	    if (sscanf(value, "%d", &g3d_cache_default) != 1) {
-		G3d_fatalError
-		    ("G3d_initDefaults: cache environment variable has invalid value");
+		Rast3d_fatalError
+		    ("Rast3d_initDefaults: cache environment variable has invalid value");
 	    }
 	    if (g3d_cache_default < 0) {
-		G3d_fatalError
-		    ("G3d_initDefaults: value for cache environment variable out of range");
+		Rast3d_fatalError
+		    ("Rast3d_initDefaults: value for cache environment variable out of range");
 	    }
 	}
     }
@@ -460,12 +460,12 @@ void G3d_initDefaults(void)
 	}
 	else {
 	    if (sscanf(value, "%d", &g3d_cache_max) != 1) {
-		G3d_fatalError
-		    ("G3d_initDefaults: cache environment variable has invalid value");
+		Rast3d_fatalError
+		    ("Rast3d_initDefaults: cache environment variable has invalid value");
 	    }
 	    if (g3d_cache_max < 0) {
-		G3d_fatalError
-		    ("G3d_initDefaults: value for cache environment variable out of range");
+		Rast3d_fatalError
+		    ("Rast3d_initDefaults: value for cache environment variable out of range");
 	    }
 	}
     }
@@ -478,12 +478,12 @@ void G3d_initDefaults(void)
 	}
 	else {
 	    if (sscanf(value, "%d", g3d_tile_dimension) != 1) {
-		G3d_fatalError
-		    ("G3d_initDefaults: tile dimension x environment variable has invalid value");
+		Rast3d_fatalError
+		    ("Rast3d_initDefaults: tile dimension x environment variable has invalid value");
 	    }
 	    if (g3d_tile_dimension[0] <= 0) {
-		G3d_fatalError
-		    ("G3d_initDefaults: value for tile x environment variable out of range");
+		Rast3d_fatalError
+		    ("Rast3d_initDefaults: value for tile x environment variable out of range");
 	    }
 	}
 
@@ -494,12 +494,12 @@ void G3d_initDefaults(void)
 	}
 	else {
 	    if (sscanf(value, "%d", g3d_tile_dimension + 1) != 1) {
-		G3d_fatalError
-		    ("G3d_initDefaults: tile dimension y environment variable has invalid value");
+		Rast3d_fatalError
+		    ("Rast3d_initDefaults: tile dimension y environment variable has invalid value");
 	    }
 	    if (g3d_tile_dimension[1] <= 0) {
-		G3d_fatalError
-		    ("G3d_initDefaults: value for tile y environment variable out of range");
+		Rast3d_fatalError
+		    ("Rast3d_initDefaults: value for tile y environment variable out of range");
 	    }
 	}
 
@@ -510,12 +510,12 @@ void G3d_initDefaults(void)
 	}
 	else {
 	    if (sscanf(value, "%d", g3d_tile_dimension + 2) != 1) {
-		G3d_fatalError
-		    ("G3d_initDefaults: tile dimension z environment variable has invalid value");
+		Rast3d_fatalError
+		    ("Rast3d_initDefaults: tile dimension z environment variable has invalid value");
 	    }
 	    if (g3d_tile_dimension[2] <= 0) {
-		G3d_fatalError
-		    ("G3d_initDefaults: value for tile z environment variable out of range");
+		Rast3d_fatalError
+		    ("Rast3d_initDefaults: value for tile z environment variable out of range");
 	    }
 	}
     }
@@ -524,13 +524,13 @@ void G3d_initDefaults(void)
 	value = getenv(RASTER3D_FATAL_ERROR_ENV_VAR);
 
 	if (value != NULL) {
-	    g3d_error_fun = G3d_fatalError_noargs;
+	    g3d_error_fun = Rast3d_fatalError_noargs;
 	}
 	else {
 	    value = getenv(RASTER3D_PRINT_ERROR_ENV_VAR);
 
 	    if (value != NULL) {
-		g3d_error_fun = G3d_printError;
+		g3d_error_fun = Rast3d_printError;
 	    }
 	    else {
 		g3d_error_fun = RASTER3D_ERROR_FUN_DEFAULT;
@@ -541,7 +541,7 @@ void G3d_initDefaults(void)
     if (g3d_unit_default == NULL)
 	g3d_unit_default = G_store(RASTER3D_UNIT_DEFAULT);
 
-    windowName = G3d_getWindowParams();
+    windowName = Rast3d_getWindowParams();
     if (windowName == NULL) {
 	value = getenv(RASTER3D_DEFAULT_WINDOW3D);
 	if (value != NULL)
@@ -549,8 +549,8 @@ void G3d_initDefaults(void)
 		windowName = value;
     }
 
-    if (!G3d_readWindow(&window, windowName))
-	G3d_fatalError("G3d_initDefaults: Error reading window");
-    G3d_setWindow(&window);
+    if (!Rast3d_readWindow(&window, windowName))
+	Rast3d_fatalError("Rast3d_initDefaults: Error reading window");
+    Rast3d_setWindow(&window);
 
 }

lib/raster3d/doubleio.c

@@ -8,7 +8,7 @@
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_writeDoubles(int fd, int useXdr, const double *i, int nofNum)
+int Rast3d_writeDoubles(int fd, int useXdr, const double *i, int nofNum)
 {
     int firstTime = 1;
     XDR xdrEncodeStream;
@@ -16,11 +16,11 @@ int G3d_writeDoubles(int fd, int useXdr, const double *i, int nofNum)
     u_int n;
 
     if (nofNum <= 0)
-	G3d_fatalError("G3d_writeDoubles: nofNum out of range");
+	Rast3d_fatalError("Rast3d_writeDoubles: nofNum out of range");
 
     if (useXdr == RASTER3D_NO_XDR) {
 	if (write(fd, i, sizeof(double) * nofNum) != sizeof(double) * nofNum) {
-	    G3d_error("G3d_writeDoubles: writing to file failed");
+	    Rast3d_error("Rast3d_writeDoubles: writing to file failed");
 	    return 0;
 	}
 	else {
@@ -41,19 +41,19 @@ int G3d_writeDoubles(int fd, int useXdr, const double *i, int nofNum)
 	    n = 1024;
 
 	if (!xdr_setpos(&xdrEncodeStream, 0)) {
-	    G3d_error("G3d_writeDoubles: positioning xdr failed");
+	    Rast3d_error("Rast3d_writeDoubles: positioning xdr failed");
 	    return 0;
 	}
 
 	if (!xdr_vector(&xdrEncodeStream, (char *)i, n, sizeof(double),
 			(xdrproc_t) xdr_double)) {
-	    G3d_error("G3d_writeDoubles: writing xdr failed");
+	    Rast3d_error("Rast3d_writeDoubles: writing xdr failed");
 	    return 0;
 	}
 
 	if (write(fd, xdrDoubleBuf, RASTER3D_XDR_DOUBLE_LENGTH * n) !=
 	    RASTER3D_XDR_DOUBLE_LENGTH * n) {
-	    G3d_error("G3d_writeDoubles: writing xdr to file failed");
+	    Rast3d_error("Rast3d_writeDoubles: writing xdr to file failed");
 	    return 0;
 	}
 
@@ -66,7 +66,7 @@ int G3d_writeDoubles(int fd, int useXdr, const double *i, int nofNum)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_readDoubles(int fd, int useXdr, double *i, int nofNum)
+int Rast3d_readDoubles(int fd, int useXdr, double *i, int nofNum)
 {
     int firstTime = 1;
     XDR xdrDecodeStream;
@@ -74,11 +74,11 @@ int G3d_readDoubles(int fd, int useXdr, double *i, int nofNum)
     u_int n;
 
     if (nofNum <= 0)
-	G3d_fatalError("G3d_readDoubles: nofNum out of range");
+	Rast3d_fatalError("Rast3d_readDoubles: nofNum out of range");
 
     if (useXdr == RASTER3D_NO_XDR) {
 	if (read(fd, i, sizeof(double) * nofNum) != sizeof(double) * nofNum) {
-	    G3d_error("G3d_readDoubles: reading from file failed");
+	    Rast3d_error("Rast3d_readDoubles: reading from file failed");
 	    return 0;
 	}
 	else {
@@ -99,18 +99,18 @@ int G3d_readDoubles(int fd, int useXdr, double *i, int nofNum)
 
 	if (read(fd, xdrDoubleBuf, RASTER3D_XDR_DOUBLE_LENGTH * n) !=
 	    RASTER3D_XDR_DOUBLE_LENGTH * n) {
-	    G3d_error("G3d_readDoubles: reading xdr from file failed");
+	    Rast3d_error("Rast3d_readDoubles: reading xdr from file failed");
 	    return 0;
 	}
 
 	if (!xdr_setpos(&xdrDecodeStream, 0)) {
-	    G3d_error("G3d_readDoubles: positioning xdr failed");
+	    Rast3d_error("Rast3d_readDoubles: positioning xdr failed");
 	    return 0;
 	}
 
 	if (!xdr_vector(&xdrDecodeStream, (char *)i, n, sizeof(double),
 			(xdrproc_t) xdr_double)) {
-	    G3d_error("G3d_readDoubles: reading xdr failed");
+	    Rast3d_error("Rast3d_readDoubles: reading xdr failed");
 	    return 0;
 	}
 

lib/raster3d/error.c

@@ -22,7 +22,7 @@
  *  \return void
  */
 
-void G3d_skipError(const char *msg)
+void Rast3d_skipError(const char *msg)
 {
 }
 
@@ -37,7 +37,7 @@ void G3d_skipError(const char *msg)
  *  \return void
  */
 
-void G3d_printError(const char *msg)
+void Rast3d_printError(const char *msg)
 {
     fprintf(stderr, "ERROR: ");
     fprintf(stderr, msg);
@@ -55,7 +55,7 @@ void G3d_printError(const char *msg)
  *  \return void
  */
 
-void G3d_fatalError(const char *msg, ...)
+void Rast3d_fatalError(const char *msg, ...)
 {
     char buffer[2000];		/* No novels to the error logs, OK? */
     va_list ap;
@@ -67,12 +67,12 @@ void G3d_fatalError(const char *msg, ...)
     G_fatal_error("%s", buffer);
 }
 
-void G3d_fatalError_noargs(const char *msg)
+void Rast3d_fatalError_noargs(const char *msg)
 {
     G_fatal_error("%s", msg);
 }
 
-void G3d_error(const char *msg, ...)
+void Rast3d_error(const char *msg, ...)
 {
     char buffer[2000];		/* No novels to the error logs, OK? */
     va_list ap;

lib/raster3d/filecompare.c

@@ -13,41 +13,41 @@ static unsigned char clearMask[9] =
 
 /*---------------------------------------------------------------------------*/
 
-static void G3d_float2xdrFloat(float *f, float *xdrf)
+static void Rast3d_float2xdrFloat(float *f, float *xdrf)
 {
     XDR xdrEncodeStream;
 
     xdrmem_create(&xdrEncodeStream, (caddr_t) xdrf, 4, XDR_ENCODE);
 
     if (!xdr_setpos(&xdrEncodeStream, 0))
-	G3d_fatalError("G3d_float2xdrFloat: positioning xdr failed");
+	Rast3d_fatalError("Rast3d_float2xdrFloat: positioning xdr failed");
 
     if (!xdr_float(&xdrEncodeStream, f))
-	G3d_fatalError("G3d_float2xdrFloat: writing xdr failed");
+	Rast3d_fatalError("Rast3d_float2xdrFloat: writing xdr failed");
 
     xdr_destroy(&xdrEncodeStream);
 }
 
 /*---------------------------------------------------------------------------*/
 
-static void G3d_double2xdrDouble(double *d, double *xdrd)
+static void Rast3d_double2xdrDouble(double *d, double *xdrd)
 {
     XDR xdrEncodeStream;
 
     xdrmem_create(&xdrEncodeStream, (caddr_t) xdrd, 8, XDR_ENCODE);
 
     if (!xdr_setpos(&xdrEncodeStream, 0))
-	G3d_fatalError("G3d_double2xdrDouble: positioning xdr failed");
+	Rast3d_fatalError("Rast3d_double2xdrDouble: positioning xdr failed");
 
     if (!xdr_double(&xdrEncodeStream, d))
-	G3d_fatalError("G3d_double2xdrDouble: writing xdr failed");
+	Rast3d_fatalError("Rast3d_double2xdrDouble: writing xdr failed");
 
     xdr_destroy(&xdrEncodeStream);
 }
 
 /*---------------------------------------------------------------------------*/
 
-static void G3d_truncFloat(float *f, int p)
+static void Rast3d_truncFloat(float *f, int p)
 {
     unsigned char *c;
 
@@ -78,7 +78,7 @@ static void G3d_truncFloat(float *f, int p)
 
 /*---------------------------------------------------------------------------*/
 
-static void G3d_truncDouble(double *d, int p)
+static void Rast3d_truncDouble(double *d, int p)
 {
     unsigned char *c;
 
@@ -151,7 +151,7 @@ static void G3d_truncDouble(double *d, int p)
 
 /*---------------------------------------------------------------------------*/
 
-static void G3d_float2Double(float *f, double *d)
+static void Rast3d_float2Double(float *f, double *d)
 {
     unsigned char *c1, *c2, sign, c;
     int e;
@@ -191,16 +191,16 @@ static void G3d_float2Double(float *f, double *d)
 
 /*---------------------------------------------------------------------------*/
 
-static int G3d_compareFloats(float *f1, int p1, float *f2, int p2)
+static int Rast3d_compareFloats(float *f1, int p1, float *f2, int p2)
 {
     unsigned char *c1, *c2;
     float xdrf1, xdrf2;
 
-    if (G3d_isNullValueNum(f1, FCELL_TYPE))
-	return G3d_isNullValueNum(f2, FCELL_TYPE);
+    if (Rast3d_isNullValueNum(f1, FCELL_TYPE))
+	return Rast3d_isNullValueNum(f2, FCELL_TYPE);
 
-    G3d_float2xdrFloat(f1, &xdrf1);
-    G3d_float2xdrFloat(f2, &xdrf2);
+    Rast3d_float2xdrFloat(f1, &xdrf1);
+    Rast3d_float2xdrFloat(f2, &xdrf2);
 
     c1 = (unsigned char *)&xdrf1;
     c2 = (unsigned char *)&xdrf2;
@@ -208,9 +208,9 @@ static int G3d_compareFloats(float *f1, int p1, float *f2, int p2)
     /*   printf ("%d %d (%d %d %d %d) (%d %d %d %d) %d\n", p1, p2, *c1, *(c1 + 1), *(c1 + 2), *(c1 + 3), *c2, *(c2 + 1), *(c2 + 2), *(c2 + 3), *f1 == *f2); */
 
     if ((p1 != -1) && (p1 < 23) && ((p1 < p2) || (p2 == -1)))
-	G3d_truncFloat(&xdrf2, p1);
+	Rast3d_truncFloat(&xdrf2, p1);
     if ((p2 != -1) && (p2 < 23) && ((p2 < p1) || (p1 == -1)))
-	G3d_truncFloat(&xdrf1, p2);
+	Rast3d_truncFloat(&xdrf1, p2);
 
     /*   printf ("%d %d (%d %d %d %d) (%d %d %d %d) %d\n", p1, p2, *c1, *(c1 + 1), *(c1 + 2), *(c1 + 3), *c2, *(c2 + 1), *(c2 + 2), *(c2 + 3), *f1 == *f2); */
 
@@ -222,16 +222,16 @@ static int G3d_compareFloats(float *f1, int p1, float *f2, int p2)
 
 /*---------------------------------------------------------------------------*/
 
-static int G3d_compareDoubles(double *d1, int p1, double *d2, int p2)
+static int Rast3d_compareDoubles(double *d1, int p1, double *d2, int p2)
 {
     unsigned char *c1, *c2;
     double xdrd1, xdrd2;
 
-    if (G3d_isNullValueNum(d1, DCELL_TYPE))
-	return G3d_isNullValueNum(d2, DCELL_TYPE);
+    if (Rast3d_isNullValueNum(d1, DCELL_TYPE))
+	return Rast3d_isNullValueNum(d2, DCELL_TYPE);
 
-    G3d_double2xdrDouble(d1, &xdrd1);
-    G3d_double2xdrDouble(d2, &xdrd2);
+    Rast3d_double2xdrDouble(d1, &xdrd1);
+    Rast3d_double2xdrDouble(d2, &xdrd2);
 
     c1 = (unsigned char *)&xdrd1;
     c2 = (unsigned char *)&xdrd2;
@@ -239,9 +239,9 @@ static int G3d_compareDoubles(double *d1, int p1, double *d2, int p2)
     /*    printf ("%d %d (%d %d %d %d %d %d %d %d) (%d %d %d %d %d %d %d %d)\n", p1, p2, *c1, *(c1 + 1), *(c1 + 2), *(c1 + 3), *(c1 + 4), *(c1 + 5), *(c1 + 6), *(c1 + 7), *c2, *(c2 + 1), *(c2 + 2), *(c2 + 3), *(c2 + 4), *(c2 + 5), *(c2 + 6), *(c2 + 7));  */
 
     if ((p1 != -1) && (p1 < 52) && ((p1 < p2) || (p2 == -1)))
-	G3d_truncDouble(&xdrd2, p1);
+	Rast3d_truncDouble(&xdrd2, p1);
     if ((p2 != -1) && (p2 < 52) && ((p2 < p1) || (p1 == -1)))
-	G3d_truncDouble(&xdrd1, p2);
+	Rast3d_truncDouble(&xdrd1, p2);
 
     /*    printf ("%d %d (%d %d %d %d %d %d %d %d) (%d %d %d %d %d %d %d %d)\n", p1, p2, *c1, *(c1 + 1), *(c1 + 2), *(c1 + 3), *(c1 + 4), *(c1 + 5), *(c1 + 6), *(c1 + 7), *c2, *(c2 + 1), *(c2 + 2), *(c2 + 3), *(c2 + 4), *(c2 + 5), *(c2 + 6), *(c2 + 7));  */
 
@@ -255,14 +255,14 @@ static int G3d_compareDoubles(double *d1, int p1, double *d2, int p2)
 
 /*---------------------------------------------------------------------------*/
 
-static int G3d_compareFloatDouble(float *f, int p1, double *d, int p2)
+static int Rast3d_compareFloatDouble(float *f, int p1, double *d, int p2)
 {
     unsigned char *c1, *c2;
     float xdrf, fTmp;
     double xdrd, xdrd2, dTmp;
 
-    if (G3d_isNullValueNum(f, FCELL_TYPE))
-	return G3d_isNullValueNum(d, DCELL_TYPE);
+    if (Rast3d_isNullValueNum(f, FCELL_TYPE))
+	return Rast3d_isNullValueNum(d, DCELL_TYPE);
 
     /* need this since assigning a double to a float actually may change the */
     /* bit pattern. an example (in xdr format) is the double */
@@ -272,9 +272,9 @@ static int G3d_compareFloatDouble(float *f, int p1, double *d, int p2)
     fTmp = *d;
     dTmp = fTmp;
 
-    G3d_float2xdrFloat(f, &xdrf);
-    G3d_float2Double(&xdrf, &xdrd2);
-    G3d_double2xdrDouble(&dTmp, &xdrd);
+    Rast3d_float2xdrFloat(f, &xdrf);
+    Rast3d_float2Double(&xdrf, &xdrd2);
+    Rast3d_double2xdrDouble(&dTmp, &xdrd);
 
     c1 = (unsigned char *)&xdrd2;
     c2 = (unsigned char *)&xdrd;
@@ -284,9 +284,9 @@ static int G3d_compareFloatDouble(float *f, int p1, double *d, int p2)
 
     if (((p1 != -1) && ((p1 < p2) || (p2 == -1))) ||
 	((p1 == -1) && ((p2 > 23) || (p2 == -1))))
-	G3d_truncDouble(&xdrd, (p1 != -1 ? p1 : 23));
+	Rast3d_truncDouble(&xdrd, (p1 != -1 ? p1 : 23));
     if ((p2 != -1) && (p2 < 23) && ((p2 < p1) || (p1 == -1)))
-	G3d_truncDouble(&xdrd2, p2);
+	Rast3d_truncDouble(&xdrd2, p2);
 
     /*   printf ("%d %d (%d %d %d %d) (%d %d %d %d %d %d %d %d) (%d %d %d %d %d %d %d %d)\n", p1, p2, *((unsigned char *) &xdrf), *(((unsigned char *) &xdrf) + 1), *(((unsigned char *) &xdrf) + 2), *(((unsigned char *) &xdrf) + 3), *c1, *(c1 + 1), *(c1 + 2), *(c1 + 3), *(c1 + 4), *(c1 + 5), *(c1 + 6), *(c1 + 7), *c2, *(c2 + 1), *(c2 + 2), *(c2 + 3), *(c2 + 4), *(c2 + 5), *(c2 + 6), *(c2 + 7));  */
 
@@ -309,13 +309,13 @@ static void compareFilesNocache(void *map, void *map2)
     int tileX, tileY, tileZ, typeIntern, typeIntern2;
     int nx, ny, nz;
 
-    p1 = G3d_tilePrecisionMap(map);
-    p2 = G3d_tilePrecisionMap(map2);
+    p1 = Rast3d_tilePrecisionMap(map);
+    p2 = Rast3d_tilePrecisionMap(map2);
 
-    G3d_getTileDimensionsMap(map, &tileX, &tileY, &tileZ);
-    G3d_getNofTilesMap(map2, &nx, &ny, &nz);
-    typeIntern = G3d_tileTypeMap(map);
-    typeIntern2 = G3d_tileTypeMap(map2);
+    Rast3d_getTileDimensionsMap(map, &tileX, &tileY, &tileZ);
+    Rast3d_getNofTilesMap(map2, &nx, &ny, &nz);
+    typeIntern = Rast3d_tileTypeMap(map);
+    typeIntern2 = Rast3d_tileTypeMap(map2);
 
     n1p = &n1;
     f1p = (float *)&n1;
@@ -328,31 +328,31 @@ static void compareFilesNocache(void *map, void *map2)
 	for (y = 0; y < ny * tileY; y++) {
 	    for (x = 0; x < nx * tileX; x++) {
 
-		G3d_getBlock(map, x, y, z, 1, 1, 1, n1p, typeIntern);
-		G3d_getBlock(map2, x, y, z, 1, 1, 1, n2p, typeIntern2);
+		Rast3d_getBlock(map, x, y, z, 1, 1, 1, n1p, typeIntern);
+		Rast3d_getBlock(map2, x, y, z, 1, 1, 1, n2p, typeIntern2);
 
 		if (typeIntern == FCELL_TYPE) {
 		    if (typeIntern2 == FCELL_TYPE)
-			correct = G3d_compareFloats(f1p, p1, f2p, p2);
+			correct = Rast3d_compareFloats(f1p, p1, f2p, p2);
 		    else
-			correct = G3d_compareFloatDouble(f1p, p1, n2p, p2);
+			correct = Rast3d_compareFloatDouble(f1p, p1, n2p, p2);
 		}
 		else {
 		    if (typeIntern2 == FCELL_TYPE)
-			correct = G3d_compareFloatDouble(f2p, p2, n1p, p1);
+			correct = Rast3d_compareFloatDouble(f2p, p2, n1p, p1);
 		    else
-			correct = G3d_compareDoubles(n1p, p1, n2p, p2);
+			correct = Rast3d_compareDoubles(n1p, p1, n2p, p2);
 		}
 
 		if (!correct) {
 		    int xTile, yTile, zTile, xOffs, yOffs, zOffs;
 
-		    G3d_coord2tileCoord(map2, x, y, z, &xTile, &yTile, &zTile,
+		    Rast3d_coord2tileCoord(map2, x, y, z, &xTile, &yTile, &zTile,
 					&xOffs, &yOffs, &zOffs);
 		    printf("(%d %d %d) (%d %d %d) (%d %d %d) %.20f %.20f\n",
 			   x, y, z, xTile, yTile, zTile, xOffs, yOffs, zOffs,
 			   *n1p, *n2p);
-		    G3d_fatalError
+		    Rast3d_fatalError
 			("compareFilesNocache: files don't match\n");
 		}
 	    }
@@ -383,7 +383,7 @@ static void compareFilesNocache(void *map, void *map2)
  */
 
 void
-G3d_compareFiles(const char *f1, const char *mapset1, const char *f2,
+Rast3d_compareFiles(const char *f1, const char *mapset1, const char *f2,
 		 const char *mapset2)
 {
     void *map, *map2;
@@ -398,35 +398,35 @@ G3d_compareFiles(const char *f1, const char *mapset1, const char *f2,
 
     printf("\nComparing %s and %s\n", f1, f2);
 
-    map = G3d_openCellOld(f1, mapset1, RASTER3D_DEFAULT_WINDOW,
+    map = Rast3d_openCellOld(f1, mapset1, RASTER3D_DEFAULT_WINDOW,
 			  RASTER3D_TILE_SAME_AS_FILE, RASTER3D_USE_CACHE_DEFAULT);
     if (map == NULL)
-	G3d_fatalError("G3d_compareFiles: error in G3d_openCellOld");
+	Rast3d_fatalError("Rast3d_compareFiles: error in Rast3d_openCellOld");
 
-    G3d_printHeader(map);
+    Rast3d_printHeader(map);
 
-    map2 = G3d_openCellOld(f2, mapset2, RASTER3D_DEFAULT_WINDOW,
+    map2 = Rast3d_openCellOld(f2, mapset2, RASTER3D_DEFAULT_WINDOW,
 			   RASTER3D_TILE_SAME_AS_FILE, RASTER3D_USE_CACHE_DEFAULT);
     if (map2 == NULL)
-	G3d_fatalError("G3d_compareFiles: error in G3d_openCellOld");
+	Rast3d_fatalError("Rast3d_compareFiles: error in Rast3d_openCellOld");
 
-    G3d_printHeader(map2);
+    Rast3d_printHeader(map2);
 
-    typeIntern = G3d_tileTypeMap(map);
-    typeIntern2 = G3d_tileTypeMap(map2);
+    typeIntern = Rast3d_tileTypeMap(map);
+    typeIntern2 = Rast3d_tileTypeMap(map2);
 
-    p1 = G3d_tilePrecisionMap(map);
-    p2 = G3d_tilePrecisionMap(map2);
+    p1 = Rast3d_tilePrecisionMap(map);
+    p2 = Rast3d_tilePrecisionMap(map2);
 
-    G3d_getTileDimensionsMap(map, &tileX, &tileY, &tileZ);
-    G3d_getTileDimensionsMap(map2, &tileX2, &tileY2, &tileZ2);
-    G3d_getNofTilesMap(map2, &nx, &ny, &nz);
-    G3d_getCoordsMap(map, &rows, &cols, &depths);
+    Rast3d_getTileDimensionsMap(map, &tileX, &tileY, &tileZ);
+    Rast3d_getTileDimensionsMap(map2, &tileX2, &tileY2, &tileZ2);
+    Rast3d_getNofTilesMap(map2, &nx, &ny, &nz);
+    Rast3d_getCoordsMap(map, &rows, &cols, &depths);
 
-    if ((!G3d_tileUseCacheMap(map)) || (!G3d_tileUseCacheMap(map2))) {
+    if ((!Rast3d_tileUseCacheMap(map)) || (!Rast3d_tileUseCacheMap(map2))) {
 	compareFilesNocache(map, map2);
-	G3d_closeCell(map);
-	G3d_closeCell(map2);
+	Rast3d_closeCell(map);
+	Rast3d_closeCell(map2);
 	return;
     }
 
@@ -435,59 +435,59 @@ G3d_compareFiles(const char *f1, const char *mapset1, const char *f2,
     n2p = &n2;
     f2p = (float *)&n2;
 
-    G3d_autolockOn(map);
-    G3d_autolockOn(map2);
-    G3d_minUnlocked(map, cols / tileX + 1);
+    Rast3d_autolockOn(map);
+    Rast3d_autolockOn(map2);
+    Rast3d_minUnlocked(map, cols / tileX + 1);
 
-    G3d_getCoordsMap(map2, &rows, &cols, &depths);
-    G3d_minUnlocked(map2, cols / tileX + 1);
+    Rast3d_getCoordsMap(map2, &rows, &cols, &depths);
+    Rast3d_minUnlocked(map2, cols / tileX + 1);
 
-    G3d_getCoordsMap(map, &rows, &cols, &depths);
+    Rast3d_getCoordsMap(map, &rows, &cols, &depths);
     for (z = 0; z < depths; z++) {
 	printf("comparing: z = %d\n", z);
 
 	if ((z % tileZ) == 0) {
-	    if (!G3d_unlockAll(map))
-		G3d_fatalError("G3d_compareFiles: error in G3d_unlockAll");
+	    if (!Rast3d_unlockAll(map))
+		Rast3d_fatalError("Rast3d_compareFiles: error in Rast3d_unlockAll");
 	}
 	if ((z % tileZ2) == 0) {
-	    if (!G3d_unlockAll(map2))
-		G3d_fatalError("G3d_compareFiles: error in G3d_unlockAll");
+	    if (!Rast3d_unlockAll(map2))
+		Rast3d_fatalError("Rast3d_compareFiles: error in Rast3d_unlockAll");
 	}
 
 	for (y = 0; y < rows; y++) {
 	    for (x = 0; x < cols; x++) {
-		G3d_getValueRegion(map, x, y, z, n1p, typeIntern);
-		G3d_getValueRegion(map2, x, y, z, n2p, typeIntern2);
+		Rast3d_getValueRegion(map, x, y, z, n1p, typeIntern);
+		Rast3d_getValueRegion(map2, x, y, z, n2p, typeIntern2);
 
-		G3d_isNullValueNum(n1p, typeIntern);
-		G3d_isNullValueNum(n2p, typeIntern2);
+		Rast3d_isNullValueNum(n1p, typeIntern);
+		Rast3d_isNullValueNum(n2p, typeIntern2);
 
 		if (typeIntern == FCELL_TYPE) {
 		    if (typeIntern2 == FCELL_TYPE)
-			correct = G3d_compareFloats(f1p, p1, f2p, p2);
+			correct = Rast3d_compareFloats(f1p, p1, f2p, p2);
 		    else
-			correct = G3d_compareFloatDouble(f1p, p1, n2p, p2);
+			correct = Rast3d_compareFloatDouble(f1p, p1, n2p, p2);
 		}
 		else {
 		    if (typeIntern2 == FCELL_TYPE)
-			correct = G3d_compareFloatDouble(f2p, p2, n1p, p1);
+			correct = Rast3d_compareFloatDouble(f2p, p2, n1p, p1);
 		    else
-			correct = G3d_compareDoubles(n1p, p1, n2p, p2);
+			correct = Rast3d_compareDoubles(n1p, p1, n2p, p2);
 		}
 
 		if (!correct) {
 		    int xTile, yTile, zTile, xOffs, yOffs, zOffs;
 
-		    G3d_coord2tileCoord(map2, x, y, z, &xTile, &yTile, &zTile,
+		    Rast3d_coord2tileCoord(map2, x, y, z, &xTile, &yTile, &zTile,
 					&xOffs, &yOffs, &zOffs);
-		    G3d_fatalError("G3d_compareFiles: files don't match\n");
+		    Rast3d_fatalError("Rast3d_compareFiles: files don't match\n");
 		}
 	    }
 	}
     }
 
     printf("Files are identical up to precision.\n");
-    G3d_closeCell(map);
-    G3d_closeCell(map2);
+    Rast3d_closeCell(map);
+    Rast3d_closeCell(map2);
 }

lib/raster3d/filename.c

@@ -7,7 +7,7 @@
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_filename(char *path, const char *elementName, const char *mapName,
+Rast3d_filename(char *path, const char *elementName, const char *mapName,
 	     const char *mapset)
 {
     G_file_name_misc(path, RASTER3D_DIRECTORY, elementName, mapName, mapset);

lib/raster3d/fpcompress.c

@@ -100,7 +100,7 @@ G_fpcompress_rearrangeEncodeFloats(unsigned char *src, int size,
     f = (float *)src;
     nofNull = 0;
     while (srcStop != (unsigned char *)f)
-	nofNull += G3d_isXdrNullFloat(f++);
+	nofNull += Rast3d_isXdrNullFloat(f++);
 
     if (nofNull == size) {
 	*dst = (unsigned char)ALL_NULL_CODE;
@@ -135,7 +135,7 @@ G_fpcompress_rearrangeEncodeFloats(unsigned char *src, int size,
 
     while (srcStop != src) {
 	if (nofNull) {
-	    isNull = G3d_isXdrNullFloat((float *)src);
+	    isNull = Rast3d_isXdrNullFloat((float *)src);
 
 	    if (nNullBits) {
 		*nullBits |= ((unsigned char)isNull << nNullBits++);
@@ -258,7 +258,7 @@ G_fpcompress_rearrangeEncodeDoubles(unsigned char *src, int size,
     d = (double *)src;
     nofNull = 0;
     while (srcStop != (unsigned char *)d)
-	nofNull += G3d_isXdrNullDouble(d++);
+	nofNull += Rast3d_isXdrNullDouble(d++);
 
     if (nofNull == size) {
 	*dst = (unsigned char)ALL_NULL_CODE;
@@ -300,7 +300,7 @@ G_fpcompress_rearrangeEncodeDoubles(unsigned char *src, int size,
 
     while (srcStop != src) {
 	if (nofNull) {
-	    isNull = G3d_isXdrNullDouble((double *)src);
+	    isNull = Rast3d_isXdrNullDouble((double *)src);
 
 	    if (nNullBits) {
 		*nullBits |= ((unsigned char)isNull << nNullBits++);
@@ -435,7 +435,7 @@ G_fpcompress_rearrangeDecodeFloats(unsigned char *src, int size,
     if (*src == (unsigned char)ALL_NULL_CODE) {
 	f = (float *)dst;
 	while (dstStop != (unsigned char *)f)
-	    G3d_setXdrNullFloat(f++);
+	    Rast3d_setXdrNullFloat(f++);
 
 	return;
     }
@@ -485,7 +485,7 @@ G_fpcompress_rearrangeDecodeFloats(unsigned char *src, int size,
 	    }
 
 	    if (isNull) {
-		G3d_setXdrNullFloat((float *)dst);
+		Rast3d_setXdrNullFloat((float *)dst);
 		dst += XDR_FLOAT_LENGTH;
 		continue;
 	    }
@@ -577,7 +577,7 @@ G_fpcompress_rearrangeDecodeDoubles(unsigned char *src, int size,
 	/*printf ("all null\n"); */
 	d = (double *)dst;
 	while (dstStop != (unsigned char *)d)
-	    G3d_setXdrNullDouble(d++);
+	    Rast3d_setXdrNullDouble(d++);
 
 	return;
     }
@@ -637,7 +637,7 @@ G_fpcompress_rearrangeDecodeDoubles(unsigned char *src, int size,
 	    }
 
 	    if (isNull) {
-		G3d_setXdrNullDouble((double *)dst);
+		Rast3d_setXdrNullDouble((double *)dst);
 		dst += XDR_DOUBLE_LENGTH;
 		continue;
 	    }
@@ -782,7 +782,7 @@ G_fpcompress_writeXdrNums(int fd, char *src, int nofNum, int precision,
     }
 
     if (status < 0) {
-	G3d_error("G_fpcompress_writeXdrNums: write error");
+	Rast3d_error("G_fpcompress_writeXdrNums: write error");
 	return 0;
     }
 
@@ -797,7 +797,7 @@ G_fpcompress_writeXdrFloats(int fd, char *src, int nofNum, int precision,
 {
     if (!G_fpcompress_writeXdrNums(fd, src, nofNum, precision, compressBuf, 1,
 				   useRle, useLzw)) {
-	G3d_error
+	Rast3d_error
 	    ("G_fpcompress_writeXdrFloats: error in G_fpcompress_writeXdrNums");
 	return 0;
     }
@@ -813,7 +813,7 @@ G_fpcompress_writeXdrDouble(int fd, char *src, int nofNum, int precision,
 {
     if (!G_fpcompress_writeXdrNums(fd, src, nofNum, precision, compressBuf, 0,
 				   useRle, useLzw)) {
-	G3d_error
+	Rast3d_error
 	    ("G_fpcompress_writeXdrDouble: error in G_fpcompress_writeXdrNums");
 	return 0;
     }
@@ -840,7 +840,7 @@ G_fpcompress_readXdrNums(int fd, char *dst, int nofNum, int fileBytes,
 			 nofNum * nBytes + 1);
 #endif
     if (status < 0) {
-	G3d_error("G_fpcompress_readXdrNums: read error");
+	Rast3d_error("G_fpcompress_readXdrNums: read error");
 	return 0;
     }
 
@@ -849,7 +849,7 @@ G_fpcompress_readXdrNums(int fd, char *dst, int nofNum, int fileBytes,
 	G_rle_decode(compressBuf, dst, nofNum * nBytes, 1,
 		     &lengthEncode, &lengthDecode);
 	if (*dst == ALL_NULL_CODE)
-	    G3d_fatalError("G_fpcompress_readXdrNums: wrong code");
+	    Rast3d_fatalError("G_fpcompress_readXdrNums: wrong code");
 
 	if (status == nofNum * nBytes)
 	    status -= lengthDecode - lengthEncode;
@@ -885,7 +885,7 @@ G_fpcompress_readXdrFloats(int fd, char *dst, int nofNum, int fileBytes,
 {
     if (!G_fpcompress_readXdrNums(fd, dst, nofNum, fileBytes, precision,
 				  compressBuf, 1)) {
-	G3d_error
+	Rast3d_error
 	    ("G_fpcompress_readXdrFloats: error in G_fpcompress_readXdrNums");
 	return 0;
     }
@@ -901,7 +901,7 @@ G_fpcompress_readXdrDoubles(int fd, char *dst, int nofNum, int fileBytes,
 {
     if (!G_fpcompress_readXdrNums(fd, dst, nofNum, fileBytes, precision,
 				  compressBuf, 0)) {
-	G3d_error
+	Rast3d_error
 	    ("G_fpcompress_readXdrDouble: error in G_fpcompress_readXdrNums");
 	return 0;
     }

lib/raster3d/fpxdr.c

@@ -12,7 +12,7 @@
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_isXdrNullNum(const void *num, int isFloat)
+int Rast3d_isXdrNullNum(const void *num, int isFloat)
 {
     static const char null_bytes[8] = {
 	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
@@ -23,21 +23,21 @@ int G3d_isXdrNullNum(const void *num, int isFloat)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_isXdrNullFloat(const float *f)
+int Rast3d_isXdrNullFloat(const float *f)
 {
-    return G3d_isXdrNullNum(f, 1);
+    return Rast3d_isXdrNullNum(f, 1);
 }
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_isXdrNullDouble(const double *d)
+int Rast3d_isXdrNullDouble(const double *d)
 {
-    return G3d_isXdrNullNum(d, 0);
+    return Rast3d_isXdrNullNum(d, 0);
 }
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_setXdrNullNum(void *num, int isFloat)
+void Rast3d_setXdrNullNum(void *num, int isFloat)
 {
     static const char null_bytes[8] = {
 	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
@@ -48,23 +48,23 @@ void G3d_setXdrNullNum(void *num, int isFloat)
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_setXdrNullDouble(double *d)
+void Rast3d_setXdrNullDouble(double *d)
 {
-    G3d_setXdrNullNum(d, 0);
+    Rast3d_setXdrNullNum(d, 0);
 }
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_setXdrNullFloat(float *f)
+void Rast3d_setXdrNullFloat(float *f)
 {
-    G3d_setXdrNullNum(f, 1);
+    Rast3d_setXdrNullNum(f, 1);
 }
 
 /*---------------------------------------------------------------------------*/
 
 XDR xdrEncodeStream, xdrDecodeStream;	/* xdr support structures */
 
-int G3d_initFpXdr(RASTER3D_Map * map, int misuseBytes)
+int Rast3d_initFpXdr(RASTER3D_Map * map, int misuseBytes)
 
 
 
@@ -79,9 +79,9 @@ int G3d_initFpXdr(RASTER3D_Map * map, int misuseBytes)
 	xdrLength = map->tileSize * RASTER3D_MAX(map->numLengthExtern,
 					    map->numLengthIntern) +
 	    misuseBytes;
-	xdr = G3d_malloc(xdrLength);
+	xdr = Rast3d_malloc(xdrLength);
 	if (xdr == NULL) {
-	    G3d_error("G3d_initFpXdr: error in G3d_malloc");
+	    Rast3d_error("Rast3d_initFpXdr: error in Rast3d_malloc");
 	    return 0;
 	}
 
@@ -93,9 +93,9 @@ int G3d_initFpXdr(RASTER3D_Map * map, int misuseBytes)
 	xdrLength = map->tileSize * RASTER3D_MAX(map->numLengthExtern,
 					    map->numLengthIntern) +
 	    misuseBytes;
-	xdr = G3d_realloc(xdr, xdrLength);
+	xdr = Rast3d_realloc(xdr, xdrLength);
 	if (xdr == NULL) {
-	    G3d_error("G3d_initFpXdr: error in G3d_realloc");
+	    Rast3d_error("Rast3d_initFpXdr: error in Rast3d_realloc");
 	    return 0;
 	}
 
@@ -118,7 +118,7 @@ static int (*xdrFun) ();
 static XDR *xdrs;
 static double tmpValue, *tmp;
 
-int G3d_initCopyToXdr(RASTER3D_Map * map, int sType)
+int Rast3d_initCopyToXdr(RASTER3D_Map * map, int sType)
 {
     xdrTmp = xdr;
     useXdr = map->useXdr;
@@ -126,7 +126,7 @@ int G3d_initCopyToXdr(RASTER3D_Map * map, int sType)
 
     if (map->useXdr == RASTER3D_USE_XDR) {
 	if (!xdr_setpos(&(xdrEncodeStream), 0)) {
-	    G3d_error("G3d_InitCopyToXdr: positioning xdr failed");
+	    Rast3d_error("Rast3d_InitCopyToXdr: positioning xdr failed");
 	    return 0;
 	}
 	xdrs = &(xdrEncodeStream);
@@ -134,8 +134,8 @@ int G3d_initCopyToXdr(RASTER3D_Map * map, int sType)
 
     type = map->type;
     isFloat = (type == FCELL_TYPE);
-    externLength = G3d_externLength(type);
-    eltLength = G3d_length(srcType);
+    externLength = Rast3d_externLength(type);
+    eltLength = Rast3d_length(srcType);
     if (isFloat)
 	xdrFun = xdr_float;
     else
@@ -147,29 +147,29 @@ int G3d_initCopyToXdr(RASTER3D_Map * map, int sType)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_copyToXdr(const void *src, int nofNum)
+int Rast3d_copyToXdr(const void *src, int nofNum)
 {
     int i;
 
     if (useXdr == RASTER3D_NO_XDR) {
-	G3d_copyValues(src, 0, srcType, xdrTmp, 0, type, nofNum);
-	xdrTmp = G_incr_void_ptr(xdrTmp, nofNum * G3d_externLength(type));
+	Rast3d_copyValues(src, 0, srcType, xdrTmp, 0, type, nofNum);
+	xdrTmp = G_incr_void_ptr(xdrTmp, nofNum * Rast3d_externLength(type));
 	return 1;
     }
 
     for (i = 0; i < nofNum; i++, src = G_incr_void_ptr(src, eltLength)) {
 
-	if (G3d_isNullValueNum(src, srcType)) {
-	    G3d_setXdrNullNum(xdrTmp, isFloat);
+	if (Rast3d_isNullValueNum(src, srcType)) {
+	    Rast3d_setXdrNullNum(xdrTmp, isFloat);
 	    if (!xdr_setpos(xdrs, xdr_getpos(xdrs) + externLength)) {
-		G3d_error("G3d_copyToXdr: positioning xdr failed");
+		Rast3d_error("Rast3d_copyToXdr: positioning xdr failed");
 		return 0;
 	    }
 	}
 	else {
 	    if (type == srcType) {
 		if (xdrFun(xdrs, src) < 0) {
-		    G3d_error("G3d_copyToXdr: writing xdr failed");
+		    Rast3d_error("Rast3d_copyToXdr: writing xdr failed");
 		    return 0;
 		}
 	    }
@@ -179,7 +179,7 @@ int G3d_copyToXdr(const void *src, int nofNum)
 		else
 		    *((double *)tmp) = (double)*((float *)src);
 		if (xdrFun(xdrs, tmp) < 0) {
-		    G3d_error("G3d_copyToXdr: writing xdr failed");
+		    Rast3d_error("Rast3d_copyToXdr: writing xdr failed");
 		    return 0;
 		}
 	    }
@@ -193,7 +193,7 @@ int G3d_copyToXdr(const void *src, int nofNum)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_initCopyFromXdr(RASTER3D_Map * map, int dType)
+int Rast3d_initCopyFromXdr(RASTER3D_Map * map, int dType)
 {
     xdrTmp = xdr;
     useXdr = map->useXdr;
@@ -201,7 +201,7 @@ int G3d_initCopyFromXdr(RASTER3D_Map * map, int dType)
 
     if (useXdr == RASTER3D_USE_XDR) {
 	if (!xdr_setpos(&(xdrDecodeStream), 0)) {
-	    G3d_error("G3d_initCopyFromXdr: positioning xdr failed");
+	    Rast3d_error("Rast3d_initCopyFromXdr: positioning xdr failed");
 	    return 0;
 	}
 	xdrs = &(xdrDecodeStream);
@@ -209,8 +209,8 @@ int G3d_initCopyFromXdr(RASTER3D_Map * map, int dType)
 
     type = map->type;
     isFloat = (type == FCELL_TYPE);
-    externLength = G3d_externLength(type);
-    eltLength = G3d_length(dstType);
+    externLength = Rast3d_externLength(type);
+    eltLength = Rast3d_length(dstType);
     if (isFloat)
 	xdrFun = xdr_float;
     else
@@ -222,35 +222,35 @@ int G3d_initCopyFromXdr(RASTER3D_Map * map, int dType)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_copyFromXdr(int nofNum, void *dst)
+int Rast3d_copyFromXdr(int nofNum, void *dst)
 {
     int i;
 
     if (useXdr == RASTER3D_NO_XDR) {
-	G3d_copyValues(xdrTmp, 0, type, dst, 0, dstType, nofNum);
-	xdrTmp = G_incr_void_ptr(xdrTmp, nofNum * G3d_externLength(type));
+	Rast3d_copyValues(xdrTmp, 0, type, dst, 0, dstType, nofNum);
+	xdrTmp = G_incr_void_ptr(xdrTmp, nofNum * Rast3d_externLength(type));
 	return 1;
     }
 
     for (i = 0; i < nofNum; i++, dst = G_incr_void_ptr(dst, eltLength)) {
 
-	if (G3d_isXdrNullNum(xdrTmp, isFloat)) {
-	    G3d_setNullValue(dst, 1, dstType);
+	if (Rast3d_isXdrNullNum(xdrTmp, isFloat)) {
+	    Rast3d_setNullValue(dst, 1, dstType);
 	    if (!xdr_setpos(xdrs, xdr_getpos(xdrs) + externLength)) {
-		G3d_error("G3d_copyFromXdr: positioning xdr failed");
+		Rast3d_error("Rast3d_copyFromXdr: positioning xdr failed");
 		return 0;
 	    }
 	}
 	else {
 	    if (type == dstType) {
 		if (xdrFun(xdrs, dst) < 0) {
-		    G3d_error("G3d_copyFromXdr: reading xdr failed");
+		    Rast3d_error("Rast3d_copyFromXdr: reading xdr failed");
 		    return 0;
 		}
 	    }
 	    else {
 		if (xdrFun(xdrs, tmp) < 0) {
-		    G3d_error("G3d_copyFromXdr: reading xdr failed");
+		    Rast3d_error("Rast3d_copyFromXdr: reading xdr failed");
 		    return 0;
 		}
 		if (type == FCELL_TYPE)

lib/raster3d/getblock.c

@@ -9,7 +9,7 @@
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_getBlockNocache(RASTER3D_Map * map, int x0, int y0, int z0, int nx, int ny,
+Rast3d_getBlockNocache(RASTER3D_Map * map, int x0, int y0, int z0, int nx, int ny,
 		    int nz, void *block, int type)
 {
     void *tile;
@@ -19,13 +19,13 @@ G3d_getBlockNocache(RASTER3D_Map * map, int x0, int y0, int z0, int nx, int ny,
     int tileIndex;
 
     if (!map->useCache)
-	tile = G3d_allocTilesType(map, 1, type);
+	tile = Rast3d_allocTilesType(map, 1, type);
     if (tile == NULL)
-	G3d_fatalError("G3d_getBlockNocache: error in G3d_allocTiles");
+	Rast3d_fatalError("Rast3d_getBlockNocache: error in Rast3d_allocTiles");
 
-    G3d_coord2tileCoord(map, x0, y0, z0, &tileX0, &tileY0, &tileZ0,
+    Rast3d_coord2tileCoord(map, x0, y0, z0, &tileX0, &tileY0, &tileZ0,
 			&tileOffsX0, &tileOffsY0, &tileOffsZ0);
-    G3d_coord2tileCoord(map, x0 + nx - 1, y0 + ny - 1, z0 + nz - 1,
+    Rast3d_coord2tileCoord(map, x0 + nx - 1, y0 + ny - 1, z0 + nz - 1,
 			&tileX1, &tileY1, &tileZ1,
 			&tileOffsX1, &tileOffsY1, &tileOffsZ1);
 
@@ -36,24 +36,24 @@ G3d_getBlockNocache(RASTER3D_Map * map, int x0, int y0, int z0, int nx, int ny,
 	    for (tx = tileX0; tx <= tileX1; tx++) {
 		dx = (tx - tileX0) * map->tileX - tileOffsX0;
 
-		tileIndex = G3d_tile2tileIndex(map, tx, ty, tz);
+		tileIndex = Rast3d_tile2tileIndex(map, tx, ty, tz);
 
-		if (G3d_tileIndexInRange(map, tileIndex))
+		if (Rast3d_tileIndexInRange(map, tileIndex))
 		    if (map->useCache) {
-			tile = G3d_getTilePtr(map, tileIndex);
+			tile = Rast3d_getTilePtr(map, tileIndex);
 			if (tile == NULL)
-			    G3d_fatalError
-				("G3d_getBlockNocache: error in G3d_getTilePtr");
+			    Rast3d_fatalError
+				("Rast3d_getBlockNocache: error in Rast3d_getTilePtr");
 		    }
 		    else {
-			if (!G3d_readTile
+			if (!Rast3d_readTile
 			    (map, tileIndex, tile, map->typeIntern))
-			    G3d_fatalError
-				("G3d_getBlockNocache: error in G3d_readTile");
+			    Rast3d_fatalError
+				("Rast3d_getBlockNocache: error in Rast3d_readTile");
 		    }
 
 		else
-		    G3d_setNullTile(map, tile);
+		    Rast3d_setNullTile(map, tile);
 
 		cols = (tx == tileX1 ? tileOffsX1 : map->tileX - 1);
 		rows = (ty == tileY1 ? tileOffsY1 : map->tileY - 1);
@@ -63,7 +63,7 @@ G3d_getBlockNocache(RASTER3D_Map * map, int x0, int y0, int z0, int nx, int ny,
 
 		for (z = (tz == tileZ0 ? tileOffsZ0 : 0); z <= depths; z++)
 		    for (y = (ty == tileY0 ? tileOffsY0 : 0); y <= rows; y++) {
-			G3d_copyValues(tile,
+			Rast3d_copyValues(tile,
 				       z * map->tileXY + y * map->tileX + x,
 				       map->typeIntern,
 				       block,
@@ -75,7 +75,7 @@ G3d_getBlockNocache(RASTER3D_Map * map, int x0, int y0, int z0, int nx, int ny,
     }
 
     if (!map->useCache)
-	G3d_freeTiles(tile);
+	Rast3d_freeTiles(tile);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -102,13 +102,13 @@ G3d_getBlockNocache(RASTER3D_Map * map, int x0, int y0, int z0, int nx, int ny,
  */
 
 void
-G3d_getBlock(RASTER3D_Map * map, int x0, int y0, int z0, int nx, int ny, int nz,
+Rast3d_getBlock(RASTER3D_Map * map, int x0, int y0, int z0, int nx, int ny, int nz,
 	     void *block, int type)
 {
     int x, y, z, nNull, x1, y1, z1, length;
 
     if (!map->useCache) {
-	G3d_getBlockNocache(map, x0, y0, z0, nx, ny, nz, block, type);
+	Rast3d_getBlockNocache(map, x0, y0, z0, nx, ny, nz, block, type);
 	return;
     }
 
@@ -116,22 +116,22 @@ G3d_getBlock(RASTER3D_Map * map, int x0, int y0, int z0, int nx, int ny, int nz,
     y1 = RASTER3D_MIN(y0 + ny, map->region.rows);
     z1 = RASTER3D_MIN(z0 + nz, map->region.depths);
 
-    length = G3d_length(type);
+    length = Rast3d_length(type);
 
     for (z = z0; z < z1; z++) {
 	for (y = y0; y < y1; y++) {
 	    for (x = x0; x < x1; x++) {
-		G3d_getValueRegion(map, x, y, z, block, type);
+		Rast3d_getValueRegion(map, x, y, z, block, type);
 		block = G_incr_void_ptr(block, length);
 	    }
 	    nNull = x0 + nx - x;
-	    G3d_setNullValue(block, nNull, type);
+	    Rast3d_setNullValue(block, nNull, type);
 	    block = G_incr_void_ptr(block, length * nNull);
 	}
 	nNull = (y0 + ny - y) * nx;
-	G3d_setNullValue(block, nNull, type);
+	Rast3d_setNullValue(block, nNull, type);
 	block = G_incr_void_ptr(block, length * nNull);
     }
     nNull = (z0 + nz - z) * ny * nx;
-    G3d_setNullValue(block, nNull, type);
+    Rast3d_setNullValue(block, nNull, type);
 }

lib/raster3d/getvalue.c

@@ -19,7 +19,7 @@
  *  \return void
  */
 
-void G3d_getValue(RASTER3D_Map * map, int x, int y, int z, void *value, int type)
+void Rast3d_getValue(RASTER3D_Map * map, int x, int y, int z, void *value, int type)
 {
     /* get the resampled value */
     map->resampleFun(map, x, y, z, value, type);
@@ -31,7 +31,7 @@ void G3d_getValue(RASTER3D_Map * map, int x, int y, int z, void *value, int type
  * \brief 
  *
  * Is equivalent to
- * <tt>G3d_getValue (map, x, y, z, &value, FCELL_TYPE);</tt> return value.
+ * <tt>Rast3d_getValue (map, x, y, z, &value, FCELL_TYPE);</tt> return value.
  *
  *  \param map
  *  \param x
@@ -40,11 +40,11 @@ void G3d_getValue(RASTER3D_Map * map, int x, int y, int z, void *value, int type
  *  \return float
  */
 
-float G3d_getFloat(RASTER3D_Map * map, int x, int y, int z)
+float Rast3d_getFloat(RASTER3D_Map * map, int x, int y, int z)
 {
     float value;
 
-    G3d_getValue(map, x, y, z, &value, FCELL_TYPE);
+    Rast3d_getValue(map, x, y, z, &value, FCELL_TYPE);
     return value;
 }
 
@@ -54,7 +54,7 @@ float G3d_getFloat(RASTER3D_Map * map, int x, int y, int z)
  * \brief 
  *
  * Is equivalent
- * to <tt>G3d_getValue (map, x, y, z, &value, DCELL_TYPE);</tt> return value.
+ * to <tt>Rast3d_getValue (map, x, y, z, &value, DCELL_TYPE);</tt> return value.
  *
  *  \param map
  *  \param x
@@ -63,11 +63,11 @@ float G3d_getFloat(RASTER3D_Map * map, int x, int y, int z)
  *  \return double
  */
 
-double G3d_getDouble(RASTER3D_Map * map, int x, int y, int z)
+double Rast3d_getDouble(RASTER3D_Map * map, int x, int y, int z)
 {
     double value;
 
-    G3d_getValue(map, x, y, z, &value, DCELL_TYPE);
+    Rast3d_getValue(map, x, y, z, &value, DCELL_TYPE);
     return value;
 }
 
@@ -91,18 +91,18 @@ double G3d_getDouble(RASTER3D_Map * map, int x, int y, int z)
  */
 
 void
-G3d_getWindowValue(RASTER3D_Map * map, double north, double east, double top,
+Rast3d_getWindowValue(RASTER3D_Map * map, double north, double east, double top,
 		   void *value, int type)
 {
     int col, row, depth;
 
-    G3d_location2coord(&(map->window), north, east, top, &col, &row, &depth);
+    Rast3d_location2coord(&(map->window), north, east, top, &col, &row, &depth);
 
     /* if (row, col, depth) outside window return NULL value */
     if ((row < 0) || (row >= map->window.rows) ||
 	(col < 0) || (col >= map->window.cols) ||
 	(depth < 0) || (depth >= map->window.depths)) {
-	G3d_setNullValue(value, 1, type);
+	Rast3d_setNullValue(value, 1, type);
 	return;
     }
 
@@ -128,23 +128,23 @@ G3d_getWindowValue(RASTER3D_Map * map, double north, double east, double top,
  */
 
 void
-G3d_getRegionValue(RASTER3D_Map * map, double north, double east, double top,
+Rast3d_getRegionValue(RASTER3D_Map * map, double north, double east, double top,
 		   void *value, int type)
 {
     int row, col, depth;
 
-    G3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);
+    Rast3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);
 
     /* if (row, col, depth) outside region return NULL value */
     if ((row < 0) || (row >= map->region.rows) ||
 	(col < 0) || (col >= map->region.cols) ||
 	(depth < 0) || (depth >= map->region.depths)) {
-	G3d_setNullValue(value, 1, type);
+	Rast3d_setNullValue(value, 1, type);
 	return;
     }
 
     /* Get the value from the map in map-region resolution */
-	G3d_getValueRegion(map, col, row, depth, value, type);
+	Rast3d_getValueRegion(map, col, row, depth, value, type);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -152,7 +152,7 @@ G3d_getRegionValue(RASTER3D_Map * map, double north, double east, double top,
 /*!
  * \brief 
  *
- * Is equivalent to <tt>G3d_getValueRegion (map, x, y, z, &value, FCELL_TYPE);</tt>
+ * Is equivalent to <tt>Rast3d_getValueRegion (map, x, y, z, &value, FCELL_TYPE);</tt>
  * return value.
  *
  *  \param map
@@ -162,19 +162,19 @@ G3d_getRegionValue(RASTER3D_Map * map, double north, double east, double top,
  *  \return float
  */
 
-float G3d_getFloatRegion(RASTER3D_Map * map, int x, int y, int z)
+float Rast3d_getFloatRegion(RASTER3D_Map * map, int x, int y, int z)
 {
     int tileIndex, offs;
     float *tile;
 
     if (map->typeIntern == DCELL_TYPE)
-	return (float)G3d_getDoubleRegion(map, x, y, z);
+	return (float)Rast3d_getDoubleRegion(map, x, y, z);
 
-    G3d_coord2tileIndex(map, x, y, z, &tileIndex, &offs);
-    tile = (float *)G3d_getTilePtr(map, tileIndex);
+    Rast3d_coord2tileIndex(map, x, y, z, &tileIndex, &offs);
+    tile = (float *)Rast3d_getTilePtr(map, tileIndex);
 
     if (tile == NULL)
-	G3d_fatalError("G3d_getFloatRegion: error in G3d_getTilePtr");
+	Rast3d_fatalError("Rast3d_getFloatRegion: error in Rast3d_getTilePtr");
 
     return tile[offs];
 }
@@ -185,7 +185,7 @@ float G3d_getFloatRegion(RASTER3D_Map * map, int x, int y, int z)
 /*!
  * \brief 
  *
- * Is equivalent to <tt>G3d_getValueRegion (map, x, y, z, &value,
+ * Is equivalent to <tt>Rast3d_getValueRegion (map, x, y, z, &value,
  * DCELL_TYPE);</tt> return value.
  *
  *  \param map
@@ -195,19 +195,19 @@ float G3d_getFloatRegion(RASTER3D_Map * map, int x, int y, int z)
  *  \return double
  */
 
-double G3d_getDoubleRegion(RASTER3D_Map * map, int x, int y, int z)
+double Rast3d_getDoubleRegion(RASTER3D_Map * map, int x, int y, int z)
 {
     int tileIndex, offs;
     double *tile;
 
     if (map->typeIntern == FCELL_TYPE)
-	return (double)G3d_getFloatRegion(map, x, y, z);
+	return (double)Rast3d_getFloatRegion(map, x, y, z);
 
-    G3d_coord2tileIndex(map, x, y, z, &tileIndex, &offs);
-    tile = (double *)G3d_getTilePtr(map, tileIndex);
+    Rast3d_coord2tileIndex(map, x, y, z, &tileIndex, &offs);
+    tile = (double *)Rast3d_getTilePtr(map, tileIndex);
 
     if (tile == NULL)
-	G3d_fatalError("G3d_getDoubleRegion: error in G3d_getTilePtr");
+	Rast3d_fatalError("Rast3d_getDoubleRegion: error in Rast3d_getTilePtr");
 
     return tile[offs];
 }
@@ -234,12 +234,12 @@ double G3d_getDoubleRegion(RASTER3D_Map * map, int x, int y, int z)
  */
 
 void
-G3d_getValueRegion(RASTER3D_Map * map, int x, int y, int z, void *value, int type)
+Rast3d_getValueRegion(RASTER3D_Map * map, int x, int y, int z, void *value, int type)
 {
     if (type == FCELL_TYPE) {
-	*((float *)value) = G3d_getFloatRegion(map, x, y, z);
+	*((float *)value) = Rast3d_getFloatRegion(map, x, y, z);
 	return;
     }
 
-    *((double *)value) = G3d_getDoubleRegion(map, x, y, z);
+    *((double *)value) = Rast3d_getDoubleRegion(map, x, y, z);
 }

lib/raster3d/header.c

@@ -32,7 +32,7 @@ int xdrLength;
 /*---------------------------------------------------------------------------*/
 
 static int
-G3d_readWriteHeader(struct Key_Value *headerKeys, int doRead, int *proj,
+Rast3d_readWriteHeader(struct Key_Value *headerKeys, int doRead, int *proj,
 		    int *zone, double *north, double *south, double *east,
 		    double *west, double *top, double *bottom, int *rows,
 		    int *cols, int *depths, double *ew_res, double *ns_res,
@@ -46,16 +46,16 @@ G3d_readWriteHeader(struct Key_Value *headerKeys, int doRead, int *proj,
     int (*headerString) ();
 
     if (doRead) {
-	headerDouble = G3d_keyGetDouble;
-	headerInt = G3d_keyGetInt;
-	headerString = G3d_keyGetString;
-	headerValue = G3d_keyGetValue;
+	headerDouble = Rast3d_keyGetDouble;
+	headerInt = Rast3d_keyGetInt;
+	headerString = Rast3d_keyGetString;
+	headerValue = Rast3d_keyGetValue;
     }
     else {
-	headerDouble = G3d_keySetDouble;
-	headerInt = G3d_keySetInt;
-	headerString = G3d_keySetString;
-	headerValue = G3d_keySetValue;
+	headerDouble = Rast3d_keySetDouble;
+	headerInt = Rast3d_keySetInt;
+	headerString = Rast3d_keySetString;
+	headerValue = Rast3d_keySetValue;
     }
 
     returnVal = 1;
@@ -102,14 +102,14 @@ G3d_readWriteHeader(struct Key_Value *headerKeys, int doRead, int *proj,
     if (returnVal)
 	return 1;
 
-    G3d_error("G3d_readWriteHeader: error writing header");
+    Rast3d_error("Rast3d_readWriteHeader: error writing header");
     return 0;
 }
 
 /*---------------------------------------------------------------------------*/
 
 int
-G3d_readHeader(RASTER3D_Map * map, int *proj, int *zone, double *north,
+Rast3d_readHeader(RASTER3D_Map * map, int *proj, int *zone, double *north,
 	       double *south, double *east, double *west, double *top,
 	       double *bottom, int *rows, int *cols, int *depths,
 	       double *ew_res, double *ns_res, double *tb_res, int *tileX,
@@ -120,15 +120,15 @@ G3d_readHeader(RASTER3D_Map * map, int *proj, int *zone, double *north,
     struct Key_Value *headerKeys;
     char path[GPATH_MAX];
 
-    G3d_filename(path, RASTER3D_HEADER_ELEMENT, map->fileName, map->mapset);
+    Rast3d_filename(path, RASTER3D_HEADER_ELEMENT, map->fileName, map->mapset);
     if (access(path, R_OK) != 0) {
-	G3d_error("G3d_readHeader: unable to find [%s]", path);
+	Rast3d_error("Rast3d_readHeader: unable to find [%s]", path);
 	return 0;
     }
 
     headerKeys = G_read_key_value_file(path);
 
-    if (!G3d_readWriteHeader(headerKeys, 1,
+    if (!Rast3d_readWriteHeader(headerKeys, 1,
 			     proj, zone,
 			     north, south, east, west, top, bottom,
 			     rows, cols, depths,
@@ -136,7 +136,7 @@ G3d_readHeader(RASTER3D_Map * map, int *proj, int *zone, double *north,
 			     tileX, tileY, tileZ,
 			     type, compression, useRle, useLzw, precision,
 			     dataOffset, useXdr, hasIndex, unit)) {
-	G3d_error("G3d_readHeader: error extracting header key(s) of file %s",
+	Rast3d_error("Rast3d_readHeader: error extracting header key(s) of file %s",
 		  path);
 	return 0;
     }
@@ -148,7 +148,7 @@ G3d_readHeader(RASTER3D_Map * map, int *proj, int *zone, double *north,
 /*---------------------------------------------------------------------------*/
 
 int
-G3d_writeHeader(RASTER3D_Map * map, int proj, int zone, double north, double south,
+Rast3d_writeHeader(RASTER3D_Map * map, int proj, int zone, double north, double south,
 		double east, double west, double top, double bottom, int rows,
 		int cols, int depths, double ew_res, double ns_res,
 		double tb_res, int tileX, int tileY, int tileZ, int type,
@@ -160,7 +160,7 @@ G3d_writeHeader(RASTER3D_Map * map, int proj, int zone, double north, double sou
 
     headerKeys = G_create_key_value();
 
-    if (!G3d_readWriteHeader(headerKeys, 0,
+    if (!Rast3d_readWriteHeader(headerKeys, 0,
 			     &proj, &zone,
 			     &north, &south, &east, &west, &top, &bottom,
 			     &rows, &cols, &depths,
@@ -169,13 +169,13 @@ G3d_writeHeader(RASTER3D_Map * map, int proj, int zone, double north, double sou
 			     &type, &compression, &useRle, &useLzw,
 			     &precision, &dataOffset, &useXdr, &hasIndex,
 			     &unit)) {
-	G3d_error("G3d_writeHeader: error adding header key(s) for file %s",
+	Rast3d_error("Rast3d_writeHeader: error adding header key(s) for file %s",
 		  path);
 	return 0;
     }
 
-    G3d_filename(path, RASTER3D_HEADER_ELEMENT, map->fileName, map->mapset);
-    G3d_makeMapsetMapDirectory(map->fileName);
+    Rast3d_filename(path, RASTER3D_HEADER_ELEMENT, map->fileName, map->mapset);
+    Rast3d_makeMapsetMapDirectory(map->fileName);
     G_write_key_value_file(path, headerKeys);
 
     G_free_key_value(headerKeys);
@@ -211,7 +211,7 @@ G3d_writeHeader(RASTER3D_Map * map, int proj, int zone, double north, double sou
  *  \return int
  */
 
-int G3d_cacheSizeEncode(int cacheCode, int n)
+int Rast3d_cacheSizeEncode(int cacheCode, int n)
 {
     if (cacheCode >= RASTER3D_NO_CACHE)
 	return cacheCode * n;
@@ -219,14 +219,14 @@ int G3d_cacheSizeEncode(int cacheCode, int n)
 	return cacheCode;
 
     if (cacheCode < RASTER3D_USE_CACHE_XYZ)
-	G3d_fatalError("G3d_cacheSizeEncode: invalid cache code");
+	Rast3d_fatalError("Rast3d_cacheSizeEncode: invalid cache code");
 
     return n * (-10) + cacheCode;
 }
 
 /*---------------------------------------------------------------------------*/
 
-int G3d__computeCacheSize(RASTER3D_Map * map, int cacheCode)
+int Rast3d__computeCacheSize(RASTER3D_Map * map, int cacheCode)
 {
     int n, size;
 
@@ -254,7 +254,7 @@ int G3d__computeCacheSize(RASTER3D_Map * map, int cacheCode)
     else if (cacheCode == RASTER3D_USE_CACHE_XYZ)
 	size = map->nTiles;
     else
-	G3d_fatalError("G3d__computeCacheSize: invalid cache code");
+	Rast3d_fatalError("Rast3d__computeCacheSize: invalid cache code");
 
     return RASTER3D_MIN(size, map->nTiles);
 }
@@ -266,7 +266,7 @@ int G3d__computeCacheSize(RASTER3D_Map * map, int cacheCode)
 /* and initializes the index and cache. This function should be taken apart. */
 
 int
-G3d_fillHeader(RASTER3D_Map * map, int operation, int compression, int useRle,
+Rast3d_fillHeader(RASTER3D_Map * map, int operation, int compression, int useRle,
 	       int useLzw, int type, int precision, int cache, int hasIndex,
 	       int useXdr, int typeIntern, int nofHeaderBytes, int tileX,
 	       int tileY, int tileZ, int proj, int zone, double north,
@@ -275,7 +275,7 @@ G3d_fillHeader(RASTER3D_Map * map, int operation, int compression, int useRle,
 	       double ns_res, double tb_res, char *unit)
 {
     if (!RASTER3D_VALID_OPERATION(operation))
-	G3d_fatalError("G3d_fillHeader: operation not valid\n");
+	Rast3d_fatalError("Rast3d_fillHeader: operation not valid\n");
 
     map->operation = operation;
 
@@ -299,7 +299,7 @@ G3d_fillHeader(RASTER3D_Map * map, int operation, int compression, int useRle,
     map->region.ns_res = ns_res;
     map->region.tb_res = tb_res;
 
-    G3d_adjustRegion(&(map->region));
+    Rast3d_adjustRegion(&(map->region));
 
     map->tileX = tileX;
     map->tileY = tileY;
@@ -327,28 +327,28 @@ G3d_fillHeader(RASTER3D_Map * map, int operation, int compression, int useRle,
 	map->clipZ = -1;
 
     if ((type != FCELL_TYPE) && (type != DCELL_TYPE))
-	G3d_fatalError("G3d_fillHeader: invalid type");
+	Rast3d_fatalError("Rast3d_fillHeader: invalid type");
     map->type = type;
 
     if ((typeIntern != FCELL_TYPE) && (typeIntern != DCELL_TYPE))
-	G3d_fatalError("G3d_fillHeader: invalid type");
+	Rast3d_fatalError("Rast3d_fillHeader: invalid type");
     map->typeIntern = typeIntern;
 
     if (!RASTER3D_VALID_XDR_OPTION(useXdr))
-	G3d_fatalError("G3d_fillHeader: invalid xdr option");
+	Rast3d_fatalError("Rast3d_fillHeader: invalid xdr option");
     map->useXdr = useXdr;
 
     map->offset = nofHeaderBytes;
 
     if ((map->fileEndPtr = lseek(map->data_fd, (long)0, SEEK_END)) == -1) {
-	G3d_error("G3d_fillHeader: can't position file");
+	Rast3d_error("Rast3d_fillHeader: can't position file");
 	return 0;
     }
 
     map->useCache = (cache != RASTER3D_NO_CACHE);
 
-    map->numLengthIntern = G3d_length(map->typeIntern);
-    map->numLengthExtern = G3d_externLength(map->type);
+    map->numLengthIntern = Rast3d_length(map->typeIntern);
+    map->numLengthExtern = Rast3d_externLength(map->type);
 
     map->compression = compression;
     map->useRle = useRle;
@@ -362,9 +362,9 @@ G3d_fillHeader(RASTER3D_Map * map, int operation, int compression, int useRle,
 	    tmpCompressLength = map->tileSize *
 		RASTER3D_MAX(map->numLengthIntern, map->numLengthExtern) +
 		RLE_STATUS_BYTES;
-	    tmpCompress = G3d_malloc(tmpCompressLength);
+	    tmpCompress = Rast3d_malloc(tmpCompressLength);
 	    if (tmpCompress == NULL) {
-		G3d_error("G3d_fillHeader: error in G3d_malloc");
+		Rast3d_error("Rast3d_fillHeader: error in Rast3d_malloc");
 		return 0;
 	    }
 	}
@@ -374,9 +374,9 @@ G3d_fillHeader(RASTER3D_Map * map, int operation, int compression, int useRle,
 	    tmpCompressLength = map->tileSize *
 		RASTER3D_MAX(map->numLengthIntern, map->numLengthExtern) +
 		RLE_STATUS_BYTES;
-	    tmpCompress = G3d_realloc(tmpCompress, tmpCompressLength);
+	    tmpCompress = Rast3d_realloc(tmpCompress, tmpCompressLength);
 	    if (tmpCompress == NULL) {
-		G3d_error("G3d_fillHeader: error in G3d_realloc");
+		Rast3d_error("Rast3d_fillHeader: error in Rast3d_realloc");
 		return 0;
 	    }
 	}
@@ -384,8 +384,8 @@ G3d_fillHeader(RASTER3D_Map * map, int operation, int compression, int useRle,
 
 #define XDR_MISUSE_BYTES 10
 
-    if (!G3d_initFpXdr(map, XDR_MISUSE_BYTES)) {
-	G3d_error("G3d_fillHeader: error in G3d_initFpXdr");
+    if (!Rast3d_initFpXdr(map, XDR_MISUSE_BYTES)) {
+	Rast3d_error("Rast3d_fillHeader: error in Rast3d_initFpXdr");
 	return 0;
     }
 
@@ -394,27 +394,27 @@ G3d_fillHeader(RASTER3D_Map * map, int operation, int compression, int useRle,
 	map->useCache = 0;
 	map->cache = NULL;
 	/* allocate one tile buffer */
-	map->data = G3d_malloc(map->tileSize * map->numLengthIntern);
+	map->data = Rast3d_malloc(map->tileSize * map->numLengthIntern);
 	if (map->data == NULL) {
-	    G3d_error("G3d_fillHeader: error in G3d_malloc");
+	    Rast3d_error("Rast3d_fillHeader: error in Rast3d_malloc");
 	    return 0;
 	}
 	map->currentIndex = -1;
     }
     else {
-	if (!G3d_initCache(map,
+	if (!Rast3d_initCache(map,
 			   RASTER3D_MAX(1,
-				   RASTER3D_MIN(G3d__computeCacheSize(map, cache),
+				   RASTER3D_MIN(Rast3d__computeCacheSize(map, cache),
 					   g3d_cache_max /
 					   map->tileSize /
 					   map->numLengthIntern)))) {
-	    G3d_error("G3d_fillHeader: error in G3d_initCache");
+	    Rast3d_error("Rast3d_fillHeader: error in Rast3d_initCache");
 	    return 0;
 	}
     }
 
-    if (!G3d_initIndex(map, hasIndex)) {
-	G3d_error("G3d_fillHeader: error in G3d_initIndex");
+    if (!Rast3d_initIndex(map, hasIndex)) {
+	Rast3d_error("Rast3d_fillHeader: error in Rast3d_initIndex");
 	return 0;
     }
 

lib/raster3d/headerinfo.c

@@ -16,7 +16,7 @@
  *  \return void
  */
 
-void G3d_getCoordsMap(RASTER3D_Map * map, int *rows, int *cols, int *depths)
+void Rast3d_getCoordsMap(RASTER3D_Map * map, int *rows, int *cols, int *depths)
 {
     *rows = map->region.rows;
     *cols = map->region.cols;
@@ -25,7 +25,7 @@ void G3d_getCoordsMap(RASTER3D_Map * map, int *rows, int *cols, int *depths)
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_getCoordsMapWindow(RASTER3D_Map * map, int *rows, int *cols, int *depths)
+void Rast3d_getCoordsMapWindow(RASTER3D_Map * map, int *rows, int *cols, int *depths)
 {
     *rows = map->window.rows;
     *cols = map->window.cols;
@@ -48,7 +48,7 @@ void G3d_getCoordsMapWindow(RASTER3D_Map * map, int *rows, int *cols, int *depth
  *  \return void
  */
 
-void G3d_getNofTilesMap(RASTER3D_Map * map, int *nx, int *ny, int *nz)
+void Rast3d_getNofTilesMap(RASTER3D_Map * map, int *nx, int *ny, int *nz)
 {
     *nx = map->nx;
     *ny = map->ny;
@@ -74,7 +74,7 @@ void G3d_getNofTilesMap(RASTER3D_Map * map, int *nx, int *ny, int *nz)
  */
 
 void
-G3d_getRegionMap(RASTER3D_Map * map, double *north, double *south, double *east,
+Rast3d_getRegionMap(RASTER3D_Map * map, double *north, double *south, double *east,
 		 double *west, double *top, double *bottom)
 {
     *north = map->region.north;
@@ -88,7 +88,7 @@ G3d_getRegionMap(RASTER3D_Map * map, double *north, double *south, double *east,
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_getWindowMap(RASTER3D_Map * map, double *north, double *south, double *east,
+Rast3d_getWindowMap(RASTER3D_Map * map, double *north, double *south, double *east,
 		 double *west, double *top, double *bottom)
 {
     *north = map->window.north;
@@ -112,16 +112,16 @@ G3d_getWindowMap(RASTER3D_Map * map, double *north, double *south, double *east,
  *  \return void
  */
 
-void G3d_getRegionStructMap(RASTER3D_Map * map, RASTER3D_Region * region)
+void Rast3d_getRegionStructMap(RASTER3D_Map * map, RASTER3D_Region * region)
 {
-    G3d_regionCopy(region, &(map->region));
+    Rast3d_regionCopy(region, &(map->region));
 }
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_getWindowStructMap(RASTER3D_Map * map, RASTER3D_Region * window)
+void Rast3d_getWindowStructMap(RASTER3D_Map * map, RASTER3D_Region * window)
 {
-    G3d_regionCopy(window, &(map->window));
+    Rast3d_regionCopy(window, &(map->window));
 }
 
 /*---------------------------------------------------------------------------*/
@@ -139,7 +139,7 @@ void G3d_getWindowStructMap(RASTER3D_Map * map, RASTER3D_Region * window)
  *  \return void
  */
 
-void G3d_getTileDimensionsMap(RASTER3D_Map * map, int *x, int *y, int *z)
+void Rast3d_getTileDimensionsMap(RASTER3D_Map * map, int *x, int *y, int *z)
 {
     *x = map->tileX;
     *y = map->tileY;
@@ -158,7 +158,7 @@ void G3d_getTileDimensionsMap(RASTER3D_Map * map, int *x, int *y, int *z)
  *  \return int
  */
 
-int G3d_tileTypeMap(RASTER3D_Map * map)
+int Rast3d_tileTypeMap(RASTER3D_Map * map)
 {
     return map->typeIntern;
 }
@@ -175,7 +175,7 @@ int G3d_tileTypeMap(RASTER3D_Map * map)
  *  \return int
  */
 
-int G3d_fileTypeMap(RASTER3D_Map * map)
+int Rast3d_fileTypeMap(RASTER3D_Map * map)
 {
     return map->type;
 }
@@ -192,7 +192,7 @@ int G3d_fileTypeMap(RASTER3D_Map * map)
  *  \return int
  */
 
-int G3d_tilePrecisionMap(RASTER3D_Map * map)
+int Rast3d_tilePrecisionMap(RASTER3D_Map * map)
 {
     return map->precision;
 }
@@ -209,7 +209,7 @@ int G3d_tilePrecisionMap(RASTER3D_Map * map)
  *  \return int
  */
 
-int G3d_tileUseCacheMap(RASTER3D_Map * map)
+int Rast3d_tileUseCacheMap(RASTER3D_Map * map)
 {
     return map->useCache;
 }
@@ -225,7 +225,7 @@ int G3d_tileUseCacheMap(RASTER3D_Map * map)
  *  \return void
  */
 
-void G3d_printHeader(RASTER3D_Map * map)
+void Rast3d_printHeader(RASTER3D_Map * map)
 {
     double rangeMin, rangeMax;
 
@@ -256,7 +256,7 @@ void G3d_printHeader(RASTER3D_Map * map)
 	       (map->operation == RASTER3D_WRITE_DATA ? ", File Cache used" : ""));
     }
 
-    G3d_range_min_max(map, &rangeMin, &rangeMax);
+    Rast3d_range_min_max(map, &rangeMin, &rangeMax);
 
     printf("  Region: (%f %f) (%f %f) (%f %f)\n",
 	   map->region.south, map->region.north, map->region.west,
@@ -265,11 +265,11 @@ void G3d_printHeader(RASTER3D_Map * map)
 	   map->region.depths);
     printf("  Tile size (%d %d %d)\n", map->tileX, map->tileY, map->tileZ);
     printf("  Range (");
-    if (G3d_isNullValueNum(&rangeMin, DCELL_TYPE))
+    if (Rast3d_isNullValueNum(&rangeMin, DCELL_TYPE))
 	printf("NULL, ");
     else
 	printf("%f, ", (double)rangeMin);
-    if (G3d_isNullValueNum(&rangeMax, DCELL_TYPE))
+    if (Rast3d_isNullValueNum(&rangeMax, DCELL_TYPE))
 	printf("NULL)\n");
     else
 	printf("%f)\n", (double)rangeMax);

lib/raster3d/history.c

@@ -1,7 +1,7 @@
 
 /**********************************************************************
  *
- *  G3d_readHistory (name, mapset, hist)
+ *  Rast3d_readHistory (name, mapset, hist)
  *      char *name                   name of map
  *      char *mapset                 mapset that map belongs to
  *      struct History *hist        structure to hold history info
@@ -16,7 +16,7 @@
  *
  **********************************************************************
  *
- *  G3d_writeHistory (name, hist)
+ *  Rast3d_writeHistory (name, hist)
  *      char *name                   name of map
  *      struct History *hist        structure holding history info
  *
@@ -61,7 +61,7 @@ void SimpleErrorMessage(FILE * fd, const char *name, const char *mapset)
  *  \return int
  */
 
-int G3d_readHistory(const char *name, const char *mapset, struct History *hist)
+int Rast3d_readHistory(const char *name, const char *mapset, struct History *hist)
 {
     FILE *fp;
 
@@ -94,7 +94,7 @@ int G3d_readHistory(const char *name, const char *mapset, struct History *hist)
  *  \return int
  */
 
-int G3d_writeHistory(const char *name, struct History *hist)
+int Rast3d_writeHistory(const char *name, struct History *hist)
 /* This function is adapted from Rast_write_history */
 {
     FILE *fp = G_fopen_new_misc(RASTER3D_DIRECTORY, RASTER3D_HISTORY_ELEMENT, name);

lib/raster3d/index.c

@@ -7,7 +7,7 @@
 
 /*---------------------------------------------------------------------------*/
 
-static int G3d_readIndex(RASTER3D_Map * map)
+static int Rast3d_readIndex(RASTER3D_Map * map)
 {
     unsigned char *tmp, *tmp2;
     int dummy1, dummy2, indexLength, tileIndex;
@@ -15,21 +15,21 @@ static int G3d_readIndex(RASTER3D_Map * map)
 
     indexLast = lseek(map->data_fd, (long)0, SEEK_END);
     if (indexLast == -1) {
-	G3d_error("G3d_readIndex: can't position file");
+	Rast3d_error("Rast3d_readIndex: can't position file");
 	return 0;
     }
 
     indexLength = indexLast - map->indexOffset;
 
     if (lseek(map->data_fd, map->indexOffset, SEEK_SET) == -1) {
-	G3d_error("G3d_readIndex: can't position file");
+	Rast3d_error("Rast3d_readIndex: can't position file");
 	return 0;
     }
 
-    tmp = G3d_malloc(map->indexLongNbytes * map->nTiles);
+    tmp = Rast3d_malloc(map->indexLongNbytes * map->nTiles);
 
     if (tmp == NULL) {
-	G3d_error("G3d_readIndex: error in G3d_malloc");
+	Rast3d_error("Rast3d_readIndex: error in Rast3d_malloc");
 	return 0;
     }
 
@@ -37,9 +37,9 @@ static int G3d_readIndex(RASTER3D_Map * map)
 
 	if (indexLength > sizeof(long) * map->nTiles) {
 						     /*->index large enough? */
-	    tmp2 = G3d_malloc(indexLength);
+	    tmp2 = Rast3d_malloc(indexLength);
 	    if (tmp2 == NULL) {
-		G3d_error("G3d_readIndex: error in G3d_malloc");
+		Rast3d_error("Rast3d_readIndex: error in Rast3d_malloc");
 		return 0;
 	    }
 	}
@@ -47,7 +47,7 @@ static int G3d_readIndex(RASTER3D_Map * map)
 	    tmp2 = (unsigned char *)map->index;
 
 	if (read(map->data_fd, tmp2, indexLength) != indexLength) {
-	    G3d_error("G3d_readIndex: can't read file");
+	    Rast3d_error("Rast3d_readIndex: can't read file");
 	    return 0;
 	}
 
@@ -55,27 +55,27 @@ static int G3d_readIndex(RASTER3D_Map * map)
 		     &dummy1, &dummy2);
 
 	if (indexLength > sizeof(long) * map->nTiles)
-	    G3d_free(tmp2);
+	    Rast3d_free(tmp2);
     }
     else /* NO RLE */ if (read(map->data_fd, tmp, indexLength) != indexLength) {
-	G3d_error("G3d_readIndex: can't read file");
+	Rast3d_error("Rast3d_readIndex: can't read file");
 	return 0;
     }
 
-    G3d_longDecode(tmp, map->index, map->nTiles, map->indexLongNbytes);
+    Rast3d_longDecode(tmp, map->index, map->nTiles, map->indexLongNbytes);
 
     for (tileIndex = 0; tileIndex < map->nTiles; tileIndex++)
 	if (map->index[tileIndex] == 0)
 	    map->index[tileIndex] = -1;
 
-    G3d_free(tmp);
+    Rast3d_free(tmp);
 
     return 1;
 }
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_flushIndex(RASTER3D_Map * map)
+int Rast3d_flushIndex(RASTER3D_Map * map)
 {
     int sizeCompressed, indexLength, tileIndex;
     unsigned char *tmp;
@@ -86,16 +86,16 @@ int G3d_flushIndex(RASTER3D_Map * map)
 
     map->indexOffset = lseek(map->data_fd, (long)0, SEEK_END);
     if (map->indexOffset == -1) {
-	G3d_error("G3d_flushIndex: can't rewind file");
+	Rast3d_error("Rast3d_flushIndex: can't rewind file");
 	return 0;
     }
 
-    map->indexNbytesUsed = G3d_longEncode(&(map->indexOffset),
+    map->indexNbytesUsed = Rast3d_longEncode(&(map->indexOffset),
 					  (unsigned char *)&ldummy, 1);
 
-    tmp = G3d_malloc(sizeof(long) * map->nTiles);
+    tmp = Rast3d_malloc(sizeof(long) * map->nTiles);
     if (tmp == NULL) {
-	G3d_error("G3d_flushIndex: error in G3d_malloc");
+	Rast3d_error("Rast3d_flushIndex: error in Rast3d_malloc");
 	return 0;
     }
 
@@ -103,14 +103,14 @@ int G3d_flushIndex(RASTER3D_Map * map)
 	if (map->index[tileIndex] == -1)
 	    map->index[tileIndex] = 0;
 
-    (void)G3d_longEncode(map->index, tmp, map->nTiles);
+    (void)Rast3d_longEncode(map->index, tmp, map->nTiles);
 
     sizeCompressed = G_rle_count_only(tmp, sizeof(long) * map->nTiles, 1);
 
     if (sizeCompressed >= map->nTiles * sizeof(long)) {
 	indexLength = map->nTiles * sizeof(long);
 	if (write(map->data_fd, tmp, indexLength) != indexLength) {
-	    G3d_error("G3d_flushIndex: can't write file");
+	    Rast3d_error("Rast3d_flushIndex: can't write file");
 	    return 0;
 	}
     }
@@ -118,14 +118,14 @@ int G3d_flushIndex(RASTER3D_Map * map)
 	indexLength = sizeCompressed;
 	G_rle_encode(tmp, (char *)map->index, sizeof(long) * map->nTiles, 1);
 	if (write(map->data_fd, map->index, sizeCompressed) != sizeCompressed) {
-	    G3d_error("G3d_flushIndex: can't write file");
+	    Rast3d_error("Rast3d_flushIndex: can't write file");
 	    return 0;
 	}
     }
 
-    G3d_free(tmp);
-    if (!G3d_readIndex(map)) {
-	G3d_error("G3d_flushIndex: error in G3d_readIndex");
+    Rast3d_free(tmp);
+    if (!Rast3d_readIndex(map)) {
+	Rast3d_error("Rast3d_flushIndex: error in Rast3d_readIndex");
 	return 0;
     }
 
@@ -152,18 +152,18 @@ static int indexSortCompare(const void *a, const void *b)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_initIndex(RASTER3D_Map * map, int hasIndex)
+int Rast3d_initIndex(RASTER3D_Map * map, int hasIndex)
 {
     int tile;
     int i0, i1, i2, i3, i4, i5, offset, nofElts;
     int *offsetP;
 
     map->hasIndex = hasIndex;
-    map->index = G3d_malloc(sizeof(long) * map->nTiles);
-    map->tileLength = G3d_malloc(sizeof(int) * map->nTiles);
+    map->index = Rast3d_malloc(sizeof(long) * map->nTiles);
+    map->tileLength = Rast3d_malloc(sizeof(int) * map->nTiles);
 
     if ((map->index == NULL) || (map->tileLength == NULL)) {
-	G3d_error("G3d_initIndex: error in G3d_malloc");
+	Rast3d_error("Rast3d_initIndex: error in Rast3d_malloc");
 	return 0;
     }
 
@@ -177,7 +177,7 @@ int G3d_initIndex(RASTER3D_Map * map, int hasIndex)
 	offset = 0;
 	for (tile = 0; tile < map->nTiles; tile++) {
 	    map->index[tile] = offset * map->numLengthExtern + map->offset;
-	    nofElts = G3d_computeClippedTileDimensions
+	    nofElts = Rast3d_computeClippedTileDimensions
 		(map, tile, &i0, &i1, &i2, &i3, &i4, &i5);
 	    map->tileLength[tile] = nofElts * map->numLengthExtern;
 	    offset += nofElts;
@@ -185,14 +185,14 @@ int G3d_initIndex(RASTER3D_Map * map, int hasIndex)
 	return 1;
     }
 
-    if (!G3d_readIndex(map)) {
-	G3d_error("G3d_initIndex: error in G3d_readIndex");
+    if (!Rast3d_readIndex(map)) {
+	Rast3d_error("Rast3d_initIndex: error in Rast3d_readIndex");
 	return 0;
     }
 
-    offsetP = G3d_malloc(sizeof(int) * map->nTiles);
+    offsetP = Rast3d_malloc(sizeof(int) * map->nTiles);
     if (offsetP == NULL) {
-	G3d_error("G3d_initIndex: error in G3d_malloc");
+	Rast3d_error("Rast3d_initIndex: error in Rast3d_malloc");
 	return 0;
     }
 
@@ -217,7 +217,7 @@ int G3d_initIndex(RASTER3D_Map * map, int hasIndex)
 	map->tileLength[offsetP[map->nTiles - 1]] =
 	    map->indexOffset - map->index[offsetP[map->nTiles - 1]];
 
-    G3d_free(offsetP);
+    Rast3d_free(offsetP);
 
     return 1;
 }

lib/raster3d/intio.c

@@ -8,7 +8,7 @@
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_writeInts(int fd, int useXdr, const int *i, int nofNum)
+int Rast3d_writeInts(int fd, int useXdr, const int *i, int nofNum)
 {
     int firstTime = 1;
     XDR xdrEncodeStream;
@@ -16,11 +16,11 @@ int G3d_writeInts(int fd, int useXdr, const int *i, int nofNum)
     u_int n;
 
     if (nofNum <= 0)
-	G3d_fatalError("G3d_writeInts: nofNum out of range");
+	Rast3d_fatalError("Rast3d_writeInts: nofNum out of range");
 
     if (useXdr == RASTER3D_NO_XDR) {
 	if (write(fd, i, sizeof(int) * nofNum) != sizeof(int) * nofNum) {
-	    G3d_error("G3d_writeInts: writing to file failed");
+	    Rast3d_error("Rast3d_writeInts: writing to file failed");
 	    return 0;
 	}
 	else {
@@ -40,19 +40,19 @@ int G3d_writeInts(int fd, int useXdr, const int *i, int nofNum)
 	    n = 1024;
 
 	if (!xdr_setpos(&xdrEncodeStream, 0)) {
-	    G3d_error("G3d_writeInts: positioning xdr failed");
+	    Rast3d_error("Rast3d_writeInts: positioning xdr failed");
 	    return 0;
 	}
 
 	if (!xdr_vector(&xdrEncodeStream, (char *)i, n, sizeof(int),
 			(xdrproc_t) xdr_int)) {
-	    G3d_error("G3d_writeInts: writing xdr failed");
+	    Rast3d_error("Rast3d_writeInts: writing xdr failed");
 	    return 0;
 	}
 
 	if (write(fd, xdrIntBuf, RASTER3D_XDR_INT_LENGTH * n) !=
 	    RASTER3D_XDR_INT_LENGTH * n) {
-	    G3d_error("G3d_writeInts: writing xdr to file failed");
+	    Rast3d_error("Rast3d_writeInts: writing xdr to file failed");
 	    return 0;
 	}
 
@@ -65,7 +65,7 @@ int G3d_writeInts(int fd, int useXdr, const int *i, int nofNum)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_readInts(int fd, int useXdr, int *i, int nofNum)
+int Rast3d_readInts(int fd, int useXdr, int *i, int nofNum)
 {
     int firstTime = 1;
     XDR xdrDecodeStream;
@@ -73,11 +73,11 @@ int G3d_readInts(int fd, int useXdr, int *i, int nofNum)
     u_int n;
 
     if (nofNum <= 0)
-	G3d_fatalError("G3d_readInts: nofNum out of range");
+	Rast3d_fatalError("Rast3d_readInts: nofNum out of range");
 
     if (useXdr == RASTER3D_NO_XDR) {
 	if (read(fd, i, sizeof(int) * nofNum) != sizeof(int) * nofNum) {
-	    G3d_error("G3d_readInts: reading from file failed");
+	    Rast3d_error("Rast3d_readInts: reading from file failed");
 	    return 0;
 	}
 	else {
@@ -98,18 +98,18 @@ int G3d_readInts(int fd, int useXdr, int *i, int nofNum)
 
 	if (read(fd, xdrIntBuf, RASTER3D_XDR_INT_LENGTH * n) !=
 	    RASTER3D_XDR_INT_LENGTH * n) {
-	    G3d_error("G3d_readInts: reading xdr from file failed");
+	    Rast3d_error("Rast3d_readInts: reading xdr from file failed");
 	    return 0;
 	}
 
 	if (!xdr_setpos(&xdrDecodeStream, 0)) {
-	    G3d_error("G3d_readInts: positioning xdr failed");
+	    Rast3d_error("Rast3d_readInts: positioning xdr failed");
 	    return 0;
 	}
 
 	if (!xdr_vector(&xdrDecodeStream, (char *)i, n, sizeof(int),
 			(xdrproc_t) xdr_int)) {
-	    G3d_error("G3d_readInts: reading xdr failed");
+	    Rast3d_error("Rast3d_readInts: reading xdr failed");
 	    return 0;
 	}
 

lib/raster3d/keys.c

@@ -4,12 +4,12 @@
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_keyGetInt(struct Key_Value *keys, const char *key, int *i)
+int Rast3d_keyGetInt(struct Key_Value *keys, const char *key, int *i)
 {
     const char *str;
 
     if ((str = G_find_key_value(key, keys)) == NULL) {
-	G3d_error("G3d_keyGetInt: cannot find field %s in key structure",
+	Rast3d_error("Rast3d_keyGetInt: cannot find field %s in key structure",
 		  key);
 	return 0;
     }
@@ -17,18 +17,18 @@ int G3d_keyGetInt(struct Key_Value *keys, const char *key, int *i)
     if (sscanf(str, "%d", i) == 1)
 	return 1;
 
-    G3d_error("G3d_keyGetInt: invalid value: field %s in key structure", key);
+    Rast3d_error("Rast3d_keyGetInt: invalid value: field %s in key structure", key);
     return 0;
 }
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_keyGetDouble(struct Key_Value *keys, const char *key, double *d)
+int Rast3d_keyGetDouble(struct Key_Value *keys, const char *key, double *d)
 {
     const char *str;
 
     if ((str = G_find_key_value(key, keys)) == NULL) {
-	G3d_error("G3d_keyGetDouble: cannot find field %s in key structure",
+	Rast3d_error("Rast3d_keyGetDouble: cannot find field %s in key structure",
 		  key);
 	return 0;
     }
@@ -36,7 +36,7 @@ int G3d_keyGetDouble(struct Key_Value *keys, const char *key, double *d)
     if (sscanf(str, "%lf", d) == 1)
 	return 1;
 
-    G3d_error("G3d_keyGetDouble: invalid value: field %s in key structure",
+    Rast3d_error("Rast3d_keyGetDouble: invalid value: field %s in key structure",
 	      key);
     return 0;
 }
@@ -44,12 +44,12 @@ int G3d_keyGetDouble(struct Key_Value *keys, const char *key, double *d)
 /*---------------------------------------------------------------------------*/
 
 int
-G3d_keyGetString(struct Key_Value *keys, const char *key, char **returnStr)
+Rast3d_keyGetString(struct Key_Value *keys, const char *key, char **returnStr)
 {
     const char *str;
 
     if ((str = G_find_key_value(key, keys)) == NULL) {
-	G3d_error("G3d_keyGetString: cannot find field %s in key structure",
+	Rast3d_error("Rast3d_keyGetString: cannot find field %s in key structure",
 		  key);
 	return 0;
     }
@@ -61,13 +61,13 @@ G3d_keyGetString(struct Key_Value *keys, const char *key, char **returnStr)
 /*---------------------------------------------------------------------------*/
 
 int
-G3d_keyGetValue(struct Key_Value *keys, const char *key, char *val1,
+Rast3d_keyGetValue(struct Key_Value *keys, const char *key, char *val1,
 		char *val2, int result1, int result2, int *resultVar)
 {
     const char *str;
 
     if ((str = G_find_key_value(key, keys)) == NULL) {
-	G3d_error("G3d_keyGetValue: cannot find field %s in key structure",
+	Rast3d_error("Rast3d_keyGetValue: cannot find field %s in key structure",
 		  key);
 	return 0;
     }
@@ -81,14 +81,14 @@ G3d_keyGetValue(struct Key_Value *keys, const char *key, char *val1,
 	return 1;
     }
 
-    G3d_error("G3d_keyGetValue: invalid type: field %s in key structure",
+    Rast3d_error("Rast3d_keyGetValue: invalid type: field %s in key structure",
 	      key);
     return 0;
 }
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_keySetInt(struct Key_Value *keys, const char *key, const int *i)
+int Rast3d_keySetInt(struct Key_Value *keys, const char *key, const int *i)
 {
     char keyValStr[200];
 
@@ -99,7 +99,7 @@ int G3d_keySetInt(struct Key_Value *keys, const char *key, const int *i)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_keySetDouble(struct Key_Value *keys, const char *key, const double *d)
+int Rast3d_keySetDouble(struct Key_Value *keys, const char *key, const double *d)
 {
     char keyValStr[200];
 
@@ -111,7 +111,7 @@ int G3d_keySetDouble(struct Key_Value *keys, const char *key, const double *d)
 /*---------------------------------------------------------------------------*/
 
 int
-G3d_keySetString(struct Key_Value *keys, const char *key,
+Rast3d_keySetString(struct Key_Value *keys, const char *key,
 		 char *const *keyValStr)
 {
     G_set_key_value(key, *keyValStr, keys);
@@ -121,7 +121,7 @@ G3d_keySetString(struct Key_Value *keys, const char *key,
 /*---------------------------------------------------------------------------*/
 
 int
-G3d_keySetValue(struct Key_Value *keys, const char *key, const char *val1,
+Rast3d_keySetValue(struct Key_Value *keys, const char *key, const char *val1,
 		const char *val2, int keyval1, int keyval2,
 		const int *keyvalVar)
 {
@@ -135,6 +135,6 @@ G3d_keySetValue(struct Key_Value *keys, const char *key, const char *val1,
 	return 1;
     }
 
-    G3d_error("G3d_keySetValue: wrong key value");
+    Rast3d_error("Rast3d_keySetValue: wrong key value");
     return 0;
 }

lib/raster3d/long.c

@@ -2,7 +2,7 @@
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_longEncode(long *source, unsigned char *dst, int nofNums)
+int Rast3d_longEncode(long *source, unsigned char *dst, int nofNums)
 {
     long *src, d;
     int eltLength, nBytes;
@@ -33,7 +33,7 @@ int G3d_longEncode(long *source, unsigned char *dst, int nofNums)
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_longDecode(unsigned char *source, long *dst, int nofNums, int longNbytes)
+Rast3d_longDecode(unsigned char *source, long *dst, int nofNums, int longNbytes)
 {
     long *dest;
     int eltLength;
@@ -50,7 +50,7 @@ G3d_longDecode(unsigned char *source, long *dst, int nofNums, int longNbytes)
     while (source != srcStop) {
 	*dest = *source--;
 	if ((eltLength >= RASTER3D_LONG_LENGTH) && (*dest != 0))
-	    G3d_fatalError("G3d_longDecode: decoded long too long");
+	    Rast3d_fatalError("Rast3d_longDecode: decoded long too long");
 	dest--;
     }
 
@@ -62,7 +62,7 @@ G3d_longDecode(unsigned char *source, long *dst, int nofNums, int longNbytes)
 	    *dest *= 256;
 	    *dest += *source--;
 	    if ((eltLength >= RASTER3D_LONG_LENGTH) && (*dest != 0))
-		G3d_fatalError("G3d_longDecode: decoded long too long");
+		Rast3d_fatalError("Rast3d_longDecode: decoded long too long");
 	    dest--;
 	}
     }

lib/raster3d/mapset.c

@@ -6,7 +6,7 @@
 
 /*---------------------------------------------------------------------------*/
 
-void G3d_makeMapsetMapDirectory(const char *mapName)
+void Rast3d_makeMapsetMapDirectory(const char *mapName)
 {
     char buf[GNAME_MAX + sizeof(RASTER3D_DIRECTORY) + 2];
 

lib/raster3d/mask.c

@@ -12,8 +12,8 @@
 
 /*--------------------------------------------------------------------------*/
 
-static int G3d_maskMapExistsVar = 0;
-static RASTER3D_Map *G3d_maskMap;
+static int Rast3d_maskMapExistsVar = 0;
+static RASTER3D_Map *Rast3d_maskMap;
 
 /*--------------------------------------------------------------------------*/
 static void dummy(void)
@@ -24,25 +24,25 @@ static void dummy(void)
 
 static float RASTER3D_MASKNUMmaskValue;
 
-/* Call to dummy() to match void return type of G3d_setNullValue() */
+/* Call to dummy() to match void return type of Rast3d_setNullValue() */
 #define RASTER3D_MASKNUM(map,Xmask,Ymask,Zmask,VALUEmask,TYPEmask) \
 \
-   (RASTER3D_MASKNUMmaskValue = G3d_getMaskFloat (map, Xmask, Ymask, Zmask), \
-    ((G3d_isNullValueNum (&RASTER3D_MASKNUMmaskValue, FCELL_TYPE)) ? \
-      G3d_setNullValue (VALUEmask, 1, TYPEmask) : dummy()))
+   (RASTER3D_MASKNUMmaskValue = Rast3d_getMaskFloat (map, Xmask, Ymask, Zmask), \
+    ((Rast3d_isNullValueNum (&RASTER3D_MASKNUMmaskValue, FCELL_TYPE)) ? \
+      Rast3d_setNullValue (VALUEmask, 1, TYPEmask) : dummy()))
 
 /*--------------------------------------------------------------------------*/
 
-int G3d_maskClose()
+int Rast3d_maskClose()
 {
     /* No Idea if this is correct return value */
-    if (!G3d_maskMapExistsVar)
+    if (!Rast3d_maskMapExistsVar)
 	return 1;
 
-    G3d_maskMapExistsVar = 0;
+    Rast3d_maskMapExistsVar = 0;
 
-    if (!G3d_closeCell(G3d_maskMap)) {
-	G3d_error("G3d_maskClose: error closing mask");
+    if (!Rast3d_closeCell(Rast3d_maskMap)) {
+	Rast3d_error("Rast3d_maskClose: error closing mask");
 
 	return 0;
     }
@@ -61,7 +61,7 @@ int G3d_maskClose()
  *  \return int
  */
 
-int G3d_maskFileExists(void)
+int Rast3d_maskFileExists(void)
 {
     return G_find_file_misc(RASTER3D_DIRECTORY, RASTER3D_CELL_ELEMENT, RASTER3D_MASK_MAP, G_mapset()) != NULL;
 }
@@ -70,37 +70,37 @@ int G3d_maskFileExists(void)
 
 static int maskOpenOldCacheDefault = RASTER3D_USE_CACHE_DEFAULT;
 
-int G3d_maskOpenOld(void)
+int Rast3d_maskOpenOld(void)
 {
     RASTER3D_Region region;
 
     /* No Idea if this is correct return value */
-    if (G3d_maskMapExistsVar)
+    if (Rast3d_maskMapExistsVar)
 	return 1;
 
-    G3d_maskMapExistsVar = G3d_maskFileExists();
+    Rast3d_maskMapExistsVar = Rast3d_maskFileExists();
 
-    if (!G3d_maskMapExistsVar)
+    if (!Rast3d_maskMapExistsVar)
 	return 1;
 
-    if ((G3d_maskMap = G3d_openCellOld(RASTER3D_MASK_MAP, G_mapset(),
+    if ((Rast3d_maskMap = Rast3d_openCellOld(RASTER3D_MASK_MAP, G_mapset(),
 				       RASTER3D_DEFAULT_WINDOW, FCELL_TYPE,
 				       maskOpenOldCacheDefault))
 	== NULL) {
-	G3d_error("G3d_maskOpenOld: cannot open mask");
+	Rast3d_error("Rast3d_maskOpenOld: cannot open mask");
 
 	return 0;
     }
 
-    G3d_getRegionStructMap(G3d_maskMap, &region);
-    G3d_setWindowMap(G3d_maskMap, &region);
+    Rast3d_getRegionStructMap(Rast3d_maskMap, &region);
+    Rast3d_setWindowMap(Rast3d_maskMap, &region);
 
     return 1;
 }
 
 /*--------------------------------------------------------------------------*/
 
-static float G3d_getMaskFloat(RASTER3D_Map * map, int x, int y, int z)
+static float Rast3d_getMaskFloat(RASTER3D_Map * map, int x, int y, int z)
 {
     double north, east, top;
     float value;
@@ -112,7 +112,7 @@ static float G3d_getMaskFloat(RASTER3D_Map * map, int x, int y, int z)
     top = ((double)z + 0.5) / (double)map->window.depths *
 	(map->window.top - map->window.bottom) + map->window.bottom;
 
-    G3d_getRegionValue(G3d_maskMap, north, east, top, &value, FCELL_TYPE);
+    Rast3d_getRegionValue(Rast3d_maskMap, north, east, top, &value, FCELL_TYPE);
     return value;
 }
 
@@ -131,13 +131,13 @@ static float G3d_getMaskFloat(RASTER3D_Map * map, int x, int y, int z)
  *          0 ... otherwise.
  */
 
-int G3d_maskReopen(int cache)
+int Rast3d_maskReopen(int cache)
 {
     int tmp;
 
-    if (G3d_maskMapExistsVar)
-	if (!G3d_maskClose()) {
-	    G3d_error("G3d_maskReopen: error closing mask");
+    if (Rast3d_maskMapExistsVar)
+	if (!Rast3d_maskClose()) {
+	    Rast3d_error("Rast3d_maskReopen: error closing mask");
 
 	    return 0;
 	}
@@ -145,8 +145,8 @@ int G3d_maskReopen(int cache)
     tmp = maskOpenOldCacheDefault;
     maskOpenOldCacheDefault = cache;
 
-    if (!G3d_maskOpenOld()) {
-	G3d_error("G3d_maskReopen: error opening mask");
+    if (!Rast3d_maskOpenOld()) {
+	Rast3d_error("Rast3d_maskReopen: error opening mask");
 
 	return 0;
     }
@@ -170,13 +170,13 @@ int G3d_maskReopen(int cache)
  *  \return int
  */
 
-int G3d_isMasked(RASTER3D_Map * map, int x, int y, int z)
+int Rast3d_isMasked(RASTER3D_Map * map, int x, int y, int z)
 {
-    if (!G3d_maskMapExistsVar)
+    if (!Rast3d_maskMapExistsVar)
 	return 0;
 
-    RASTER3D_MASKNUMmaskValue = G3d_getMaskFloat(map, x, y, z);
-    return (G3d_isNullValueNum(&RASTER3D_MASKNUMmaskValue, FCELL_TYPE));
+    RASTER3D_MASKNUMmaskValue = Rast3d_getMaskFloat(map, x, y, z);
+    return (Rast3d_isNullValueNum(&RASTER3D_MASKNUMmaskValue, FCELL_TYPE));
 }
 
 /*--------------------------------------------------------------------------*/
@@ -186,7 +186,7 @@ int G3d_isMasked(RASTER3D_Map * map, int x, int y, int z)
  * \brief 
  *
  * Replaces the value stored in <em>value</em> with the NULL-value if 
- * <em>G3d_isMasked (x, y, z)</em> returns 1. Does nothing otherwise.
+ * <em>Rast3d_isMasked (x, y, z)</em> returns 1. Does nothing otherwise.
  * <em>value</em> is assumed to be of<em>type</em>.
  *
  *  \param x
@@ -197,9 +197,9 @@ int G3d_isMasked(RASTER3D_Map * map, int x, int y, int z)
  *  \return void
  */
 
-void G3d_maskNum(RASTER3D_Map * map, int x, int y, int z, void *value, int type)
+void Rast3d_maskNum(RASTER3D_Map * map, int x, int y, int z, void *value, int type)
 {
-    if (!G3d_maskMapExistsVar)
+    if (!Rast3d_maskMapExistsVar)
 	return;
     RASTER3D_MASKNUM(map, x, y, z, value, type);
 }
@@ -210,7 +210,7 @@ void G3d_maskNum(RASTER3D_Map * map, int x, int y, int z, void *value, int type)
 /*!
  * \brief 
  *
- *  Same as <em>G3d_maskNum (x, y, z, value, FCELL_TYPE)</em>.
+ *  Same as <em>Rast3d_maskNum (x, y, z, value, FCELL_TYPE)</em>.
  *
  *  \param x
  *  \param y
@@ -219,9 +219,9 @@ void G3d_maskNum(RASTER3D_Map * map, int x, int y, int z, void *value, int type)
  *  \return void
  */
 
-void G3d_maskFloat(RASTER3D_Map * map, int x, int y, int z, float *value)
+void Rast3d_maskFloat(RASTER3D_Map * map, int x, int y, int z, float *value)
 {
-    if (!G3d_maskMapExistsVar)
+    if (!Rast3d_maskMapExistsVar)
 	return;
     RASTER3D_MASKNUM(map, x, y, z, value, FCELL_TYPE);
 }
@@ -232,7 +232,7 @@ void G3d_maskFloat(RASTER3D_Map * map, int x, int y, int z, float *value)
 /*!
  * \brief 
  *
- * Same as <em>G3d_maskNum (x, y, z, value, DCELL_TYPE)</em>.
+ * Same as <em>Rast3d_maskNum (x, y, z, value, DCELL_TYPE)</em>.
  *
  *  \param x
  *  \param y
@@ -241,9 +241,9 @@ void G3d_maskFloat(RASTER3D_Map * map, int x, int y, int z, float *value)
  *  \return void
  */
 
-void G3d_maskDouble(RASTER3D_Map * map, int x, int y, int z, double *value)
+void Rast3d_maskDouble(RASTER3D_Map * map, int x, int y, int z, double *value)
 {
-    if (!G3d_maskMapExistsVar)
+    if (!Rast3d_maskMapExistsVar)
 	return;
     RASTER3D_MASKNUM(map, x, y, z, value, DCELL_TYPE);
 }
@@ -255,7 +255,7 @@ void G3d_maskDouble(RASTER3D_Map * map, int x, int y, int z, double *value)
  * \brief 
  *
  *  Replaces the values stored in <em>tile</em> (with <em>tileIndex</em>) for 
- *  which <em>G3d_isMasked</em> returns 1 with NULL-values. Does not change
+ *  which <em>Rast3d_isMasked</em> returns 1 with NULL-values. Does not change
  *  the remaining values. The values are assumed to be of <em>type</em>. 
  *  Whether replacement is performed or not only depends on location of the
  *  cells of the tile and not on the status of the mask for <em>map</em>
@@ -268,29 +268,29 @@ void G3d_maskDouble(RASTER3D_Map * map, int x, int y, int z, double *value)
  *  \return void
  */
 
-void G3d_maskTile(RASTER3D_Map * map, int tileIndex, void *tile, int type)
+void Rast3d_maskTile(RASTER3D_Map * map, int tileIndex, void *tile, int type)
 {
     int nofNum, rows, cols, depths, xRedundant, yRedundant, zRedundant;
     int x, y, z, xLength, yLength, dx, dy, dz, length;
 
-    if (!G3d_maskMapExistsVar)
+    if (!Rast3d_maskMapExistsVar)
 	return;
 
-    nofNum = G3d_computeClippedTileDimensions(map, tileIndex,
+    nofNum = Rast3d_computeClippedTileDimensions(map, tileIndex,
 					      &rows, &cols, &depths,
 					      &xRedundant, &yRedundant,
 					      &zRedundant);
-    G3d_tileIndexOrigin(map, tileIndex, &x, &y, &z);
+    Rast3d_tileIndexOrigin(map, tileIndex, &x, &y, &z);
 
     if (nofNum == map->tileSize) {
 	 /*AV*/
 	    /* BEGIN OF ORIGINAL CODE */
 	    /*
-	     *    G3d_getTileDimensionsMap (map, &rows, &cols, &depths);
+	     *    Rast3d_getTileDimensionsMap (map, &rows, &cols, &depths);
 	     */
 	     /*AV*/
 	    /* BEGIN OF MY CODE */
-	    G3d_getTileDimensionsMap(map, &cols, &rows, &depths);
+	    Rast3d_getTileDimensionsMap(map, &cols, &rows, &depths);
 	/* END OF MY CODE */
 	xRedundant = yRedundant = 0;
     }
@@ -298,7 +298,7 @@ void G3d_maskTile(RASTER3D_Map * map, int tileIndex, void *tile, int type)
     rows += y;
     cols += x;
     depths += z;
-    length = G3d_length(type);
+    length = Rast3d_length(type);
     xLength = xRedundant * length;
     yLength = map->tileX * yRedundant * length;
 
@@ -329,7 +329,7 @@ void G3d_maskTile(RASTER3D_Map * map, int tileIndex, void *tile, int type)
  *  \return void
  */
 
-void G3d_maskOn(RASTER3D_Map * map)
+void Rast3d_maskOn(RASTER3D_Map * map)
 {
     map->useMask = 1;
 }
@@ -346,7 +346,7 @@ void G3d_maskOn(RASTER3D_Map * map)
  *  \return void
  */
 
-void G3d_maskOff(RASTER3D_Map * map)
+void Rast3d_maskOff(RASTER3D_Map * map)
 {
     map->useMask = 0;
 }
@@ -362,7 +362,7 @@ void G3d_maskOff(RASTER3D_Map * map)
  *  \return int
  */
 
-int G3d_maskIsOn(RASTER3D_Map * map)
+int Rast3d_maskIsOn(RASTER3D_Map * map)
 {
     return map->useMask;
 }
@@ -377,7 +377,7 @@ int G3d_maskIsOn(RASTER3D_Map * map)
  *  \return int
  */
 
-int G3d_maskIsOff(RASTER3D_Map * map)
+int Rast3d_maskIsOff(RASTER3D_Map * map)
 {
     return !map->useMask;
 }
@@ -391,7 +391,7 @@ int G3d_maskIsOff(RASTER3D_Map * map)
  *  \return char * 
  */
 
-const char *G3d_maskFile(void)
+const char *Rast3d_maskFile(void)
 {
     return RASTER3D_MASK_MAP;
 }
@@ -405,7 +405,7 @@ const char *G3d_maskFile(void)
  *  \return int
  */
 
-int G3d_maskMapExists(void)
+int Rast3d_maskMapExists(void)
 {
-    return G3d_maskMapExistsVar;
+    return Rast3d_maskMapExistsVar;
 }

lib/raster3d/maskfn.c

@@ -43,20 +43,20 @@ void add_d_mask_rule(d_Mask * d_mask, double a, double b, int inf)
     d_mask->list = I;
 }
 
-int G3d_mask_d_select(DCELL * x, d_Mask * mask)
+int Rast3d_mask_d_select(DCELL * x, d_Mask * mask)
 {
     d_Interval *I;
 
     if (mask->list == NULL)
 	return 0;
     for (I = mask->list; I; I = I->next) {
-	if (G3d_mask_match_d_interval(*x, I))
+	if (Rast3d_mask_match_d_interval(*x, I))
 	    return 1;
     }
     return 0;
 }
 
-DCELL G3d_mask_match_d_interval(DCELL x, d_Interval * I)
+DCELL Rast3d_mask_match_d_interval(DCELL x, d_Interval * I)
 {
     if (I->inf < 0)
 	return x <= I->low;
@@ -98,7 +98,7 @@ void parse_d_mask_rule(char *vallist, d_Mask * d_mask, char *where)
     }
 }
 
-void G3d_parse_vallist(char **vallist, d_Mask ** d_mask)
+void Rast3d_parse_vallist(char **vallist, d_Mask ** d_mask)
 {
     char buf[1024];
     char x[2];

lib/raster3d/misc.c

@@ -12,7 +12,7 @@
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_g3dType2cellType(int g3dType)
+int Rast3d_g3dType2cellType(int g3dType)
 {
     if (g3dType == FCELL_TYPE)
 	return FCELL_TYPE;
@@ -22,7 +22,7 @@ int G3d_g3dType2cellType(int g3dType)
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_copyFloat2Double(const float *src, int offsSrc, double *dst, int offsDst,
+Rast3d_copyFloat2Double(const float *src, int offsSrc, double *dst, int offsDst,
 		     int nElts)
 {
     int i;
@@ -37,7 +37,7 @@ G3d_copyFloat2Double(const float *src, int offsSrc, double *dst, int offsDst,
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_copyDouble2Float(const double *src, int offsSrc, float *dst, int offsDst,
+Rast3d_copyDouble2Float(const double *src, int offsSrc, float *dst, int offsDst,
 		     int nElts)
 {
     int i;
@@ -52,22 +52,22 @@ G3d_copyDouble2Float(const double *src, int offsSrc, float *dst, int offsDst,
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_copyValues(const void *src, int offsSrc, int typeSrc, void *dst,
+Rast3d_copyValues(const void *src, int offsSrc, int typeSrc, void *dst,
 	       int offsDst, int typeDst, int nElts)
 {
     int eltLength;
 
     if ((typeSrc == FCELL_TYPE) && (typeDst == DCELL_TYPE)) {
-	G3d_copyFloat2Double(src, offsSrc, dst, offsDst, nElts);
+	Rast3d_copyFloat2Double(src, offsSrc, dst, offsDst, nElts);
 	return;
     }
 
     if ((typeSrc == DCELL_TYPE) && (typeDst == FCELL_TYPE)) {
-	G3d_copyDouble2Float(src, offsSrc, dst, offsDst, nElts);
+	Rast3d_copyDouble2Float(src, offsSrc, dst, offsDst, nElts);
 	return;
     }
 
-    eltLength = G3d_length(typeSrc);
+    eltLength = Rast3d_length(typeSrc);
 
     src = G_incr_void_ptr(src, eltLength * offsSrc);
     dst = G_incr_void_ptr(dst, eltLength * offsDst);
@@ -77,10 +77,10 @@ G3d_copyValues(const void *src, int offsSrc, int typeSrc, void *dst,
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_length(int t)
+int Rast3d_length(int t)
 {
     if (!RASTER3D_IS_CORRECT_TYPE(t))
-	G3d_fatalError("G3d_length: invalid type");
+	Rast3d_fatalError("Rast3d_length: invalid type");
 
     if (t == FCELL_TYPE)
 	return sizeof(FCELL);
@@ -89,10 +89,10 @@ int G3d_length(int t)
     return 0;
 }
 
-int G3d_externLength(int t)
+int Rast3d_externLength(int t)
 {
     if (!RASTER3D_IS_CORRECT_TYPE(t))
-	G3d_fatalError("G3d_externLength: invalid type");
+	Rast3d_fatalError("Rast3d_externLength: invalid type");
 
     if (t == FCELL_TYPE)
 	return RASTER3D_XDR_FLOAT_LENGTH;

lib/raster3d/null.c

@@ -9,7 +9,7 @@
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_isNullValueNum(const void *n, int type)
+int Rast3d_isNullValueNum(const void *n, int type)
 {
     if (type == FCELL_TYPE)
 	return Rast_is_f_null_value(n);
@@ -32,7 +32,7 @@ int G3d_isNullValueNum(const void *n, int type)
  *  \return void
  */
 
-void G3d_setNullValue(void *c, int nofElts, int type)
+void Rast3d_setNullValue(void *c, int nofElts, int type)
 {
     if (type == FCELL_TYPE) {
 	Rast_set_f_null_value((float *)c, nofElts);

lib/raster3d/open.c

@@ -9,21 +9,21 @@
 
 /*---------------------------------------------------------------------------*/
 
-void *G3d_openCellOldNoHeader(const char *name, const char *mapset)
+void *Rast3d_openCellOldNoHeader(const char *name, const char *mapset)
 {
     RASTER3D_Map *map;
     char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
 
-    G3d_initDefaults();
+    Rast3d_initDefaults();
 
-    if (!G3d_maskOpenOld()) {
-	G3d_error(_("G3d_openCellOldNoHeader: error in G3d_maskOpenOld"));
+    if (!Rast3d_maskOpenOld()) {
+	Rast3d_error(_("Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"));
 	return (void *)NULL;
     }
 
-    map = G3d_malloc(sizeof(RASTER3D_Map));
+    map = Rast3d_malloc(sizeof(RASTER3D_Map));
     if (map == NULL) {
-	G3d_error(_("G3d_openCellOldNoHeader: error in G3d_malloc"));
+	Rast3d_error(_("Rast3d_openCellOldNoHeader: error in Rast3d_malloc"));
 	return (void *)NULL;
     }
 
@@ -34,12 +34,12 @@ void *G3d_openCellOldNoHeader(const char *name, const char *mapset)
 
     map->data_fd = G_open_old_misc(RASTER3D_DIRECTORY, RASTER3D_CELL_ELEMENT, xname, xmapset);
     if (map->data_fd < 0) {
-	G3d_error(_("G3d_openCellOldNoHeader: error in G_open_old"));
+	Rast3d_error(_("Rast3d_openCellOldNoHeader: error in G_open_old"));
 	return (void *)NULL;
     }
 
-    G3d_range_init(map);
-    G3d_maskOff(map);
+    Rast3d_range_init(map);
+    Rast3d_maskOff(map);
 
     return map;
 }
@@ -56,13 +56,13 @@ void *G3d_openCellOldNoHeader(const char *name, const char *mapset)
  * cache-mode used and must be either RASTER3D_NO_CACHE, RASTER3D_USE_CACHE_DEFAULT,
  * RASTER3D_USE_CACHE_X, RASTER3D_USE_CACHE_Y, RASTER3D_USE_CACHE_Z,
  * RASTER3D_USE_CACHE_XY, RASTER3D_USE_CACHE_XZ, RASTER3D_USE_CACHE_YZ,
- * RASTER3D_USE_CACHE_XYZ, the result of <tt>G3d_cacheSizeEncode ()</tt> (cf.{g3d:G3d.cacheSizeEncode}), or any positive integer which
+ * RASTER3D_USE_CACHE_XYZ, the result of <tt>Rast3d_cacheSizeEncode ()</tt> (cf.{g3d:G3d.cacheSizeEncode}), or any positive integer which
  * specifies the number of tiles buffered in the cache.  <em>window</em> sets the
  * window-region for the map. It is either a pointer to a window structure or
  * RASTER3D_DEFAULT_WINDOW, which uses the window stored at initialization time or
- * set via <tt>G3d_setWindow ()</tt> (cf.{g3d:G3d.setWindow}).
+ * set via <tt>Rast3d_setWindow ()</tt> (cf.{g3d:G3d.setWindow}).
  * To modify the window for the map after it has already been opened use
- * <tt>G3d_setWindowMap ()</tt> (cf.{g3d:G3d.setWindowMap}).
+ * <tt>Rast3d_setWindowMap ()</tt> (cf.{g3d:G3d.setWindowMap}).
  * Returns a pointer to the cell structure ... if successful, NULL ...
  * otherwise.
  *
@@ -74,7 +74,7 @@ void *G3d_openCellOldNoHeader(const char *name, const char *mapset)
  *  \return void * 
  */
 
-void *G3d_openCellOld(const char *name, const char *mapset,
+void *Rast3d_openCellOld(const char *name, const char *mapset,
 		      RASTER3D_Region * window, int typeIntern, int cache)
 {
     RASTER3D_Map *map;
@@ -86,18 +86,18 @@ void *G3d_openCellOld(const char *name, const char *mapset,
     char *ltmp, *unit;
     double north, south, east, west, top, bottom;
 
-    map = G3d_openCellOldNoHeader(name, mapset);
+    map = Rast3d_openCellOldNoHeader(name, mapset);
     if (map == NULL) {
-	G3d_error(_("G3d_openCellOld: error in G3d_openCellOldNoHeader"));
+	Rast3d_error(_("Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"));
 	return (void *)NULL;
     }
 
     if (lseek(map->data_fd, (long)0, SEEK_SET) == -1) {
-	G3d_error(_("G3d_openCellOld: can't rewind file"));
+	Rast3d_error(_("Rast3d_openCellOld: can't rewind file"));
 	return (void *)NULL;
     }
 
-    if (!G3d_readHeader(map,
+    if (!Rast3d_readHeader(map,
 			&proj, &zone,
 			&north, &south, &east, &west, &top, &bottom,
 			&rows, &cols, &depths,
@@ -105,19 +105,19 @@ void *G3d_openCellOld(const char *name, const char *mapset,
 			&tileX, &tileY, &tileZ,
 			&type, &compression, &useRle, &useLzw,
 			&precision, &dataOffset, &useXdr, &hasIndex, &unit)) {
-	G3d_error(_("G3d_openCellOld: error in G3d_readHeader"));
+	Rast3d_error(_("Rast3d_openCellOld: error in Rast3d_readHeader"));
 	return 0;
     }
 
     if (window == RASTER3D_DEFAULT_WINDOW)
-	window = G3d_windowPtr();
+	window = Rast3d_windowPtr();
 
     if (proj != window->proj) {
-	G3d_error(_("G3d_openCellOld: projection does not match window projection"));
+	Rast3d_error(_("Rast3d_openCellOld: projection does not match window projection"));
 	return (void *)NULL;
     }
     if (zone != window->zone) {
-	G3d_error(_("G3d_openCellOld: zone does not match window zone"));
+	Rast3d_error(_("Rast3d_openCellOld: zone does not match window zone"));
 	return (void *)NULL;
     }
 
@@ -125,32 +125,32 @@ void *G3d_openCellOld(const char *name, const char *mapset,
 
     if (hasIndex) {
 	/* see RASTER3D_openCell_new () for format of header */
-	if ((!G3d_readInts(map->data_fd, map->useXdr,
+	if ((!Rast3d_readInts(map->data_fd, map->useXdr,
 			   &(map->indexLongNbytes), 1)) ||
-	    (!G3d_readInts(map->data_fd, map->useXdr,
+	    (!Rast3d_readInts(map->data_fd, map->useXdr,
 			   &(map->indexNbytesUsed), 1))) {
-	    G3d_error(_("G3d_openCellOld: can't read header"));
+	    Rast3d_error(_("Rast3d_openCellOld: can't read header"));
 	    return (void *)NULL;
 	}
 
 	/* if our long is to short to store offsets we can't read the file */
 	if (map->indexNbytesUsed > sizeof(long))
-	    G3d_fatalError(_("G3d_openCellOld: index does not fit into long"));
+	    Rast3d_fatalError(_("Rast3d_openCellOld: index does not fit into long"));
 
-	ltmp = G3d_malloc(map->indexLongNbytes);
+	ltmp = Rast3d_malloc(map->indexLongNbytes);
 	if (ltmp == NULL) {
-	    G3d_error(_("G3d_openCellOld: error in G3d_malloc"));
+	    Rast3d_error(_("Rast3d_openCellOld: error in Rast3d_malloc"));
 	    return (void *)NULL;
 	}
 
 	/* convert file long to long */
 	if (read(map->data_fd, ltmp, map->indexLongNbytes) !=
 	    map->indexLongNbytes) {
-	    G3d_error(_("G3d_openCellOld: can't read header"));
+	    Rast3d_error(_("Rast3d_openCellOld: can't read header"));
 	    return (void *)NULL;
 	}
-	G3d_longDecode(ltmp, &(map->indexOffset), 1, map->indexLongNbytes);
-	G3d_free(ltmp);
+	Rast3d_longDecode(ltmp, &(map->indexOffset), 1, map->indexLongNbytes);
+	Rast3d_free(ltmp);
     }
 
     nofHeaderBytes = dataOffset;
@@ -158,20 +158,20 @@ void *G3d_openCellOld(const char *name, const char *mapset,
     if (typeIntern == RASTER3D_TILE_SAME_AS_FILE)
 	typeIntern = type;
 
-    if (!G3d_fillHeader(map, RASTER3D_READ_DATA, compression, useRle, useLzw,
+    if (!Rast3d_fillHeader(map, RASTER3D_READ_DATA, compression, useRle, useLzw,
 			type, precision, cache,
 			hasIndex, map->useXdr, typeIntern,
 			nofHeaderBytes, tileX, tileY, tileZ,
 			proj, zone,
 			north, south, east, west, top, bottom,
 			rows, cols, depths, ew_res, ns_res, tb_res, unit)) {
-	G3d_error(_("G3d_openCellOld: error in G3d_fillHeader"));
+	Rast3d_error(_("Rast3d_openCellOld: error in Rast3d_fillHeader"));
 	return (void *)NULL;
     }
 
-    G3d_regionCopy(&(map->window), window);
-    G3d_adjustRegion(&(map->window));
-    G3d_getNearestNeighborFunPtr(&(map->resampleFun));
+    Rast3d_regionCopy(&(map->window), window);
+    Rast3d_adjustRegion(&(map->window));
+    Rast3d_getNearestNeighborFunPtr(&(map->resampleFun));
 
     return map;
 }
@@ -188,7 +188,7 @@ void *G3d_openCellOld(const char *name, const char *mapset,
  * cache-mode used and must be either RASTER3D_NO_CACHE, RASTER3D_USE_CACHE_DEFAULT,
  * RASTER3D_USE_CACHE_X, RASTER3D_USE_CACHE_Y, RASTER3D_USE_CACHE_Z,
  * RASTER3D_USE_CACHE_XY, RASTER3D_USE_CACHE_XZ, RASTER3D_USE_CACHE_YZ,
- * RASTER3D_USE_CACHE_XYZ, the result of <tt>G3d_cacheSizeEncode ()</tt>
+ * RASTER3D_USE_CACHE_XYZ, the result of <tt>Rast3d_cacheSizeEncode ()</tt>
  * (cf.{g3d:G3d.cacheSizeEncode}), or any positive integer which
  * specifies the number of tiles buffered in the cache.  <em>region</em> specifies
  * the 3d region.  
@@ -202,7 +202,7 @@ void *G3d_openCellOld(const char *name, const char *mapset,
  *  \return void * 
  */
 
-void *G3d_openCellNew(const char *name, int typeIntern, int cache,
+void *Rast3d_openCellNew(const char *name, int typeIntern, int cache,
 		      RASTER3D_Region * region)
 {
     RASTER3D_Map *map;
@@ -210,18 +210,18 @@ void *G3d_openCellNew(const char *name, int typeIntern, int cache,
     long ldummy = 0;
     char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
 
-    G3d_initDefaults();
-    if (!G3d_maskOpenOld()) {
-	G3d_error(_("G3d_openCellNew: error in G3d_maskOpenOld"));
+    Rast3d_initDefaults();
+    if (!Rast3d_maskOpenOld()) {
+	Rast3d_error(_("Rast3d_openCellNew: error in Rast3d_maskOpenOld"));
 	return (void *)NULL;
     }
 
     compression = g3d_do_compression;
     precision = g3d_precision;
 
-    map = G3d_malloc(sizeof(RASTER3D_Map));
+    map = Rast3d_malloc(sizeof(RASTER3D_Map));
     if (map == NULL) {
-	G3d_error(_("G3d_openCellNew: error in G3d_malloc"));
+	Rast3d_error(_("Rast3d_openCellNew: error in Rast3d_malloc"));
 	return (void *)NULL;
     }
 
@@ -236,11 +236,11 @@ void *G3d_openCellNew(const char *name, int typeIntern, int cache,
     map->tempName = G_tempfile();
     map->data_fd = open(map->tempName, O_RDWR | O_CREAT | O_TRUNC, 0666);
     if (map->data_fd < 0) {
-	G3d_error(_("G3d_openCellNew: could not open file"));
+	Rast3d_error(_("Rast3d_openCellNew: could not open file"));
 	return (void *)NULL;
     }
 
-    G3d_makeMapsetMapDirectory(map->fileName);
+    Rast3d_makeMapsetMapDirectory(map->fileName);
 
     map->useXdr = RASTER3D_USE_XDR;
 
@@ -278,15 +278,15 @@ void *G3d_openCellNew(const char *name, int typeIntern, int cache,
 	/* the index is appended at the end of the file at closing time. since */
 	/* we do not know this position yet we write dummy values */
 
-	if ((!G3d_writeInts(map->data_fd, map->useXdr,
+	if ((!Rast3d_writeInts(map->data_fd, map->useXdr,
 			    &(map->indexLongNbytes), 1)) ||
-	    (!G3d_writeInts(map->data_fd, map->useXdr, &dummy, 1))) {
-	    G3d_error(_("G3d_openCellNew: can't write header"));
+	    (!Rast3d_writeInts(map->data_fd, map->useXdr, &dummy, 1))) {
+	    Rast3d_error(_("Rast3d_openCellNew: can't write header"));
 	    return (void *)NULL;
 	}
 	if (write(map->data_fd, &ldummy, map->indexLongNbytes) !=
 	    map->indexLongNbytes) {
-	    G3d_error(_("G3d_openCellNew: can't write header"));
+	    Rast3d_error(_("Rast3d_openCellNew: can't write header"));
 	    return (void *)NULL;
 	}
     }
@@ -294,10 +294,10 @@ void *G3d_openCellNew(const char *name, int typeIntern, int cache,
     /* can't use a constant since this depends on sizeof (long) */
     nofHeaderBytes = lseek(map->data_fd, (long)0, SEEK_CUR);
 
-    G3d_range_init(map);
-    G3d_adjustRegion(region);
+    Rast3d_range_init(map);
+    Rast3d_adjustRegion(region);
 
-    if (!G3d_fillHeader(map, RASTER3D_WRITE_DATA, compression,
+    if (!Rast3d_fillHeader(map, RASTER3D_WRITE_DATA, compression,
 			g3d_do_rle_compression, g3d_do_lzw_compression,
 			g3d_file_type, precision, cache, RASTER3D_HAS_INDEX,
 			map->useXdr, typeIntern, nofHeaderBytes,
@@ -309,16 +309,16 @@ void *G3d_openCellNew(const char *name, int typeIntern, int cache,
 			region->rows, region->cols, region->depths,
 			region->ew_res, region->ns_res, region->tb_res,
 			g3d_unit_default)) {
-	G3d_error(_("G3d_openCellNew: error in G3d_fillHeader"));
+	Rast3d_error(_("Rast3d_openCellNew: error in Rast3d_fillHeader"));
 	return (void *)NULL;
     }
 
     /*Set the map window to the map region */
-    G3d_regionCopy(&(map->window), region);
+    Rast3d_regionCopy(&(map->window), region);
     /*Set the resampling function to nearest neighbor for data access */
-    G3d_getNearestNeighborFunPtr(&(map->resampleFun));
+    Rast3d_getNearestNeighborFunPtr(&(map->resampleFun));
 
-    G3d_maskOff(map);
+    Rast3d_maskOff(map);
 
     return (void *)map;
 }

lib/raster3d/open2.c

@@ -12,7 +12,7 @@
  * cache-mode used and must be either RASTER3D_NO_CACHE, RASTER3D_USE_CACHE_DEFAULT,
  * RASTER3D_USE_CACHE_X, RASTER3D_USE_CACHE_Y, RASTER3D_USE_CACHE_Z,
  * RASTER3D_USE_CACHE_XY, RASTER3D_USE_CACHE_XZ, RASTER3D_USE_CACHE_YZ,
- * RASTER3D_USE_CACHE_XYZ, the result of <tt>G3d_cacheSizeEncode ()</tt>
+ * RASTER3D_USE_CACHE_XYZ, the result of <tt>Rast3d_cacheSizeEncode ()</tt>
  * (cf.{g3d:G3d.cacheSizeEncode}), or any positive integer which
  * specifies the number of tiles buffered in the cache.  <em>region</em> specifies
  * the 3d region.  
@@ -38,7 +38,7 @@
  */
 
 
-void *G3d_openNewParam(const char *name, int typeIntern, int cache,
+void *Rast3d_openNewParam(const char *name, int typeIntern, int cache,
 		       RASTER3D_Region * region, int type, int doLzw, int doRle,
 		       int precision, int tileX, int tileY, int tileZ)
 {
@@ -47,22 +47,22 @@ void *G3d_openNewParam(const char *name, int typeIntern, int cache,
 	oldTileZ;
     int oldType;
 
-    G3d_initDefaults();
+    Rast3d_initDefaults();
 
-    G3d_getCompressionMode(&oldCompress, &oldLzw, &oldRle, &oldPrecision);
-    G3d_setCompressionMode(oldCompress, doLzw, doRle, precision);
+    Rast3d_getCompressionMode(&oldCompress, &oldLzw, &oldRle, &oldPrecision);
+    Rast3d_setCompressionMode(oldCompress, doLzw, doRle, precision);
 
-    G3d_getTileDimension(&oldTileX, &oldTileY, &oldTileZ);
-    G3d_setTileDimension(tileX, tileY, tileZ);
+    Rast3d_getTileDimension(&oldTileX, &oldTileY, &oldTileZ);
+    Rast3d_setTileDimension(tileX, tileY, tileZ);
 
-    oldType = G3d_getFileType();
-    G3d_setFileType(type);
+    oldType = Rast3d_getFileType();
+    Rast3d_setFileType(type);
 
-    map = G3d_openCellNew(name, typeIntern, cache, region);
+    map = Rast3d_openCellNew(name, typeIntern, cache, region);
 
-    G3d_setCompressionMode(oldCompress, oldLzw, oldRle, oldPrecision);
-    G3d_setTileDimension(oldTileX, oldTileY, oldTileZ);
-    G3d_setFileType(oldType);
+    Rast3d_setCompressionMode(oldCompress, oldLzw, oldRle, oldPrecision);
+    Rast3d_setTileDimension(oldTileX, oldTileY, oldTileZ);
+    Rast3d_setFileType(oldType);
 
     return map;
 }
@@ -78,7 +78,7 @@ void *G3d_openNewParam(const char *name, int typeIntern, int cache,
  * cache-mode used and must be either RASTER3D_NO_CACHE, RASTER3D_USE_CACHE_DEFAULT,
  * RASTER3D_USE_CACHE_X, RASTER3D_USE_CACHE_Y, RASTER3D_USE_CACHE_Z,
  * RASTER3D_USE_CACHE_XY, RASTER3D_USE_CACHE_XZ, RASTER3D_USE_CACHE_YZ,
- * RASTER3D_USE_CACHE_XYZ, the result of <tt>G3d_cacheSizeEncode ()</tt>
+ * RASTER3D_USE_CACHE_XYZ, the result of <tt>Rast3d_cacheSizeEncode ()</tt>
  * (cf.{g3d:G3d.cacheSizeEncode}), or any positive integer which
  * specifies the number of tiles buffered in the cache.  <em>region</em> specifies
  * the 3d region.  
@@ -95,28 +95,28 @@ void *G3d_openNewParam(const char *name, int typeIntern, int cache,
  */
 
 
-void *G3d_openNewOptTileSize(const char *name, int cache, RASTER3D_Region * region, int type, int maxSize)
+void *Rast3d_openNewOptTileSize(const char *name, int cache, RASTER3D_Region * region, int type, int maxSize)
 {
     void *map;
     int oldTileX, oldTileY, oldTileZ, oldType;
     int tileX, tileY, tileZ;
 
-    G3d_initDefaults();
+    Rast3d_initDefaults();
 
 
-    G3d_getTileDimension(&oldTileX, &oldTileY, &oldTileZ);
+    Rast3d_getTileDimension(&oldTileX, &oldTileY, &oldTileZ);
     
-    G3d_computeOptimalTileDimension(region, type, &tileX, &tileY, &tileZ, maxSize);
+    Rast3d_computeOptimalTileDimension(region, type, &tileX, &tileY, &tileZ, maxSize);
 
-    G3d_setTileDimension(tileX, tileY, tileZ);
+    Rast3d_setTileDimension(tileX, tileY, tileZ);
 
-    oldType = G3d_getFileType();
-    G3d_setFileType(type);
+    oldType = Rast3d_getFileType();
+    Rast3d_setFileType(type);
 
-    map = G3d_openCellNew(name, RASTER3D_TILE_SAME_AS_FILE, cache, region);
+    map = Rast3d_openCellNew(name, RASTER3D_TILE_SAME_AS_FILE, cache, region);
 
-    G3d_setTileDimension(oldTileX, oldTileY, oldTileZ);
-    G3d_setFileType(oldType);
+    Rast3d_setTileDimension(oldTileX, oldTileY, oldTileZ);
+    Rast3d_setFileType(oldType);
 
     return map;
 }

lib/raster3d/param.c

@@ -14,11 +14,11 @@ typedef struct
     struct Option *dimension;
     struct Option *cache;
 
-} G3d_paramType;
+} Rast3d_paramType;
 
 /*----------------------------------------------------------------------------*/
 
-static G3d_paramType *param;
+static Rast3d_paramType *param;
 
 
 /*!
@@ -33,14 +33,14 @@ static G3d_paramType *param;
  * of the tiles (<em>tiledimension</em>). Every of these values defaults to the
  * value described in RASTER3D Defaults.
  * This function has to be used in conjunction with
- * G3d_getStandard3dInputParams() (cf.{g3d:G3d.getStandard3dInputParams}).
+ * Rast3d_getStandard3dInputParams() (cf.{g3d:G3d.getStandard3dInputParams}).
  *
  *  \return void
  */
 
-void G3d_setStandard3dInputParams()
+void Rast3d_setStandard3dInputParams()
 {
-    param = G3d_malloc(sizeof(G3d_paramType));
+    param = Rast3d_malloc(sizeof(Rast3d_paramType));
 
     param->type = G_define_standard_option(G_OPT_R3_TYPE);
 
@@ -53,7 +53,7 @@ void G3d_setStandard3dInputParams()
 
 /*----------------------------------------------------------------------------*/
 
-int G3d_getStandard3dParams(int *useTypeDefault, int *type,
+int Rast3d_getStandard3dParams(int *useTypeDefault, int *type,
 			    int *useLzwDefault, int *doLzw,
 			    int *useRleDefault, int *doRle,
 			    int *usePrecisionDefault, int *precision,
@@ -65,25 +65,25 @@ int G3d_getStandard3dParams(int *useTypeDefault, int *type,
     *useTypeDefault = *useLzwDefault = *useRleDefault = 0;
     *usePrecisionDefault = *useDimensionDefault = 0;
 
-    G3d_initDefaults();
+    Rast3d_initDefaults();
 
     if (strcmp(param->type->answer, "double") == 0)
 	*type = DCELL_TYPE;
     else if (strcmp(param->type->answer, "float") == 0)
 	*type = FCELL_TYPE;
     else {
-	*type = G3d_getFileType();
+	*type = Rast3d_getFileType();
 	*useTypeDefault = 1;
     }
 
-    G3d_getCompressionMode(&doCompress, doLzw, doRle, precision);
+    Rast3d_getCompressionMode(&doCompress, doLzw, doRle, precision);
 
     if (strcmp(param->precision->answer, "default") != 0) {
 	if (strcmp(param->precision->answer, "max") == 0)
 	    *precision = -1;
 	else if ((sscanf(param->precision->answer, "%d", precision) != 1) ||
 		 (*precision < 0)) {
-	    G3d_error(_("G3d_getStandard3dParams: precision value invalid"));
+	    Rast3d_error(_("Rast3d_getStandard3dParams: precision value invalid"));
 	    return 0;
 	}
     }
@@ -112,18 +112,18 @@ int G3d_getStandard3dParams(int *useTypeDefault, int *type,
     else
 	*useLzwDefault = *useRleDefault = 1;
 
-    G3d_getTileDimension(tileX, tileY, tileZ);
+    Rast3d_getTileDimension(tileX, tileY, tileZ);
     if (strcmp(param->dimension->answer, "default") != 0) {
 	if (sscanf(param->dimension->answer, "%dx%dx%d",
 		   tileX, tileY, tileZ) != 3) {
-	    G3d_error(_("G3d_getStandard3dParams: tile dimension value invalid"));
+	    Rast3d_error(_("Rast3d_getStandard3dParams: tile dimension value invalid"));
 	    return 0;
 	}
     }
     else
 	*useDimensionDefault = 1;
 
-    G3d_free(param);
+    Rast3d_free(param);
 
     return 1;
 }
@@ -132,7 +132,7 @@ int G3d_getStandard3dParams(int *useTypeDefault, int *type,
 
 static struct Option *windowParam = NULL;
 
-void G3d_setWindowParams(void)
+void Rast3d_setWindowParams(void)
 {
     windowParam = G_define_option();
     windowParam->key = "region3";
@@ -145,7 +145,7 @@ void G3d_setWindowParams(void)
 
 /*----------------------------------------------------------------------------*/
 
-char *G3d_getWindowParams(void)
+char *Rast3d_getWindowParams(void)
 {
     if (windowParam == NULL)
 	return NULL;

lib/raster3d/putvalue.c

@@ -5,7 +5,7 @@
 /*!
  * \brief 
  *
- * Is equivalent to G3d_putValue (map, x, y, z, &value, FCELL_TYPE).
+ * Is equivalent to Rast3d_putValue (map, x, y, z, &value, FCELL_TYPE).
  *
  *  \param map
  *  \param x
@@ -15,23 +15,23 @@
  *  \return int
  */
 
-int G3d_putFloat(RASTER3D_Map * map, int x, int y, int z, float value)
+int Rast3d_putFloat(RASTER3D_Map * map, int x, int y, int z, float value)
 {
     int tileIndex, offs;
     float *tile;
 
     if (map->typeIntern == DCELL_TYPE) {
-	if (!G3d_putDouble(map, x, y, z, (double)value)) {
-	    G3d_error("G3d_putFloat: error in G3d_putDouble");
+	if (!Rast3d_putDouble(map, x, y, z, (double)value)) {
+	    Rast3d_error("Rast3d_putFloat: error in Rast3d_putDouble");
 	    return 0;
 	}
 	return 1;
     }
 
-    G3d_coord2tileIndex(map, x, y, z, &tileIndex, &offs);
-    tile = (float *)G3d_getTilePtr(map, tileIndex);
+    Rast3d_coord2tileIndex(map, x, y, z, &tileIndex, &offs);
+    tile = (float *)Rast3d_getTilePtr(map, tileIndex);
     if (tile == NULL) {
-	G3d_error("G3d_putFloat: error in G3d_getTilePtr");
+	Rast3d_error("Rast3d_putFloat: error in Rast3d_getTilePtr");
 	return 0;
     }
 
@@ -45,7 +45,7 @@ int G3d_putFloat(RASTER3D_Map * map, int x, int y, int z, float value)
 /*!
  * \brief 
  *
- *  Is equivalent to G3d_putValue (map, x, y, z, &value, DCELL_TYPE).
+ *  Is equivalent to Rast3d_putValue (map, x, y, z, &value, DCELL_TYPE).
  *
  *  \param map
  *  \param x
@@ -55,23 +55,23 @@ int G3d_putFloat(RASTER3D_Map * map, int x, int y, int z, float value)
  *  \return int
  */
 
-int G3d_putDouble(RASTER3D_Map * map, int x, int y, int z, double value)
+int Rast3d_putDouble(RASTER3D_Map * map, int x, int y, int z, double value)
 {
     int tileIndex, offs;
     double *tile;
 
     if (map->typeIntern == FCELL_TYPE) {
-	if (!G3d_putFloat(map, x, y, z, (float)value)) {
-	    G3d_error("G3d_putDouble: error in G3d_putFloat");
+	if (!Rast3d_putFloat(map, x, y, z, (float)value)) {
+	    Rast3d_error("Rast3d_putDouble: error in Rast3d_putFloat");
 	    return 0;
 	}
 	return 1;
     }
 
-    G3d_coord2tileIndex(map, x, y, z, &tileIndex, &offs);
-    tile = (double *)G3d_getTilePtr(map, tileIndex);
+    Rast3d_coord2tileIndex(map, x, y, z, &tileIndex, &offs);
+    tile = (double *)Rast3d_getTilePtr(map, tileIndex);
     if (tile == NULL) {
-	G3d_error("G3d_putDouble: error in G3d_getTilePtr");
+	Rast3d_error("Rast3d_putDouble: error in Rast3d_getTilePtr");
 	return 0;
     }
 
@@ -99,18 +99,18 @@ int G3d_putDouble(RASTER3D_Map * map, int x, int y, int z, double value)
  */
 
 int
-G3d_putValue(RASTER3D_Map * map, int x, int y, int z, const void *value, int type)
+Rast3d_putValue(RASTER3D_Map * map, int x, int y, int z, const void *value, int type)
 {
     if (type == FCELL_TYPE) {
-	if (!G3d_putFloat(map, x, y, z, *((float *)value))) {
-	    G3d_error("G3d_putValue: error in G3d_putFloat");
+	if (!Rast3d_putFloat(map, x, y, z, *((float *)value))) {
+	    Rast3d_error("Rast3d_putValue: error in Rast3d_putFloat");
 	    return 0;
 	}
 	return 1;
     }
 
-    if (!G3d_putDouble(map, x, y, z, *((double *)value))) {
-	G3d_error("G3d_putValue: error in G3d_putDouble");
+    if (!Rast3d_putDouble(map, x, y, z, *((double *)value))) {
+	Rast3d_error("Rast3d_putValue: error in Rast3d_putDouble");
 	return 0;
     }
     return 1;

lib/raster3d/range.c

@@ -14,7 +14,7 @@
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_range_updateFromTile(RASTER3D_Map * map, const void *tile, int rows, int cols,
+Rast3d_range_updateFromTile(RASTER3D_Map * map, const void *tile, int rows, int cols,
 			 int depths, int xRedundant, int yRedundant,
 			 int zRedundant, int nofNum, int type)
 {
@@ -22,7 +22,7 @@ G3d_range_updateFromTile(RASTER3D_Map * map, const void *tile, int rows, int col
     struct FPRange *range;
 
     range = &(map->range);
-    cellType = G3d_g3dType2cellType(type);
+    cellType = Rast3d_g3dType2cellType(type);
 
     if (nofNum == map->tileSize) {
 	Rast_row_update_fp_range(tile, map->tileSize, range, cellType);
@@ -33,13 +33,13 @@ G3d_range_updateFromTile(RASTER3D_Map * map, const void *tile, int rows, int col
 	for (z = 0; z < depths; z++) {
 	    for (y = 0; y < rows; y++) {
 		Rast_row_update_fp_range(tile, cols, range, cellType);
-		tile = G_incr_void_ptr(tile, map->tileX * G3d_length(type));
+		tile = G_incr_void_ptr(tile, map->tileX * Rast3d_length(type));
 	    }
 	    if (yRedundant)
 		tile =
 		    G_incr_void_ptr(tile,
 				    map->tileX * yRedundant *
-				    G3d_length(type));
+				    Rast3d_length(type));
 	}
 	return;
     }
@@ -47,7 +47,7 @@ G3d_range_updateFromTile(RASTER3D_Map * map, const void *tile, int rows, int col
     if (yRedundant) {
 	for (z = 0; z < depths; z++) {
 	    Rast_row_update_fp_range(tile, map->tileX * rows, range, cellType);
-	    tile = G_incr_void_ptr(tile, map->tileXY * G3d_length(type));
+	    tile = G_incr_void_ptr(tile, map->tileXY * Rast3d_length(type));
 	}
 	return;
     }
@@ -58,7 +58,7 @@ G3d_range_updateFromTile(RASTER3D_Map * map, const void *tile, int rows, int col
 /*---------------------------------------------------------------------------*/
 
 int
-G3d_readRange(const char *name, const char *mapset, struct FPRange *drange)
+Rast3d_readRange(const char *name, const char *mapset, struct FPRange *drange)
  /* adapted from Rast_read_fp_range */
 {
     int fd;
@@ -111,11 +111,11 @@ G3d_readRange(const char *name, const char *mapset, struct FPRange *drange)
  *          0 ... otherwise.
  */
 
-int G3d_range_load(RASTER3D_Map * map)
+int Rast3d_range_load(RASTER3D_Map * map)
 {
     if (map->operation == RASTER3D_WRITE_DATA)
 	return 1;
-    if (G3d_readRange(map->fileName, map->mapset, &(map->range)) == -1) {
+    if (Rast3d_readRange(map->fileName, map->mapset, &(map->range)) == -1) {
 	return 0;
     }
 
@@ -137,7 +137,7 @@ int G3d_range_load(RASTER3D_Map * map)
  *  \return void
  */
 
-void G3d_range_min_max(RASTER3D_Map * map, double *min, double *max)
+void Rast3d_range_min_max(RASTER3D_Map * map, double *min, double *max)
 {
     Rast_get_fp_range_min_max(&(map->range), min, max);
 }
@@ -198,15 +198,15 @@ static int writeRange(const char *name, struct FPRange *range)
  *          0 ... otherwise.
  */
 
-int G3d_range_write(RASTER3D_Map * map)
+int Rast3d_range_write(RASTER3D_Map * map)
 {
     char path[GPATH_MAX];
 
-    G3d_filename(path, RASTER3D_RANGE_ELEMENT, map->fileName, map->mapset);
+    Rast3d_filename(path, RASTER3D_RANGE_ELEMENT, map->fileName, map->mapset);
     remove(path);
 
     if (writeRange(map->fileName, &(map->range)) == -1) {
-	G3d_error("G3d_closeCellNew: error in writeRange");
+	Rast3d_error("Rast3d_closeCellNew: error in writeRange");
 	return 0;
     }
 
@@ -215,7 +215,7 @@ int G3d_range_write(RASTER3D_Map * map)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d_range_init(RASTER3D_Map * map)
+int Rast3d_range_init(RASTER3D_Map * map)
 {
     Rast_init_fp_range(&(map->range));
     return 0;

lib/raster3d/raster3d_intern.h

@@ -61,8 +61,8 @@ extern RASTER3D_Region g3d_window;
 
 /*---------------------------------------------------------------------------*/
 
-extern void G3d_fatalError(const char * /* msg */ , ...);
-extern void G3d_fatalError_noargs(const char * /* msg */ );
+extern void Rast3d_fatalError(const char * /* msg */ , ...);
+extern void Rast3d_fatalError_noargs(const char * /* msg */ );
 
 /*---------------------------------------------------------------------------*/
 

lib/raster3d/region.c

@@ -19,7 +19,7 @@
  *  \return void
  */
 
-void G3d_extract2dRegion(RASTER3D_Region * region3d, struct Cell_head *region2d)
+void Rast3d_extract2dRegion(RASTER3D_Region * region3d, struct Cell_head *region2d)
 {
     region2d->proj = region3d->proj;
     region2d->zone = region3d->zone;
@@ -46,7 +46,7 @@ void G3d_extract2dRegion(RASTER3D_Region * region3d, struct Cell_head *region2d)
  *  \return void
  */
 
-void G3d_regionToCellHead(RASTER3D_Region * region3d, struct Cell_head *region2d)
+void Rast3d_regionToCellHead(RASTER3D_Region * region3d, struct Cell_head *region2d)
 {
     region2d->proj = region3d->proj;
     region2d->zone = region3d->zone;
@@ -86,7 +86,7 @@ void G3d_regionToCellHead(RASTER3D_Region * region3d, struct Cell_head *region2d
  */
 
 void
-G3d_incorporate2dRegion(struct Cell_head *region2d, RASTER3D_Region * region3d)
+Rast3d_incorporate2dRegion(struct Cell_head *region2d, RASTER3D_Region * region3d)
 {
     region3d->proj = region2d->proj;
     region3d->zone = region2d->zone;
@@ -115,7 +115,7 @@ G3d_incorporate2dRegion(struct Cell_head *region2d, RASTER3D_Region * region3d)
  */
 
 void
-G3d_regionFromToCellHead(struct Cell_head *region2d, RASTER3D_Region * region3d)
+Rast3d_regionFromToCellHead(struct Cell_head *region2d, RASTER3D_Region * region3d)
 {
     region3d->proj = region2d->proj;
     region3d->zone = region2d->zone;
@@ -149,16 +149,16 @@ G3d_regionFromToCellHead(struct Cell_head *region2d, RASTER3D_Region * region3d)
  *  \return void
  */
 
-void G3d_adjustRegion(RASTER3D_Region * region)
+void Rast3d_adjustRegion(RASTER3D_Region * region)
 {
     struct Cell_head region2d;
 
-    G3d_regionToCellHead(region, &region2d);
+    Rast3d_regionToCellHead(region, &region2d);
     G_adjust_Cell_head3(&region2d, 1, 1, 1);
-    G3d_regionFromToCellHead(&region2d, region);
+    Rast3d_regionFromToCellHead(&region2d, region);
 
     if (region->depths <= 0)
-	G3d_fatalError("G3d_adjustRegion: depths <= 0");
+	Rast3d_fatalError("Rast3d_adjustRegion: depths <= 0");
     region->tb_res = (region->top - region->bottom) / region->depths;
 }
 
@@ -175,16 +175,16 @@ void G3d_adjustRegion(RASTER3D_Region * region)
  *  \return void
  */
 
-void G3d_adjustRegionRes(RASTER3D_Region * region)
+void Rast3d_adjustRegionRes(RASTER3D_Region * region)
 {
     struct Cell_head region2d;
 
-    G3d_regionToCellHead(region, &region2d);
+    Rast3d_regionToCellHead(region, &region2d);
     G_adjust_Cell_head3(&region2d, 1, 1, 1);
-    G3d_regionFromToCellHead(&region2d, region);
+    Rast3d_regionFromToCellHead(&region2d, region);
 
     if (region->tb_res <= 0)
-	G3d_fatalError("G3d_adjustRegionRes: tb_res <= 0");
+	Rast3d_fatalError("Rast3d_adjustRegionRes: tb_res <= 0");
 
     region->depths = (region->top - region->bottom + region->tb_res / 2.0) /
 	region->tb_res;
@@ -205,7 +205,7 @@ void G3d_adjustRegionRes(RASTER3D_Region * region)
  *  \return void
  */
 
-void G3d_regionCopy(RASTER3D_Region * regionDest, RASTER3D_Region * regionSrc)
+void Rast3d_regionCopy(RASTER3D_Region * regionDest, RASTER3D_Region * regionSrc)
 {
     *regionDest = *regionSrc;
 }
@@ -214,19 +214,19 @@ void G3d_regionCopy(RASTER3D_Region * regionDest, RASTER3D_Region * regionSrc)
 /*---------------------------------------------------------------------------*/
 
 int
-G3d_readRegionMap(const char *name, const char *mapset, RASTER3D_Region * region)
+Rast3d_readRegionMap(const char *name, const char *mapset, RASTER3D_Region * region)
 {
     char fullName[GPATH_MAX];
     char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
 
     if (G_name_is_fully_qualified(name, xname, xmapset))
-	G3d_filename(fullName, RASTER3D_HEADER_ELEMENT, xname, xmapset);
+	Rast3d_filename(fullName, RASTER3D_HEADER_ELEMENT, xname, xmapset);
     else {
 	if (!mapset || !*mapset)
 	    mapset = G_find_grid3(name, "");
-	G3d_filename(fullName, RASTER3D_HEADER_ELEMENT, name, mapset);
+	Rast3d_filename(fullName, RASTER3D_HEADER_ELEMENT, name, mapset);
     }
-    return G3d_readWindow(region, fullName);
+    return Rast3d_readWindow(region, fullName);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -245,7 +245,7 @@ G3d_readRegionMap(const char *name, const char *mapset, RASTER3D_Region * region
  *  \return int
  */
 
-int G3d_isValidLocation(RASTER3D_Region *region, double north, double east, double top)
+int Rast3d_isValidLocation(RASTER3D_Region *region, double north, double east, double top)
 {
     return ((north >= region->south) && (north <= region->north) &&
 	    (east >= region->west) && (east <= region->east) &&
@@ -272,7 +272,7 @@ int G3d_isValidLocation(RASTER3D_Region *region, double north, double east, doub
  */
 
 void
-G3d_location2coord(RASTER3D_Region *region, double north, double east, double top,
+Rast3d_location2coord(RASTER3D_Region *region, double north, double east, double top,
 		   int *x, int *y, int *z)
 {
     double col, row, depth;
@@ -289,7 +289,7 @@ G3d_location2coord(RASTER3D_Region *region, double north, double east, double to
     *y = region->rows - (int)row - 1;
     *z = (int)depth;
         
-    G_debug(4, "G3d_location2coord x %i y %i z %i\n", *x, *y, *z);
+    G_debug(4, "Rast3d_location2coord x %i y %i z %i\n", *x, *y, *z);
 }
 
 
@@ -298,7 +298,7 @@ G3d_location2coord(RASTER3D_Region *region, double north, double east, double to
  *
  *  Converts region-coordinates <em>(north, east,
  *  top)</em> into cell-coordinates <em>(x, y, z)</em>.
- *  This function calls G3d_fatalError in case location is not in window.
+ *  This function calls Rast3d_fatalError in case location is not in window.
  *
  *  \param map
  *  \param north
@@ -311,13 +311,13 @@ G3d_location2coord(RASTER3D_Region *region, double north, double east, double to
  */
 
 void
-G3d_location2coord2(RASTER3D_Region *region, double north, double east, double top,
+Rast3d_location2coord2(RASTER3D_Region *region, double north, double east, double top,
 		   int *x, int *y, int *z)
 {
-    if (!G3d_isValidLocation(region, north, east, top))
-	G3d_fatalError("G3d_location2coord2: location not in region");
+    if (!Rast3d_isValidLocation(region, north, east, top))
+	Rast3d_fatalError("Rast3d_location2coord2: location not in region");
 
-    G3d_location2coord(region, north, east, top, x, y, z);
+    Rast3d_location2coord(region, north, east, top, x, y, z);
 }
 
 /*!
@@ -354,11 +354,11 @@ G3d_location2coord2(RASTER3D_Region *region, double north, double east, double t
  */
 
 void
-G3d_coord2location(RASTER3D_Region * region, double x, double y, double z, double *north, double *east, double *top)
+Rast3d_coord2location(RASTER3D_Region * region, double x, double y, double z, double *north, double *east, double *top)
 {
     *north = region->north - y * region->ns_res;
     *east = region->west + x * region->ew_res;
     *top = region->bottom + z * region->tb_res; 
         
-    G_debug(4, "G3d_coord2location north %g east %g top %g\n", *north, *east, *top);
+    G_debug(4, "Rast3d_coord2location north %g east %g top %g\n", *north, *east, *top);
 }

lib/raster3d/resample.c

@@ -22,28 +22,28 @@
  */
 
 void
-G3d_nearestNeighbor(RASTER3D_Map * map, int x, int y, int z, void *value,
+Rast3d_nearestNeighbor(RASTER3D_Map * map, int x, int y, int z, void *value,
 		    int type)
 {
     double north, east, top;
     int row, col, depth;
 
     /* convert (x, y, z) window coordinates into (north, east, top) */
-    G3d_coord2location(&(map->window), (double)x + 0.5, (double)y + 0.5, (double)z + 0.5, &north, &east, &top);
+    Rast3d_coord2location(&(map->window), (double)x + 0.5, (double)y + 0.5, (double)z + 0.5, &north, &east, &top);
 
     /* convert (north, east, top) into map region coordinates (row, col, depth) */
-    G3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);
+    Rast3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);
 
     /* if (row, col, depth) outside map region return NULL value */
     if ((row < 0) || (row >= map->region.rows) ||
 	(col < 0) || (col >= map->region.cols) ||
 	(depth < 0) || (depth >= map->region.depths)) {
-	G3d_setNullValue(value, 1, type);
+	Rast3d_setNullValue(value, 1, type);
 	return;
     }
     
     /* Get the value from the map in map-region resolution */
-	G3d_getValueRegion(map, col, row, depth, value, type);
+	Rast3d_getValueRegion(map, col, row, depth, value, type);
 }
 
 /*--------------------------------------------------------------------------*/
@@ -53,13 +53,13 @@ G3d_nearestNeighbor(RASTER3D_Map * map, int x, int y, int z, void *value,
  * \brief 
  *
  * Sets the resampling function to be used by
- * G3d_getValue () (cf.{g3d:G3d.getValue}). This function is defined
+ * Rast3d_getValue () (cf.{g3d:G3d.getValue}). This function is defined
  * as follows:
  *
  *  \return void
  */
 
-void G3d_setResamplingFun(RASTER3D_Map * map, void (*resampleFun) ())
+void Rast3d_setResamplingFun(RASTER3D_Map * map, void (*resampleFun) ())
 {
     map->resampleFun = resampleFun;
 }
@@ -77,7 +77,7 @@ void G3d_setResamplingFun(RASTER3D_Map * map, void (*resampleFun) ())
  *  \return void
  */
 
-void G3d_getResamplingFun(RASTER3D_Map * map, void (**resampleFun) ())
+void Rast3d_getResamplingFun(RASTER3D_Map * map, void (**resampleFun) ())
 {
     *resampleFun = map->resampleFun;
 }
@@ -89,12 +89,12 @@ void G3d_getResamplingFun(RASTER3D_Map * map, void (**resampleFun) ())
  * \brief 
  *
  *  Returns
- * in <em>nnFunPtr</em> a pointer to G3d_nearestNeighbor () (cf.{g3d:G3d.nearestNeighbor}).
+ * in <em>nnFunPtr</em> a pointer to Rast3d_nearestNeighbor () (cf.{g3d:G3d.nearestNeighbor}).
  *
  *  \return void
  */
 
-void G3d_getNearestNeighborFunPtr(void (**nnFunPtr) ())
+void Rast3d_getNearestNeighborFunPtr(void (**nnFunPtr) ())
 {
-    *nnFunPtr = G3d_nearestNeighbor;
+    *nnFunPtr = Rast3d_nearestNeighbor;
 }

lib/raster3d/retile.c

@@ -16,45 +16,45 @@ retileNocache(void *map, const char *nameOut, int tileX, int tileY, int tileZ)
     int tileXsave, tileYsave, tileZsave;
     RASTER3D_Region region;
 
-    saveType = G3d_getFileType();
-    G3d_setFileType(G3d_fileTypeMap(map));
-    G3d_getTileDimension(&tileXsave, &tileYsave, &tileZsave);
-    G3d_setTileDimension(tileX, tileY, tileZ);
-    typeIntern = G3d_tileTypeMap(map);
-    G3d_getRegionStructMap(map, &region);
+    saveType = Rast3d_getFileType();
+    Rast3d_setFileType(Rast3d_fileTypeMap(map));
+    Rast3d_getTileDimension(&tileXsave, &tileYsave, &tileZsave);
+    Rast3d_setTileDimension(tileX, tileY, tileZ);
+    typeIntern = Rast3d_tileTypeMap(map);
+    Rast3d_getRegionStructMap(map, &region);
 
-    map2 = G3d_openCellNew(nameOut, typeIntern, RASTER3D_NO_CACHE, &region);
+    map2 = Rast3d_openCellNew(nameOut, typeIntern, RASTER3D_NO_CACHE, &region);
 
     if (map2 == NULL)
-	G3d_fatalError("G3d_retile: error in G3d_openCellNew");
+	Rast3d_fatalError("Rast3d_retile: error in Rast3d_openCellNew");
 
-    G3d_setFileType(saveType);
-    G3d_setTileDimension(tileXsave, tileYsave, tileZsave);
+    Rast3d_setFileType(saveType);
+    Rast3d_setTileDimension(tileXsave, tileYsave, tileZsave);
 
-    data = G3d_allocTiles(map2, 1);
+    data = Rast3d_allocTiles(map2, 1);
     if (data == NULL)
-	G3d_fatalError("G3d_retile: error in G3d_allocTiles");
+	Rast3d_fatalError("Rast3d_retile: error in Rast3d_allocTiles");
 
-    G3d_getNofTilesMap(map2, &nx, &ny, &nz);
+    Rast3d_getNofTilesMap(map2, &nx, &ny, &nz);
 
     for (z = 0; z < nz; z++) {
         G_percent(z, nz, 1);
 	for (y = 0; y < ny; y++)
 	    for (x = 0; x < nx; x++) {
-		G3d_getBlock(map, x * tileX, y * tileY, z * tileZ,
+		Rast3d_getBlock(map, x * tileX, y * tileY, z * tileZ,
 			     tileX, tileY, tileZ, data, typeIntern);
-		if (!G3d_writeTile
-		    (map2, G3d_tile2tileIndex(map2, x, y, z), data,
+		if (!Rast3d_writeTile
+		    (map2, Rast3d_tile2tileIndex(map2, x, y, z), data,
 		     typeIntern))
-		    G3d_fatalError
-			("G3d_retileNocache: error in G3d_writeTile");
+		    Rast3d_fatalError
+			("Rast3d_retileNocache: error in Rast3d_writeTile");
 	    }
     }
     
     G_percent(1, 1, 1);
         
-    G3d_freeTiles(data);
-    G3d_closeCell(map2);
+    Rast3d_freeTiles(data);
+    Rast3d_closeCell(map2);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -76,7 +76,7 @@ retileNocache(void *map, const char *nameOut, int tileX, int tileY, int tileZ)
  */
 
 void
-G3d_retile(void *map, const char *nameOut, int tileX, int tileY, int tileZ)
+Rast3d_retile(void *map, const char *nameOut, int tileX, int tileY, int tileZ)
 {
     void *map2;
     double value;
@@ -87,28 +87,28 @@ G3d_retile(void *map, const char *nameOut, int tileX, int tileY, int tileZ)
     int tileXsave, tileYsave, tileZsave;
     RASTER3D_Region region;
 
-    if (!G3d_tileUseCacheMap(map)) {
+    if (!Rast3d_tileUseCacheMap(map)) {
 	retileNocache(map, nameOut, tileX, tileY, tileZ);
 	return;
     }
 
-    saveType = G3d_getFileType();
-    G3d_setFileType(G3d_fileTypeMap(map));
-    G3d_getTileDimension(&tileXsave, &tileYsave, &tileZsave);
-    G3d_setTileDimension(tileX, tileY, tileZ);
+    saveType = Rast3d_getFileType();
+    Rast3d_setFileType(Rast3d_fileTypeMap(map));
+    Rast3d_getTileDimension(&tileXsave, &tileYsave, &tileZsave);
+    Rast3d_setTileDimension(tileX, tileY, tileZ);
 
-    typeIntern = G3d_tileTypeMap(map);
-    G3d_getRegionStructMap(map, &region);
+    typeIntern = Rast3d_tileTypeMap(map);
+    Rast3d_getRegionStructMap(map, &region);
 
     map2 =
-	G3d_openCellNew(nameOut, typeIntern, RASTER3D_USE_CACHE_DEFAULT, &region);
+	Rast3d_openCellNew(nameOut, typeIntern, RASTER3D_USE_CACHE_DEFAULT, &region);
     if (map2 == NULL)
-	G3d_fatalError("G3d_retile: error in G3d_openCellNew");
+	Rast3d_fatalError("Rast3d_retile: error in Rast3d_openCellNew");
 
-    G3d_setFileType(saveType);
-    G3d_setTileDimension(tileXsave, tileYsave, tileZsave);
+    Rast3d_setFileType(saveType);
+    Rast3d_setTileDimension(tileXsave, tileYsave, tileZsave);
 
-    G3d_coord2tileCoord(map2, 0, 0, 0,
+    Rast3d_coord2tileCoord(map2, 0, 0, 0,
 			&xTile, &yTile, &zTile, &xOffs, &yOffs, &zOffs);
 
     prev = zTile;
@@ -116,30 +116,30 @@ G3d_retile(void *map, const char *nameOut, int tileX, int tileY, int tileZ)
     x = 0;
     y = 0;
 
-    G3d_getCoordsMap(map, &rows, &cols, &depths);
+    Rast3d_getCoordsMap(map, &rows, &cols, &depths);
 
     for (z = 0; z < depths; z++) {
         G_percent(z, depths, 1);
-	G3d_coord2tileCoord(map2, x, y, z, &xTile, &yTile, &zTile,
+	Rast3d_coord2tileCoord(map2, x, y, z, &xTile, &yTile, &zTile,
 			    &xOffs, &yOffs, &zOffs);
 	if (zTile > prev) {
-	    if (!G3d_flushAllTiles(map2))
-		G3d_fatalError("G3d_retile: error in G3d_flushAllTiles");
+	    if (!Rast3d_flushAllTiles(map2))
+		Rast3d_fatalError("Rast3d_retile: error in Rast3d_flushAllTiles");
 	    prev++;
 	}
 
 	for (y = 0; y < rows; y++)
 	    for (x = 0; x < cols; x++) {
 
-		G3d_getValueRegion(map, x, y, z, &value, typeIntern);
-		if (!G3d_putValue(map2, x, y, z, &value, typeIntern))
-		    G3d_fatalError("G3d_retile: error in G3d_putValue");
+		Rast3d_getValueRegion(map, x, y, z, &value, typeIntern);
+		if (!Rast3d_putValue(map2, x, y, z, &value, typeIntern))
+		    Rast3d_fatalError("Rast3d_retile: error in Rast3d_putValue");
 	    }
     }
 
     G_percent(1, 1, 1);
-    if (!G3d_flushAllTiles(map2))
-	G3d_fatalError("G3d_retile: error in G3d_flushAllTiles");
-    if (!G3d_closeCell(map2))
-	G3d_fatalError("G3d_retile: error in G3d_closeCell");
+    if (!Rast3d_flushAllTiles(map2))
+	Rast3d_fatalError("Rast3d_retile: error in Rast3d_flushAllTiles");
+    if (!Rast3d_closeCell(map2))
+	Rast3d_fatalError("Rast3d_retile: error in Rast3d_closeCell");
 }

lib/raster3d/rle.c

@@ -126,7 +126,7 @@ int G_rle_count_only(char *src, int nofElts, int eltLength)
     char *head, *tail, *headStop, *headStop2;
 
     if (nofElts <= 0)
-	G3d_fatalError("trying to encode 0-length list");
+	Rast3d_fatalError("trying to encode 0-length list");
 
     length = 0;
     nofEqual = 1;
@@ -169,7 +169,7 @@ void G_rle_encode(char *src, char *dst, int nofElts, int eltLength)
     char *head, *tail, *headStop, *headStop2;
 
     if (nofElts <= 0)
-	G3d_fatalError("trying to encode 0-length list");
+	Rast3d_fatalError("trying to encode 0-length list");
 
     length = 0;
     nofEqual = 1;
@@ -247,7 +247,7 @@ G_rle_decode(char *src, char *dst, int nofElts, int eltLength,
 	src += eltLength;
     }
 
-    G3d_fatalError("G_rle_decode: string ends prematurely");
+    Rast3d_fatalError("G_rle_decode: string ends prematurely");
 }
 
 /*---------------------------------------------------------------------------*/

lib/raster3d/test/test_coordinate_transform.c

@@ -41,8 +41,8 @@ int test_coordinate_transform(void)
     
     /* We need to set up a specific region for the new g3d map.
      * First we safe the default region. */
-    G3d_getWindow(&default_region);
-    G3d_regionCopy(&region, &default_region);
+    Rast3d_getWindow(&default_region);
+    Rast3d_regionCopy(&region, &default_region);
     
     region.bottom = 0.0;
     region.top = 1000;
@@ -54,12 +54,12 @@ int test_coordinate_transform(void)
     region.cols = 10;
     region.depths = 5;
         
-    G3d_adjustRegion(&region);
+    Rast3d_adjustRegion(&region);
     
-    map = G3d_openNewOptTileSize("test_coordinate_transform", RASTER3D_USE_CACHE_XYZ, &region, FCELL_TYPE, 32);
+    map = Rast3d_openNewOptTileSize("test_coordinate_transform", RASTER3D_USE_CACHE_XYZ, &region, FCELL_TYPE, 32);
         
     /* The window is the same as the map region ... of course */
-    G3d_setWindowMap(map, &region);
+    Rast3d_setWindowMap(map, &region);
     
     G_message("Test the upper right corner, coordinates must be col = 9, row = 0, depth = 4");
     
@@ -83,10 +83,10 @@ int test_coordinate_transform(void)
     east=  9999.9;
     top =  999.9;
         
-    G3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);    
-    printf("G3d_location2coord col %i row %i depth %i\n", col, row, depth);
+    Rast3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);    
+    printf("Rast3d_location2coord col %i row %i depth %i\n", col, row, depth);
     if(region.cols - 1 != col || 0 != row || region.depths - 1 != depth) {
-        G_message("Error in G3d_location2coord");
+        G_message("Error in Rast3d_location2coord");
         sum++;
     }
     
@@ -96,10 +96,10 @@ int test_coordinate_transform(void)
     east= 5000.0;
     top = 0.0;
         
-    G3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);    
-    printf("G3d_location2coord col %i row %i depth %i\n", col, row, depth);
+    Rast3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);    
+    printf("Rast3d_location2coord col %i row %i depth %i\n", col, row, depth);
     if(0 != col || 14 != row || 0 != depth) {
-        G_message("Error in G3d_location2coord");
+        G_message("Error in Rast3d_location2coord");
         sum++;
     }
     
@@ -110,10 +110,10 @@ int test_coordinate_transform(void)
     east= 7499.9;
     top = 500.0;
         
-    G3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);    
-    printf("G3d_location2coord col %i row %i depth %i\n", col, row, depth);
+    Rast3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);    
+    printf("Rast3d_location2coord col %i row %i depth %i\n", col, row, depth);
     if((region.cols - 1)/2 != col || (region.rows - 1)/2 != row || (region.depths - 1)/2 != depth) {
-        G_message("Error in G3d_location2coord");
+        G_message("Error in Rast3d_location2coord");
         sum++;
     }
     
@@ -123,10 +123,10 @@ int test_coordinate_transform(void)
     east= 7000.1;
     top = 800.1;
         
-    G3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);    
-    printf("G3d_location2coord col %i row %i depth %i\n", col, row, depth);
+    Rast3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);    
+    printf("Rast3d_location2coord col %i row %i depth %i\n", col, row, depth);
     if(4 != col || map->region.rows - 5 != row || 4 != depth) {
-        G_message("Error in G3d_location2coord");
+        G_message("Error in Rast3d_location2coord");
         sum++;
     }
     
@@ -136,14 +136,14 @@ int test_coordinate_transform(void)
     east= 6999.9;
     top = 799.9;
         
-    G3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);    
-    printf("G3d_location2coord col %i row %i depth %i\n", col, row, depth);
+    Rast3d_location2coord(&(map->region), north, east, top, &col, &row, &depth);    
+    printf("Rast3d_location2coord col %i row %i depth %i\n", col, row, depth);
     if(3 != col || map->region.rows - 4 != row || 3 != depth) {
-        G_message("Error in G3d_location2coord");
+        G_message("Error in Rast3d_location2coord");
         sum++;
     }
     
-    G3d_closeCell(map);
+    Rast3d_closeCell(map);
     
     G_remove("grid3", "test_coordinate_transform");
     
@@ -157,7 +157,7 @@ int test_region(void)
     int sum = 0;
     RASTER3D_Region region, new_region;
     
-    G3d_getWindow(&region);
+    Rast3d_getWindow(&region);
     region.bottom = 0.0;
     region.top = 1000;
     region.south = 10000;
@@ -172,93 +172,93 @@ int test_region(void)
     region.tb_res = 0;
         
     /* Test region adjustment */
-    G3d_adjustRegion(&region);
+    Rast3d_adjustRegion(&region);
     
     if(region.ew_res != 500) {
-        G_message("Error in G3d_adjustRegion: region.ew_res != 500");
+        G_message("Error in Rast3d_adjustRegion: region.ew_res != 500");
         sum++;
     }
     
     if(region.ns_res != 500) {
-        G_message("Error in G3d_adjustRegion: region.ew_res != 500");
+        G_message("Error in Rast3d_adjustRegion: region.ew_res != 500");
         sum++;
     }
     
     if(region.tb_res != 200) {
-        G_message("Error in G3d_adjustRegion: region.ew_res != 500");
+        G_message("Error in Rast3d_adjustRegion: region.ew_res != 500");
         sum++;
     }
     
     /* Test the region copy */
-    G3d_regionCopy(&new_region, &region);
+    Rast3d_regionCopy(&new_region, &region);
         
     if(region.bottom != new_region.bottom) {
-        G_message("Error in G3d_regionCopy: region.bottom != new_region.bottom");
+        G_message("Error in Rast3d_regionCopy: region.bottom != new_region.bottom");
         sum++;
     }
     
     if(region.cols != new_region.cols) {
-        G_message("Error in G3d_regionCopy: region.cols != new_region.cols");
+        G_message("Error in Rast3d_regionCopy: region.cols != new_region.cols");
         sum++;
     }
     
     if(region.depths != new_region.depths) {
-        G_message("Error in G3d_regionCopy: region.depths != new_region.depths");
+        G_message("Error in Rast3d_regionCopy: region.depths != new_region.depths");
         sum++;
     }
     
     if(region.east != new_region.east) {
-        G_message("Error in G3d_regionCopy: region.east != new_region.east");
+        G_message("Error in Rast3d_regionCopy: region.east != new_region.east");
         sum++;
     }
     
     if(region.ew_res != new_region.ew_res) {
-        G_message("Error in G3d_regionCopy: region.ew_res != new_region.ew_res");
+        G_message("Error in Rast3d_regionCopy: region.ew_res != new_region.ew_res");
         sum++;
     }
     
     if(region.north != new_region.north) {
-        G_message("Error in G3d_regionCopy: region.north != new_region.north");
+        G_message("Error in Rast3d_regionCopy: region.north != new_region.north");
         sum++;
     }
     
     if(region.ns_res != new_region.ns_res) {
-        G_message("Error in G3d_regionCopy: region.ns_res != new_region.ns_res");
+        G_message("Error in Rast3d_regionCopy: region.ns_res != new_region.ns_res");
         sum++;
     }
     
     if(region.proj != new_region.proj) {
-        G_message("Error in G3d_regionCopy: region.proj != new_region.proj");
+        G_message("Error in Rast3d_regionCopy: region.proj != new_region.proj");
         sum++;
     }
     
     if(region.rows != new_region.rows) {
-        G_message("Error in G3d_regionCopy: region.rows != new_region.rows");
+        G_message("Error in Rast3d_regionCopy: region.rows != new_region.rows");
         sum++;
     }
     
     if(region.south != new_region.south) {
-        G_message("Error in G3d_regionCopy: region.south != new_region.south");
+        G_message("Error in Rast3d_regionCopy: region.south != new_region.south");
         sum++;
     }
     
     if(region.tb_res != new_region.tb_res) {
-        G_message("Error in G3d_regionCopy: region.tb_res != new_region.tb_res");
+        G_message("Error in Rast3d_regionCopy: region.tb_res != new_region.tb_res");
         sum++;
     }
     
     if(region.top != new_region.top) {
-        G_message("Error in G3d_regionCopy: region.top != new_region.top");
+        G_message("Error in Rast3d_regionCopy: region.top != new_region.top");
         sum++;
     }
     
     if(region.west != new_region.west) {
-        G_message("Error in G3d_regionCopy: region.west != new_region.west");
+        G_message("Error in Rast3d_regionCopy: region.west != new_region.west");
         sum++;
     }
     
     if(region.zone != new_region.zone) {
-        G_message("Error in G3d_regionCopy: region.zone != new_region.zone");
+        G_message("Error in Rast3d_regionCopy: region.zone != new_region.zone");
         sum++;
     }    
     

lib/raster3d/test/test_main.c

@@ -85,7 +85,7 @@ int main(int argc, char *argv[]) {
         exit(EXIT_FAILURE);
     
     /* Initiate the defaults for testing */
-    G3d_initDefaults();
+    Rast3d_initDefaults();
 
     /*Run the unit tests */
     if (param.testunit->answer || param.full->answer) {

lib/raster3d/test/test_put_get_value.c

@@ -68,7 +68,7 @@ int test_put_get_value_dcell(void)
     
     /* We need to set up a specific region for the new g3d map.
      * First we safe the default region. */
-    G3d_getWindow(&region);
+    Rast3d_getWindow(&region);
     
     region.bottom = 0.0;
     region.top = 1000;
@@ -80,12 +80,12 @@ int test_put_get_value_dcell(void)
     region.cols = 10;
     region.depths = 5;
         
-    G3d_adjustRegion(&region);
+    Rast3d_adjustRegion(&region);
         
-    map = G3d_openNewOptTileSize("test_put_get_value_dcell", RASTER3D_USE_CACHE_XY, &region, DCELL_TYPE, 32);
+    map = Rast3d_openNewOptTileSize("test_put_get_value_dcell", RASTER3D_USE_CACHE_XY, &region, DCELL_TYPE, 32);
     
     /* The window is the same as the map region ... of course */
-    G3d_setWindowMap(map, &region);
+    Rast3d_setWindowMap(map, &region);
     /*
      ROWS
   1000 1500 2000 2500 3000 3500 4000 4500 5000 5500 6500 7000 7500 8000 8500 9000 north
@@ -108,12 +108,12 @@ int test_put_get_value_dcell(void)
             for(x = 0; x < region.cols; x++) {
                 /* Add cols, rows and depths and put this in the map */
                 value = x + y + z;
-                G3d_putValue(map, x, y, z, &value, DCELL_TYPE);
+                Rast3d_putValue(map, x, y, z, &value, DCELL_TYPE);
             }
         }
     }
     /* Write everything to the disk */
-    G3d_flushAllTiles(map);
+    Rast3d_flushAllTiles(map);
     
     /* Reread the map and compare the expected results */
     
@@ -168,21 +168,21 @@ int test_put_get_value_dcell(void)
     east = region.west + region.ew_res * col;
     top = region.bottom + region.tb_res * depth;
     
-    G3d_getRegionValue(map, north, east, top, &value, DCELL_TYPE);
-    G3d_getValue(map, col, row, depth, &value_ref, DCELL_TYPE);
-    /* G3d_getValueRegion does not work with coordinates outside the region */
+    Rast3d_getRegionValue(map, north, east, top, &value, DCELL_TYPE);
+    Rast3d_getValue(map, col, row, depth, &value_ref, DCELL_TYPE);
+    /* Rast3d_getValueRegion does not work with coordinates outside the region */
     printf("Value %g == %g\n", value, value_ref);
     
     if(value == 0 || value < 0 || value > 0) {
-        G_message("Error in G3d_getRegionValue");
+        G_message("Error in Rast3d_getRegionValue");
         sum++;
     }
     if(value_ref == 0 || value_ref < 0 || value_ref > 0) {
-        G_message("Error in G3d_getValue");
+        G_message("Error in Rast3d_getValue");
         sum++;
     }
     
-    G3d_closeCell(map);
+    Rast3d_closeCell(map);
     
     G_remove("grid3", "test_put_get_value_dcell");
     
@@ -208,7 +208,7 @@ int test_put_get_value_fcell(void)
     
     /* We need to set up a specific region for the new g3d map.
      * First we safe the default region. */
-    G3d_getWindow(&region);
+    Rast3d_getWindow(&region);
     
     region.bottom = 0.0;
     region.top = 1000;
@@ -220,24 +220,24 @@ int test_put_get_value_fcell(void)
     region.cols = 10;
     region.depths = 5;
         
-    G3d_adjustRegion(&region);
+    Rast3d_adjustRegion(&region);
         
-    map = G3d_openNewOptTileSize("test_put_get_value_dcell", RASTER3D_USE_CACHE_XY, &region, FCELL_TYPE, 32);
+    map = Rast3d_openNewOptTileSize("test_put_get_value_dcell", RASTER3D_USE_CACHE_XY, &region, FCELL_TYPE, 32);
     
     /* The window is the same as the map region ... of course */
-    G3d_setWindowMap(map, &region);
+    Rast3d_setWindowMap(map, &region);
     
     for(z = 0; z < region.depths; z++) {
         for(y = 0; y < region.rows; y++) {
             for(x = 0; x < region.cols; x++) {
                 /* Add cols, rows and depths and put this in the map */
                 value = x + y + z;
-                G3d_putValue(map, x, y, z, &value, FCELL_TYPE);
+                Rast3d_putValue(map, x, y, z, &value, FCELL_TYPE);
             }
         }
     }
     /* Write everything to the disk */
-    G3d_flushAllTiles(map);
+    Rast3d_flushAllTiles(map);
     
        /* Reread the map and compare the expected results */
     
@@ -290,21 +290,21 @@ int test_put_get_value_fcell(void)
     east = region.west + region.ew_res * col;
     top = region.bottom + region.tb_res * depth;
     
-    G3d_getRegionValue(map, north, east, top, &value, FCELL_TYPE);
-    G3d_getValue(map, 10, 15, 5, &value_ref, FCELL_TYPE);
-    /* G3d_getValueRegion does not work with coordinates outside the region */
+    Rast3d_getRegionValue(map, north, east, top, &value, FCELL_TYPE);
+    Rast3d_getValue(map, 10, 15, 5, &value_ref, FCELL_TYPE);
+    /* Rast3d_getValueRegion does not work with coordinates outside the region */
     printf("Value %g == %g\n", value, value_ref);
     
     if(value == 0 || value < 0 || value > 0) {
-        G_message("Error in G3d_getRegionValue");
+        G_message("Error in Rast3d_getRegionValue");
         sum++;
     }
     if(value_ref == 0 || value_ref < 0 || value_ref > 0) {
-        G_message("Error in G3d_getValue");
+        G_message("Error in Rast3d_getValue");
         sum++;
     }
     
-    G3d_closeCell(map);
+    Rast3d_closeCell(map);
     
     G_remove("grid3", "test_put_get_value_fcell");
     
@@ -330,7 +330,7 @@ int test_put_get_value_resampling(void)
     
     /* We need to set up a specific region for the new g3d map.
      * First we safe the default region. */
-    G3d_getWindow(&region);
+    Rast3d_getWindow(&region);
     
     region.bottom = 0.0;
     region.top = 1000;
@@ -342,22 +342,22 @@ int test_put_get_value_resampling(void)
     region.cols = 10;
     region.depths = 5;
         
-    G3d_adjustRegion(&region);
+    Rast3d_adjustRegion(&region);
     
-    map = G3d_openNewOptTileSize("test_put_get_value_resample", RASTER3D_USE_CACHE_XY, &region, DCELL_TYPE, 32);
+    map = Rast3d_openNewOptTileSize("test_put_get_value_resample", RASTER3D_USE_CACHE_XY, &region, DCELL_TYPE, 32);
     
     /* We modify the window for resampling tests */
-    G3d_regionCopy(&window, &region);
+    Rast3d_regionCopy(&window, &region);
         
     /* Double the cols, rows and depths -> 8x resolution window */
     window.rows = 30;
     window.cols = 20;
     window.depths = 10;
     
-    G3d_adjustRegion(&window);
+    Rast3d_adjustRegion(&window);
     
     /* The window is the same as the map region ... of course */
-    G3d_setWindowMap(map, &window);
+    Rast3d_setWindowMap(map, &window);
     /*
      ROWS
   1000 1500 2000 2500 3000 3500 4000 4500 5000 5500 6500 7000 7500 8000 8500 9000 north
@@ -385,12 +385,12 @@ int test_put_get_value_resampling(void)
             for(x = 0; x < region.cols; x++) {
                 /* Add cols, rows and depths and put this in the map */
                 value = x + y + z;
-                G3d_putDouble(map, x, y, z, value);
+                Rast3d_putDouble(map, x, y, z, value);
             }
         }
     }
     /* Write everything to the disk */
-    G3d_flushAllTiles(map);
+    Rast3d_flushAllTiles(map);
     
     /* Reread the map and compare the expected results */
     
@@ -435,7 +435,7 @@ int test_put_get_value_resampling(void)
     
     sum += test_resampling_dcell(map, north, east, top, col, row, depth, 2);
     
-    G3d_closeCell(map);
+    Rast3d_closeCell(map);
     
     G_remove("grid3", "test_put_get_value_dcell");
     
@@ -452,26 +452,26 @@ int test_resampling_dcell(RASTER3D_Map *map, double north, double east, double t
     DCELL value_reg;
     DCELL value_win;
     
-    G3d_getRegionValue(map, north, east, top, &value, DCELL_TYPE);
-    G3d_getWindowValue(map, north, east, top, &value_win, DCELL_TYPE);
-    G3d_getValue(map, col * fact, row * fact, depth * fact, &value_ref, DCELL_TYPE);
-    G3d_getValueRegion(map, col, row, depth, &value_reg, DCELL_TYPE);
+    Rast3d_getRegionValue(map, north, east, top, &value, DCELL_TYPE);
+    Rast3d_getWindowValue(map, north, east, top, &value_win, DCELL_TYPE);
+    Rast3d_getValue(map, col * fact, row * fact, depth * fact, &value_ref, DCELL_TYPE);
+    Rast3d_getValueRegion(map, col, row, depth, &value_reg, DCELL_TYPE);
     printf("Value %g == %g == %g == %g\n", value, value_win, value_ref, value_reg);
     
     if(value != col + row + depth) {
-        G_message("Error in G3d_getRegionValue");
+        G_message("Error in Rast3d_getRegionValue");
         sum++;
     }
     if(value != col + row + depth) {
-        G_message("Error in G3d_getWindowValue");
+        G_message("Error in Rast3d_getWindowValue");
         sum++;
     }
     if(value != col + row + depth) {
-        G_message("Error in G3d_getValue");
+        G_message("Error in Rast3d_getValue");
         sum++;
     }
     if(value != col + row + depth) {
-        G_message("Error in G3d_getValueRegion");
+        G_message("Error in Rast3d_getValueRegion");
         sum++;
     }
     
@@ -488,26 +488,26 @@ int test_resampling_fcell(RASTER3D_Map *map, double north, double east, double t
     FCELL value_reg;
     FCELL value_win;
     
-    G3d_getRegionValue(map, north, east, top, &value, FCELL_TYPE);
-    G3d_getWindowValue(map, north, east, top, &value_win, FCELL_TYPE);
-    G3d_getValue(map, col * fact, row * fact, depth * fact, &value_ref, FCELL_TYPE);
-    G3d_getValueRegion(map, col, row, depth, &value_reg, FCELL_TYPE);
+    Rast3d_getRegionValue(map, north, east, top, &value, FCELL_TYPE);
+    Rast3d_getWindowValue(map, north, east, top, &value_win, FCELL_TYPE);
+    Rast3d_getValue(map, col * fact, row * fact, depth * fact, &value_ref, FCELL_TYPE);
+    Rast3d_getValueRegion(map, col, row, depth, &value_reg, FCELL_TYPE);
     printf("Value %g == %g == %g == %g\n", value, value_win, value_ref, value_reg);
     
     if(value != col + row + depth) {
-        G_message("Error in G3d_getRegionValue");
+        G_message("Error in Rast3d_getRegionValue");
         sum++;
     }
     if(value != col + row + depth) {
-        G_message("Error in G3d_getWindowValue");
+        G_message("Error in Rast3d_getWindowValue");
         sum++;
     }
     if(value != col + row + depth) {
-        G_message("Error in G3d_getValue");
+        G_message("Error in Rast3d_getValue");
         sum++;
     }
     if(value != col + row + depth) {
-        G_message("Error in G3d_getValueRegion");
+        G_message("Error in Rast3d_getValueRegion");
         sum++;
     }
     

lib/raster3d/tilealloc.c

@@ -23,13 +23,13 @@
  *                   NULL ... otherwise.
  */
 
-void *G3d_allocTilesType(RASTER3D_Map * map, int nofTiles, int type)
+void *Rast3d_allocTilesType(RASTER3D_Map * map, int nofTiles, int type)
 {
     void *tiles;
 
-    tiles = G3d_malloc(map->tileSize * G3d_length(type) * nofTiles);
+    tiles = Rast3d_malloc(map->tileSize * Rast3d_length(type) * nofTiles);
     if (tiles == NULL) {
-	G3d_error("G3d_allocTilesType: error in G3d_malloc");
+	Rast3d_error("Rast3d_allocTilesType: error in Rast3d_malloc");
 	return NULL;
     }
 
@@ -42,20 +42,20 @@ void *G3d_allocTilesType(RASTER3D_Map * map, int nofTiles, int type)
 /*!
  * \brief 
  *
- *  Is equivalent to G3d_allocTilesType (map, nofTiles, G3d_fileTypeMap (map)).
+ *  Is equivalent to Rast3d_allocTilesType (map, nofTiles, Rast3d_fileTypeMap (map)).
  *
  *  \param map
  *  \param nofTiles
  *  \return void * 
  */
 
-void *G3d_allocTiles(RASTER3D_Map * map, int nofTiles)
+void *Rast3d_allocTiles(RASTER3D_Map * map, int nofTiles)
 {
     void *tiles;
 
-    tiles = G3d_allocTilesType(map, nofTiles, map->typeIntern);
+    tiles = Rast3d_allocTilesType(map, nofTiles, map->typeIntern);
     if (tiles == NULL) {
-	G3d_error("G3d_allocTiles: error in G3d_allocTilesType");
+	Rast3d_error("Rast3d_allocTiles: error in Rast3d_allocTilesType");
 	return NULL;
     }
 
@@ -68,13 +68,13 @@ void *G3d_allocTiles(RASTER3D_Map * map, int nofTiles)
 /*!
  * \brief 
  *
- *  Is equivalent to <tt>G3d_free (tiles);</tt>
+ *  Is equivalent to <tt>Rast3d_free (tiles);</tt>
  *
  *  \param tiles
  *  \return void
  */
 
-void G3d_freeTiles(void *tiles)
+void Rast3d_freeTiles(void *tiles)
 {
-    G3d_free(tiles);
+    Rast3d_free(tiles);
 }

lib/raster3d/tileio.c

@@ -29,7 +29,7 @@
  * is read from file and stored in the buffer provided by the map structure.
  * The pointer to this buffer is returned. If the buffer already contains the
  * tile with <em>tileIndex</em> reading is skipped. Data which was stored in
- * earlier calls to <tt>G3d_getTilePtr</tt> is destroyed.  If the tile with <em>tileIndex</em> is not stored on the file corresponding to <em>map</em>, and <em>tileIndex</em> is a valid index the buffer is filled with NULL-values.<br>
+ * earlier calls to <tt>Rast3d_getTilePtr</tt> is destroyed.  If the tile with <em>tileIndex</em> is not stored on the file corresponding to <em>map</em>, and <em>tileIndex</em> is a valid index the buffer is filled with NULL-values.<br>
  * If <em>map</em> is old and the cache is used the tile with <em>tileIndex</em> is
  * read from file and stored in one of the cache buffers.  The pointer to buffer
  * is returned.  If no free cache buffer is available an unlocked cache-buffer
@@ -42,8 +42,8 @@
  * as if <em>map</em> is old and the cache is not used.  If the tile with <em>tileIndex</em> 
  * is already stored on file, it is read into the buffer, if not,
  * the cells are set to null-values.  If the buffer corresponding to the pointer
- * is used for writing, subsequent calls to <tt>G3d_getTilePtr</tt> may destroy the
- * values already stored in the buffer.  Use <tt>G3d_flushTile</tt> to write the buffer
+ * is used for writing, subsequent calls to <tt>Rast3d_getTilePtr</tt> may destroy the
+ * values already stored in the buffer.  Use <tt>Rast3d_flushTile</tt> to write the buffer
  * to the file before reusing it for a different index.  The use of this buffer
  * as write buffer is discouraged.<br>
  * If <em>map</em> is new and the cache is used the functionality is the same as if
@@ -59,8 +59,8 @@
  * Care has to be taken if this function is used in non-cache mode since it is
  * implicitly invoked every time a read or write request is issued.  The only
  * I/O-functions for which it is safe to assume that they do not invoke
- * <tt>G3d_getTilePtr</tt> are <tt>G3d_readTile()</tt> and
- * <tt>G3d_writeTile()</tt> and their corresponding type-specific versions.
+ * <tt>Rast3d_getTilePtr</tt> are <tt>Rast3d_readTile()</tt> and
+ * <tt>Rast3d_writeTile()</tt> and their corresponding type-specific versions.
  *
  *  \param map
  *  \param tileIndex
@@ -68,19 +68,19 @@
  *                 NULL ... otherwise.
  */
 
-void *G3d_getTilePtr(RASTER3D_Map * map, int tileIndex)
+void *Rast3d_getTilePtr(RASTER3D_Map * map, int tileIndex)
 {
     void *ptr;
 
     if ((tileIndex >= map->nTiles) || (tileIndex < 0)) {
-	G3d_error("G3d_getTilePtr: tileIndex out of range");
+	Rast3d_error("Rast3d_getTilePtr: tileIndex out of range");
 	return NULL;
     }
 
     if (map->useCache) {
-	ptr = G3d_cache_elt_ptr(map->cache, tileIndex);
+	ptr = Rast3d_cache_elt_ptr(map->cache, tileIndex);
 	if (ptr == NULL) {
-	    G3d_error("G3d_getTilePtr: error in G3d_cache_elt_ptr");
+	    Rast3d_error("Rast3d_getTilePtr: error in Rast3d_cache_elt_ptr");
 	    return NULL;
 	}
 	return ptr;
@@ -90,8 +90,8 @@ void *G3d_getTilePtr(RASTER3D_Map * map, int tileIndex)
 	return map->data;
 
     map->currentIndex = tileIndex;
-    if (!G3d_readTile(map, map->currentIndex, map->data, map->typeIntern)) {
-	G3d_error("G3d_getTilePtr: error in G3d_readTile");
+    if (!Rast3d_readTile(map, map->currentIndex, map->data, map->typeIntern)) {
+	Rast3d_error("Rast3d_getTilePtr: error in Rast3d_readTile");
 	return NULL;
     }
 
@@ -104,7 +104,7 @@ void *G3d_getTilePtr(RASTER3D_Map * map, int tileIndex)
 /*!
  * \brief 
  *
- * Same functionality as <tt>G3d_getTilePtr()</tt> but does not return the pointer.
+ * Same functionality as <tt>Rast3d_getTilePtr()</tt> but does not return the pointer.
  *
  *  \param map
  *  \param tileIndex
@@ -112,10 +112,10 @@ void *G3d_getTilePtr(RASTER3D_Map * map, int tileIndex)
  *          0 ... otherwise.
  */
 
-int G3d_tileLoad(RASTER3D_Map * map, int tileIndex)
+int Rast3d_tileLoad(RASTER3D_Map * map, int tileIndex)
 {
-    if (G3d_getTilePtr(map, tileIndex) == NULL) {
-	G3d_error("G3d_tileLoad: error in G3d_getTilePtr");
+    if (Rast3d_getTilePtr(map, tileIndex) == NULL) {
+	Rast3d_error("Rast3d_tileLoad: error in Rast3d_getTilePtr");
 	return 0;
     }
 
@@ -124,13 +124,13 @@ int G3d_tileLoad(RASTER3D_Map * map, int tileIndex)
 
 /*---------------------------------------------------------------------------*/
 
-int G3d__removeTile(RASTER3D_Map * map, int tileIndex)
+int Rast3d__removeTile(RASTER3D_Map * map, int tileIndex)
 {
     if (!map->useCache)
 	return 1;
 
-    if (!G3d_cache_remove_elt(map->cache, tileIndex)) {
-	G3d_error("G3d_removeTile: error in G3d_cache_remove_elt");
+    if (!Rast3d_cache_remove_elt(map->cache, tileIndex)) {
+	Rast3d_error("Rast3d_removeTile: error in Rast3d_cache_remove_elt");
 	return 0;
     }
 

lib/raster3d/tilemath.c

@@ -22,7 +22,7 @@
  */
 
 void
-G3d_tileIndex2tile(RASTER3D_Map * map, int tileIndex, int *xTile, int *yTile,
+Rast3d_tileIndex2tile(RASTER3D_Map * map, int tileIndex, int *xTile, int *yTile,
 		   int *zTile)
 {
     int tileIndex2d;
@@ -49,7 +49,7 @@ G3d_tileIndex2tile(RASTER3D_Map * map, int tileIndex, int *xTile, int *yTile,
  *  \return int
  */
 
-int G3d_tile2tileIndex(RASTER3D_Map * map, int xTile, int yTile, int zTile)
+int Rast3d_tile2tileIndex(RASTER3D_Map * map, int xTile, int yTile, int zTile)
 {
     return map->nxy * zTile + map->nx * yTile + xTile;
 }
@@ -75,7 +75,7 @@ int G3d_tile2tileIndex(RASTER3D_Map * map, int xTile, int yTile, int zTile)
  */
 
 void
-G3d_tileCoordOrigin(RASTER3D_Map * map, int xTile, int yTile, int zTile, int *x,
+Rast3d_tileCoordOrigin(RASTER3D_Map * map, int xTile, int yTile, int zTile, int *x,
 		    int *y, int *z)
 {
     *x = map->tileX * xTile;
@@ -100,12 +100,12 @@ G3d_tileCoordOrigin(RASTER3D_Map * map, int xTile, int yTile, int zTile, int *x,
  *  \return void
  */
 
-void G3d_tileIndexOrigin(RASTER3D_Map * map, int tileIndex, int *x, int *y, int *z)
+void Rast3d_tileIndexOrigin(RASTER3D_Map * map, int tileIndex, int *x, int *y, int *z)
 {
     int xTile, yTile, zTile;
 
-    G3d_tileIndex2tile(map, tileIndex, &xTile, &yTile, &zTile);
-    G3d_tileCoordOrigin(map, xTile, yTile, zTile, x, y, z);
+    Rast3d_tileIndex2tile(map, tileIndex, &xTile, &yTile, &zTile);
+    Rast3d_tileCoordOrigin(map, xTile, yTile, zTile, x, y, z);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -133,7 +133,7 @@ void G3d_tileIndexOrigin(RASTER3D_Map * map, int tileIndex, int *x, int *y, int
  */
 
 void
-G3d_coord2tileCoord(RASTER3D_Map * map, int x, int y, int z, int *xTile,
+Rast3d_coord2tileCoord(RASTER3D_Map * map, int x, int y, int z, int *xTile,
 		    int *yTile, int *zTile, int *xOffs, int *yOffs,
 		    int *zOffs)
 {
@@ -164,14 +164,14 @@ G3d_coord2tileCoord(RASTER3D_Map * map, int x, int y, int z, int *xTile,
  */
 
 void
-G3d_coord2tileIndex(RASTER3D_Map * map, int x, int y, int z, int *tileIndex,
+Rast3d_coord2tileIndex(RASTER3D_Map * map, int x, int y, int z, int *tileIndex,
 		    int *offset)
 {
     int xTile, yTile, zTile, xOffs, yOffs, zOffs;
 
-    G3d_coord2tileCoord(map, x, y, z,
+    Rast3d_coord2tileCoord(map, x, y, z,
 			&xTile, &yTile, &zTile, &xOffs, &yOffs, &zOffs);
-    *tileIndex = G3d_tile2tileIndex(map, xTile, yTile, zTile);
+    *tileIndex = Rast3d_tile2tileIndex(map, xTile, yTile, zTile);
     *offset = zOffs * map->tileXY + yOffs * map->tileX + xOffs;
 }
 
@@ -192,7 +192,7 @@ G3d_coord2tileIndex(RASTER3D_Map * map, int x, int y, int z, int *tileIndex,
  *  \return int
  */
 
-int G3d_coordInRange(RASTER3D_Map * map, int x, int y, int z)
+int Rast3d_coordInRange(RASTER3D_Map * map, int x, int y, int z)
 {
     return (x >= 0) && (x < map->region.cols) && (y >= 0) &&
 	(y < map->region.rows) && (z >= 0) && (z < map->region.depths);
@@ -212,7 +212,7 @@ int G3d_coordInRange(RASTER3D_Map * map, int x, int y, int z)
  *  \return int
  */
 
-int G3d_tileIndexInRange(RASTER3D_Map * map, int tileIndex)
+int Rast3d_tileIndexInRange(RASTER3D_Map * map, int tileIndex)
 {
     return (tileIndex < map->nTiles) && (tileIndex >= 0);
 }
@@ -234,7 +234,7 @@ int G3d_tileIndexInRange(RASTER3D_Map * map, int tileIndex)
  *  \return int
  */
 
-int G3d_tileInRange(RASTER3D_Map * map, int x, int y, int z)
+int Rast3d_tileInRange(RASTER3D_Map * map, int x, int y, int z)
 {
     return (x >= 0) && (x < map->nx) && (y >= 0) && (y < map->ny) &&
 	(z >= 0) && (z < map->nz);
@@ -264,13 +264,13 @@ int G3d_tileInRange(RASTER3D_Map * map, int x, int y, int z)
  */
 
 int
-G3d_computeClippedTileDimensions(RASTER3D_Map * map, int tileIndex, int *rows,
+Rast3d_computeClippedTileDimensions(RASTER3D_Map * map, int tileIndex, int *rows,
 				 int *cols, int *depths, int *xRedundant,
 				 int *yRedundant, int *zRedundant)
 {
     int x, y, z;
 
-    G3d_tileIndex2tile(map, tileIndex, &x, &y, &z);
+    Rast3d_tileIndex2tile(map, tileIndex, &x, &y, &z);
 
     if ((x != map->clipX) && (y != map->clipY) && (z != map->clipZ)) {
 	return map->tileSize;
@@ -329,7 +329,7 @@ G3d_computeClippedTileDimensions(RASTER3D_Map * map, int tileIndex, int *rows,
  */
 
 void
-G3d_computeOptimalTileDimension(RASTER3D_Region *region, int type, int *tileX, int *tileY, int *tileZ, int maxSize)
+Rast3d_computeOptimalTileDimension(RASTER3D_Region *region, int type, int *tileX, int *tileY, int *tileZ, int maxSize)
 {
    int size = 0;
    int x, y, z;

lib/raster3d/tilenull.c

@@ -20,9 +20,9 @@
  *  \return void
  */
 
-void G3d_setNullTileType(RASTER3D_Map * map, void *tile, int type)
+void Rast3d_setNullTileType(RASTER3D_Map * map, void *tile, int type)
 {
-    G3d_setNullValue(tile, map->tileSize, type);
+    Rast3d_setNullValue(tile, map->tileSize, type);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -31,14 +31,14 @@ void G3d_setNullTileType(RASTER3D_Map * map, void *tile, int type)
 /*!
  * \brief 
  *
- * Is equivalent to G3d_setNullTileType (map, tile, G3d_fileTypeMap (map)).
+ * Is equivalent to Rast3d_setNullTileType (map, tile, Rast3d_fileTypeMap (map)).
  *
  *  \param map
  *  \param tile
  *  \return void
  */
 
-void G3d_setNullTile(RASTER3D_Map * map, void *tile)
+void Rast3d_setNullTile(RASTER3D_Map * map, void *tile)
 {
-    G3d_setNullTileType(map, tile, map->typeIntern);
+    Rast3d_setNullTileType(map, tile, map->typeIntern);
 }

lib/raster3d/tileread.c

@@ -9,71 +9,71 @@
 #include "raster3d_intern.h"
 
 static int
-G3d_xdrTile2tile(RASTER3D_Map * map, void *tile, int rows, int cols, int depths,
+Rast3d_xdrTile2tile(RASTER3D_Map * map, void *tile, int rows, int cols, int depths,
 		 int xRedundant, int yRedundant, int zRedundant, int nofNum,
 		 int type)
 {
     int y, z, xLength, yLength, length;
 
-    if (!G3d_initCopyFromXdr(map, type)) {
-	G3d_error("G3d_xdrTile2tile: error in G3d_initCopyFromXdr");
+    if (!Rast3d_initCopyFromXdr(map, type)) {
+	Rast3d_error("Rast3d_xdrTile2tile: error in Rast3d_initCopyFromXdr");
 	return 0;
     }
 
     if (nofNum == map->tileSize) {
-	if (!G3d_copyFromXdr(map->tileSize, tile)) {
-	    G3d_error("G3d_xdrTile2tile: error in G3d_copyFromXdr");
+	if (!Rast3d_copyFromXdr(map->tileSize, tile)) {
+	    Rast3d_error("Rast3d_xdrTile2tile: error in Rast3d_copyFromXdr");
 	    return 0;
 	}
 	return 1;
     }
 
-    length = G3d_length(type);
+    length = Rast3d_length(type);
     xLength = xRedundant * length;
     yLength = map->tileX * yRedundant * length;
 
     if (xRedundant) {
 	for (z = 0; z < depths; z++) {
 	    for (y = 0; y < rows; y++) {
-		if (!G3d_copyFromXdr(cols, tile)) {
-		    G3d_error("G3d_xdrTile2tile: error in G3d_copyFromXdr");
+		if (!Rast3d_copyFromXdr(cols, tile)) {
+		    Rast3d_error("Rast3d_xdrTile2tile: error in Rast3d_copyFromXdr");
 		    return 0;
 		}
 		tile = G_incr_void_ptr(tile, cols * length);
-		G3d_setNullValue(tile, xRedundant, type);
+		Rast3d_setNullValue(tile, xRedundant, type);
 		tile = G_incr_void_ptr(tile, xLength);
 	    }
 	    if (yRedundant) {
-		G3d_setNullValue(tile, map->tileX * yRedundant, type);
+		Rast3d_setNullValue(tile, map->tileX * yRedundant, type);
 		tile = G_incr_void_ptr(tile, yLength);
 	    }
 	}
 	if (!zRedundant)
 	    return 1;
 
-	G3d_setNullValue(tile, map->tileXY * zRedundant, type);
+	Rast3d_setNullValue(tile, map->tileXY * zRedundant, type);
 	return 1;
     }
 
     if (yRedundant) {
 	for (z = 0; z < depths; z++) {
-	    if (!G3d_copyFromXdr(map->tileX * rows, tile)) {
-		G3d_error("G3d_xdrTile2tile: error in G3d_copyFromXdr");
+	    if (!Rast3d_copyFromXdr(map->tileX * rows, tile)) {
+		Rast3d_error("Rast3d_xdrTile2tile: error in Rast3d_copyFromXdr");
 		return 0;
 	    }
 	    tile = G_incr_void_ptr(tile, map->tileX * rows * length);
-	    G3d_setNullValue(tile, map->tileX * yRedundant, type);
+	    Rast3d_setNullValue(tile, map->tileX * yRedundant, type);
 	    tile = G_incr_void_ptr(tile, yLength);
 	}
 	if (!zRedundant)
 	    return 1;
 
-	G3d_setNullValue(tile, map->tileXY * zRedundant, type);
+	Rast3d_setNullValue(tile, map->tileXY * zRedundant, type);
 	return 1;
     }
 
-    if (!G3d_copyFromXdr(map->tileXY * depths, tile)) {
-	G3d_error("G3d_xdrTile2tile: error in G3d_copyFromXdr");
+    if (!Rast3d_copyFromXdr(map->tileXY * depths, tile)) {
+	Rast3d_error("Rast3d_xdrTile2tile: error in Rast3d_copyFromXdr");
 	return 0;
     }
 
@@ -81,14 +81,14 @@ G3d_xdrTile2tile(RASTER3D_Map * map, void *tile, int rows, int cols, int depths,
 	return 1;
 
     tile = G_incr_void_ptr(tile, map->tileXY * depths * length);
-    G3d_setNullValue(tile, map->tileXY * zRedundant, type);
+    Rast3d_setNullValue(tile, map->tileXY * zRedundant, type);
 
     return 1;
 }
 
 /*---------------------------------------------------------------------------*/
 
-static int G3d_readTileUncompressed(RASTER3D_Map * map, int tileIndex, int nofNum)
+static int Rast3d_readTileUncompressed(RASTER3D_Map * map, int tileIndex, int nofNum)
 {
     int nofBytes;
 
@@ -96,7 +96,7 @@ static int G3d_readTileUncompressed(RASTER3D_Map * map, int tileIndex, int nofNu
     nofBytes = RASTER3D_MIN(nofBytes, map->fileEndPtr - map->index[tileIndex]);
 
     if (read(map->data_fd, xdr, nofBytes) != nofBytes) {
-	G3d_error("G3d_readTileUncompressed: can't read file");
+	Rast3d_error("Rast3d_readTileUncompressed: can't read file");
 	return 0;
     }
 
@@ -105,14 +105,14 @@ static int G3d_readTileUncompressed(RASTER3D_Map * map, int tileIndex, int nofNu
 
 /*---------------------------------------------------------------------------*/
 
-static int G3d_readTileCompressed(RASTER3D_Map * map, int tileIndex, int nofNum)
+static int Rast3d_readTileCompressed(RASTER3D_Map * map, int tileIndex, int nofNum)
 {
     if (!G_fpcompress_readXdrNums(map->data_fd, xdr, nofNum,
 				  map->tileLength[tileIndex],
 				  map->precision, tmpCompress,
 				  map->type == FCELL_TYPE)) {
-	G3d_error
-	    ("G3d_readTileCompressed: error in G_fpcompress_readXdrNums");
+	Rast3d_error
+	    ("Rast3d_readTileCompressed: error in G_fpcompress_readXdrNums");
 	return 0;
     }
 
@@ -144,49 +144,49 @@ static int G3d_readTileCompressed(RASTER3D_Map * map, int tileIndex, int nofNum)
  *          0 ... otherwise.
  */
 
-int G3d_readTile(RASTER3D_Map * map, int tileIndex, void *tile, int type)
+int Rast3d_readTile(RASTER3D_Map * map, int tileIndex, void *tile, int type)
 {
     int nofNum, rows, cols, depths, xRedundant, yRedundant, zRedundant;
 
     if ((tileIndex >= map->nTiles) || (tileIndex < 0))
-	G3d_fatalError("G3d_readTile: tile index out of range");
+	Rast3d_fatalError("Rast3d_readTile: tile index out of range");
 
     if (map->index[tileIndex] == -1) {
-	G3d_setNullTileType(map, tile, type);
+	Rast3d_setNullTileType(map, tile, type);
 	return 1;
     }
 
-    nofNum = G3d_computeClippedTileDimensions(map, tileIndex,
+    nofNum = Rast3d_computeClippedTileDimensions(map, tileIndex,
 					      &rows, &cols, &depths,
 					      &xRedundant, &yRedundant,
 					      &zRedundant);
 
     if (lseek(map->data_fd, map->index[tileIndex], SEEK_SET) == -1) {
-	G3d_error("G3d_readTile: can't position file");
+	Rast3d_error("Rast3d_readTile: can't position file");
 	return 0;
     }
 
     if (map->compression == RASTER3D_NO_COMPRESSION) {
-	if (!G3d_readTileUncompressed(map, tileIndex, nofNum)) {
-	    G3d_error("G3d_readTile: error in G3d_readTileUncompressed");
+	if (!Rast3d_readTileUncompressed(map, tileIndex, nofNum)) {
+	    Rast3d_error("Rast3d_readTile: error in Rast3d_readTileUncompressed");
 	    return 0;
 	}
     }
-    else if (!G3d_readTileCompressed(map, tileIndex, nofNum)) {
-	G3d_error("G3d_readTile: error in G3d_readTileCompressed");
+    else if (!Rast3d_readTileCompressed(map, tileIndex, nofNum)) {
+	Rast3d_error("Rast3d_readTile: error in Rast3d_readTileCompressed");
 	return 0;
     }
 
-    if (!G3d_xdrTile2tile(map, tile, rows, cols, depths,
+    if (!Rast3d_xdrTile2tile(map, tile, rows, cols, depths,
 			  xRedundant, yRedundant, zRedundant, nofNum, type)) {
-	G3d_error("G3d_readTile: error in G3d_xdrTile2tile");
+	Rast3d_error("Rast3d_readTile: error in Rast3d_xdrTile2tile");
 	return 0;
     }
 
-    if (G3d_maskIsOff(map))
+    if (Rast3d_maskIsOff(map))
 	return 1;
 
-    G3d_maskTile(map, tileIndex, tile, type);
+    Rast3d_maskTile(map, tileIndex, tile, type);
     return 1;
 }
 
@@ -196,7 +196,7 @@ int G3d_readTile(RASTER3D_Map * map, int tileIndex, void *tile, int type)
 /*!
  * \brief 
  *
- *  Is equivalent to G3d_readTile (map, tileIndex, tile, FCELL_TYPE).
+ *  Is equivalent to Rast3d_readTile (map, tileIndex, tile, FCELL_TYPE).
  *
  *  \param map
  *  \param tileIndex
@@ -204,10 +204,10 @@ int G3d_readTile(RASTER3D_Map * map, int tileIndex, void *tile, int type)
  *  \return int
  */
 
-int G3d_readTileFloat(RASTER3D_Map * map, int tileIndex, void *tile)
+int Rast3d_readTileFloat(RASTER3D_Map * map, int tileIndex, void *tile)
 {
-    if (!G3d_readTile(map, tileIndex, tile, FCELL_TYPE)) {
-	G3d_error("G3d_readTileFloat: error in G3d_readTile");
+    if (!Rast3d_readTile(map, tileIndex, tile, FCELL_TYPE)) {
+	Rast3d_error("Rast3d_readTileFloat: error in Rast3d_readTile");
 	return 0;
     }
 
@@ -220,7 +220,7 @@ int G3d_readTileFloat(RASTER3D_Map * map, int tileIndex, void *tile)
 /*!
  * \brief 
  *
- *  Is equivalent to G3d_readTile (map, tileIndex, tile, DCELL_TYPE).
+ *  Is equivalent to Rast3d_readTile (map, tileIndex, tile, DCELL_TYPE).
  *
  *  \param map
  *  \param tileIndex
@@ -228,10 +228,10 @@ int G3d_readTileFloat(RASTER3D_Map * map, int tileIndex, void *tile)
  *  \return int
  */
 
-int G3d_readTileDouble(RASTER3D_Map * map, int tileIndex, void *tile)
+int Rast3d_readTileDouble(RASTER3D_Map * map, int tileIndex, void *tile)
 {
-    if (!G3d_readTile(map, tileIndex, tile, DCELL_TYPE)) {
-	G3d_error("G3d_readTileDouble: error in G3d_readTile");
+    if (!Rast3d_readTile(map, tileIndex, tile, DCELL_TYPE)) {
+	Rast3d_error("Rast3d_readTileDouble: error in Rast3d_readTile");
 	return 0;
     }
 
@@ -258,13 +258,13 @@ int G3d_readTileDouble(RASTER3D_Map * map, int tileIndex, void *tile)
  *          0 ... otherwise.
  */
 
-int G3d_lockTile(RASTER3D_Map * map, int tileIndex)
+int Rast3d_lockTile(RASTER3D_Map * map, int tileIndex)
 {
     if (!map->useCache)
-	G3d_fatalError("G3d_lockTile: function invalid in non-cache mode");
+	Rast3d_fatalError("Rast3d_lockTile: function invalid in non-cache mode");
 
-    if (!G3d_cache_lock(map->cache, tileIndex)) {
-	G3d_error("G3d_lockTile: error in G3d_cache_lock");
+    if (!Rast3d_cache_lock(map->cache, tileIndex)) {
+	Rast3d_error("Rast3d_lockTile: error in Rast3d_cache_lock");
 	return 0;
     }
 
@@ -285,13 +285,13 @@ int G3d_lockTile(RASTER3D_Map * map, int tileIndex)
  *          0 ... otherwise.
  */
 
-int G3d_unlockTile(RASTER3D_Map * map, int tileIndex)
+int Rast3d_unlockTile(RASTER3D_Map * map, int tileIndex)
 {
     if (!map->useCache)
-	G3d_fatalError("G3d_unlockTile: function invalid in non-cache mode");
+	Rast3d_fatalError("Rast3d_unlockTile: function invalid in non-cache mode");
 
-    if (!G3d_cache_unlock(map->cache, tileIndex)) {
-	G3d_error("G3d_unlockTile: error in G3d_cache_unlock");
+    if (!Rast3d_cache_unlock(map->cache, tileIndex)) {
+	Rast3d_error("Rast3d_unlockTile: error in Rast3d_cache_unlock");
 	return 0;
     }
 
@@ -311,13 +311,13 @@ int G3d_unlockTile(RASTER3D_Map * map, int tileIndex)
  *          0 ... otherwise.
  */
 
-int G3d_unlockAll(RASTER3D_Map * map)
+int Rast3d_unlockAll(RASTER3D_Map * map)
 {
     if (!map->useCache)
-	G3d_fatalError("G3d_unlockAll: function invalid in non-cache mode");
+	Rast3d_fatalError("Rast3d_unlockAll: function invalid in non-cache mode");
 
-    if (!G3d_cache_unlock_all(map->cache)) {
-	G3d_error("G3d_unlockAll: error in G3d_cache_unlock_all");
+    if (!Rast3d_cache_unlock_all(map->cache)) {
+	Rast3d_error("Rast3d_unlockAll: error in Rast3d_cache_unlock_all");
 	return 0;
     }
 
@@ -336,12 +336,12 @@ int G3d_unlockAll(RASTER3D_Map * map)
  *  \return void
  */
 
-void G3d_autolockOn(RASTER3D_Map * map)
+void Rast3d_autolockOn(RASTER3D_Map * map)
 {
     if (!map->useCache)
-	G3d_fatalError("G3d_autoLockOn: function invalid in non-cache mode");
+	Rast3d_fatalError("Rast3d_autoLockOn: function invalid in non-cache mode");
 
-    G3d_cache_autolock_on(map->cache);
+    Rast3d_cache_autolock_on(map->cache);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -356,12 +356,12 @@ void G3d_autolockOn(RASTER3D_Map * map)
  *  \return void
  */
 
-void G3d_autolockOff(RASTER3D_Map * map)
+void Rast3d_autolockOff(RASTER3D_Map * map)
 {
     if (!map->useCache)
-	G3d_fatalError("G3d_autoLockOff: function invalid in non-cache mode");
+	Rast3d_fatalError("Rast3d_autoLockOff: function invalid in non-cache mode");
 
-    G3d_cache_autolock_off(map->cache);
+    Rast3d_cache_autolock_off(map->cache);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -372,11 +372,11 @@ void G3d_autolockOff(RASTER3D_Map * map)
  *
  * Sets the minimum
  * number of unlocked tiles to <em>minUnlocked</em>.  This function should be used
- * in combination with <tt>G3d_unlockAll ()</tt> in order to avoid situations where the
+ * in combination with <tt>Rast3d_unlockAll ()</tt> in order to avoid situations where the
  * new minimum is larger than the actual number of unlocked tiles.
  * <em>minUnlocked</em> must be one of RASTER3D_USE_CACHE_X, RASTER3D_USE_CACHE_Y,
  * RASTER3D_USE_CACHE_Z, RASTER3D_USE_CACHE_XY, RASTER3D_USE_CACHE_XZ,
- * RASTER3D_USE_CACHE_YZ, RASTER3D_USE_CACHE_XYZ, the result of G3d_cacheSizeEncode()
+ * RASTER3D_USE_CACHE_YZ, RASTER3D_USE_CACHE_XYZ, the result of Rast3d_cacheSizeEncode()
  * (cf.{g3d:G3d.cacheSizeEncode}), or any positive integer
  * which explicitly specifies the number of tiles.
  *
@@ -385,13 +385,13 @@ void G3d_autolockOff(RASTER3D_Map * map)
  *  \return void
  */
 
-void G3d_minUnlocked(RASTER3D_Map * map, int minUnlocked)
+void Rast3d_minUnlocked(RASTER3D_Map * map, int minUnlocked)
 {
     if (!map->useCache)
-	G3d_fatalError("G3d_autoLockOff: function invalid in non-cache mode");
+	Rast3d_fatalError("Rast3d_autoLockOff: function invalid in non-cache mode");
 
-    G3d_cache_set_minUnlock(map->cache,
-			    G3d__computeCacheSize(map, minUnlocked));
+    Rast3d_cache_set_minUnlock(map->cache,
+			    Rast3d__computeCacheSize(map, minUnlocked));
 }
 
 /*---------------------------------------------------------------------------*/
@@ -407,14 +407,14 @@ void G3d_minUnlocked(RASTER3D_Map * map, int minUnlocked)
  *          0 ... otherwise.
  */
 
-int G3d_beginCycle(RASTER3D_Map * map)
+int Rast3d_beginCycle(RASTER3D_Map * map)
 {
-    if (!G3d_unlockAll(map)) {
-	G3d_fatalError("G3d_beginCycle: error in G3d_unlockAll");
+    if (!Rast3d_unlockAll(map)) {
+	Rast3d_fatalError("Rast3d_beginCycle: error in Rast3d_unlockAll");
 	return 0;
     }
 
-    G3d_autolockOn(map);
+    Rast3d_autolockOn(map);
     return 1;
 }
 
@@ -431,8 +431,8 @@ int G3d_beginCycle(RASTER3D_Map * map)
  *          0 ... otherwise.
  */
 
-int G3d_endCycle(RASTER3D_Map * map)
+int Rast3d_endCycle(RASTER3D_Map * map)
 {
-    G3d_autolockOff(map);
+    Rast3d_autolockOff(map);
     return 1;
 }

lib/raster3d/tilewrite.c

@@ -12,21 +12,21 @@
 /*---------------------------------------------------------------------------*/
 
 static int
-G3d_tile2xdrTile(RASTER3D_Map * map, const void *tile, int rows, int cols,
+Rast3d_tile2xdrTile(RASTER3D_Map * map, const void *tile, int rows, int cols,
 		 int depths, int xRedundant, int yRedundant, int zRedundant,
 		 int nofNum, int type)
 {
     int y, z;
 
-    if (!G3d_initCopyToXdr(map, type)) {
-	G3d_error("G3d_tile2xdrTile: error in G3d_initCopyToXdr");
+    if (!Rast3d_initCopyToXdr(map, type)) {
+	Rast3d_error("Rast3d_tile2xdrTile: error in Rast3d_initCopyToXdr");
 	return 0;
     }
 
 
     if (nofNum == map->tileSize) {
-	if (!G3d_copyToXdr(tile, map->tileSize)) {
-	    G3d_error("G3d_tile2xdrTile: error in G3d_copyToXdr");
+	if (!Rast3d_copyToXdr(tile, map->tileSize)) {
+	    Rast3d_error("Rast3d_tile2xdrTile: error in Rast3d_copyToXdr");
 	    return 0;
 	}
 	return 1;
@@ -35,34 +35,34 @@ G3d_tile2xdrTile(RASTER3D_Map * map, const void *tile, int rows, int cols,
     if (xRedundant) {
 	for (z = 0; z < depths; z++) {
 	    for (y = 0; y < rows; y++) {
-		if (!G3d_copyToXdr(tile, cols)) {
-		    G3d_error("G3d_tile2xdrTile: error in G3d_copyToXdr");
+		if (!Rast3d_copyToXdr(tile, cols)) {
+		    Rast3d_error("Rast3d_tile2xdrTile: error in Rast3d_copyToXdr");
 		    return 0;
 		}
-		tile = G_incr_void_ptr(tile, map->tileX * G3d_length(type));
+		tile = G_incr_void_ptr(tile, map->tileX * Rast3d_length(type));
 	    }
 	    if (yRedundant)
 		tile =
 		    G_incr_void_ptr(tile,
 				    map->tileX * yRedundant *
-				    G3d_length(type));
+				    Rast3d_length(type));
 	}
 	return 1;
     }
 
     if (yRedundant) {
 	for (z = 0; z < depths; z++) {
-	    if (!G3d_copyToXdr(tile, map->tileX * rows)) {
-		G3d_error("G3d_tile2xdrTile: error in G3d_copyToXdr");
+	    if (!Rast3d_copyToXdr(tile, map->tileX * rows)) {
+		Rast3d_error("Rast3d_tile2xdrTile: error in Rast3d_copyToXdr");
 		return 0;
 	    }
-	    tile = G_incr_void_ptr(tile, map->tileXY * G3d_length(type));
+	    tile = G_incr_void_ptr(tile, map->tileXY * Rast3d_length(type));
 	}
 	return 1;
     }
 
-    if (!G3d_copyToXdr(tile, map->tileXY * depths)) {
-	G3d_error("G3d_tile2xdrTile: error in G3d_copyToXdr");
+    if (!Rast3d_copyToXdr(tile, map->tileXY * depths)) {
+	Rast3d_error("Rast3d_tile2xdrTile: error in Rast3d_copyToXdr");
 	return 0;
     }
     return 1;
@@ -70,11 +70,11 @@ G3d_tile2xdrTile(RASTER3D_Map * map, const void *tile, int rows, int cols,
 
 /*---------------------------------------------------------------------------*/
 
-static int G3d_writeTileUncompressed(RASTER3D_Map * map, int nofNum)
+static int Rast3d_writeTileUncompressed(RASTER3D_Map * map, int nofNum)
 {
     if (write(map->data_fd, xdr, map->numLengthExtern * nofNum) !=
 	map->numLengthExtern * nofNum) {
-	G3d_error("G3d_writeTileUncompressed: can't write file.");
+	Rast3d_error("Rast3d_writeTileUncompressed: can't write file.");
 	return 0;
     }
 
@@ -83,13 +83,13 @@ static int G3d_writeTileUncompressed(RASTER3D_Map * map, int nofNum)
 
 /*---------------------------------------------------------------------------*/
 
-static int G3d_writeTileCompressed(RASTER3D_Map * map, int nofNum)
+static int Rast3d_writeTileCompressed(RASTER3D_Map * map, int nofNum)
 {
     if (!G_fpcompress_writeXdrNums(map->data_fd, xdr, nofNum, map->precision,
 				   tmpCompress, map->type == FCELL_TYPE,
 				   map->useRle, map->useLzw)) {
-	G3d_error
-	    ("G3d_writeTileCompressed: error in G_fpcompress_writeXdrNums");
+	Rast3d_error
+	    ("Rast3d_writeTileCompressed: error in G_fpcompress_writeXdrNums");
 	return 0;
     }
 
@@ -127,13 +127,13 @@ static int G3d_writeTileCompressed(RASTER3D_Map * map, int nofNum)
  *          0 ... otherwise.
  */
 
-int G3d_writeTile(RASTER3D_Map * map, int tileIndex, const void *tile, int type)
+int Rast3d_writeTile(RASTER3D_Map * map, int tileIndex, const void *tile, int type)
 {
     int rows, cols, depths, xRedundant, yRedundant, zRedundant, nofNum;
 
     /* valid tileIndex ? */
     if ((tileIndex >= map->nTiles) || (tileIndex < 0))
-	G3d_fatalError("G3d_writeTile: tileIndex out of range");
+	Rast3d_fatalError("Rast3d_writeTile: tileIndex out of range");
 
     /* already written ? */
     if (map->index[tileIndex] != -1)
@@ -142,33 +142,33 @@ int G3d_writeTile(RASTER3D_Map * map, int tileIndex, const void *tile, int type)
     /* save the file position */
     map->index[tileIndex] = lseek(map->data_fd, (long)0, SEEK_END);
     if (map->index[tileIndex] == -1) {
-	G3d_error("G3d_writeTile: can't position file");
+	Rast3d_error("Rast3d_writeTile: can't position file");
 	return 0;
     }
 
-    nofNum = G3d_computeClippedTileDimensions(map, tileIndex,
+    nofNum = Rast3d_computeClippedTileDimensions(map, tileIndex,
 					      &rows, &cols, &depths,
 					      &xRedundant, &yRedundant,
 					      &zRedundant);
 
-    G3d_range_updateFromTile(map, tile, rows, cols, depths,
+    Rast3d_range_updateFromTile(map, tile, rows, cols, depths,
 			     xRedundant, yRedundant, zRedundant, nofNum,
 			     type);
 
-    if (!G3d_tile2xdrTile(map, tile, rows, cols, depths,
+    if (!Rast3d_tile2xdrTile(map, tile, rows, cols, depths,
 			  xRedundant, yRedundant, zRedundant, nofNum, type)) {
-	G3d_error("G3d_writeTileCompressed: error in G3d_tile2xdrTile");
+	Rast3d_error("Rast3d_writeTileCompressed: error in Rast3d_tile2xdrTile");
 	return 0;
     }
 
     if (map->compression == RASTER3D_NO_COMPRESSION) {
-	if (!G3d_writeTileUncompressed(map, nofNum)) {
-	    G3d_error("G3d_writeTile: error in G3d_writeTileUncompressed");
+	if (!Rast3d_writeTileUncompressed(map, nofNum)) {
+	    Rast3d_error("Rast3d_writeTile: error in Rast3d_writeTileUncompressed");
 	    return 0;
 	}
     }
-    else if (!G3d_writeTileCompressed(map, nofNum)) {
-	G3d_error("G3d_writeTile: error in G3d_writeTileCompressed");
+    else if (!Rast3d_writeTileCompressed(map, nofNum)) {
+	Rast3d_error("Rast3d_writeTile: error in Rast3d_writeTileCompressed");
 	return 0;
     }
 
@@ -185,7 +185,7 @@ int G3d_writeTile(RASTER3D_Map * map, int tileIndex, const void *tile, int type)
 /*!
  * \brief 
  *
- *  Is equivalent to <tt>G3d_writeTile (map, tileIndex, tile, FCELL_TYPE).</tt>
+ *  Is equivalent to <tt>Rast3d_writeTile (map, tileIndex, tile, FCELL_TYPE).</tt>
  *
  *  \param map
  *  \param tileIndex
@@ -193,14 +193,14 @@ int G3d_writeTile(RASTER3D_Map * map, int tileIndex, const void *tile, int type)
  *  \return int
  */
 
-int G3d_writeTileFloat(RASTER3D_Map * map, int tileIndex, const void *tile)
+int Rast3d_writeTileFloat(RASTER3D_Map * map, int tileIndex, const void *tile)
 {
     int status;
 
-    if ((status = G3d_writeTile(map, tileIndex, tile, FCELL_TYPE)))
+    if ((status = Rast3d_writeTile(map, tileIndex, tile, FCELL_TYPE)))
 	return status;
 
-    G3d_error("G3d_writeTileFloat: error in G3d_writeTile");
+    Rast3d_error("Rast3d_writeTileFloat: error in Rast3d_writeTile");
     return 0;
 }
 
@@ -210,7 +210,7 @@ int G3d_writeTileFloat(RASTER3D_Map * map, int tileIndex, const void *tile)
 /*!
  * \brief 
  *
- * Is equivalent to <tt>G3d_writeTile (map, tileIndex, tile, DCELL_TYPE).</tt>
+ * Is equivalent to <tt>Rast3d_writeTile (map, tileIndex, tile, DCELL_TYPE).</tt>
  *
  *  \param map
  *  \param tileIndex
@@ -218,14 +218,14 @@ int G3d_writeTileFloat(RASTER3D_Map * map, int tileIndex, const void *tile)
  *  \return int
  */
 
-int G3d_writeTileDouble(RASTER3D_Map * map, int tileIndex, const void *tile)
+int Rast3d_writeTileDouble(RASTER3D_Map * map, int tileIndex, const void *tile)
 {
     int status;
 
-    if ((status = G3d_writeTile(map, tileIndex, tile, DCELL_TYPE)))
+    if ((status = Rast3d_writeTile(map, tileIndex, tile, DCELL_TYPE)))
 	return status;
 
-    G3d_error("G3d_writeTileDouble: error in G3d_writeTile");
+    Rast3d_error("Rast3d_writeTileDouble: error in Rast3d_writeTile");
     return 0;
 }
 
@@ -244,7 +244,7 @@ int G3d_writeTileDouble(RASTER3D_Map * map, int tileIndex, const void *tile)
  * from the cache (in non-cache mode the buffer provided by the map-structure is
  * written).
  * If this tile has already been written before the write request is ignored.
- * If the tile was never referred to before the invokation of G3d_flushTile, a
+ * If the tile was never referred to before the invokation of Rast3d_flushTile, a
  * tile filled with NULL-values is written.
  *
  *  \param map
@@ -253,23 +253,23 @@ int G3d_writeTileDouble(RASTER3D_Map * map, int tileIndex, const void *tile)
  *          0 ... otherwise.
  */
 
-int G3d_flushTile(RASTER3D_Map * map, int tileIndex)
+int Rast3d_flushTile(RASTER3D_Map * map, int tileIndex)
 {
     const void *tile;
 
-    tile = G3d_getTilePtr(map, tileIndex);
+    tile = Rast3d_getTilePtr(map, tileIndex);
     if (tile == NULL) {
-	G3d_error("G3d_flushTile: error in G3d_getTilePtr");
+	Rast3d_error("Rast3d_flushTile: error in Rast3d_getTilePtr");
 	return 0;
     }
 
-    if (!G3d_writeTile(map, tileIndex, tile, map->typeIntern)) {
-	G3d_error("G3d_flushTile: error in G3d_writeTile");
+    if (!Rast3d_writeTile(map, tileIndex, tile, map->typeIntern)) {
+	Rast3d_error("Rast3d_flushTile: error in Rast3d_writeTile");
 	return 0;
     }
 
-    if (!G3d__removeTile(map, tileIndex)) {
-	G3d_error("G3d_flushTile: error in G3d__removeTile");
+    if (!Rast3d__removeTile(map, tileIndex)) {
+	Rast3d_error("Rast3d_flushTile: error in Rast3d__removeTile");
 	return 0;
     }
 
@@ -305,20 +305,20 @@ int G3d_flushTile(RASTER3D_Map * map, int tileIndex)
  */
 
 int
-G3d_flushTileCube(RASTER3D_Map * map, int xMin, int yMin, int zMin, int xMax,
+Rast3d_flushTileCube(RASTER3D_Map * map, int xMin, int yMin, int zMin, int xMax,
 		  int yMax, int zMax)
 {
     int x, y, z;
 
     if (!map->useCache)
-	G3d_fatalError
-	    ("G3d_flushTileCube: function invalid in non-cache mode");
+	Rast3d_fatalError
+	    ("Rast3d_flushTileCube: function invalid in non-cache mode");
 
     for (x = xMin; x <= xMax; x++)
 	for (y = yMin; y <= yMax; y++)
 	    for (z = zMin; z <= zMax; z++)
-		if (!G3d_flushTile(map, G3d_tile2tileIndex(map, x, y, z))) {
-		    G3d_error("G3d_flushTileCube: error in G3d_flushTile");
+		if (!Rast3d_flushTile(map, Rast3d_tile2tileIndex(map, x, y, z))) {
+		    Rast3d_error("Rast3d_flushTileCube: error in Rast3d_flushTile");
 		    return 0;
 		}
 
@@ -351,7 +351,7 @@ G3d_flushTileCube(RASTER3D_Map * map, int xMin, int yMin, int zMin, int xMax,
  */
 
 int
-G3d_flushTilesInCube(RASTER3D_Map * map, int xMin, int yMin, int zMin, int xMax,
+Rast3d_flushTilesInCube(RASTER3D_Map * map, int xMin, int yMin, int zMin, int xMax,
 		     int yMax, int zMax)
 {
     int xTileMin, yTileMin, zTileMin, xTileMax, yTileMax, zTileMax;
@@ -359,40 +359,40 @@ G3d_flushTilesInCube(RASTER3D_Map * map, int xMin, int yMin, int zMin, int xMax,
     int regionMaxX, regionMaxY, regionMaxZ;
 
     if (!map->useCache)
-	G3d_fatalError
-	    ("G3d_flushTilesInCube: function invalid in non-cache mode");
+	Rast3d_fatalError
+	    ("Rast3d_flushTilesInCube: function invalid in non-cache mode");
      /*AV*/
 	/*BEGIN OF ORIGINAL CODE */
 	/*
-	 *  G3d_getCoordsMap (map, &regionMaxX, &regionMaxY, &regionMaxZ);
+	 *  Rast3d_getCoordsMap (map, &regionMaxX, &regionMaxY, &regionMaxZ);
 	 */
 	 /*AV*/
 	/* BEGIN OF MY CODE */
-	G3d_getCoordsMap(map, &regionMaxY, &regionMaxX, &regionMaxZ);
+	Rast3d_getCoordsMap(map, &regionMaxY, &regionMaxX, &regionMaxZ);
     /* END OF MY CODE */
 
     if ((xMin < 0) && (xMax < 0))
-	G3d_fatalError("G3d_flushTilesInCube: coordinate out of Range");
+	Rast3d_fatalError("Rast3d_flushTilesInCube: coordinate out of Range");
     if ((xMin >= regionMaxX) && (xMax >= regionMaxX))
-	G3d_fatalError("G3d_flushTilesInCube: coordinate out of Range");
+	Rast3d_fatalError("Rast3d_flushTilesInCube: coordinate out of Range");
 
     xMin = MIN(MAX(0, xMin), regionMaxX - 1);
 
     if ((yMin < 0) && (yMax < 0))
-	G3d_fatalError("G3d_flushTilesInCube: coordinate out of Range");
+	Rast3d_fatalError("Rast3d_flushTilesInCube: coordinate out of Range");
     if ((yMin >= regionMaxY) && (yMax >= regionMaxY))
-	G3d_fatalError("G3d_flushTilesInCube: coordinate out of Range");
+	Rast3d_fatalError("Rast3d_flushTilesInCube: coordinate out of Range");
 
     yMin = MIN(MAX(0, yMin), regionMaxY - 1);
 
     if ((zMin < 0) && (zMax < 0))
-	G3d_fatalError("G3d_flushTilesInCube: coordinate out of Range");
+	Rast3d_fatalError("Rast3d_flushTilesInCube: coordinate out of Range");
     if ((zMin >= regionMaxZ) && (zMax >= regionMaxZ))
-	G3d_fatalError("G3d_flushTilesInCube: coordinate out of Range");
+	Rast3d_fatalError("Rast3d_flushTilesInCube: coordinate out of Range");
 
     zMin = MIN(MAX(0, zMin), regionMaxZ - 1);
 
-    G3d_coord2tileCoord(map, xMin, yMin, zMin,
+    Rast3d_coord2tileCoord(map, xMin, yMin, zMin,
 			&xTileMin, &yTileMin, &zTileMin,
 			&xOffs, &yOffs, &zOffs);
 
@@ -403,7 +403,7 @@ G3d_flushTilesInCube(RASTER3D_Map * map, int xMin, int yMin, int zMin, int xMax,
     if (zOffs != 0)
 	zTileMin++;
 
-    G3d_coord2tileCoord(map, xMax + 1, yMax + 1, zMax + 1,
+    Rast3d_coord2tileCoord(map, xMax + 1, yMax + 1, zMax + 1,
 			&xTileMax, &yTileMax, &zTileMax,
 			&xOffs, &yOffs, &zOffs);
 
@@ -411,9 +411,9 @@ G3d_flushTilesInCube(RASTER3D_Map * map, int xMin, int yMin, int zMin, int xMax,
     yTileMax--;
     zTileMax--;
 
-    if (!G3d_flushTileCube(map, xTileMin, yTileMin, zTileMin,
+    if (!Rast3d_flushTileCube(map, xTileMin, yTileMin, zTileMin,
 			   xTileMax, yTileMax, zTileMax)) {
-	G3d_error("G3d_flushTilesInCube: error in G3d_flushTileCube");
+	Rast3d_error("Rast3d_flushTilesInCube: error in Rast3d_flushTileCube");
 	return 0;
     }
 

lib/raster3d/volume.c

@@ -14,23 +14,23 @@ static int verifyVolumeVertices(map, v)
      double v[2][2][2][3];
 
 {
-    if (!(G3d_isValidLocation(map, v[0][0][0][0], v[0][0][0][1],
+    if (!(Rast3d_isValidLocation(map, v[0][0][0][0], v[0][0][0][1],
 			      v[0][0][0][2]) &&
-	  G3d_isValidLocation(map, v[0][0][1][0], v[0][0][1][1],
+	  Rast3d_isValidLocation(map, v[0][0][1][0], v[0][0][1][1],
 			      v[0][0][1][2]) &&
-	  G3d_isValidLocation(map, v[0][1][0][0], v[0][1][0][1],
+	  Rast3d_isValidLocation(map, v[0][1][0][0], v[0][1][0][1],
 			      v[0][1][0][2]) &&
-	  G3d_isValidLocation(map, v[0][1][1][0], v[0][1][1][1],
+	  Rast3d_isValidLocation(map, v[0][1][1][0], v[0][1][1][1],
 			      v[0][1][1][2]) &&
-	  G3d_isValidLocation(map, v[1][0][0][0], v[1][0][0][1],
+	  Rast3d_isValidLocation(map, v[1][0][0][0], v[1][0][0][1],
 			      v[1][0][0][2]) &&
-	  G3d_isValidLocation(map, v[1][0][1][0], v[1][0][1][1],
+	  Rast3d_isValidLocation(map, v[1][0][1][0], v[1][0][1][1],
 			      v[1][0][1][2]) &&
-	  G3d_isValidLocation(map, v[1][1][0][0], v[1][1][0][1],
+	  Rast3d_isValidLocation(map, v[1][1][0][0], v[1][1][0][1],
 			      v[1][1][0][2]) &&
-	  G3d_isValidLocation(map, v[1][1][1][0], v[1][1][1][1],
+	  Rast3d_isValidLocation(map, v[1][1][1][0], v[1][1][1][1],
 			      v[1][1][1][2])))
-	G3d_fatalError("verifyCubeVertices: volume vertex out of range");
+	Rast3d_fatalError("verifyCubeVertices: volume vertex out of range");
     return 0;
 }
 
@@ -43,14 +43,14 @@ static int verifyVolumeEdges(nx, ny, nz)
 
 {
     if ((nx <= 0) || (ny <= 0) || (nz <= 0))
-	G3d_fatalError("verifyCubeEdges: Volume edge out of range");
+	Rast3d_fatalError("verifyCubeEdges: Volume edge out of range");
     return 0;
 }
 
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_getVolumeA(void *map, double u[2][2][2][3], int nx, int ny, int nz,
+Rast3d_getVolumeA(void *map, double u[2][2][2][3], int nx, int ny, int nz,
 	       void *volumeBuf, int type)
 {
     typedef double doubleArray[3];
@@ -119,22 +119,22 @@ G3d_getVolumeA(void *map, double u[2][2][2][3], int nx, int ny, int nz,
 		v[1] = t * v0[1] + tp * v1[1];
 		v[2] = t * v0[2] + tp * v1[2];
 
-		G3d_location2coord2(map, v[0], v[1], v[2], &x, &y, &z);
+		Rast3d_location2coord2(map, v[0], v[1], v[2], &x, &y, &z);
 		/* DEBUG
 		   printf ("(%d %d %d) (%lf %lf %lf) (%d %d %d) %lf\n", 
 		   (int) dx / 2, (int) dy / 2, (int) dz / 2,
 		   v[0], v[1], v[2],
 		   x, y, z, 
-		   G3d_getDoubleRegion (map, x, y, z));
+		   Rast3d_getDoubleRegion (map, x, y, z));
 		 */
 		if (type == DCELL_TYPE)
 		    *(doubleBuf + ((int)dz / 2) * nx * ny +
 		      ((int)dy / 2) * nx + (int)dx / 2) =
-G3d_getDoubleRegion(map, x, y, z);
+Rast3d_getDoubleRegion(map, x, y, z);
 		else
 		    *(floatBuf + ((int)dz / 2) * nx * ny +
 		      ((int)dy / 2) * nx + (int)dx / 2) =
-G3d_getFloatRegion(map, x, y, z);
+Rast3d_getFloatRegion(map, x, y, z);
 	    }
 	}
     }
@@ -143,7 +143,7 @@ G3d_getFloatRegion(map, x, y, z);
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_getVolume(void *map,
+Rast3d_getVolume(void *map,
 	      double originNorth, double originWest, double originBottom,
 	      double vxNorth, double vxWest, double vxBottom,
 	      double vyNorth, double vyWest, double vyBottom,
@@ -184,19 +184,19 @@ G3d_getVolume(void *map,
     u[1][1][1][1] = (u[1][0][0][1] - u[0][0][0][1]) + u[0][1][1][1];
     u[1][1][1][2] = (u[1][0][0][2] - u[0][0][0][2]) + u[0][1][1][2];
 
-    G3d_getVolumeA(map, u, nx, ny, nz, volumeBuf, type);
+    Rast3d_getVolumeA(map, u, nx, ny, nz, volumeBuf, type);
 }
 
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_getAlignedVolume(void *map,
+Rast3d_getAlignedVolume(void *map,
 		     double originNorth, double originWest,
 		     double originBottom, double lengthNorth,
 		     double lengthWest, double lengthBottom, int nx, int ny,
 		     int nz, void *volumeBuf, int type)
 {
-    G3d_getVolume(map,
+    Rast3d_getVolume(map,
 		  originNorth, originWest, originBottom,
 		  originNorth + lengthNorth, originWest, originBottom,
 		  originNorth, originWest + lengthWest, originBottom,
@@ -207,7 +207,7 @@ G3d_getAlignedVolume(void *map,
 /*---------------------------------------------------------------------------*/
 
 void
-G3d_makeAlignedVolumeFile(void *map, const char *fileName,
+Rast3d_makeAlignedVolumeFile(void *map, const char *fileName,
 			  double originNorth, double originWest,
 			  double originBottom, double lengthNorth,
 			  double lengthWest, double lengthBottom, int nx,
@@ -218,14 +218,14 @@ G3d_makeAlignedVolumeFile(void *map, const char *fileName,
     int x, y, z, eltLength;
     RASTER3D_Region region;
 
-    volumeBuf = G3d_malloc(nx * ny * nz * sizeof(G3d_getFileType()));
+    volumeBuf = Rast3d_malloc(nx * ny * nz * sizeof(Rast3d_getFileType()));
     if (volumeBuf == NULL)
-	G3d_fatalError("G3d_makeAlignedVolumeFile: error in G3d_malloc");
+	Rast3d_fatalError("Rast3d_makeAlignedVolumeFile: error in Rast3d_malloc");
 
-    G3d_getAlignedVolume(map,
+    Rast3d_getAlignedVolume(map,
 			 originNorth, originWest, originBottom,
 			 lengthNorth, lengthWest, lengthBottom,
-			 nx, ny, nz, volumeBuf, G3d_getFileType());
+			 nx, ny, nz, volumeBuf, Rast3d_getFileType());
 
     region.north = originNorth;
     region.south = originNorth + lengthNorth;
@@ -238,30 +238,30 @@ G3d_makeAlignedVolumeFile(void *map, const char *fileName,
     region.cols = nx;
     region.depths = nz;
 
-    mapVolume = G3d_openCellNew(fileName, G3d_getFileType(),
+    mapVolume = Rast3d_openCellNew(fileName, Rast3d_getFileType(),
 				RASTER3D_USE_CACHE_DEFAULT, &region);
     if (mapVolume == NULL)
-	G3d_fatalError("G3d_makeAlignedVolumeFile: error in G3d_openCellNew");
+	Rast3d_fatalError("Rast3d_makeAlignedVolumeFile: error in Rast3d_openCellNew");
 
-    eltLength = G3d_length(G3d_getFileType());
+    eltLength = Rast3d_length(Rast3d_getFileType());
 
     for (z = 0; z < nz; z++) {
 	for (y = 0; y < ny; y++) {
 	    for (x = 0; x < nx; x++) {
-		/* G3d_putValueRegion? */
-		if (!G3d_putValue(mapVolume, x, y, z,
+		/* Rast3d_putValueRegion? */
+		if (!Rast3d_putValue(mapVolume, x, y, z,
 				  G_incr_void_ptr(volumeBuf,
 						  (z * ny * nx + y * nx +
 						   x) * eltLength),
-				  G3d_fileTypeMap(mapVolume)))
-		    G3d_fatalError
-			("G3d_makeAlignedVolumeFile: error in G3d_putValue");
+				  Rast3d_fileTypeMap(mapVolume)))
+		    Rast3d_fatalError
+			("Rast3d_makeAlignedVolumeFile: error in Rast3d_putValue");
 	    }
 	}
     }
 
-    if (!G3d_closeCell(mapVolume))
-	G3d_fatalError("G3d_makeAlignedVolumeFile: error in G3d_closeCell");
+    if (!Rast3d_closeCell(mapVolume))
+	Rast3d_fatalError("Rast3d_makeAlignedVolumeFile: error in Rast3d_closeCell");
 
-    G3d_free(volumeBuf);
+    Rast3d_free(volumeBuf);
 }

lib/raster3d/window.c

@@ -21,10 +21,10 @@ RASTER3D_Region g3d_window;
  *  \return void
  */
 
-void G3d_setWindowMap(RASTER3D_Map * map, RASTER3D_Region * window)
+void Rast3d_setWindowMap(RASTER3D_Map * map, RASTER3D_Region * window)
 {
-    G3d_regionCopy(&(map->window), window);
-    G3d_adjustRegion(&(map->window));
+    Rast3d_regionCopy(&(map->window), window);
+    Rast3d_adjustRegion(&(map->window));
 }
 
 /*---------------------------------------------------------------------------*/
@@ -40,10 +40,10 @@ void G3d_setWindowMap(RASTER3D_Map * map, RASTER3D_Region * window)
  *  \return void
  */
 
-void G3d_setWindow(RASTER3D_Region * window)
+void Rast3d_setWindow(RASTER3D_Region * window)
 {
-    G3d_regionCopy(&g3d_window, window);
-    G3d_adjustRegion(&g3d_window);
+    Rast3d_regionCopy(&g3d_window, window);
+    Rast3d_adjustRegion(&g3d_window);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -58,14 +58,14 @@ void G3d_setWindow(RASTER3D_Region * window)
  *  \return void
  */
 
-void G3d_getWindow(RASTER3D_Region * window)
+void Rast3d_getWindow(RASTER3D_Region * window)
 {
-    G3d_regionCopy(window, &g3d_window);
+    Rast3d_regionCopy(window, &g3d_window);
 }
 
 /*---------------------------------------------------------------------------*/
 
-RASTER3D_Region *G3d_windowPtr()
+RASTER3D_Region *Rast3d_windowPtr()
 {
     return &g3d_window;
 }
@@ -87,7 +87,7 @@ RASTER3D_Region *G3d_windowPtr()
  *  \return int
  */
 
-int G3d_isValidLocationWindow(RASTER3D_Map * map, double north, double east, double top)
+int Rast3d_isValidLocationWindow(RASTER3D_Map * map, double north, double east, double top)
 {
     return ((north >= map->window.south) && (north <= map->window.north) &&
 	    (east >= map->window.west) && (east <= map->window.east) &&

lib/raster3d/windowio.c

@@ -10,7 +10,7 @@
 /*---------------------------------------------------------------------------*/
 
 static int
-G3d_readWriteWindow(struct Key_Value *windowKeys, int doRead, int *proj,
+Rast3d_readWriteWindow(struct Key_Value *windowKeys, int doRead, int *proj,
 		    int *zone, double *north, double *south, double *east,
 		    double *west, double *top, double *bottom, int *rows,
 		    int *cols, int *depths, double *ew_res, double *ns_res,
@@ -20,12 +20,12 @@ G3d_readWriteWindow(struct Key_Value *windowKeys, int doRead, int *proj,
     int (*windowInt) (), (*windowDouble) ();
 
     if (doRead) {
-	windowDouble = G3d_keyGetDouble;
-	windowInt = G3d_keyGetInt;
+	windowDouble = Rast3d_keyGetDouble;
+	windowInt = Rast3d_keyGetInt;
     }
     else {
-	windowDouble = G3d_keySetDouble;
-	windowInt = G3d_keySetInt;
+	windowDouble = Rast3d_keySetDouble;
+	windowInt = Rast3d_keySetInt;
     }
 
     returnVal = 1;
@@ -50,7 +50,7 @@ G3d_readWriteWindow(struct Key_Value *windowKeys, int doRead, int *proj,
     if (returnVal)
 	return 1;
 
-    G3d_error("G3d_readWriteWindow: error writing window");
+    Rast3d_error("Rast3d_readWriteWindow: error writing window");
     return 0;
 }
 
@@ -58,7 +58,7 @@ G3d_readWriteWindow(struct Key_Value *windowKeys, int doRead, int *proj,
  * If windowName == NULL -> RASTER3D_WINDOW_ELEMENT ("$MAPSET/WIND3")
  * otherwise RASTER3D_WINDOW_DATABASE ("$MAPSET/windows3d/$NAME")
  */
-static void G3d_getFullWindowPath(char *path, const char *windowName)
+static void Rast3d_getFullWindowPath(char *path, const char *windowName)
 {
     char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
 
@@ -86,7 +86,7 @@ static void G3d_getFullWindowPath(char *path, const char *windowName)
 /*---------------------------------------------------------------------------*/
 /*
    static void
-   G3d_getWindowLocation (path, windowName)
+   Rast3d_getWindowLocation (path, windowName)
 
    char path[1024];
    char *windowName;
@@ -136,7 +136,7 @@ static void G3d_getFullWindowPath(char *path, const char *windowName)
  *          0 ... otherwise.
  */
 
-int G3d_readWindow(RASTER3D_Region * window, const char *windowName)
+int Rast3d_readWindow(RASTER3D_Region * window, const char *windowName)
 {
     struct Cell_head win;
     struct Key_Value *windowKeys;
@@ -162,16 +162,16 @@ int G3d_readWindow(RASTER3D_Region * window, const char *windowName)
 	window->tb_res = win.tb_res;
     }
     else {
-	G3d_getFullWindowPath(path, windowName);
+	Rast3d_getFullWindowPath(path, windowName);
 
 	if (access(path, R_OK) != 0) {
-	    G_warning("G3d_readWindow: unable to find [%s].", path);
+	    G_warning("Rast3d_readWindow: unable to find [%s].", path);
 	    return 0;
 	}
 
 	windowKeys = G_read_key_value_file(path);
 
-	if (!G3d_readWriteWindow(windowKeys, 1,
+	if (!Rast3d_readWriteWindow(windowKeys, 1,
 				 &(window->proj), &(window->zone),
 				 &(window->north), &(window->south),
 				 &(window->east), &(window->west),
@@ -179,8 +179,8 @@ int G3d_readWindow(RASTER3D_Region * window, const char *windowName)
 				 &(window->rows), &(window->cols),
 				 &(window->depths), &(window->ew_res),
 				 &(window->ns_res), &(window->tb_res))) {
-	    G3d_error
-		("G3d_readWindow: error extracting window key(s) of file %s",
+	    Rast3d_error
+		("Rast3d_readWindow: error extracting window key(s) of file %s",
 		 path);
 	    return 0;
 	}
@@ -195,7 +195,7 @@ int G3d_readWindow(RASTER3D_Region * window, const char *windowName)
 /* modified version of G__make_mapset_element */
 /*
    static int
-   G3d_createPath (thePath)
+   Rast3d_createPath (thePath)
 
    char *thePath;
 
@@ -250,7 +250,7 @@ int G3d_readWindow(RASTER3D_Region * window, const char *windowName)
 
 /*
    int
-   G3d_writeWindow (window, windowName)
+   Rast3d_writeWindow (window, windowName)
 
    RASTER3D_Region *window;
    char *windowName;
@@ -273,7 +273,7 @@ int G3d_readWindow(RASTER3D_Region * window, const char *windowName)
  *  \return void
  */
 
-void G3d_useWindowParams(void)
+void Rast3d_useWindowParams(void)
 {
-    G3d_setWindowParams();
+    Rast3d_setWindowParams();
 }

lib/raster3d/writeascii.c

@@ -16,7 +16,7 @@
  *  \return void
  */
 
-void G3d_writeAscii(void *map, const char *fname)
+void Rast3d_writeAscii(void *map, const char *fname)
 {
     FILE *fp;
     DCELL d1 = 0;
@@ -25,8 +25,8 @@ void G3d_writeAscii(void *map, const char *fname)
     int x, y, z;
     int rows, cols, depths, typeIntern;
 
-    G3d_getCoordsMap(map, &rows, &cols, &depths);
-    typeIntern = G3d_tileTypeMap(map);
+    Rast3d_getCoordsMap(map, &rows, &cols, &depths);
+    typeIntern = Rast3d_tileTypeMap(map);
 
     d1p = &d1;
     f1p = (FCELL *) &d1;
@@ -34,13 +34,13 @@ void G3d_writeAscii(void *map, const char *fname)
     if (fname == NULL)
         fp = stdout;
     else if ((fp = fopen(fname, "w")) == NULL)
-        G3d_fatalError("G3d_writeAscii: can't open file to write\n");
+        Rast3d_fatalError("Rast3d_writeAscii: can't open file to write\n");
 
     for (z = 0; z < depths; z++) {
         for (y = 0; y < rows; y++) {
             fprintf(fp, "z y x %d %d (%d - %d)\n", z, y, 0, cols - 1);
             for (x = 0; x < cols; x++) {
-                G3d_getValueRegion(map, x, y, z, d1p, typeIntern);
+                Rast3d_getValueRegion(map, x, y, z, d1p, typeIntern);
 
                 if (typeIntern == FCELL_TYPE)
                     fprintf(fp, "%.18f ", *f1p);

locale/po/grasslibs_ar.po

@@ -141,11 +141,11 @@ msgid "Unable to write output file <%s>"
 msgstr "لم يمكن فتحه %s فى %s"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:143
@@ -244,59 +244,59 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
+msgid "Rast3d_openCellOld: can't rewind file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
+msgid "Rast3d_openCellOld: projection does not match window projection"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
+msgid "Rast3d_openCellOld: zone does not match window zone"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
+msgid "Rast3d_openCellOld: can't read header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
+msgid "Rast3d_openCellOld: index does not fit into long"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:229
@@ -305,15 +305,15 @@ msgid "map <%s> is not in the current mapset"
 msgstr "خطأ: محاولة لتحديث خريطة ليست ضمن مجموعة الخرائط الحالية"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
+msgid "Rast3d_openCellNew: could not open file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
+msgid "Rast3d_openCellNew: can't write header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/vector/vedit/select.c:231

locale/po/grasslibs_cs.po

@@ -148,12 +148,12 @@ msgid "Unable to write output file <%s>"
 msgstr "Nelze otevøít soubor <%s>"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams: hodnota pøesnosti není platná"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams: hodnota pøesnosti není platná"
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams: dimenze dla¾dic není platná"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams: dimenze dla¾dic není platná"
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -269,60 +269,60 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "nelze získat informace o historii pro [%s] v mapsetu [%s]"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: chyba v G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: chyba v Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: chyba v G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: chyba v Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: chyba v G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: chyba v G_open_old"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld: chyba v G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld: chyba v Rast3d_openCellOldNoHeader"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: nemohu znovu natáhnoutsoubor"
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: nemohu znovu natáhnoutsoubor"
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: chyba v G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: chyba v Rast3d_readHeader"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
-msgstr "G3d_openCellOld: projekce mapy neodpovídá projekci okna"
+msgid "Rast3d_openCellOld: projection does not match window projection"
+msgstr "Rast3d_openCellOld: projekce mapy neodpovídá projekci okna"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: zóna neodpovídá zónì okna"
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: zóna neodpovídá zónì okna"
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld: nemohu pøeèíst hlavièku"
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld: nemohu pøeèíst hlavièku"
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: index neodpovídá typu long"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: index neodpovídá typu long"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: chyba v G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: chyba v Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: chyba v G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: chyba v Rast3d_fillHeader"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: chyba v G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: chyba v Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew: chyba v G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew: chyba v Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -330,16 +330,16 @@ msgid "map <%s> is not in the current mapset"
 msgstr "Rastrová mapa <%s> není v aktuálním mapsetu (%s)"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: nemohu otevøít soubor"
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: nemohu otevøít soubor"
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: nemohu ulo¾it hlavièku"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: nemohu ulo¾it hlavièku"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: chyba v G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: chyba v Rast3d_fillHeader"
 
 #: ../lib/vector/vedit/select.c:231
 msgid "Unknown query tool"

locale/po/grasslibs_de.po

@@ -147,12 +147,12 @@ msgid "Unable to write output file <%s>"
 msgstr "Kann Datei %s nicht öffnen."
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams: Genauigkeitswert ungültig"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams: Genauigkeitswert ungültig"
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams: Kacheldimensionswert ungültig"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams: Kacheldimensionswert ungültig"
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -269,60 +269,60 @@ msgstr ""
 "Kann die History-Informationen der Karte [%s] in Mapset [%s] nicht bekommen."
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: Fehler in G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: Fehler in Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: Fehler in G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: Fehler in Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: Fehler in G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: Fehler in G_open_old"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld: Fehler in G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld: Fehler in Rast3d_openCellOldNoHeader"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: Kann Datei nicht zurücksetzen"
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: Kann Datei nicht zurücksetzen"
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: Fehler in G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: Fehler in Rast3d_readHeader"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
-msgstr "G3d_openCellOld: Reprojektion passt nicht in das Fenster"
+msgid "Rast3d_openCellOld: projection does not match window projection"
+msgstr "Rast3d_openCellOld: Reprojektion passt nicht in das Fenster"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: Zone passt nicht mit der Fensterzone überein."
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: Zone passt nicht mit der Fensterzone überein."
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld: Kann die Headerdatei nicht lesen."
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld: Kann die Headerdatei nicht lesen."
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: Index passt nicht in das Format long"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: Index passt nicht in das Format long"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: Fehler in G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: Fehler in Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: Fehler in G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: Fehler in Rast3d_fillHeader"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: Fehlerin G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: Fehlerin Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew: Fehler in G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew: Fehler in Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -330,16 +330,16 @@ msgid "map <%s> is not in the current mapset"
 msgstr "BUG: Aktualisiere die Karte, welche nicht im aktuellen Mapset ist."
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: Kann Datei nicht öffnen."
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: Kann Datei nicht öffnen."
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: Kann Header nicht schreiben"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: Kann Header nicht schreiben"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: Fehler in G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: Fehler in Rast3d_fillHeader"
 
 #: ../lib/vector/vedit/select.c:231
 msgid "Unknown query tool"

locale/po/grasslibs_el.po

@@ -142,12 +142,12 @@ msgid "Unable to write output file <%s>"
 msgstr "Áäõíáìßá áíïßãìáôïò ôïõ áñ÷åßïõ ðïõ ðåñéÝ÷åé ôïí ðßíáêá datum <%s>"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams: ç ôéìÞ áêñßâåéáò åßíáé ìç åðéôñåðôÞ"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams: ç ôéìÞ áêñßâåéáò åßíáé ìç åðéôñåðôÞ"
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams: ç ôéìÞ tile åßíáé ìç åðéôñåðôÞ"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams: ç ôéìÞ tile åßíáé ìç åðéôñåðôÞ"
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -265,61 +265,61 @@ msgstr ""
 "äåäïìÝíá[%s]"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: óöÜëìá óôï G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: óöÜëìá óôï Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: óöÜëìá óôï G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: óöÜëìá óôï Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: óöÜëìá óôï G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: óöÜëìá óôï G_open_old"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "3d_openCellOld: óöÜëìá óôï G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "3d_openCellOld: óöÜëìá óôï Rast3d_openCellOldNoHeader"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: äåí åßíáé äõíáôÞ ç áíáäßðëùóç ôïõ áñ÷åßïõ"
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: äåí åßíáé äõíáôÞ ç áíáäßðëùóç ôïõ áñ÷åßïõ"
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: óöÜëìá óôï G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: óöÜëìá óôï Rast3d_readHeader"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
-msgstr "G3d_openCellOld: ç ðñïâïëÞ äåí ôáéñéÜæåé ìå ôçí ðñïâïëÞ ôïõ ðáñáèýñïõ"
+msgid "Rast3d_openCellOld: projection does not match window projection"
+msgstr "Rast3d_openCellOld: ç ðñïâïëÞ äåí ôáéñéÜæåé ìå ôçí ðñïâïëÞ ôïõ ðáñáèýñïõ"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: ç æþíç äåí ôáéñéÜæåé ìå ôç æþíç ôïõ ðáñáèýñïõ"
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: ç æþíç äåí ôáéñéÜæåé ìå ôç æþíç ôïõ ðáñáèýñïõ"
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
+msgid "Rast3d_openCellOld: can't read header"
 msgstr ""
-"G3d_openCellOld: äåí åßíáé äõíáôÞ ç áíÜãíùóç ôçò êåöáëßäáò áñ÷åßïõ (header)"
+"Rast3d_openCellOld: äåí åßíáé äõíáôÞ ç áíÜãíùóç ôçò êåöáëßäáò áñ÷åßïõ (header)"
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: index does not fit into long"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: index does not fit into long"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: óöÜëìá óôï G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: óöÜëìá óôï Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: óöÜëìá óôï G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: óöÜëìá óôï Rast3d_fillHeader"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: óöÜëìá óôï G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: óöÜëìá óôï Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew: óöÜëìá óôï G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew: óöÜëìá óôï Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -327,16 +327,16 @@ msgid "map <%s> is not in the current mapset"
 msgstr "Ï ñáóôåñ ÷Üñôçò <%s> äåí áíÞêåé óôï ôñÝ÷ïí mapset (%s)"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: äåí ìðïñåß íá áíïßîåé ôï áñ÷åßï"
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: äåí ìðïñåß íá áíïßîåé ôï áñ÷åßï"
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: äåí ìðïñåß íá ãñáöôåß ç êåöáëßäá (header)"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: äåí ìðïñåß íá ãñáöôåß ç êåöáëßäá (header)"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: óöÜëìá óôï G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: óöÜëìá óôï Rast3d_fillHeader"
 
 #: ../lib/vector/vedit/select.c:231
 msgid "Unknown query tool"

locale/po/grasslibs_es.po

@@ -149,12 +149,12 @@ msgid "Unable to write output file <%s>"
 msgstr "No se puede abrir el archivo <%s>"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams: Valor de precisión inválido."
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams: Valor de precisión inválido."
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams: Valor de dimensión de mosaico no válido."
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams: Valor de dimensión de mosaico no válido."
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -275,61 +275,61 @@ msgstr ""
 "de mapas de usuario (mapset) [%s]."
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: Error en G3d_maskOpenOld."
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: Error en Rast3d_maskOpenOld."
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: Error en G3d_malloc."
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: Error en Rast3d_malloc."
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: Error en G_open_old."
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: Error en G_open_old."
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld: Error en G3d_openCellOldNoHeader."
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld: Error en Rast3d_openCellOldNoHeader."
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: No se puede regresar al comienzo del archivo."
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: No se puede regresar al comienzo del archivo."
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: Error en G3d_readHeader."
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: Error en Rast3d_readHeader."
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
+msgid "Rast3d_openCellOld: projection does not match window projection"
 msgstr ""
-"G3d_openCellOld: La proyección no coincide con la proyección de la ventana."
+"Rast3d_openCellOld: La proyección no coincide con la proyección de la ventana."
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: La zona no coincide con la zona de la ventana."
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: La zona no coincide con la zona de la ventana."
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld: No se puede leer el encabezado."
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld: No se puede leer el encabezado."
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: El índice no se ajusta a la longitud."
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: El índice no se ajusta a la longitud."
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: Error en G3d_malloc."
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: Error en Rast3d_malloc."
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: Error en G3d_fillHeader."
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: Error en Rast3d_fillHeader."
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: Error en G3d_maskOpenOld."
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: Error en Rast3d_maskOpenOld."
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew: Error en G3d_malloc."
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew: Error en Rast3d_malloc."
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -338,16 +338,16 @@ msgstr ""
 "El mapa raster <%s> no se encuentra en el directorio de mapas actual. (%s)"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: No se puede abrir el archivo."
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: No se puede abrir el archivo."
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: No se puede escribir el encabezado."
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: No se puede escribir el encabezado."
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: Error en G3d_fillHeader."
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: Error en Rast3d_fillHeader."
 
 #: ../lib/vector/vedit/select.c:231
 msgid "Unknown query tool"

locale/po/grasslibs_fr.po

@@ -142,12 +142,12 @@ msgid "Unable to write output file <%s>"
 msgstr "Impossible d'ouvrir le fichier statistique <%s>"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams : valeur de précision invalide"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams : valeur de précision invalide"
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams : valeur de dimension de tuile invalide"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams : valeur de dimension de tuile invalide"
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -265,62 +265,62 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "impossible d'obtenir l'historique pour [%s] dans le mapset [%s]"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader : erreur dans G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader : erreur dans Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader : erreur dans G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader : erreur dans Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader : erreur dans G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader : erreur dans G_open_old"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld : erreur dans G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld : erreur dans Rast3d_openCellOldNoHeader"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld : impossible de recharger le fichier"
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld : impossible de recharger le fichier"
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld : erreur dans G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld : erreur dans Rast3d_readHeader"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
+msgid "Rast3d_openCellOld: projection does not match window projection"
 msgstr ""
-"G3d_openCellOld : la projection ne correspond pas à la projection de la "
+"Rast3d_openCellOld : la projection ne correspond pas à la projection de la "
 "fenêtre"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld : la zone ne correspond pas à la zone de la fenêtre"
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld : la zone ne correspond pas à la zone de la fenêtre"
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld : impossible de lire l'en-tête"
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld : impossible de lire l'en-tête"
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld : l'index ne loge pas dans un champ long"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld : l'index ne loge pas dans un champ long"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld : erreur dans G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld : erreur dans Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld : erreur dans G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld : erreur dans Rast3d_fillHeader"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew : erreur dans G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew : erreur dans Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew : erreur dans G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew : erreur dans Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -328,16 +328,16 @@ msgid "map <%s> is not in the current mapset"
 msgstr "pas de fichier %s disponible dans le jeu de données actuel\n"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew : impossible d'ouvrir le fichier"
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew : impossible d'ouvrir le fichier"
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew : impossible d'écrire l'en-tête"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew : impossible d'écrire l'en-tête"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew : erreur dans G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew : erreur dans Rast3d_fillHeader"
 
 #: ../lib/vector/vedit/select.c:231
 #, fuzzy

locale/po/grasslibs_hi.po

@@ -140,11 +140,11 @@ msgid "Unable to write output file <%s>"
 msgstr "का"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:143
@@ -242,59 +242,59 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "के लिए"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
+msgid "Rast3d_openCellOld: can't rewind file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
+msgid "Rast3d_openCellOld: projection does not match window projection"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
+msgid "Rast3d_openCellOld: zone does not match window zone"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
+msgid "Rast3d_openCellOld: can't read header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
+msgid "Rast3d_openCellOld: index does not fit into long"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:229
@@ -303,15 +303,15 @@ msgid "map <%s> is not in the current mapset"
 msgstr "है नहीं."
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
+msgid "Rast3d_openCellNew: could not open file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
+msgid "Rast3d_openCellNew: can't write header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/vector/vedit/select.c:231

locale/po/grasslibs_it.po

@@ -147,12 +147,12 @@ msgid "Unable to write output file <%s>"
 msgstr "Impossibile aprire il file %s in %s"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams: valore di precisione invalido"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams: valore di precisione invalido"
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams: valore di dimensione tile invalido"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams: valore di dimensione tile invalido"
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -263,61 +263,61 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "Non riesco a trovare lo storico per [%s] nel mapset [%s]"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: errore in G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: errore in Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: errore in G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: errore in Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: errore in G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: errore in G_open_old"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld: errore in G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld: errore in Rast3d_openCellOldNoHeader"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: impossibile riavvolgere file"
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: impossibile riavvolgere file"
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: errore in G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: errore in Rast3d_readHeader"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
+msgid "Rast3d_openCellOld: projection does not match window projection"
 msgstr ""
-"G3d_openCellOld: proiezione non corrisponde alla proiezione della finestra"
+"Rast3d_openCellOld: proiezione non corrisponde alla proiezione della finestra"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: zona non corrisponde alla zona della finestra"
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: zona non corrisponde alla zona della finestra"
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld: impossibile leggere testata"
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld: impossibile leggere testata"
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: indice non è adatto per long"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: indice non è adatto per long"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: errore in G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: errore in Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: errore in G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: errore in Rast3d_fillHeader"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: errore in G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: errore in Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew: errore in G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew: errore in Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -326,16 +326,16 @@ msgstr ""
 "Bug: attesa di aggiornamento di una mappa non presente nel mapset in uso"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: impossibile aprire file"
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: impossibile aprire file"
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: impossibile scrivere testata"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: impossibile scrivere testata"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: errore in G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: errore in Rast3d_fillHeader"
 
 #: ../lib/vector/vedit/select.c:231
 msgid "Unknown query tool"

locale/po/grasslibs_ja.po

@@ -145,12 +145,12 @@ msgid "Unable to write output file <%s>"
 msgstr "���"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams: 精度の値は不正です"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams: 精度の値は不正です"
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams: タイル ディメンション値は無効です"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams: タイル ディメンション値は無効です"
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -266,60 +266,60 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "マップセット [%s]内から [%s] の履歴を取得出来ません"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: G3d_maskOpenOldにおけるエラー"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: Rast3d_maskOpenOldにおけるエラー"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: G3d_mallocにおけるエラー"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: Rast3d_mallocにおけるエラー"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: G_open_oldにおけるエラー"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: G_open_oldにおけるエラー"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld: G3d_openCellOldNoHeaderにおけるエラー"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld: Rast3d_openCellOldNoHeaderにおけるエラー"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: ファイルを巻き戻せません"
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: ファイルを巻き戻せません"
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: G3d_readHeaderにおけるエラー"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: Rast3d_readHeaderにおけるエラー"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
-msgstr "G3d_openCellOld: 投影はウインドー投影と一致しません"
+msgid "Rast3d_openCellOld: projection does not match window projection"
+msgstr "Rast3d_openCellOld: 投影はウインドー投影と一致しません"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: ゾーンがウインドウゾーンと一致しません"
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: ゾーンがウインドウゾーンと一致しません"
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld: ヘッダーを読み込めません"
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld: ヘッダーを読み込めません"
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: 索引がロングに適合しません"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: 索引がロングに適合しません"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: G3d_mallocにおけるエラー"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: Rast3d_mallocにおけるエラー"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: G3d_fillHeaderにおけるエラー"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: Rast3d_fillHeaderにおけるエラー"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: G3d_maskOpenOldにおけるエラー"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: Rast3d_maskOpenOldにおけるエラー"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew: G3d_mallocにおけるエラー"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew: Rast3d_mallocにおけるエラー"
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -327,16 +327,16 @@ msgid "map <%s> is not in the current mapset"
 msgstr "���"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: ファイルを開けません"
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: ファイルを開けません"
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: ヘッダーを書き込めません"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: ヘッダーを書き込めません"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: G3d_fillHeaderにおけるエラー"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: Rast3d_fillHeaderにおけるエラー"
 
 #: ../lib/vector/vedit/select.c:231
 msgid "Unknown query tool"

locale/po/grasslibs_ko.po

@@ -141,11 +141,11 @@ msgid "Unable to write output file <%s>"
 msgstr "Datum %s 테이블파일을 열 수 없습니다"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:143
@@ -243,59 +243,59 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
+msgid "Rast3d_openCellOld: can't rewind file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
+msgid "Rast3d_openCellOld: projection does not match window projection"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
+msgid "Rast3d_openCellOld: zone does not match window zone"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
+msgid "Rast3d_openCellOld: can't read header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
+msgid "Rast3d_openCellOld: index does not fit into long"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:229
@@ -304,15 +304,15 @@ msgid "map <%s> is not in the current mapset"
 msgstr "'%s' 디버그파일을 열 수 없습니다"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
+msgid "Rast3d_openCellNew: could not open file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
+msgid "Rast3d_openCellNew: can't write header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/vector/vedit/select.c:231

locale/po/grasslibs_lv.po

@@ -146,11 +146,11 @@ msgid "Unable to write output file <%s>"
 msgstr "Neiespējami atvērt failu %s iekš %s"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:143
@@ -258,59 +258,59 @@ msgstr ""
 "nevar iegūt vēstures informāciju priekš [%s] no karšu biblotēkas/mapset [%s]"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
+msgid "Rast3d_openCellOld: can't rewind file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
+msgid "Rast3d_openCellOld: projection does not match window projection"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
+msgid "Rast3d_openCellOld: zone does not match window zone"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
+msgid "Rast3d_openCellOld: can't read header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
+msgid "Rast3d_openCellOld: index does not fit into long"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:229
@@ -319,15 +319,15 @@ msgid "map <%s> is not in the current mapset"
 msgstr "Defekts: atteikts papildināt karti,kura nav tekošajā karšu komplektā."
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
+msgid "Rast3d_openCellNew: could not open file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
+msgid "Rast3d_openCellNew: can't write header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/vector/vedit/select.c:231

locale/po/grasslibs_ml.po

@@ -140,11 +140,11 @@ msgid "Unable to write output file <%s>"
 msgstr "ടേബിൾ ഉണ്ടാക്കാൻ പറ്റുന്നില്ല <%s>"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:143
@@ -242,59 +242,59 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
+msgid "Rast3d_openCellOld: can't rewind file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
+msgid "Rast3d_openCellOld: projection does not match window projection"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
+msgid "Rast3d_openCellOld: zone does not match window zone"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
+msgid "Rast3d_openCellOld: can't read header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
+msgid "Rast3d_openCellOld: index does not fit into long"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:229
@@ -303,15 +303,15 @@ msgid "map <%s> is not in the current mapset"
 msgstr "തെറ്റ്: നിലവിലുള്ള മാപ്പ്സെറ്റിലില്ലാത്ത മാപ്പിനെ മാറ്റം വരുത്താൻ ശ്രമിക്കുന്നു"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
+msgid "Rast3d_openCellNew: could not open file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
+msgid "Rast3d_openCellNew: can't write header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/vector/vedit/select.c:231

locale/po/grasslibs_mr.po

@@ -139,11 +139,11 @@ msgid "Unable to write output file <%s>"
 msgstr "%s उघडता आले नाही"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:143
@@ -241,59 +241,59 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
+msgid "Rast3d_openCellOld: can't rewind file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
+msgid "Rast3d_openCellOld: projection does not match window projection"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
+msgid "Rast3d_openCellOld: zone does not match window zone"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
+msgid "Rast3d_openCellOld: can't read header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
+msgid "Rast3d_openCellOld: index does not fit into long"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:229
@@ -302,15 +302,15 @@ msgid "map <%s> is not in the current mapset"
 msgstr "temp फाइल उघडता आली नाही"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
+msgid "Rast3d_openCellNew: could not open file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
+msgid "Rast3d_openCellNew: can't write header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/vector/vedit/select.c:231

locale/po/grasslibs_pl.po

@@ -142,12 +142,12 @@ msgid "Unable to write output file <%s>"
 msgstr "Nie można zapisać pliku wyjściowego <%s>"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams: błędna liczba miejsc dziesiętnych"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams: błędna liczba miejsc dziesiętnych"
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams: błędny wymiar kafli"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams: błędny wymiar kafli"
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -261,60 +261,60 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "nie można pobrać historii dla [%s] w mapsecie [%s]"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: błąd w G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: błąd w Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: błąd w G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: błąd w Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: błąd w G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: błąd w G_open_old"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld: błąd w G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld: błąd w Rast3d_openCellOldNoHeader"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: nie można przewinąć pliku"
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: nie można przewinąć pliku"
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: błąd w G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: błąd w Rast3d_readHeader"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
-msgstr "G3d_openCellOld: odwzorowanie inne niż odwzorowanie regionu"
+msgid "Rast3d_openCellOld: projection does not match window projection"
+msgstr "Rast3d_openCellOld: odwzorowanie inne niż odwzorowanie regionu"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: strefa inna niż strefa regionu"
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: strefa inna niż strefa regionu"
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld: nie można odczytać nagłówka"
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld: nie można odczytać nagłówka"
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: indeks nie mieści się w long"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: indeks nie mieści się w long"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: błąd w G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: błąd w Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: błąd w G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: błąd w Rast3d_fillHeader"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: błąd w G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: błąd w Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew: błąd w G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew: błąd w Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:229
 #, c-format
@@ -322,16 +322,16 @@ msgid "map <%s> is not in the current mapset"
 msgstr "mapa <%s> nie znajduje się w bieżącym mapsecie"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: nie można otworzyć pliku"
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: nie można otworzyć pliku"
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: nie można zapisać nagłówka"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: nie można zapisać nagłówka"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: błąd w G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: błąd w Rast3d_fillHeader"
 
 #: ../lib/vector/vedit/select.c:231
 msgid "Unknown query tool"

locale/po/grasslibs_pt.po

@@ -146,12 +146,12 @@ msgid "Unable to write output file <%s>"
 msgstr "Impossível abrir arquivo %s"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams: valores de precisão inválidos"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams: valores de precisão inválidos"
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams: dimensão do recorte inválido"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams: dimensão do recorte inválido"
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -267,60 +267,60 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "não consegui obter dados históricos para [%s] no mapset [%s]"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: erro em G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: erro em Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: erro em G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: erro em Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: erro em G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: erro em G_open_old"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld: erro em G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld: erro em Rast3d_openCellOldNoHeader"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: não posso rebobinar aquivo"
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: não posso rebobinar aquivo"
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: erro em G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: erro em Rast3d_readHeader"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
-msgstr "G3d_openCellOld: projeção não coincide com a projeção na janela"
+msgid "Rast3d_openCellOld: projection does not match window projection"
+msgstr "Rast3d_openCellOld: projeção não coincide com a projeção na janela"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: zona não coincide com a zona da janela"
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: zona não coincide com a zona da janela"
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld: não consigo ler cabeçalho"
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld: não consigo ler cabeçalho"
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: index não cabe num long"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: index não cabe num long"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: erro em G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: erro em Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: erro em G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: erro em Rast3d_fillHeader"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: erro em G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: erro em Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew: erro em G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew: erro em Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -328,16 +328,16 @@ msgid "map <%s> is not in the current mapset"
 msgstr "Bug: tentativa de atualizar mapa que não está no mapset atual."
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: não consegui abrir arquivo"
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: não consegui abrir arquivo"
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: não consegui escrever cabeçalho"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: não consegui escrever cabeçalho"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: erro em G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: erro em Rast3d_fillHeader"
 
 #: ../lib/vector/vedit/select.c:231
 #, fuzzy

locale/po/grasslibs_pt_br.po

@@ -146,11 +146,11 @@ msgid "Unable to write output file <%s>"
 msgstr "não foi possível abrir o arquivo %s em %s"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:143
@@ -257,60 +257,60 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "não consegui obter dados históricos para [%s] no mapset [%s]"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: erro em G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: erro em Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: erro em G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: erro em Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: erro em G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: erro em G_open_old"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld: erro em G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld: erro em Rast3d_openCellOldNoHeader"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: não posso rebobinar aquivo"
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: não posso rebobinar aquivo"
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: erro em G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: erro em Rast3d_readHeader"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
-msgstr "G3d_openCellOld: projeção não coincide com a projeção na janela"
+msgid "Rast3d_openCellOld: projection does not match window projection"
+msgstr "Rast3d_openCellOld: projeção não coincide com a projeção na janela"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: zona não coincide com a zona da janela"
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: zona não coincide com a zona da janela"
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld: não consigo ler cabeçalho"
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld: não consigo ler cabeçalho"
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: index não cabe num long"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: index não cabe num long"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: erro em G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: erro em Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: erro em G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: erro em Rast3d_fillHeader"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: erro em G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: erro em Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew: erro em G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew: erro em Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -318,16 +318,16 @@ msgid "map <%s> is not in the current mapset"
 msgstr "Bug: tentativa de atualizar mapa que não está no mapset atual."
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: não consegui abrir arquivo"
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: não consegui abrir arquivo"
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: não consegui escrever cabeçalho"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: não consegui escrever cabeçalho"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: erro em G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: erro em Rast3d_fillHeader"
 
 #: ../lib/vector/vedit/select.c:231
 #, fuzzy

locale/po/grasslibs_ru.po

@@ -140,12 +140,12 @@ msgid "Unable to write output file <%s>"
 msgstr "Невозможно открыть файл статистики <%s>"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams: неправильное значение точности"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams: неправильное значение точности"
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams: неправильные размеры тайлов"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams: неправильные размеры тайлов"
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -263,60 +263,60 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "невозможно прочитать историю для [%s] в наборе [%s]"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: ошибка в G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: ошибка в Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: ошибка в G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: ошибка в Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: ошибка в G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: ошибка в G_open_old"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld: ошибка в G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld: ошибка в Rast3d_openCellOldNoHeader"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: невозможно перемотать файл"
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: невозможно перемотать файл"
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: ошибка в G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: ошибка в Rast3d_readHeader"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
-msgstr "G3d_openCellOld: проекция не соответствует проекции окна"
+msgid "Rast3d_openCellOld: projection does not match window projection"
+msgstr "Rast3d_openCellOld: проекция не соответствует проекции окна"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: зона не совпадает с зоной окна"
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: зона не совпадает с зоной окна"
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld: невозможно прочитать заголовок"
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld: невозможно прочитать заголовок"
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: индекс не помещается в long"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: индекс не помещается в long"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: ошибка в G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: ошибка в Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: ошибка в G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: ошибка в Rast3d_fillHeader"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: ошибка в G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: ошибка в Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew: ошибка в G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew: ошибка в Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -324,16 +324,16 @@ msgid "map <%s> is not in the current mapset"
 msgstr "Растрового слоя <%s> нет в текущем наборе (%s)"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: невозможно открыть файл"
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: невозможно открыть файл"
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: невозможно создать заголовок"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: невозможно создать заголовок"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: ошибка в G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: ошибка в Rast3d_fillHeader"
 
 #: ../lib/vector/vedit/select.c:231
 msgid "Unknown query tool"

locale/po/grasslibs_sl.po

@@ -142,11 +142,11 @@ msgid "Unable to write output file <%s>"
 msgstr "Nezmo¾en odpreti datoteko %s v %s"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:143
@@ -254,59 +254,59 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "ne morem dobiti podatka \"history\" za [%s] v \"mapset\" [%s]"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
+msgid "Rast3d_openCellOld: can't rewind file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
+msgid "Rast3d_openCellOld: projection does not match window projection"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
+msgid "Rast3d_openCellOld: zone does not match window zone"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
+msgid "Rast3d_openCellOld: can't read header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
+msgid "Rast3d_openCellOld: index does not fit into long"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:229
@@ -315,15 +315,15 @@ msgid "map <%s> is not in the current mapset"
 msgstr "Hro¹è: poskus posodobitve sloja, ki ni v trenutnem mapset."
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
+msgid "Rast3d_openCellNew: could not open file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
+msgid "Rast3d_openCellNew: can't write header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/vector/vedit/select.c:231

locale/po/grasslibs_th.po

@@ -143,12 +143,12 @@ msgid "Unable to write output file <%s>"
 msgstr "ไม่สามารถระบุสภาพไฟล์ <%s>"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams:ค่าความละเอียดไม่ถูกต้อง"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams:ค่าความละเอียดไม่ถูกต้อง"
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams: มิติของ tile ไม่ถูกต้อง"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams: มิติของ tile ไม่ถูกต้อง"
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -264,60 +264,60 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "ไม่สามารถอ่านข้อมูล ประวัติสำหรับ [%s] ในชุดแผนที่  [%s]"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: ข้อผิดพลาดใน  G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: ข้อผิดพลาดใน  Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: ข้อผิดพลาดใน  G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: ข้อผิดพลาดใน  Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: ข้อผิดพลาดใน  G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: ข้อผิดพลาดใน  G_open_old"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld: ข้อผิดพลาดใน  G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld: ข้อผิดพลาดใน  Rast3d_openCellOldNoHeader"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: ไม่สามารถย้อนไฟล์กลับได้"
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: ไม่สามารถย้อนไฟล์กลับได้"
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: ข้อผิดพลาดใน  G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: ข้อผิดพลาดใน  Rast3d_readHeader"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
-msgstr "G3d_openCellOld: การฉายไม่เหมาะสมกับการฉายของหน้าต่างนี้"
+msgid "Rast3d_openCellOld: projection does not match window projection"
+msgstr "Rast3d_openCellOld: การฉายไม่เหมาะสมกับการฉายของหน้าต่างนี้"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: โซนไม่เหมาะสมกับโซนของหน้าต่างนี้"
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: โซนไม่เหมาะสมกับโซนของหน้าต่างนี้"
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld: ไม่สามารถอ่านส่วนหัวได้"
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld: ไม่สามารถอ่านส่วนหัวได้"
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: ค่าดัชนี แปลงเป็นค่าแบบ  long ไม่ได้"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: ค่าดัชนี แปลงเป็นค่าแบบ  long ไม่ได้"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: ข้อผิดพลาดใน  G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: ข้อผิดพลาดใน  Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: ข้อผิดพลาดใน  G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: ข้อผิดพลาดใน  Rast3d_fillHeader"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: ข้อผิดพลาดใน  G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: ข้อผิดพลาดใน  Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew: ข้อผิดพลาดใน  G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew: ข้อผิดพลาดใน  Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -325,16 +325,16 @@ msgid "map <%s> is not in the current mapset"
 msgstr "ข้อผิดพลาด: ตั้งใจที่จะปรับปรุงแผนที่ ที่ไม่อยู่ในชุดแผนที่ที่กำลังใช้งาน"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: ไม่สามารถเปิดไฟล์ได้"
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: ไม่สามารถเปิดไฟล์ได้"
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: ไม่สามารถเขียนส่วนหัวได้"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: ไม่สามารถเขียนส่วนหัวได้"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: ข้อผิดพลาดใน  G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: ข้อผิดพลาดใน  Rast3d_fillHeader"
 
 #: ../lib/vector/vedit/select.c:231
 #, fuzzy

locale/po/grasslibs_tr.po

@@ -141,11 +141,11 @@ msgid "Unable to write output file <%s>"
 msgstr "datum tablo dosyası açılamıyor <%s>"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../lib/g3d/g3dparam.c:143
@@ -246,59 +246,59 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "[%s] harita takımındaki [%s] in geçmiş bilgisi alınamıyor"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
+msgid "Rast3d_openCellOld: can't rewind file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
+msgid "Rast3d_openCellOld: projection does not match window projection"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
+msgid "Rast3d_openCellOld: zone does not match window zone"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
+msgid "Rast3d_openCellOld: can't read header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
+msgid "Rast3d_openCellOld: index does not fit into long"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:229
@@ -307,15 +307,15 @@ msgid "map <%s> is not in the current mapset"
 msgstr "%s dosyası geçerli harita takımında değil (%s)"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
+msgid "Rast3d_openCellNew: could not open file"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
+msgid "Rast3d_openCellNew: can't write header"
 msgstr ""
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
 msgstr ""
 
 #: ../lib/vector/vedit/select.c:231

locale/po/grasslibs_vi.po

@@ -143,12 +143,12 @@ msgid "Unable to write output file <%s>"
 msgstr "Không thể mở tập tin %s trong %s"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams: giá trị độ chính xác không hợp lệ"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams: giá trị độ chính xác không hợp lệ"
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams: giá trị kích thước 'tile' không hợp lệ"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams: giá trị kích thước 'tile' không hợp lệ"
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -264,60 +264,60 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "không thể lấy thông tin lịch sử cho [%s] trong bộ bản đồ [%s] "
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: lỗi trong G3d_maskOpenOld"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: lỗi trong Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: lỗi trong G3d_malloc"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: lỗi trong Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: lỗi trong G_open_old"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: lỗi trong G_open_old"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld: lỗi trong G3d_openCellOldNoHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld: lỗi trong Rast3d_openCellOldNoHeader"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: không thể tua lại tập tin"
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: không thể tua lại tập tin"
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: lỗi trong G3d_readHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: lỗi trong Rast3d_readHeader"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
-msgstr "G3d_openCellOld: phép chiếu không khớp với phép chiếu của cửa sổ"
+msgid "Rast3d_openCellOld: projection does not match window projection"
+msgstr "Rast3d_openCellOld: phép chiếu không khớp với phép chiếu của cửa sổ"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: múi không khớp với múi của cửa sổ"
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: múi không khớp với múi của cửa sổ"
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld: không thể đọc header"
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld: không thể đọc header"
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: chỉ mục không vừa vào định dạng long"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: chỉ mục không vừa vào định dạng long"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: lỗi trong G3d_malloc"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: lỗi trong Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: lỗi trong G3d_fillHeader"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: lỗi trong Rast3d_fillHeader"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: lỗi trong G3d_maskOpenOld"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: lỗi trong Rast3d_maskOpenOld"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr " G3d_openCellNew: lỗi trong G3d_malloc"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr " Rast3d_openCellNew: lỗi trong Rast3d_malloc"
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -325,16 +325,16 @@ msgid "map <%s> is not in the current mapset"
 msgstr "'Bọ': cố gắng cập nhật bản đồ không ở trong bộ bản đồ hiện tại."
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: không thể mở tập tin"
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: không thể mở tập tin"
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: không thể ghi header"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: không thể ghi header"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: lỗi trong G3d_fillHeader"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: lỗi trong Rast3d_fillHeader"
 
 #: ../lib/vector/vedit/select.c:231
 msgid "Unknown query tool"

locale/po/grasslibs_zh.po

@@ -144,12 +144,12 @@ msgid "Unable to write output file <%s>"
 msgstr "无法打开文件 %s 在 %s 中"
 
 #: ../lib/g3d/g3dparam.c:86
-msgid "G3d_getStandard3dParams: precision value invalid"
-msgstr "G3d_getStandard3dParams: 无效的精度值"
+msgid "Rast3d_getStandard3dParams: precision value invalid"
+msgstr "Rast3d_getStandard3dParams: 无效的精度值"
 
 #: ../lib/g3d/g3dparam.c:119
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
-msgstr "G3d_getStandard3dParams: 无效的扩展维度值"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
+msgstr "Rast3d_getStandard3dParams: 无效的扩展维度值"
 
 #: ../lib/g3d/g3dparam.c:143
 msgid "Window replacing the default"
@@ -265,60 +265,60 @@ msgid "can't get history information for [%s] in mapset [%s]"
 msgstr "无法得到[%s](在地图集[%s]中)的历史信息"
 
 #: ../lib/g3d/g3dopen.c:20
-msgid "G3d_openCellOldNoHeader: error in G3d_maskOpenOld"
-msgstr "G3d_openCellOldNoHeader: G3d_maskOpenOld错误"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellOldNoHeader: Rast3d_maskOpenOld错误"
 
 #: ../lib/g3d/g3dopen.c:26
-msgid "G3d_openCellOldNoHeader: error in G3d_malloc"
-msgstr "G3d_openCellOldNoHeader: G3d_malloc错误"
+msgid "Rast3d_openCellOldNoHeader: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOldNoHeader: Rast3d_malloc错误"
 
 #: ../lib/g3d/g3dopen.c:37
-msgid "G3d_openCellOldNoHeader: error in G_open_old"
-msgstr "G3d_openCellOldNoHeader: G_open_old错误"
+msgid "Rast3d_openCellOldNoHeader: error in G_open_old"
+msgstr "Rast3d_openCellOldNoHeader: G_open_old错误"
 
 #: ../lib/g3d/g3dopen.c:91
-msgid "G3d_openCellOld: error in G3d_openCellOldNoHeader"
-msgstr "G3d_openCellOld: G3d_openCellOldNoHeader错误"
+msgid "Rast3d_openCellOld: error in Rast3d_openCellOldNoHeader"
+msgstr "Rast3d_openCellOld: Rast3d_openCellOldNoHeader错误"
 
 #: ../lib/g3d/g3dopen.c:96
-msgid "G3d_openCellOld: can't rewind file"
-msgstr "G3d_openCellOld: "
+msgid "Rast3d_openCellOld: can't rewind file"
+msgstr "Rast3d_openCellOld: "
 
 #: ../lib/g3d/g3dopen.c:108
-msgid "G3d_openCellOld: error in G3d_readHeader"
-msgstr "G3d_openCellOld: G3d_readHeader错误"
+msgid "Rast3d_openCellOld: error in Rast3d_readHeader"
+msgstr "Rast3d_openCellOld: Rast3d_readHeader错误"
 
 #: ../lib/g3d/g3dopen.c:116
-msgid "G3d_openCellOld: projection does not match window projection"
-msgstr "G3d_openCellOld: 投影类型与窗口投影类型不匹配"
+msgid "Rast3d_openCellOld: projection does not match window projection"
+msgstr "Rast3d_openCellOld: 投影类型与窗口投影类型不匹配"
 
 #: ../lib/g3d/g3dopen.c:120
-msgid "G3d_openCellOld: zone does not match window zone"
-msgstr "G3d_openCellOld: 投影带与窗口投影带不匹配"
+msgid "Rast3d_openCellOld: zone does not match window zone"
+msgstr "Rast3d_openCellOld: 投影带与窗口投影带不匹配"
 
 #: ../lib/g3d/g3dopen.c:132 ../lib/g3d/g3dopen.c:149
-msgid "G3d_openCellOld: can't read header"
-msgstr "G3d_openCellOld: 不能读取文件头"
+msgid "Rast3d_openCellOld: can't read header"
+msgstr "Rast3d_openCellOld: 不能读取文件头"
 
 #: ../lib/g3d/g3dopen.c:138
-msgid "G3d_openCellOld: index does not fit into long"
-msgstr "G3d_openCellOld: 索引长度有误"
+msgid "Rast3d_openCellOld: index does not fit into long"
+msgstr "Rast3d_openCellOld: 索引长度有误"
 
 #: ../lib/g3d/g3dopen.c:142
-msgid "G3d_openCellOld: error in G3d_malloc"
-msgstr "G3d_openCellOld: G3d_malloc错误"
+msgid "Rast3d_openCellOld: error in Rast3d_malloc"
+msgstr "Rast3d_openCellOld: Rast3d_malloc错误"
 
 #: ../lib/g3d/g3dopen.c:168
-msgid "G3d_openCellOld: error in G3d_fillHeader"
-msgstr "G3d_openCellOld: G3d_fillHeader错误"
+msgid "Rast3d_openCellOld: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellOld: Rast3d_fillHeader错误"
 
 #: ../lib/g3d/g3dopen.c:215
-msgid "G3d_openCellNew: error in G3d_maskOpenOld"
-msgstr "G3d_openCellNew: G3d_maskOpenOld错误"
+msgid "Rast3d_openCellNew: error in Rast3d_maskOpenOld"
+msgstr "Rast3d_openCellNew: Rast3d_maskOpenOld错误"
 
 #: ../lib/g3d/g3dopen.c:224
-msgid "G3d_openCellNew: error in G3d_malloc"
-msgstr "G3d_openCellNew: G3d_malloc错误"
+msgid "Rast3d_openCellNew: error in Rast3d_malloc"
+msgstr "Rast3d_openCellNew: Rast3d_malloc错误"
 
 #: ../lib/g3d/g3dopen.c:229
 #, fuzzy, c-format
@@ -326,16 +326,16 @@ msgid "map <%s> is not in the current mapset"
 msgstr "错误：试图更新不在当前地图集中的地图。"
 
 #: ../lib/g3d/g3dopen.c:239
-msgid "G3d_openCellNew: could not open file"
-msgstr "G3d_openCellNew: 不能打开文件"
+msgid "Rast3d_openCellNew: could not open file"
+msgstr "Rast3d_openCellNew: 不能打开文件"
 
 #: ../lib/g3d/g3dopen.c:284 ../lib/g3d/g3dopen.c:289
-msgid "G3d_openCellNew: can't write header"
-msgstr "G3d_openCellNew: 文件头不可写"
+msgid "Rast3d_openCellNew: can't write header"
+msgstr "Rast3d_openCellNew: 文件头不可写"
 
 #: ../lib/g3d/g3dopen.c:312
-msgid "G3d_openCellNew: error in G3d_fillHeader"
-msgstr "G3d_openCellNew: G3d_fillHeader错误"
+msgid "Rast3d_openCellNew: error in Rast3d_fillHeader"
+msgstr "Rast3d_openCellNew: Rast3d_fillHeader错误"
 
 #: ../lib/vector/vedit/select.c:231
 #, fuzzy

locale/po/grassmods_ar.po

@@ -32923,7 +32923,7 @@ msgid "Unable to open 3d raster map <%s>"
 msgstr "<%s> لم يمكن فتح"
 
 #: ../raster3d/r3.retile/main.c:140
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../raster3d/r3.info/r3.info.main.c:82

locale/po/grassmods_cs.po

@@ -33225,7 +33225,7 @@ msgid "Unable to open 3d raster map <%s>"
 msgstr "Nelze otevøít rastrovou mapu <%s>"
 
 #: ../raster3d/r3.retile/main.c:140
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../raster3d/r3.info/r3.info.main.c:82

locale/po/grassmods_de.po

@@ -33533,7 +33533,7 @@ msgid "Unable to open 3d raster map <%s>"
 msgstr "Kann die Rasterkarte <%s> nicht öffnen."
 
 #: ../raster3d/r3.retile/main.c:140
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../raster3d/r3.info/r3.info.main.c:82

locale/po/grassmods_el.po

@@ -31309,7 +31309,7 @@ msgid "Unable to open 3d raster map <%s>"
 msgstr "Áäõíáìßá áíïßãìáôïò ôïõ ÷Üñôç raster <%s>"
 
 #: ../raster3d/r3.retile/main.c:140
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../raster3d/r3.info/r3.info.main.c:82

locale/po/grassmods_es.po

@@ -33453,7 +33453,7 @@ msgid "Unable to open 3d raster map <%s>"
 msgstr "No se puede abrir el mapa ráster <%s>"
 
 #: ../raster3d/r3.retile/main.c:140
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../raster3d/r3.info/r3.info.main.c:82

locale/po/grassmods_fr.po

@@ -35331,7 +35331,7 @@ msgid "Unable to open 3d raster map <%s>"
 msgstr "Impossible d'ouvrir la couche raster <%s>"
 
 #: ../raster3d/r3.retile/main.c:140
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../raster3d/r3.info/r3.info.main.c:82

locale/po/grassmods_hi.po

@@ -33417,7 +33417,7 @@ msgid "Unable to open 3d raster map <%s>"
 msgstr "के लिए."
 
 #: ../raster3d/r3.retile/main.c:140
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../raster3d/r3.info/r3.info.main.c:82

locale/po/grassmods_it.po

@@ -32533,7 +32533,7 @@ msgid "Unable to open 3d raster map <%s>"
 msgstr "Impossibile aprire la mappa raster <%s>"
 
 #: ../raster3d/r3.retile/main.c:140
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../raster3d/r3.info/r3.info.main.c:82

locale/po/grassmods_ja.po

@@ -32585,7 +32585,7 @@ msgid "Unable to open 3d raster map <%s>"
 msgstr "ラスターマップ <%s> が開けません"
 
 #: ../raster3d/r3.retile/main.c:140
-msgid "G3d_getStandard3dParams: tile dimension value invalid"
+msgid "Rast3d_getStandard3dParams: tile dimension value invalid"
 msgstr ""
 
 #: ../raster3d/r3.info/r3.info.main.c:82