rasterlib: fns from cats.c cleaned up, see http://trac.osgeo.org/grass/wiki/Grass7/RasterLib

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

display/d.colors/curses.c

@@ -85,18 +85,18 @@ int Write_cats(struct Categories *pcats, int current_cat)
 	if (at_cat == current_cat) {
 	    if (!at_cat)
 		sprintf(buffer, "-> %3s %s", "N",
-			Rast_get_c_raster_cat(&tmp, pcats));
+			Rast_get_c_cat(&tmp, pcats));
 	    else
 		sprintf(buffer, "-> %3d %s", at_cat - 1,
-			Rast_get_cat(at_cat - 1, pcats));
+			Rast_get_c_cat(at_cat - 1, pcats));
 	}
 	else {
 	    if (!at_cat)
 		sprintf(buffer, "   %3s %s", "N",
-			Rast_get_c_raster_cat(&tmp, pcats));
+			Rast_get_c_cat(&tmp, pcats));
 	    else
 		sprintf(buffer, "   %3d %s", at_cat - 1,
-			Rast_get_cat(at_cat - 1, pcats));
+			Rast_get_c_cat(at_cat - 1, pcats));
 	}
 	wmove(CAT_WIN, at_line++, 1);
 	waddstr(CAT_WIN, buffer);

display/d.histogram/bar.c

@@ -216,7 +216,7 @@ int bar(struct stat_list *dist_stats,	/* list of distribution statistics */
 		/* draw the bar as a box */
 		if (!Rast_is_c_null_value(&bar_color) && is_fp) {
 		    if (cat_ranges)
-			Rast_get_ith_d_raster_cat(&cats, bar_color,
+			Rast_get_ith_d_cat(&cats, bar_color,
 					       &dmin, &dmax);
 		    else {
 			dmin = range_dmin + i * (range_dmax - range_dmin) / nsteps;
@@ -269,7 +269,7 @@ int bar(struct stat_list *dist_stats,	/* list of distribution statistics */
 		/* draw the bar as a line */
 		if (is_fp) {
 		    if (cat_ranges)
-			Rast_get_ith_d_raster_cat(&cats, bar_color,
+			Rast_get_ith_d_cat(&cats, bar_color,
 					       &dmin, &dmax);
 		    else {
 			dmin = range_dmin + i * (range_dmax - range_dmin) / nsteps;

display/d.histogram/get_stats.c

@@ -54,9 +54,9 @@ int get_stats(const char *mapname, struct stat_list *dist_stats,	/* linked list
     is_fp = Rast_raster_map_is_fp(mapname, "");
     if (is_fp) {
 	if (cat_ranges) {
-	    if (Rast_read_raster_cats(mapname, "", &cats) < 0)
+	    if (Rast_read_cats(mapname, "", &cats) < 0)
 		G_fatal_error("Can't read category file");
-	    if (Rast_number_of_raster_cats(&cats) <= 0) {
+	    if (Rast_number_of_cats(&cats) <= 0) {
 		G_warning("There are no labeled cats, using nsteps argument");
 		cat_ranges = 0;
 	    }

display/d.histogram/pie.c

@@ -187,7 +187,7 @@ int pie(struct stat_list *dist_stats,	/* list of distribution statistics */
 		draw = YES;
 		if (is_fp) {
 		    if (cat_ranges)
-			Rast_get_ith_d_raster_cat(&cats, (CELL) i, &dmin, &dmax);
+			Rast_get_ith_d_cat(&cats, (CELL) i, &dmin, &dmax);
 		    else {
 			dmin = range_dmin + i * (range_dmax - range_dmin) / nsteps;
 			dmax = range_dmin + (i + 1) * (range_dmax - range_dmin) / nsteps;
@@ -227,7 +227,7 @@ int pie(struct stat_list *dist_stats,	/* list of distribution statistics */
 		    draw = YES;
 		    if (is_fp) {
 			if (cat_ranges)
-			    Rast_get_ith_d_raster_cat(&cats, (CELL) i, &dmin, &dmax);
+			    Rast_get_ith_d_cat(&cats, (CELL) i, &dmin, &dmax);
 			else {
 			    dmin = range_dmin + i * (range_dmax - range_dmin) / nsteps;
 			    dmax = range_dmin + (i + 1) * (range_dmax - range_dmin) / nsteps;

display/d.legend/main.c

@@ -372,9 +372,9 @@ int main(int argc, char **argv)
 	for (i = min_ind, j = 1, k = 0; j <= do_cats && i <= max_ind;
 	     j++, i += thin) {
 	    if (!flip)
-		cstr = Rast_get_cat(i, &cats);
+		cstr = Rast_get_c_cat(&i, &cats);
 	    else
-		cstr = Rast_get_cat((max_ind - (i - min_ind)), &cats);
+		cstr = Rast_get_c_cat((max_ind - (i - min_ind)), &cats);
 
 	    if (!use_catlist)
 		catlist[j - 1] = (double)i;
@@ -405,7 +405,7 @@ int main(int argc, char **argv)
 				  opt8->answers[i], min_ind, max_ind);
 		}
 
-		cstr = Rast_get_cat(catlist[i], &cats);
+		cstr = Rast_get_c_cat(&(catlist[i]), &cats);
 		if (!cstr[0]) {	/* no cat label found, skip str output */
 		    if (hide_nodata)
 			continue;
@@ -604,7 +604,7 @@ int main(int argc, char **argv)
 			max_ind - k * (double)(max_ind - min_ind) / (steps -
 								     1);
 
-		cstr = Rast_get_cat(tcell, &cats);
+		cstr = Rast_get_c_cat(tcell, &cats);
 		if (!cstr[0])	/* no cats found, disable str output */
 		    hide_catstr = 1;
 		else
@@ -780,9 +780,9 @@ int main(int argc, char **argv)
 	    /*              for(i=min_ind, j=1, k=0; j<=do_cats && i<=max_ind; j++, i+=thin)        */
 	{
 	    if (!flip)
-		cstr = Rast_get_cat(catlist[i], &cats);
+		cstr = Rast_get_c_cat(&(catlist[i]), &cats);
 	    else
-		cstr = Rast_get_cat(catlist[catlistCount - i - 1], &cats);
+		cstr = Rast_get_c_cat(&(catlist[catlistCount - i - 1]), &cats);
 
 
 	    if (!cstr[0]) {	/* no cat label found, skip str output */

display/d.what.rast/what.c

@@ -61,7 +61,7 @@ int what(int once, int terse, int colrow, char *fs, int width, int mwidth)
 			 "ERROR reading raster map", terse, fs, map_type[i]);
 	    else if (map_type[i] == CELL_TYPE) {
 		show_cat(width, mwidth, name[i], mapset[i], buf[col],
-			 Rast_get_c_raster_cat(&buf[col], &cats[i]), terse, fs,
+			 Rast_get_c_cat(&buf[col], &cats[i]), terse, fs,
 			 map_type[i]);
 		continue;
 	    }
@@ -79,7 +79,7 @@ int what(int once, int terse, int colrow, char *fs, int width, int mwidth)
 			  "ERROR reading fcell file", terse, fs);
 	    else
 		show_dval(width, mwidth, name[i], mapset[i], dbuf[col],
-			  Rast_get_d_raster_cat(&dbuf[col], &cats[i]), terse,
+			  Rast_get_d_cat(&dbuf[col], &cats[i]), terse,
 			  fs);
 	}
     }

imagery/i.gensig/get_train.c

@@ -48,7 +48,7 @@ int get_training_classes(struct files *files, struct Signature *S)
 	    S->sig[n].status = 1;
 	    S->sig[n].npoints = count;
 	    strncpy(S->sig[n].desc,
-		      Rast_get_cat(cat, &files->training_labels),
+		      Rast_get_c_cat(&cat, &files->training_labels),
 		      sizeof(S->sig[n].desc)
 		);
 	    n++;

imagery/i.gensigset/get_train.c

@@ -48,7 +48,7 @@ int get_training_classes(struct parms *parms,
     while (Rast_next_cell_stat(&cat, &count, &cell_stats)) {
 	if (count > 1) {
 	    Sig = I_NewClassSig(S);
-	    I_SetClassTitle(Sig, Rast_get_cat(cat, &files->training_labels));
+	    I_SetClassTitle(Sig, Rast_get_c_cat(&cat, &files->training_labels));
 	    Sig->classnum = cat;
 	    /* initialize this class with maxsubclasses (by allocating them) */
 	    for (i = 0; i < parms->maxsubclasses; i++)

imagery/i.maxlik/main.c

@@ -38,6 +38,7 @@ int class_fd, reject_fd;
 char *class_name, *reject_name;
 double *B;
 double *P;
+CELL cat;
 
 int main(int argc, char *argv[])
 {
@@ -123,39 +124,30 @@ int main(int argc, char *argv[])
     if (reject_fd > 0)
 	Rast_close_cell(reject_fd);
 
-    Rast_init_cats((CELL) S.nsigs, "Maximum Likelihood Classification", &cats);
+    Rast_init_cats("Maximum Likelihood Classification", &cats);
     for (i = 0; i < S.nsigs; i++) {
-	if (*S.sig[i].desc)
-	    Rast_set_cat((CELL) (i + 1), S.sig[i].desc, &cats);
+	if (*S.sig[i].desc) {
+	    cat = i + 1;
+	    Rast_set_c_cat(&cat, &cat, S.sig[i].desc, &cats);
+	}
     }
     Rast_write_cats(class_name, &cats);
     Rast_free_cats(&cats);
 
     if (reject_fd > 0) {
 	char title[100];
-
+	char *label[] = { "no data", "0.1%", "0.5%",
+			  "1%", "2%", "5%", "10%",
+			  "20%", "30%", "50%", "70%",
+			  "80%", "90%", "95%", "98%",
+			  "99%", "100%", "bad" };
 	sprintf(title, "Rejection Probability for %s", class_name);
 
-	Rast_init_cats((CELL) 17, title, &cats);
+	Rast_init_cats(title, &cats);
 	Rast_set_cats_title(title, &cats);
-	Rast_set_cat((CELL) 0, "no data", &cats);
-	Rast_set_cat((CELL) 1, "0.1%", &cats);
-	Rast_set_cat((CELL) 2, "0.5%", &cats);
-	Rast_set_cat((CELL) 3, "1%", &cats);
-	Rast_set_cat((CELL) 4, "2%", &cats);
-	Rast_set_cat((CELL) 5, "5%", &cats);
-	Rast_set_cat((CELL) 6, "10%", &cats);
-	Rast_set_cat((CELL) 7, "20%", &cats);
-	Rast_set_cat((CELL) 8, "30%", &cats);
-	Rast_set_cat((CELL) 9, "50%", &cats);
-	Rast_set_cat((CELL) 10, "70%", &cats);
-	Rast_set_cat((CELL) 11, "80%", &cats);
-	Rast_set_cat((CELL) 12, "90%", &cats);
-	Rast_set_cat((CELL) 13, "95%", &cats);
-	Rast_set_cat((CELL) 14, "98%", &cats);
-	Rast_set_cat((CELL) 15, "99%", &cats);
-	Rast_set_cat((CELL) 16, "100%", &cats);
-	Rast_set_cat((CELL) 17, "bad", &cats);
+	for(i = 0; i < (int) (sizeof(label) / sizeof (char *)); i++) {
+	    Rast_set_c_cat(&i, &i, label[i], &cats);
+	}
 	Rast_write_cats(reject_name, &cats);
 	Rast_free_cats(&cats);
 

imagery/i.smap/labels.c

@@ -8,10 +8,12 @@ int create_output_labels(struct SigSet *S, struct files *files)
     int n;
     struct ClassSig *C;
 
-    Rast_init_cats((CELL) 0, S->title, &files->output_labels);
+    Rast_init_cats(S->title, &files->output_labels);
     for (n = 0; n < S->nclasses; n++) {
 	C = &S->ClassSig[n];
-	Rast_set_cat((CELL) C->classnum, C->title, &files->output_labels);
+	Rast_set_c_cat((CELL*) &(C->classnum),
+		       (CELL*) &(C->classnum),
+		       C->title, &files->output_labels);
     }
 
     return 0;

include/raster.h

@@ -21,57 +21,47 @@ void Rast_unsuppress_masking(void);
 
 /* cats.c */
 int Rast_read_cats(const char *, const char *, struct Categories *);
-int Rast_read_raster_cats(const char *, const char *, struct Categories *);
 int Rast_read_vector_cats(const char *, const char *, struct Categories *);
-CELL Rast_number_of_cats(const char *, const char *);
+CELL Rast_get_max_c_cat(const char *, const char *);
 char *Rast_get_cats_title(const struct Categories *);
-char *Rast_get_raster_cats_title(const struct Categories *);
-char *Rast_get_cat(CELL, struct Categories *);
-char *Rast_get_c_raster_cat(CELL *, struct Categories *);
-char *Rast_get_f_raster_cat(FCELL *, struct Categories *);
-char *Rast_get_d_raster_cat(DCELL *, struct Categories *);
-char *Rast_get_raster_cat(void *, struct Categories *, RASTER_MAP_TYPE);
-void Rast_unmark_raster_cats(struct Categories *);
-void Rast_mark_c_raster_cats(const CELL *, int, struct Categories *);
-void Rast_mark_f_raster_cats(const FCELL *, int, struct Categories *);
-void Rast_mark_d_raster_cats(const DCELL *, int, struct Categories *);
-int Rast_mark_raster_cats(const void *, int, struct Categories *, RASTER_MAP_TYPE);
-void Rast_rewind_raster_cats(struct Categories *);
-char *Rast_get_next_marked_d_raster_cat(struct Categories *, DCELL *, DCELL *,
+char *Rast_get_c_cat(CELL *, struct Categories *);
+char *Rast_get_f_cat(FCELL *, struct Categories *);
+char *Rast_get_d_cat(DCELL *, struct Categories *);
+char *Rast_get_cat(void *, struct Categories *, RASTER_MAP_TYPE);
+void Rast_unmark_cats(struct Categories *);
+void Rast_mark_c_cats(const CELL *, int, struct Categories *);
+void Rast_mark_f_cats(const FCELL *, int, struct Categories *);
+void Rast_mark_d_cats(const DCELL *, int, struct Categories *);
+int Rast_mark_cats(const void *, int, struct Categories *, RASTER_MAP_TYPE);
+void Rast_rewind_cats(struct Categories *);
+char *Rast_get_next_marked_d_cat(struct Categories *, DCELL *, DCELL *,
+				 long *);
+char *Rast_get_next_marked_c_cat(struct Categories *, CELL *, CELL *,
+				 long *);
+char *Rast_get_next_marked_f_cat(struct Categories *, FCELL *, FCELL *,
 				     long *);
-char *Rast_get_next_marked_c_raster_cat(struct Categories *, CELL *, CELL *,
-				     long *);
-char *Rast_get_next_marked_f_raster_cat(struct Categories *, FCELL *, FCELL *,
-				     long *);
-char *Rast_get_next_marked_raster_cat(struct Categories *, void *, void *,
-				   long *, RASTER_MAP_TYPE);
-int Rast_set_cat(CELL, const char *, struct Categories *);
-int Rast_set_c_raster_cat(const CELL *, const CELL *, const char *, struct Categories *);
-int Rast_set_f_raster_cat(const FCELL *, const FCELL *, const char *, struct Categories *);
-int Rast_set_d_raster_cat(const DCELL *, const DCELL *, const char *, struct Categories *);
-int Rast_set_raster_cat(const void *, const void *, const char *, struct Categories *,
-		     RASTER_MAP_TYPE);
+char *Rast_get_next_marked_cat(struct Categories *, void *, void *,
+			       long *, RASTER_MAP_TYPE);
+int Rast_set_c_cat(const CELL *, const CELL *, const char *, struct Categories *);
+int Rast_set_f_cat(const FCELL *, const FCELL *, const char *, struct Categories *);
+int Rast_set_d_cat(const DCELL *, const DCELL *, const char *, struct Categories *);
+int Rast_set_cat(const void *, const void *, const char *, struct Categories *,
+		 RASTER_MAP_TYPE);
 int Rast_write_cats(const char *, struct Categories *);
-int Rast_write_raster_cats(const char *, struct Categories *);
 int Rast_write_vector_cats(const char *, struct Categories *);
-char *Rast_get_ith_d_raster_cat(const struct Categories *, int, DCELL *,
-			     DCELL *);
-char *Rast_get_ith_f_raster_cat(const struct Categories *, int, void *, void *);
-char *Rast_get_ith_c_raster_cat(const struct Categories *, int, void *, void *);
-char *Rast_get_ith_raster_cat(const struct Categories *, int, void *, void *,
-			   RASTER_MAP_TYPE);
-void Rast_init_cats(CELL, const char *, struct Categories *);
-void Rast_init_raster_cats(const char *, struct Categories *);
+char *Rast_get_ith_d_cat(const struct Categories *, int, DCELL *,
+			 DCELL *);
+char *Rast_get_ith_f_cat(const struct Categories *, int, void *, void *);
+char *Rast_get_ith_c_cat(const struct Categories *, int, void *, void *);
+char *Rast_get_ith_cat(const struct Categories *, int, void *, void *,
+		       RASTER_MAP_TYPE);
+void Rast_init_cats(const char *, struct Categories *);
 void Rast_set_cats_title(const char *, struct Categories *);
-void Rast_set_raster_cats_title(const char *, struct Categories *);
 void Rast_set_cats_fmt(const char *, double, double, double, double,
-		   struct Categories *);
-void Rast_set_raster_cats_fmt(const char *, double, double, double, double,
 			   struct Categories *);
 void Rast_free_cats(struct Categories *);
-void Rast_free_raster_cats(struct Categories *);
-void Rast_copy_raster_cats(struct Categories *, const struct Categories *);
-int Rast_number_of_raster_cats(struct Categories *);
+void Rast_copy_cats(struct Categories *, const struct Categories *);
+int Rast_number_of_cats(struct Categories *);
 int Rast_sort_cats(struct Categories *);
 
 /* cell_stats.c */

lib/g3d/g3dcats.c

@@ -52,7 +52,7 @@ int G3d_writeCats(const char *name, struct Categories *cats)
 
     /* write the cat numbers:label */
     for (i = 0; i < Rast_quant_nof_rules(&cats->q); i++) {
-	descr = Rast_get_ith_d_raster_cat(cats, i, &val1, &val2);
+	descr = Rast_get_ith_d_cat(cats, i, &val1, &val2);
 	if ((cats->fmt && cats->fmt[0]) || (descr && descr[0])) {
 	    if (val1 == val2) {
 		sprintf(str1, "%.10f", val1);
@@ -104,7 +104,7 @@ read_cats(const char *name, const char *mapset, struct Categories *pcats)
 	goto error;
     G_strip(buff);
 
-    Rast_init_raster_cats(buff, pcats);
+    Rast_init_cats(buff, pcats);
     if (num >= 0)
 	pcats->num = num;
 
@@ -119,7 +119,7 @@ read_cats(const char *name, const char *mapset, struct Categories *pcats)
 	    goto error;
 	if (sscanf(buff, "%f %f %f %f", &m1, &a1, &m2, &a2) != 4)
 	    goto error;
-	Rast_set_raster_cats_fmt(fmt, m1, a1, m2, a2, pcats);
+	Rast_set_cats_fmt(fmt, m1, a1, m2, a2, pcats);
     }
 
     /* Read all category names */
@@ -130,7 +130,7 @@ read_cats(const char *name, const char *mapset, struct Categories *pcats)
 	    break;
 
 	if (old)
-	    Rast_set_cat(cat, buff, pcats);
+	    Rast_set_c_cat(&cat, &cat, buff, pcats);
 	else {
 	    *label = 0;
 	    if (sscanf(buff, "%1s", label) != 1)
@@ -141,11 +141,11 @@ read_cats(const char *name, const char *mapset, struct Categories *pcats)
 
 	    /* try to read a range of data */
 	    if (sscanf(buff, "%lf:%lf:%[^\n]", &val1, &val2, label) == 3)
-		Rast_set_raster_cat(&val1, &val2, label, pcats, DCELL_TYPE);
+		Rast_set_cat(&val1, &val2, label, pcats, DCELL_TYPE);
 	    else if (sscanf(buff, "%d:%[^\n]", &cat, label) >= 1)
-		Rast_set_raster_cat(&cat, &cat, label, pcats, CELL_TYPE);
+		Rast_set_cat(&cat, &cat, label, pcats, CELL_TYPE);
 	    else if (sscanf(buff, "%lf:%[^\n]", &val1, label) >= 1)
-		Rast_set_raster_cat(&val1, &val1, label, pcats, DCELL_TYPE);
+		Rast_set_cat(&val1, &val1, label, pcats, DCELL_TYPE);
 	    else
 		goto error;
 	}

lib/g3d/g3dclose.c

@@ -21,7 +21,7 @@ static int G3d_closeNew(G3D_Map * map)
     G3d_removeColor(map->fileName);
 
     /* create empty cats file */
-    Rast_init_raster_cats(NULL, &cats);
+    Rast_init_cats(NULL, &cats);
     G3d_writeCats(map->fileName, &cats);
     Rast_free_cats(&cats);
 

lib/ogsf/Gs3.c

@@ -849,11 +849,11 @@ int Gs_get_cat_label(const char *filename, int drow, int dcol, char *catstr)
 	    }
 	    else if (Rast_is_c_null_value(&buf[dcol])) {
 		sprintf(catstr, "(NULL) %s",
-			Rast_get_c_raster_cat(&buf[dcol], &cats));
+			Rast_get_c_cat(&buf[dcol], &cats));
 	    }
 	    else {
 		sprintf(catstr, "(%d) %s", buf[dcol],
-			Rast_get_c_raster_cat(&buf[dcol], &cats));
+			Rast_get_c_cat(&buf[dcol], &cats));
 	    }
 
 	    G_free(buf);
@@ -868,11 +868,11 @@ int Gs_get_cat_label(const char *filename, int drow, int dcol, char *catstr)
 	    }
 	    else if (Rast_is_d_null_value(&dbuf[dcol])) {
 		sprintf(catstr, "(NULL) %s",
-			Rast_get_d_raster_cat(&dbuf[dcol], &cats));
+			Rast_get_d_cat(&dbuf[dcol], &cats));
 	    }
 	    else {
 		sprintf(catstr, "(%g) %s", dbuf[dcol],
-			Rast_get_d_raster_cat(&dbuf[dcol], &cats));
+			Rast_get_d_cat(&dbuf[dcol], &cats));
 	    }
 
 	    G_free(dbuf);

lib/ogsf/gsd_legend.c

@@ -403,7 +403,7 @@ GLuint gsd_put_legend(const char *name, GLuint fontbase, int size, int *flags,
 		if (is_fp) {
 		    tdcell = discrete ? Listcats[k] : labvals[k];
 		    if (cat_labs) {
-			cstr = Rast_get_d_raster_cat(&tdcell, &cats);
+			cstr = Rast_get_d_cat(&tdcell, &cats);
 		    }
 		    if (cat_labs && !cat_vals) {
 			sprintf(buff, "%s", cstr);
@@ -424,10 +424,10 @@ GLuint gsd_put_legend(const char *name, GLuint fontbase, int size, int *flags,
 		    tcell = discrete ? Listnum ?
 			Listcats[k] : min + k : labvals[k];
 		    if (cat_labs && !cat_vals)
-			sprintf(buff, "%s", Rast_get_cat(tcell, &cats));
+			sprintf(buff, "%s", Rast_get_c_cat(&tcell, &cats));
 		    else {
 			if (cat_labs && cat_vals) {
-			    cstr = Rast_get_cat(tcell, &cats);
+			    cstr = Rast_get_c_cat(&tcell, &cats);
 			    if (cstr[0])
 				sprintf(buff, "%*d) %s", iprec, tcell, cstr);
 			    else
@@ -635,9 +635,9 @@ GLuint gsd_put_legend(const char *name, GLuint fontbase, int size, int *flags,
 		    labpos = 1. - labpos;
 		if (cat_labs) {
 		    if (!is_fp)
-			cstr = Rast_get_cat(tcell, &cats);
+			cstr = Rast_get_c_cat(&tcell, &cats);
 		    else
-			cstr = Rast_get_d_raster_cat(&tdcell, &cats);
+			cstr = Rast_get_d_cat(&tdcell, &cats);
 		}
 		if (cat_labs && !cat_vals)
 		    sprintf(buff, "%s", cstr);

lib/raster/cats.c

@@ -89,14 +89,12 @@ static struct Categories save_cats;
 /*!
  * \brief Read raster category file
  *
- * \todo Remove, the function Rast_read_raster_cats()
- *
  * The category file for raster map <i>name</i> in <i>mapset</i> is
  * read into the <i>cats</i> structure. If there is an error reading
  * the category file, a diagnostic message is printed and -1 is
  * returned. Otherwise, 0 is returned.
  *
- * \param name map name
+ * \param name raster map name
  * \param mapset mapset name
  * \param[out] cats pointer to Cats structure
  * 
@@ -104,44 +102,21 @@ static struct Categories save_cats;
  * \return 0 on success
  */
 int Rast_read_cats(const char *name,
-		const char *mapset, struct Categories *pcats)
+		   const char *mapset, struct Categories *pcats)
 {
-    return Rast_read_raster_cats(name, mapset, pcats);
-}
-
-/*!
- * \brief Read raster category file
- *
- * The category file for raster map <i>name</i> in <i>mapset</i> is
- * read into the <i>cats</i> structure. If there is an error reading
- * the category file, a diagnostic message is printed and -1 is
- * returned. Otherwise, 0 is returned.
- *
- * \param name map name
- * \param mapset mapset name
- * \param[out] cats pointer to Cats structure
- * 
- * \return -1 on error
- * \return 0 on success
- */
-int Rast_read_raster_cats(const char *name,
-		       const char *mapset, struct Categories *pcats)
-{
-    char *type;
-
     switch (read_cats("cats", name, mapset, pcats, 1)) {
     case -2:
-	type = "missing";
+	G_warning(_("Category support for <%s@%s> missing"),
+		  name, mapset);
 	break;
     case -1:
-	type = "invalid";
+	G_warning(_("Category support for <%s@%s> invalid"),
+		  name, mapset);
 	break;
     default:
 	return 0;
     }
 
-    G_warning(_("Category support for <%s@%s> %s"),
-	      name, mapset, type);
     return -1;
 }
 
@@ -149,13 +124,15 @@ int Rast_read_raster_cats(const char *name,
  * \brief Read vector category file
  *
  * <b>Note:</b> This function works with <b>old</b> vector format.
-
- * The category file for vector map <i>name</i> in <i>mapset</i> is
- * read into the <i>cats</i> structure. If there is an error reading
- * the category file, a diagnostic message is printed and -1 is
+ *
+ * \todo: To be moved to the vector library
+ *
+ * The category  file for vector  map <i>name</i> in  <i>mapset</i> is
+ * read into the  <i>cats</i> structure. If there is  an error reading
+ * the  category file,  a  diagnostic  message is  printed  and -1  is
  * returned. Otherwise, 0 is returned.
  *
- * \param name map name
+ * \param name vector map name
  * \param mapset mapset name
  * \param[out] cats pointer to Cats structure
  * 
@@ -165,34 +142,32 @@ int Rast_read_raster_cats(const char *name,
 int Rast_read_vector_cats(const char *name,
 		       const char *mapset, struct Categories *pcats)
 {
-    char *type;
-
     switch (read_cats("dig_cats", name, mapset, pcats, 1)) {
     case -2:
-	type = "missing";
+	G_warning(_("Category support for vector map <%s@%s> missing"),
+	      name, mapset);
 	break;
     case -1:
-	type = "invalid";
+	G_warning(_("Category support for vector map <%s@%s> invalid"),
+	      name, mapset);
 	break;
     default:
 	return 0;
     }
 
-    G_warning(_("Category support for vector map <%s@%s> %s"),
-	      name, mapset, type);
     return -1;
 }
 
 /*!
   \brief Get number of categories
 
-  \param name map name
+  \param name raster map name
   \param mapset mapset name
 
   \return -1 on error
   \return number of cats
 */
-CELL Rast_number_of_cats(const char *name, const char *mapset)
+CELL Rast_get_max_c_cat(const char *name, const char *mapset)
 {
     struct Range range;
     CELL min, max;
@@ -248,7 +223,7 @@ static CELL read_cats(const char *element,
     G_strip(buff);
     /*    G_ascii_check(buff) ; */
 
-    Rast_init_raster_cats(buff, pcats);
+    Rast_init_cats(buff, pcats);
     if (num >= 0)
 	pcats->num = num;
 
@@ -263,7 +238,7 @@ static CELL read_cats(const char *element,
 	    goto error;
 	if (sscanf(buff, "%f %f %f %f", &m1, &a1, &m2, &a2) != 4)
 	    goto error;
-	Rast_set_raster_cats_fmt(fmt, m1, a1, m2, a2, pcats);
+	Rast_set_cats_fmt(fmt, m1, a1, m2, a2, pcats);
     }
 
     /* Read all category names */
@@ -273,7 +248,7 @@ static CELL read_cats(const char *element,
 	if (G_getl(buff, sizeof buff, fd) == 0)
 	    break;
 	if (old)
-	    Rast_set_cat(cat, buff, pcats);
+	    Rast_set_c_cat(&cat, &cat, buff, pcats);
 	else {
 	    *label = 0;
 	    if (sscanf(buff, "%1s", label) != 1)
@@ -284,11 +259,11 @@ static CELL read_cats(const char *element,
 	    /* for fp maps try to read a range of data */
 	    if (fp_map
 		&& sscanf(buff, "%lf:%lf:%[^\n]", &val1, &val2, label) == 3)
-		Rast_set_raster_cat(&val1, &val2, label, pcats, DCELL_TYPE);
+		Rast_set_cat(&val1, &val2, label, pcats, DCELL_TYPE);
 	    else if (sscanf(buff, "%d:%[^\n]", &cat, label) >= 1)
-		Rast_set_raster_cat(&cat, &cat, label, pcats, CELL_TYPE);
+		Rast_set_cat(&cat, &cat, label, pcats, CELL_TYPE);
 	    else if (sscanf(buff, "%lf:%[^\n]", &val1, label) >= 1)
-		Rast_set_raster_cat(&val1, &val1, label, pcats, DCELL_TYPE);
+		Rast_set_cat(&val1, &val1, label, pcats, DCELL_TYPE);
 	    else
 		goto error;
 	}
@@ -304,7 +279,7 @@ static CELL read_cats(const char *element,
 /*!
  * \brief Get title from category structure struct
  *
- * \todo Remove from GIS Library, replace by Rast_get_raster_cats_title().
+ * \todo Remove from GIS Library, replace by Rast_get_c_cats_title().
  *
  * Map layers store a one-line title in the category structure as
  * well. This routine returns a pointer to the title contained in the
@@ -317,55 +292,12 @@ static CELL read_cats(const char *element,
  * \return title
  * \return "" if missing
  */
-
 char *Rast_get_cats_title(const struct Categories *pcats)
 {
-    return Rast_get_raster_cats_title(pcats);
-}
-
-/*!
- * \brief Get raster cats title
- *
- * Returns pointer to a string with title.
- *
- * \param pcats pointer to Categories structure
- *
- * \return title
- * \return "" if missing
- */
-
-char *Rast_get_raster_cats_title(const struct Categories *pcats)
-{
     return pcats->title ? pcats->title : "";
 }
 
 /*!
- * \brief Get a raster category label
- *
- * \todo Remove from GIS Library, replaced by Rast_get_c_raster_cat().
- *
- * This routine looks up category <i>num</i> in the <i>pcats</i>
- * structure and returns a pointer to a string which is the label for
- * the category. A legal pointer is always returned. If the category
- * does not exist in <i>pcats</i>, then a pointer to the empty string
- * "" is returned.
- *
- * <b>Warning:</b> The pointer that is returned points to a hidden
- * static buffer. Successive calls to Rast_get_cat() overwrite this
- * buffer.
- *
- * \param num cell value
- * \param pcats pointer to Categories structure
- *
- * \return pointer to category label
- * \return "" if category is not found
- */
-char *Rast_get_cat(CELL num, struct Categories *pcats)
-{
-    return Rast_get_c_raster_cat(&num, pcats);
-}
-
-/*!
  * \brief Get a raster category label (CELL)
  *
  * This routine looks up category <i>rast</i> in the <i>pcats</i>
@@ -375,7 +307,7 @@ char *Rast_get_cat(CELL num, struct Categories *pcats)
  * "" is returned.
  *
  * <b>Warning:</b> The pointer that is returned points to a hidden
- * static buffer. Successive calls to Rast_get_cat() overwrite this
+ * static buffer. Successive calls to Rast_get_c_cat() overwrite this
  * buffer.
  *
  * \param rast cell value
@@ -384,9 +316,9 @@ char *Rast_get_cat(CELL num, struct Categories *pcats)
  * \return pointer to category label
  * \return "" if category is not found
  */
-char *Rast_get_c_raster_cat(CELL * rast, struct Categories *pcats)
+char *Rast_get_c_cat(CELL * rast, struct Categories *pcats)
 {
-    return Rast_get_raster_cat(rast, pcats, CELL_TYPE);
+    return Rast_get_cat(rast, pcats, CELL_TYPE);
 }
 
 /*!
@@ -399,7 +331,7 @@ char *Rast_get_c_raster_cat(CELL * rast, struct Categories *pcats)
  * "" is returned.
  *
  * <b>Warning:</b> The pointer that is returned points to a hidden
- * static buffer. Successive calls to Rast_get_cat() overwrite this
+ * static buffer. Successive calls to Rast_get_c_cat() overwrite this
  * buffer.
  *
  * \param rast cell value
@@ -408,9 +340,9 @@ char *Rast_get_c_raster_cat(CELL * rast, struct Categories *pcats)
  * \return pointer to category label
  * \return "" if category is not found
  */
-char *Rast_get_f_raster_cat(FCELL * rast, struct Categories *pcats)
+char *Rast_get_f_cat(FCELL * rast, struct Categories *pcats)
 {
-    return Rast_get_raster_cat(rast, pcats, FCELL_TYPE);
+    return Rast_get_cat(rast, pcats, FCELL_TYPE);
 }
 
 /*!
@@ -423,7 +355,7 @@ char *Rast_get_f_raster_cat(FCELL * rast, struct Categories *pcats)
  * "" is returned.
  *
  * <b>Warning:</b> The pointer that is returned points to a hidden
- * static buffer. Successive calls to Rast_get_cat() overwrite this
+ * static buffer. Successive calls to Rast_get_c_cat() overwrite this
  * buffer.
  *
  * \param rast cell value
@@ -432,9 +364,9 @@ char *Rast_get_f_raster_cat(FCELL * rast, struct Categories *pcats)
  * \return pointer to category label
  * \return "" if category is not found
  */
-char *Rast_get_d_raster_cat(DCELL * rast, struct Categories *pcats)
+char *Rast_get_d_cat(DCELL * rast, struct Categories *pcats)
 {
-    return Rast_get_raster_cat(rast, pcats, DCELL_TYPE);
+    return Rast_get_cat(rast, pcats, DCELL_TYPE);
 }
 
 /*!
@@ -447,7 +379,7 @@ char *Rast_get_d_raster_cat(DCELL * rast, struct Categories *pcats)
  * "" is returned.
  *
  * <b>Warning:</b> The pointer that is returned points to a hidden
- * static buffer. Successive calls to Rast_get_cat() overwrite this
+ * static buffer. Successive calls to Rast_get_c_cat() overwrite this
  * buffer.
  *
  * \param rast cell value
@@ -457,8 +389,8 @@ char *Rast_get_d_raster_cat(DCELL * rast, struct Categories *pcats)
  * \return pointer to category label
  * \return "" if category is not found
  */
-char *Rast_get_raster_cat(void *rast,
-		       struct Categories *pcats, RASTER_MAP_TYPE data_type)
+char *Rast_get_cat(void *rast,
+		   struct Categories *pcats, RASTER_MAP_TYPE data_type)
 {
     static char label[1024];
     char *f, *l, *v;
@@ -477,7 +409,7 @@ char *Rast_get_raster_cat(void *rast,
     val = Rast_get_raster_value_d(rast, data_type);
     i = Rast_quant_get_cell_value(&pcats->q, val);
 
-    G_debug(5, "Rast_get_raster_cat(): val %lf found i %d", val, i);
+    G_debug(5, "Rast_get_cat(): val %lf found i %d", val, i);
 
     if (!Rast_is_c_null_value(&i) && i < pcats->ncats) {
 	if (pcats->labels[i] != NULL)
@@ -524,7 +456,7 @@ char *Rast_get_raster_cat(void *rast,
  * \brief Sets marks for all categories to 0.
  *
  * This initializes Categories structure for subsequest calls to
- * Rast_mark_raster_cats() for each row of data, where non-zero mark for
+ * Rast_mark_cats() for each row of data, where non-zero mark for
  * i-th label means that some of the cells in rast_row are labeled
  * with i-th label and fall into i-th data range. These marks help
  * determine from the Categories structure which labels were used and
@@ -532,7 +464,7 @@ char *Rast_get_raster_cat(void *rast,
  *
  * \param pcats pointer to Categories structure
  */
-void Rast_unmark_raster_cats(struct Categories *pcats)
+void Rast_unmark_cats(struct Categories *pcats)
 {
     int i;
 
@@ -555,10 +487,10 @@ void Rast_unmark_raster_cats(struct Categories *pcats)
  * \param pcats pointer to Categories structure
  *
  */
-void Rast_mark_c_raster_cats(const CELL * rast_row,
-			  int ncols, struct Categories *pcats)
+void Rast_mark_c_cats(const CELL * rast_row,
+		      int ncols, struct Categories *pcats)
 {
-    Rast_mark_raster_cats(rast_row, ncols, pcats, CELL_TYPE);
+    Rast_mark_cats(rast_row, ncols, pcats, CELL_TYPE);
 }
 
 /*!
@@ -576,10 +508,10 @@ void Rast_mark_c_raster_cats(const CELL * rast_row,
  * \param pcats pointer to Categories structure
  *
  */
-void Rast_mark_f_raster_cats(const FCELL * rast_row,
-			 int ncols, struct Categories *pcats)
+void Rast_mark_f_cats(const FCELL * rast_row,
+		      int ncols, struct Categories *pcats)
 {
-    Rast_mark_raster_cats(rast_row, ncols, pcats, FCELL_TYPE);
+    Rast_mark_cats(rast_row, ncols, pcats, FCELL_TYPE);
 }
 
 /*!
@@ -597,10 +529,10 @@ void Rast_mark_f_raster_cats(const FCELL * rast_row,
  * \param pcats pointer to Categories structure
  *
  */
-void Rast_mark_d_raster_cats(const DCELL * rast_row,
-			  int ncols, struct Categories *pcats)
+void Rast_mark_d_cats(const DCELL * rast_row,
+		      int ncols, struct Categories *pcats)
 {
-    Rast_mark_raster_cats(rast_row, ncols, pcats, DCELL_TYPE);
+    Rast_mark_cats(rast_row, ncols, pcats, DCELL_TYPE);
 }
 
 /*!
@@ -620,9 +552,9 @@ void Rast_mark_d_raster_cats(const DCELL * rast_row,
  * \return -1 on error
  * \return 1 on success
  */
-int Rast_mark_raster_cats(const void *rast_row,
-		       int ncols, struct Categories *pcats,
-		       RASTER_MAP_TYPE data_type)
+int Rast_mark_cats(const void *rast_row,
+		   int ncols, struct Categories *pcats,
+		   RASTER_MAP_TYPE data_type)
 {
     CELL i;
 
@@ -642,12 +574,12 @@ int Rast_mark_raster_cats(const void *rast_row,
 /*!
  * \brief Rewind raster categories
  *
- * After call to this function Rast_get_next_marked_raster_cat() returns
+ * After call to this function Rast_get_next_marked_cat() returns
  * the first marked cat label.
  *
  * \param pcats pointer to Categories structure
  */
-void Rast_rewind_raster_cats(struct Categories *pcats)
+void Rast_rewind_cats(struct Categories *pcats)
 {
     pcats->last_marked_rule = -1;
 }
@@ -662,9 +594,9 @@ void Rast_rewind_raster_cats(struct Categories *pcats)
   \return NULL if not found
   \return description if found
 */
-char *Rast_get_next_marked_d_raster_cat(struct Categories *pcats,
-				     DCELL * rast1, DCELL * rast2,
-				     long *count)
+char *Rast_get_next_marked_d_cat(struct Categories *pcats,
+				 DCELL * rast1, DCELL * rast2,
+				 long *count)
 {
     char *descr = NULL;
     int found, i;
@@ -675,7 +607,7 @@ char *Rast_get_next_marked_d_raster_cat(struct Categories *pcats,
     G_debug(3, "last marked %d nrules %d\n", pcats->last_marked_rule, Rast_quant_nof_rules(&pcats->q));
 
     for (i = pcats->last_marked_rule + 1; i < Rast_quant_nof_rules(&pcats->q); i++) {
-	descr = Rast_get_ith_d_raster_cat(pcats, i, rast1, rast2);
+	descr = Rast_get_ith_d_cat(pcats, i, rast1, rast2);
 	G_debug(5, "%d %d", i, pcats->marks[i]);
 	if (pcats->marks[i]) {
 	    found = 1;
@@ -701,11 +633,11 @@ char *Rast_get_next_marked_d_raster_cat(struct Categories *pcats,
   \return NULL if not found
   \return description if found
 */
-char *Rast_get_next_marked_c_raster_cat(struct Categories *pcats,
-				     CELL * rast1, CELL * rast2,
-				     long *count)
+char *Rast_get_next_marked_c_cat(struct Categories *pcats,
+				 CELL * rast1, CELL * rast2,
+				 long *count)
 {
-    return Rast_get_next_marked_raster_cat(pcats, rast1, rast2, count,
+    return Rast_get_next_marked_cat(pcats, rast1, rast2, count,
 					CELL_TYPE);
 }
 
@@ -719,11 +651,11 @@ char *Rast_get_next_marked_c_raster_cat(struct Categories *pcats,
   \return NULL if not found
   \return description if found
 */
-char *Rast_get_next_marked_f_raster_cat(struct Categories *pcats,
+char *Rast_get_next_marked_f_cat(struct Categories *pcats,
 				     FCELL * rast1, FCELL * rast2,
 				     long *count)
 {
-    return Rast_get_next_marked_raster_cat(pcats, rast1, rast2, count,
+    return Rast_get_next_marked_cat(pcats, rast1, rast2, count,
 					FCELL_TYPE);
 }
 
@@ -738,14 +670,14 @@ char *Rast_get_next_marked_f_raster_cat(struct Categories *pcats,
   \return NULL if not found
   \return description if found
 */
-char *Rast_get_next_marked_raster_cat(struct Categories *pcats,
-				   void *rast1, void *rast2,
-				   long *count, RASTER_MAP_TYPE data_type)
+char *Rast_get_next_marked_cat(struct Categories *pcats,
+			       void *rast1, void *rast2,
+			       long *count, RASTER_MAP_TYPE data_type)
 {
     DCELL val1, val2;
     char *lab;
 
-    lab = Rast_get_next_marked_d_raster_cat(pcats, &val1, &val2, count);
+    lab = Rast_get_next_marked_d_cat(pcats, &val1, &val2, count);
     Rast_set_raster_value_d(rast1, val1, data_type);
     Rast_set_raster_value_d(rast2, val2, data_type);
     return lab;
@@ -818,29 +750,6 @@ static void get_cond(char **f, char *value, DCELL val)
     *f = ff;
 }
 
-
-/*!
- * \brief Set a raster category label
- *
- * \todo To be removed, replaced by Rast_set_c_raster_cat().
- *
- * The <i>label</i> is copied into the <i>pcats</i> structure for
- * category <i>num</i>.
- *
- * \param num raster cell
- * \param label category label
- * \param pcats pointer to Categories structure
- *
- * \return -1 on error
- * \return 0 if null value detected
- * \return 1 on success
- */
-int Rast_set_cat(CELL num, const char *label, struct Categories *pcats)
-{
-    return Rast_set_c_raster_cat(&num, &num, label, pcats);
-}
-
-
 /*!
  * \brief Set a raster category label (CELL)
  *
@@ -855,10 +764,10 @@ int Rast_set_cat(CELL num, const char *label, struct Categories *pcats)
  * \return 0 if null value detected
  * \return 1 on success
  */
-int Rast_set_c_raster_cat(const CELL * rast1, const CELL * rast2,
-		       const char *label, struct Categories *pcats)
+int Rast_set_c_cat(const CELL * rast1, const CELL * rast2,
+		   const char *label, struct Categories *pcats)
 {
-    return Rast_set_raster_cat(rast1, rast2, label, pcats, CELL_TYPE);
+    return Rast_set_cat(rast1, rast2, label, pcats, CELL_TYPE);
 }
 
 /*!
@@ -873,10 +782,10 @@ int Rast_set_c_raster_cat(const CELL * rast1, const CELL * rast2,
  *
  * \return
  */
-int Rast_set_f_raster_cat(const FCELL * rast1, const FCELL * rast2,
-		       const char *label, struct Categories *pcats)
+int Rast_set_f_cat(const FCELL * rast1, const FCELL * rast2,
+		   const char *label, struct Categories *pcats)
 {
-    return Rast_set_raster_cat(rast1, rast2, label, pcats, FCELL_TYPE);
+    return Rast_set_cat(rast1, rast2, label, pcats, FCELL_TYPE);
 }
 
 /*!
@@ -893,21 +802,21 @@ int Rast_set_f_raster_cat(const FCELL * rast1, const FCELL * rast2,
  * \return 0 if null value detected
  * \return 1 on success
  */
-int Rast_set_d_raster_cat(const DCELL * rast1, const DCELL * rast2,
-		       const char *label, struct Categories *pcats)
+int Rast_set_d_cat(const DCELL * rast1, const DCELL * rast2,
+		   const char *label, struct Categories *pcats)
 {
     long len;
     DCELL dtmp1, dtmp2;
     int i;
     char *descr;
 
-    /* DEBUG fprintf(stderr,"Rast_set_d_raster_cat(rast1 = %p,rast2 = %p,label = '%s',pcats = %p)\n",
+    /* DEBUG fprintf(stderr,"Rast_set_d_cat(rast1 = %p,rast2 = %p,label = '%s',pcats = %p)\n",
        rast1,rast2,label,pcats); */
     if (Rast_is_d_null_value(rast1))
 	return 0;
     if (Rast_is_d_null_value(rast2))
 	return 0;
-    /* DEBUG fprintf (stderr, "Rast_set_d_raster_cat(): adding quant rule: %f %f %d %d\n", *rast1, *rast2, pcats->ncats, pcats->ncats); */
+    /* DEBUG fprintf (stderr, "Rast_set_d_cat(): adding quant rule: %f %f %d %d\n", *rast1, *rast2, pcats->ncats, pcats->ncats); */
     /* the set_cat() functions are used in many places to reset the labels
        for the range (or cat) with existing label. In this case we don't
        want to store both rules with identical range even though the result
@@ -917,7 +826,7 @@ int Rast_set_d_raster_cat(const DCELL * rast1, const DCELL * rast2,
        the label for this range has been sen, and if it has, overwrite it */
 
     for (i = 0; i < pcats->ncats; i++) {
-	descr = Rast_get_ith_d_raster_cat(pcats, i, &dtmp1, &dtmp2);
+	descr = Rast_get_ith_d_cat(pcats, i, &dtmp1, &dtmp2);
 	if ((dtmp1 == *rast1 && dtmp2 == *rast2)
 	    || (dtmp1 == *rast2 && dtmp2 == *rast1)) {
 	    if (pcats->labels[i] != NULL)
@@ -929,29 +838,29 @@ int Rast_set_d_raster_cat(const DCELL * rast1, const DCELL * rast2,
 	}
     }
     /* when rule for this range does not exist */
-    /* DEBUG fprintf (stderr, "Rast_set_d_raster_cat(): New rule: adding %d %p\n", i, pcats->labels); */
+    /* DEBUG fprintf (stderr, "Rast_set_d_cat(): New rule: adding %d %p\n", i, pcats->labels); */
     Rast_quant_add_rule(&pcats->q, *rast1, *rast2, pcats->ncats, pcats->ncats);
     pcats->ncats++;
     if (pcats->nalloc < pcats->ncats) {
-	/* DEBUG fprintf (stderr, "Rast_set_d_raster_cat(): need more space nalloc = %d ncats = %d\n", pcats->nalloc,pcats->ncats); */
+	/* DEBUG fprintf (stderr, "Rast_set_d_cat(): need more space nalloc = %d ncats = %d\n", pcats->nalloc,pcats->ncats); */
 	len = (pcats->nalloc + 256) * sizeof(char *);
-	/* DEBUG fprintf (stderr, "Rast_set_d_raster_cat(): allocating %d labels(%d)\n", pcats->nalloc + 256,(int)len); */
+	/* DEBUG fprintf (stderr, "Rast_set_d_cat(): allocating %d labels(%d)\n", pcats->nalloc + 256,(int)len); */
 	if (len != (int)len) {	/* make sure len doesn't overflow int */
 	    pcats->ncats--;
 	    return -1;
 	}
-	/* DEBUG fprintf(stderr,"Rast_set_d_raster_cat(): pcats->nalloc = %d, pcats->labels = (%p), len = %d\n",pcats->nalloc,pcats->labels,(int)len); */
+	/* DEBUG fprintf(stderr,"Rast_set_d_cat(): pcats->nalloc = %d, pcats->labels = (%p), len = %d\n",pcats->nalloc,pcats->labels,(int)len); */
 	if (pcats->nalloc) {
-	    /* DEBUG fprintf(stderr,"Rast_set_d_raster_cat(): Realloc-ing pcats->labels (%p)\n",pcats->labels); */
+	    /* DEBUG fprintf(stderr,"Rast_set_d_cat(): Realloc-ing pcats->labels (%p)\n",pcats->labels); */
 	    pcats->labels =
 		(char **)G_realloc((char *)pcats->labels, (int)len);
 	}
 	else {
-	    /* DEBUG fprintf(stderr,"Rast_set_d_raster_cat(): alloc-ing new labels pointer array\n"); */
+	    /* DEBUG fprintf(stderr,"Rast_set_d_cat(): alloc-ing new labels pointer array\n"); */
 	    pcats->labels = (char **)G_malloc((int)len);
 	}
 	/* fflush(stderr); */
-	/* DEBUG fprintf (stderr, "Rast_set_d_raster_cats(): allocating %d marks(%d)\n", pcats->nalloc + 256,(int)len); */
+	/* DEBUG fprintf (stderr, "Rast_set_d_cats(): allocating %d marks(%d)\n", pcats->nalloc + 256,(int)len); */
 	len = (pcats->nalloc + 256) * sizeof(int);
 	if (len != (int)len) {	/* make sure len doesn't overflow int */
 	    pcats->ncats--;
@@ -963,7 +872,7 @@ int Rast_set_d_raster_cat(const DCELL * rast1, const DCELL * rast2,
 	    pcats->marks = (int *)G_malloc((int)len);
 	pcats->nalloc += 256;
     }
-    /* DEBUG fprintf(stderr,"Rast_set_d_raster_cats(): store new label\n"); */
+    /* DEBUG fprintf(stderr,"Rast_set_d_cats(): store new label\n"); */
     pcats->labels[pcats->ncats - 1] = G_store(label);
     G_newlines_to_spaces(pcats->labels[pcats->ncats - 1]);
     G_strip(pcats->labels[pcats->ncats - 1]);
@@ -976,14 +885,14 @@ int Rast_set_d_raster_cat(const DCELL * rast1, const DCELL * rast2,
 	pcats->num = (CELL) * rast1;
     if ((CELL) * rast2 > pcats->num)
 	pcats->num = (CELL) * rast2;
-    /* DEBUG fprintf(stderr,"Rast_set_d_raster_cat(): done\n"); */
+    /* DEBUG fprintf(stderr,"Rast_set_d_cat(): done\n"); */
     /* DEBUG fflush(stderr); */
     return 1;
 }
 
 
 /*!
- * \brief Set a raster category label (DCELL)
+ * \brief Set a raster category label
  *
  * Adds the label for range <i>rast1</i> through <i>rast2</i> in
  * category structure <i>pcats</i>.
@@ -998,21 +907,21 @@ int Rast_set_d_raster_cat(const DCELL * rast1, const DCELL * rast2,
  * \return 1 on success
  */
 
-int Rast_set_raster_cat(const void *rast1, const void *rast2,
-		     const char *label,
-		     struct Categories *pcats, RASTER_MAP_TYPE data_type)
+int Rast_set_cat(const void *rast1, const void *rast2,
+		 const char *label,
+		 struct Categories *pcats, RASTER_MAP_TYPE data_type)
 {
     DCELL val1, val2;
 
     val1 = Rast_get_raster_value_d(rast1, data_type);
     val2 = Rast_get_raster_value_d(rast2, data_type);
-    return Rast_set_d_raster_cat(&val1, &val2, label, pcats);
+    return Rast_set_d_cat(&val1, &val2, label, pcats);
 }
 
 /*!
  * \brief Write raster category file
  *
- * \todo To be removed, replaced by Rast_write_raster_cats().
+ * \todo To be removed, replaced by Rast_write_cats().
  *
  * Writes the category file for the raster map <i>name</i> in the
  * current mapset from the <i>cats</i> structure.
@@ -1029,29 +938,12 @@ int Rast_write_cats(const char *name, struct Categories *cats)
 }
 
 /*!
- * \brief Write raster category file
- *
- * \todo To be removed, replaced by Rast_write_raster_cats().
- *
- * Writes the category file for the raster map <i>name</i> in the
- * current mapset from the <i>cats</i> structure.
- *
- * \param name map name
- * \param cats pointer to Categories structure
- *
- * \return 1 on success
- * \return -1 is returned (no diagnostic is printed)
- */
-int Rast_write_raster_cats(const char *name, struct Categories *cats)
-{
-    return write_cats("cats", name, cats);
-}
-
-/*!
  * \brief Write vector category file
  *
  * <b>Note:</b> Used for only old vector format!
  *
+ * \todo Move to the vector library.
+ *
  * \param name map name
  * \param cats pointer to Categories structure
  *
@@ -1095,7 +987,7 @@ static int write_cats(const char *element, const char *name, struct Categories *
 
     /* write the cat numbers:label */
     for (i = 0; i < Rast_quant_nof_rules(&cats->q); i++) {
-	descr = Rast_get_ith_d_raster_cat(cats, i, &val1, &val2);
+	descr = Rast_get_ith_d_cat(cats, i, &val1, &val2);
 	if ((cats->fmt && cats->fmt[0])
 	    || (descr && descr[0])) {
 	    if (val1 == val2) {
@@ -1131,8 +1023,8 @@ static int write_cats(const char *element, const char *name, struct Categories *
  * \return "" on error
  * \return pointer to category description
  */
-char *Rast_get_ith_d_raster_cat(const struct Categories *pcats,
-			     int i, DCELL * rast1, DCELL * rast2)
+char *Rast_get_ith_d_cat(const struct Categories *pcats,
+			 int i, DCELL * rast1, DCELL * rast2)
 {
     int index;
 
@@ -1159,14 +1051,14 @@ char *Rast_get_ith_d_raster_cat(const struct Categories *pcats,
  * \return "" on error
  * \return pointer to category description
  */
-char *Rast_get_ith_f_raster_cat(const struct Categories *pcats,
-			     int i, void *rast1, void *rast2)
+char *Rast_get_ith_f_cat(const struct Categories *pcats,
+			 int i, void *rast1, void *rast2)
 {
     RASTER_MAP_TYPE data_type = FCELL_TYPE;
     char *tmp;
     DCELL val1, val2;
 
-    tmp = Rast_get_ith_d_raster_cat(pcats, i, &val1, &val2);
+    tmp = Rast_get_ith_d_cat(pcats, i, &val1, &val2);
     Rast_set_raster_value_d(rast1, val1, data_type);
     Rast_set_raster_value_d(rast2, val2, data_type);
     return tmp;
@@ -1186,14 +1078,14 @@ char *Rast_get_ith_f_raster_cat(const struct Categories *pcats,
  * \return "" on error
  * \return pointer to category description
  */
-char *Rast_get_ith_c_raster_cat(const struct Categories *pcats,
-			     int i, void *rast1, void *rast2)
+char *Rast_get_ith_c_cat(const struct Categories *pcats,
+			 int i, void *rast1, void *rast2)
 {
     RASTER_MAP_TYPE data_type = CELL_TYPE;
     char *tmp;
     DCELL val1, val2;
 
-    tmp = Rast_get_ith_d_raster_cat(pcats, i, &val1, &val2);
+    tmp = Rast_get_ith_d_cat(pcats, i, &val1, &val2);
     Rast_set_raster_value_d(rast1, val1, data_type);
     Rast_set_raster_value_d(rast2, val2, data_type);
     return tmp;
@@ -1214,13 +1106,13 @@ char *Rast_get_ith_c_raster_cat(const struct Categories *pcats,
  * \return "" on error
  * \return pointer to category description
  */
-char *Rast_get_ith_raster_cat(const struct Categories *pcats, int i, void *rast1,
-			   void *rast2, RASTER_MAP_TYPE data_type)
+char *Rast_get_ith_cat(const struct Categories *pcats, int i, void *rast1,
+		       void *rast2, RASTER_MAP_TYPE data_type)
 {
     char *tmp;
     DCELL val1, val2;
 
-    tmp = Rast_get_ith_d_raster_cat(pcats, i, &val1, &val2);
+    tmp = Rast_get_ith_d_cat(pcats, i, &val1, &val2);
     Rast_set_raster_value_d(rast1, val1, data_type);
     Rast_set_raster_value_d(rast2, val2, data_type);
     return tmp;
@@ -1237,32 +1129,19 @@ char *Rast_get_ith_raster_cat(const struct Categories *pcats, int i, void *rast1
  * For example:
  \code
  struct Categories cats;
- Rast_init_cats ((CELL)0, * "", &cats);
+ Rast_init_cats ("", &cats);
  \endcode
  *
- * \param num raster value
- * \param title title
- * \param pcats pointer to Categories structure
- */
-void Rast_init_cats(CELL num, const char *title, struct Categories *pcats)
-{
-    Rast_init_raster_cats(title, pcats);
-    pcats->num = num;
-}
-
-/*!
- * \brief Initialize category structure
- *
- * Same as existing Rast_init_raster_cats() only ncats argument is
- * missign. ncats has no meaning in new Categories structure and only
- * stores (int) largets data value for backwards compatibility.
+ * \todo Eliminate pcats->num. Num has no meaning in new Categories
+ * structure and only stores (int) largets data value for backwards
+ * compatibility.
  *
  * \param title title
  * \param pcats pointer to Categories structure
  */
-void Rast_init_raster_cats(const char *title, struct Categories *pcats)
+void Rast_init_cats(const char *title, struct Categories *pcats)
 {
-    Rast_set_raster_cats_title(title, pcats);
+    Rast_set_cats_title(title, pcats);
     pcats->labels = NULL;
     pcats->nalloc = 0;
     pcats->ncats = 0;
@@ -1279,7 +1158,7 @@ void Rast_init_raster_cats(const char *title, struct Categories *pcats)
 /*!
  * \brief Set title in category structure
  *
- * \todo To be removed, replaced by Rast_set_raster_cats_title().
+ * \todo To be removed, replaced by Rast_set_cats_title().
  *
  * The <i>title</i> is copied into the <i>pcats</i> structure.
  *
@@ -1288,19 +1167,6 @@ void Rast_init_raster_cats(const char *title, struct Categories *pcats)
  */
 void Rast_set_cats_title(const char *title, struct Categories *pcats)
 {
-    Rast_set_raster_cats_title(title, pcats);
-}
-
-/*!
- * \brief Set title in category structure
- *
- * The <i>title</i> is copied into the <i>pcats</i> structure.
- *
- * \param title title
- * \param pcats pointer to Categories structure
- */
-void Rast_set_raster_cats_title(const char *title, struct Categories *pcats)
-{
     if (title == NULL)
 	title = "";
     pcats->title = G_store(title);
@@ -1311,31 +1177,13 @@ void Rast_set_raster_cats_title(const char *title, struct Categories *pcats)
 /*!
   \brief Set category fmt (?)
 
-  \todo To be removed, replaced by Rast_set_raster_cats_fmt().
-
   \param fmt
   \param m1,
   \param a1,m2,a2
   \param pcats pointer to Categories structure
 */
 void Rast_set_cats_fmt(const char *fmt, double m1, double a1, double m2,
-		    double a2, struct Categories *pcats)
-{
-    Rast_set_raster_cats_fmt(fmt, m1, a1, m2, a2, pcats);
-}
-
-/*!
-  \brief Set category fmt (?)
-
-  \todo To be removed, replaced by Rast_set_raster_cats_fmt().
-
-  \param fmt
-  \param m1,
-  \param a1,m2,a2
-  \param pcats pointer to Categories structure
-*/
-void Rast_set_raster_cats_fmt(const char *fmt, double m1, double a1, double m2,
-			   double a2, struct Categories *pcats)
+		       double a2, struct Categories *pcats)
 {
     pcats->m1 = m1;
     pcats->a1 = a1;
@@ -1350,30 +1198,15 @@ void Rast_set_raster_cats_fmt(const char *fmt, double m1, double a1, double m2,
 /*!
  * \brief Free category structure memory
  *
- * \todo To be removed, replaced by Rast_free_raster_cats().
+ * \todo To be removed, replaced by Rast_free_cats().
  *
  * Frees memory allocated by Rast_read_cats(), Rast_init_cats() and
- * Rast_set_cat().
+ * Rast_set_c_cat().
  *
  * \param pcats pointer to Categories structure
  */
 void Rast_free_cats(struct Categories *pcats)
 {
-    Rast_free_raster_cats(pcats);
-}
-
-/*!
- * \brief Free category structure memory
- *
- * \todo To be removed, replaced by Rast_free_raster_cats().
- *
- * Frees memory allocated by Rast_read_cats(), Rast_init_cats() and
- * Rast_set_cat().
- *
- * \param pcats pointer to Categories structure
- */
-void Rast_free_raster_cats(struct Categories *pcats)
-{
     int i;
 
     if (pcats->title != NULL) {
@@ -1407,17 +1240,17 @@ void Rast_free_raster_cats(struct Categories *pcats)
  * \param pcats_to pointer to destination Categories structure
  * \param pcats_from pointer to source Categories structure
  */
-void Rast_copy_raster_cats(struct Categories *pcats_to,
-			const struct Categories *pcats_from)
+void Rast_copy_cats(struct Categories *pcats_to,
+		    const struct Categories *pcats_from)
 {
     int i;
     char *descr;
     DCELL d1, d2;
 
-    Rast_init_raster_cats(pcats_from->title, pcats_to);
+    Rast_init_cats(pcats_from->title, pcats_to);
     for (i = 0; i < pcats_from->ncats; i++) {
-	descr = Rast_get_ith_d_raster_cat(pcats_from, i, &d1, &d2);
-	Rast_set_d_raster_cat(&d1, &d2, descr, pcats_to);
+	descr = Rast_get_ith_d_cat(pcats_from, i, &d1, &d2);
+	Rast_set_d_cat(&d1, &d2, descr, pcats_to);
     }
 }
 
@@ -1428,7 +1261,7 @@ void Rast_copy_raster_cats(struct Categories *pcats_to,
 
   \return number of categories
 */
-int Rast_number_of_raster_cats(struct Categories *pcats)
+int Rast_number_of_cats(struct Categories *pcats)
 {
     return pcats->ncats;
 }
@@ -1452,22 +1285,22 @@ int Rast_sort_cats(struct Categories *pcats)
 
     ncats = pcats->ncats;
     G_debug(3, "Rast_sort_cats(): Copying to save cats buffer");
-    Rast_copy_raster_cats(&save_cats, pcats);
-    Rast_free_raster_cats(pcats);
+    Rast_copy_cats(&save_cats, pcats);
+    Rast_free_cats(pcats);
 
     indexes = (int *)G_malloc(sizeof(int) * ncats);
     for (i = 0; i < ncats; i++)
 	indexes[i] = i;
 
     qsort(indexes, ncats, sizeof(int), cmp);
-    Rast_init_raster_cats(save_cats.title, pcats);
+    Rast_init_cats(save_cats.title, pcats);
     for (i = 0; i < ncats; i++) {
-	descr = Rast_get_ith_d_raster_cat(&save_cats, indexes[i], &d1, &d2);
+	descr = Rast_get_ith_d_cat(&save_cats, indexes[i], &d1, &d2);
 	G_debug(4, "  Write sorted cats, pcats = %p pcats->labels = %p",
 		pcats, pcats->labels);
-	Rast_set_d_raster_cat(&d1, &d2, descr, pcats);
+	Rast_set_d_cat(&d1, &d2, descr, pcats);
     }
-    Rast_free_raster_cats(&save_cats);
+    Rast_free_cats(&save_cats);
 
     return 0;
 }

lib/raster/sample.c

@@ -116,7 +116,7 @@ DCELL Rast_get_raster_sample_nearest(int fd,
     }
 
     if (usedesc) {
-	char *buf = Rast_get_cat(maprow[col], cats);
+	char *buf = Rast_get_c_cat((CELL *) &(maprow[col]), cats);
 
 	G_squeeze(buf);
 	result = scancatlabel(buf);
@@ -194,13 +194,13 @@ DCELL Rast_get_raster_sample_bilinear(int fd,
     if (usedesc) {
 	char *buf;
 
-	G_squeeze(buf = Rast_get_cat((int)arow[col], cats));
+	G_squeeze(buf = Rast_get_c_cat((int*) &(arow[col]), cats));
 	grid[0][0] = scancatlabel(buf);
-	G_squeeze(buf = Rast_get_cat((int)arow[col + 1], cats));
+	G_squeeze(buf = Rast_get_c_cat((CELL *) &(arow[col + 1]), cats));
 	grid[0][1] = scancatlabel(buf);
-	G_squeeze(buf = Rast_get_cat((int)brow[col], cats));
+	G_squeeze(buf = Rast_get_c_cat((CELL *) &(brow[col]), cats));
 	grid[1][0] = scancatlabel(buf);
-	G_squeeze(buf = Rast_get_cat((int)brow[col + 1], cats));
+	G_squeeze(buf = Rast_get_c_cat((CELL *) &(brow[col + 1]), cats));
 	grid[1][1] = scancatlabel(buf);
     }
     else {
@@ -289,7 +289,7 @@ DCELL Rast_get_raster_sample_cubic(int fd,
 
 	for (i = 0; i < 4; i++) {
 	    for (j = 0; j < 4; j++) {
-		G_squeeze(buf = Rast_get_cat(rows[i][col + j], cats));
+		G_squeeze(buf = Rast_get_c_cat((CELL *) &(rows[i][col + j]), cats));
 		grid[i][j] = scancatlabel(buf);
 	    }
 	}

ps/ps.map/ps_clrtbl.c

@@ -42,7 +42,7 @@ int PS_colortable(void)
     do_color = (PS.grey == 0 && PS.level == 2);
 
     /* How many categories to show */
-    num_cats = Rast_number_of_raster_cats(&PS.cats);
+    num_cats = Rast_number_of_cats(&PS.cats);
     G_debug(3, "clrtbl: %d categories", num_cats);
     if (!num_cats) {
 	G_warning(_("Your cats/ file is invalid. A cats/ file with categories "
@@ -89,7 +89,7 @@ int PS_colortable(void)
 	    fprintf(PS.fp, "(%s)\n", "no data");
 	else
 	    fprintf(PS.fp, "(%s)\n",
-		    Rast_get_ith_d_raster_cat(&PS.cats, i - 1, &dmin, &dmax));
+		    Rast_get_ith_d_cat(&PS.cats, i - 1, &dmin, &dmax));
     }
     fprintf(PS.fp, "] def\n");
 
@@ -136,7 +136,7 @@ int PS_colortable(void)
 
 	    /* fill box and outline in black */
 	    if (i)
-		label = Rast_get_ith_d_raster_cat(&PS.cats, i - 1, &dmin, &dmax);
+		label = Rast_get_ith_d_cat(&PS.cats, i - 1, &dmin, &dmax);
 
 	    x1 = l + (double)j *72.0 * col_width;
 

raster/r.buffer/support.c

@@ -27,15 +27,17 @@ int make_support_files(char *output, char *units)
 {
     struct Categories pcats;
 
+    int i;
     CELL cat;
     char label[128];
 
-    Rast_init_cats((CELL) 1, "Distance Zones", &pcats);
+    Rast_init_cats("Distance Zones", &pcats);
 
-    Rast_set_cat(cat = 1, "distances calculated from these locations", &pcats);
-    for (cat = 0; cat < ndist; cat++) {
-	if (cat == 0)
-	    sprintf(label, "0-%s %s", distances[cat].label, units);
+    cat = 1;
+    Rast_set_c_cat(&cat, &cat, "distances calculated from these locations", &pcats);
+    for (i = 0; i < ndist; i++) {
+	if (i == 0)
+	    sprintf(label, "0-%s %s", distances[i].label, units);
 	else {
 	    /* improved next, but it would be perfect to achieve (example):
 	     * 0-100.55 meters
@@ -47,11 +49,12 @@ int make_support_files(char *output, char *units)
 	     *
 	     *but it's better that the original code. MN 1/2002
 	     */
-	    sprintf(label, "%s-%s %s", distances[cat - 1].label,
-		    distances[cat].label, units);
+	    sprintf(label, "%s-%s %s", distances[i - 1].label,
+		    distances[i].label, units);
 	}
 
-	Rast_set_cat(cat + ZONE_INCR, label, &pcats);
+	cat = i + ZONE_INCR;
+	Rast_set_c_cat(&cat, &cat, label, &pcats);
     }
 
     Rast_write_cats(output, &pcats);

raster/r.category/main.c

@@ -150,7 +150,7 @@ int main(int argc, char *argv[])
 	    if ((fd = Rast_open_cell_old(name, mapset)) < 0)
 		G_fatal_error(_("Unable to open raster map <%s>"), name);
 
-	    Rast_init_raster_cats("", &cats);
+	    Rast_init_cats("", &cats);
 
 	    if (0 > Rast_read_cats(parm.raster->answer, cmapset, &cats))
 		G_fatal_error(_("Unable to read category file of raster map <%s@%s>"),
@@ -179,7 +179,7 @@ int main(int argc, char *argv[])
 				  parm.file->answer);
 	    }
 
-	    Rast_init_raster_cats("", &cats);
+	    Rast_init_cats("", &cats);
 
 	    for (;;) {
 		char buf[1024], label[1024];
@@ -189,9 +189,9 @@ int main(int argc, char *argv[])
 		    break;
 
 		if (sscanf(buf, "%lf:%lf:%[^\n]", &d1, &d2, label) == 3)
-		    Rast_set_d_raster_cat(&d1, &d2, label, &cats);
+		    Rast_set_d_cat(&d1, &d2, label, &cats);
 		else if (sscanf(buf, "%lf:%[^\n]", &d1, label) == 2)
-		    Rast_set_d_raster_cat(&d1, &d1, label, &cats);
+		    Rast_set_d_cat(&d1, &d1, label, &cats);
 	    }
 
 	    if (Rast_write_cats(name, &cats) < 0)
@@ -208,7 +208,7 @@ int main(int argc, char *argv[])
 	    double m1, a1, m2, a2;
 
 	    /* read existing values */
-	    Rast_init_raster_cats("", &cats);
+	    Rast_init_cats("", &cats);
 
 	    if (0 > Rast_read_cats(name, G_mapset(), &cats))
 		G_warning(_("Unable to read category file of raster map <%s@%s>"),
@@ -302,7 +302,7 @@ int print_label(long x)
 {
     char *label;
 
-    G_squeeze(label = Rast_get_cat((CELL) x, &cats));
+    G_squeeze(label = Rast_get_c_cat((CELL *) &x, &cats));
     fprintf(stdout, "%ld%c%s\n", x, fs, label);
 
     return 0;
@@ -314,7 +314,7 @@ int print_d_label(double x)
     DCELL dtmp;
 
     dtmp = x;
-    G_squeeze(label = Rast_get_d_raster_cat(&dtmp, &cats));
+    G_squeeze(label = Rast_get_d_cat(&dtmp, &cats));
     sprintf(tmp, "%.10f", x);
     G_trim_decimal(tmp);
     fprintf(stdout, "%s%c%s\n", tmp, fs, label);

raster/r.compress/main.c

@@ -136,7 +136,7 @@ static int process(char *name, int uncompress)
     if (hist_ok)
 	Rast_write_history(name, &hist);
     if (cats_ok) {
-	cats.num = Rast_number_of_cats(name, G_mapset());
+	cats.num = Rast_get_max_c_cat(name, G_mapset());
 	Rast_write_cats(name, &cats);
 	Rast_free_cats(&cats);
     }

raster/r.cross/cats.c

@@ -49,7 +49,7 @@ int set_cat(CELL result, CELL * cat, struct Categories *pcats)
 	lbl = get_label(cat[i], &labels[i]);
 	strcat(buf, lbl);
     }
-    Rast_set_cat(result, buf, pcats);
+    Rast_set_c_cat(&result, &result, buf, pcats);
     return 0;
 }
 
@@ -58,7 +58,7 @@ static char *get_label(CELL cat, struct Categories *labels)
     char *lbl;
     static char temp[256];
 
-    lbl = Rast_get_cat(cat, labels);
+    lbl = Rast_get_c_cat(&cat, labels);
     if (*lbl == 0)
 	sprintf(lbl = temp, "category %ld", (long)cat);
     return lbl;

raster/r.digit/get_label.c

@@ -44,7 +44,7 @@ char *get_label(long cat, struct Categories *labels)
 
     for (;;) {
 	fprintf(stdout, _("Enter a label for category %ld [%s] "),
-		cat, Rast_get_cat((CELL) cat, labels));
+		cat, Rast_get_c_cat((CELL *) &cat, labels));
 	if (!G_gets(buffer))
 	    continue;;
 	G_strip(buffer);
@@ -64,10 +64,10 @@ int get_category(FILE * fd, char *type, struct Categories *labels)
 	cat = get_cat(type);
 	lbl = get_label(cat, labels);
 	fprintf(stdout, "%ld [%s]\n", cat,
-		*lbl ? lbl : Rast_get_cat((CELL) cat, labels));
+		*lbl ? lbl : Rast_get_c_cat((CELL) cat, labels));
     } while (!G_yes(_("Look ok? "), 1));
     if (*lbl)
-	Rast_set_cat((CELL) cat, lbl, labels);
+      Rast_set_c_cat((CELL *) &cat, (CELL *) &cat, lbl, labels);
 
     fprintf(fd, "= %ld %s\n", cat, lbl);
     return (0);

raster/r.distance/labels.c

@@ -30,7 +30,5 @@ void read_labels(struct Map *map)
 
 char *get_label(struct Map *map, CELL cat)
 {
-    char *Rast_get_cat();
-
-    return Rast_get_cat(cat, &map->labels);
+    return Rast_get_c_cat(&cat, &map->labels);
 }

raster/r.grow/Makefile

@@ -2,8 +2,8 @@ MODULE_TOPDIR = ../..
 
 PGM = r.grow
 
-LIBES = $(GISLIB)
-DEPENDENCIES = $(GISDEP)
+LIBES = $(GISLIB) $(RASTERLIB)
+DEPENDENCIES = $(GISDEP) $(RASTERDEP)
 
 include $(MODULE_TOPDIR)/include/Make/Module.make
 

raster/r.grow/main.c

@@ -21,9 +21,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <grass/gis.h>
+#include <grass/raster.h>
 #include <grass/glocale.h>
 
-
 #define MAX(a, b)	((a) > (b) ? (a) : (b))
 
 static int size;
@@ -194,7 +194,7 @@ int main(int argc, char **argv)
 
     if (Rast_read_cats(in_name, "", &cats) == -1) {
 	G_warning(_("Error reading category file for <%s>"), in_name);
-	Rast_init_cats(0, "", &cats);
+	Rast_init_cats("", &cats);
     }
 
     if (Rast_read_colors(in_name, "", &colr) == -1) {
@@ -205,10 +205,10 @@ int main(int argc, char **argv)
 	colrfile = 1;
 
     if (opt.old->answer && oldval >= 0)
-	Rast_set_cat(oldval, "original cells", &cats);
+	Rast_set_c_cat(&oldval, &oldval, "original cells", &cats);
 
     if (opt.new->answer)
-	Rast_set_cat(newval, "grown cells", &cats);
+	Rast_set_c_cat(&newval, &newval,"grown cells", &cats);
 
     in_rows = G_malloc((size * 2 + 1) * sizeof(DCELL *));
 

raster/r.in.poly/get_item.c

@@ -66,7 +66,7 @@ int get_item(FILE * fd, int *type, long *cat, double **x, double **y,
 	    /* probably change this as G_getl2() doesn't store the new line (?) */
 	    if (sscanf(buf + 1, "%ld%[^\n]", cat, lbl) == 2) {
 		G_strip(lbl);
-		Rast_set_cat((CELL) * cat, lbl, labels);
+		Rast_set_c_cat((CELL*) cat, (CELL *) cat, lbl, labels);
 	    }
 	    continue;
 	}

raster/r.kappa/prt_label.c

@@ -24,7 +24,7 @@ void prt_label(void)
 	fprintf(fd, "MAP%-d Category Description\n", i + 1);
 	for (j = 0; j < ncat; j++) {
 	    cats = rlst;
-	    cl = Rast_get_cat((CELL) cats[j], &(layers[i].labels));
+	    cl = Rast_get_c_cat((CELL *) &(cats[j]), &(layers[i].labels));
 	    if (cl)
 		G_strip(cl);
 	    if (cl == NULL || *cl == 0)

raster/r.le/r.le.patch/trace.c

@@ -180,7 +180,7 @@ void cell_clip_drv(int col0, int row0, int ncols, int nrows, double **value,
 
 	infd = Rast_open_cell_old(name, mapset);
 	colr_ok = Rast_read_colors(name, mapset, &colr) > 0;
-	cats_ok = Rast_read_raster_cats(name, mapset, &cats) >= 0;
+	cats_ok = Rast_read_cats(name, mapset, &cats) >= 0;
 	hist_ok = Rast_read_history(name, mapset, &hist) >= 0;
 	range_ok = Rast_read_range(name, mapset, &range) >= 0;
 
@@ -198,7 +198,7 @@ void cell_clip_drv(int col0, int row0, int ncols, int nrows, double **value,
 	/* 3. initialize appropriate data structures */
 
 	if (cats_ok)
-	    Rast_init_raster_cats(Rast_get_raster_cats_title(&cats), &newcats);
+	    Rast_init_cats(Rast_get_cats_title(&cats), &newcats);
 	if (data_type == CELL_TYPE)
 	    Rast_init_cell_stats(&stats);
 
@@ -369,7 +369,7 @@ void cell_clip_drv(int col0, int row0, int ncols, int nrows, double **value,
     if (choice->coremap) {
 	Rast_close_cell(fe);
 	Rast_rewind_cell_stats(&stats);
-	Rast_rewind_raster_cats(&cats);
+	Rast_rewind_cats(&cats);
 
 	if (cats_ok && data_type == CELL_TYPE) {
 	    long count;
@@ -378,12 +378,12 @@ void cell_clip_drv(int col0, int row0, int ncols, int nrows, double **value,
 	    rast1 = cor_cell_buf;
 	    rast2 = G_incr_void_ptr(rast1, Rast_cell_size(CELL_TYPE));
 	    while (Rast_next_cell_stat(rast1, &count, &stats))
-		Rast_set_raster_cat(rast1, rast2, Rast_get_raster_cat(rast1, &cats,
+		Rast_set_cat(rast1, rast2, Rast_get_cat(rast1, &cats,
 								CELL_TYPE),
 				 &newcats, CELL_TYPE);
-	    Rast_write_raster_cats("interior", &newcats);
-	    Rast_free_raster_cats(&cats);
-	    Rast_free_raster_cats(&newcats);
+	    Rast_write_cats("interior", &newcats);
+	    Rast_free_cats(&cats);
+	    Rast_free_cats(&newcats);
 	    Rast_free_cell_stats(&stats);
 	}
 

raster/r.le/r.le.pixel/cellclip.c

@@ -21,6 +21,7 @@
 #include <grass/gis.h>
 #include "pixel.h"
 #include <grass/config.h>
+#include <grass/raster.h>
 #include "local_proto.h"
 
 

raster/r.le/r.le.pixel/driver.c

@@ -23,7 +23,7 @@
 #include <grass/gis.h>
 #include "pixel.h"
 #include <grass/config.h>
-
+#include <grass/raster.h>
 
 
 int finput, g_scale = 1, g_unit = 1;

raster/r.le/r.le.pixel/texture.c

@@ -19,6 +19,7 @@
 
 #include <grass/gis.h>
 #include <grass/config.h>
+#include <grass/raster.h>
 #include "pixel.h"
 
 
@@ -37,7 +38,6 @@ extern int g_scale, g_unit;
 
 struct Categories cats;
 
-char *Rast_get_cat();
 
 					/* declare a counter for the number
 					   of pixels with non-null values

raster/r.mapcalc/map.c

@@ -340,7 +340,8 @@ static void translate_from_cats(struct map *m, CELL * cell, DCELL * xcell,
 	if (!btree_find(btree, &key, &ptr)) {
 	    values = vbuf;
 	    for (i = 0; i < NCATS; i++) {
-		if ((label = Rast_get_cat((CELL) (i + key), pcats)) == NULL
+		CELL cat = i + key;
+		if ((label = Rast_get_c_cat((CELL *) cat, pcats)) == NULL
 		    || sscanf(label, "%lf", values) != 1)
 		    SET_NULL_D(values);
 		values++;

raster/r.mapcalc/map3.c

@@ -298,8 +298,9 @@ static void translate_from_cats(map * m, CELL * cell, DCELL * xcell,
 	 */
 	if (!btree_find(btree, &key, &ptr)) {
 	    values = vbuf;
+	    int cat = i + key;
 	    for (i = 0; i < NCATS; i++) {
-		if ((label = Rast_get_cat((CELL) (i + key), pcats)) == NULL
+		if ((label = Rast_get_c_cat((CELL *) &cat, pcats)) == NULL
 		    || sscanf(label, "%lf", values) != 1)
 		    SET_NULL_D(values);
 		values++;

raster/r.mode/main.c

@@ -105,7 +105,7 @@ int main(int argc, char *argv[])
 	    max = value;
 	}
 	if (basecat != catb) {
-	    write_reclass(reclass, catb, catc, Rast_get_cat(catc, &cover_cats));
+	  write_reclass(reclass, catb, catc, Rast_get_c_cat((CELL *) &catc, &cover_cats));
 	    catb = basecat;
 	    catc = covercat;
 	    max = value;
@@ -118,7 +118,7 @@ int main(int argc, char *argv[])
     if (first) {
 	catb = catc = 0;
     }
-    write_reclass(reclass, catb, catc, Rast_get_cat(catc, &cover_cats));
+    write_reclass(reclass, catb, catc, Rast_get_c_cat((CELL *) &catc, &cover_cats));
 
     pclose(stats);
     pclose(reclass);

raster/r.neighbors/divr_cats.c

@@ -4,7 +4,7 @@
 int divr_cats(void)
 {
     Rast_set_cats_fmt("$1 $?different categories$category$", 1.0, 0.0, 0.0, 0.0,
-		   &ncb.cats);
+		      &ncb.cats);
 
     return 0;
 }

raster/r.neighbors/intr_cats.c

@@ -5,6 +5,6 @@
 int intr_cats(void)
 {
     Rast_set_cats_fmt("$1% dispersion", 1.0, -1.0, 0.0, 0.0, &ncb.cats);
-
+    
     return 0;
 }

raster/r.neighbors/null_cats.c

@@ -4,10 +4,7 @@
 
 int null_cats(void)
 {
-    int ncats;
-
-    ncats = Rast_number_of_cats(ncb.newcell, G_mapset());
-    Rast_init_cats(ncats, ncb.title, &ncb.cats);
+    Rast_init_cats(ncb.title, &ncb.cats);
 
     return 0;
 }

raster/r.null/main.c

@@ -279,7 +279,7 @@ int process(const char *name, const char *mapset, int change_null, RASTER_MAP_TY
     G_suppress_warnings(1);
     colr_ok = Rast_read_colors(name, mapset, &colr) > 0;
     hist_ok = Rast_read_history(name, mapset, &hist) >= 0;
-    cats_ok = Rast_read_raster_cats(name, mapset, &cats) >= 0;
+    cats_ok = Rast_read_cats(name, mapset, &cats) >= 0;
 
     if (map_type != CELL_TYPE) {
 	Rast_quant_init(&quant);
@@ -297,8 +297,8 @@ int process(const char *name, const char *mapset, int change_null, RASTER_MAP_TY
     if (hist_ok)
 	Rast_write_history(name, &hist);
     if (cats_ok) {
-	cats.num = Rast_number_of_cats(name, mapset);
-	Rast_write_raster_cats(name, &cats);
+	cats.num = Rast_get_max_c_cat(name, mapset);
+	Rast_write_cats(name, &cats);
 	Rast_free_cats(&cats);
     }
     if (map_type != CELL_TYPE && quant_ok)

raster/r.param.scale/param.h

@@ -23,27 +23,27 @@
 #define RAD2DEG 57.29578
 #define DEG2RAD 0.017453293
 
-#define TINY 1.0e-20;
+#define TINY 1.0e-20
 
 /* Bug? start with 1 as G_set_cats() doesn't accept 0 category */
-#define FLAT ((CELL)1)
-#define PIT ((CELL)2)
-#define CHANNEL ((CELL)3)
-#define PASS ((CELL)4)
-#define RIDGE ((CELL)5)
-#define PEAK ((CELL)6)
-
-#define NUM_CATS ((CELL)7)
-
-#define ELEV   1
-#define SLOPE  2
-#define ASPECT 3
-#define PROFC  4
-#define PLANC  5
-#define LONGC  6
-#define CROSC  7
-#define MINIC  8
-#define MAXIC  9
+#define FLAT    1
+#define PIT     2
+#define CHANNEL 3
+#define PASS    4
+#define RIDGE   5
+#define PEAK    6
+
+#define NUM_CATS 7
+
+#define ELEV    1
+#define SLOPE   2
+#define ASPECT  3
+#define PROFC   4
+#define PLANC   5
+#define LONGC   6
+#define CROSC   7
+#define MINIC   8
+#define MAXIC   9
 #define FEATURE 10
 
 /* The six quadratic coefficients are stored in the array coeff */

raster/r.param.scale/write_cats.c

@@ -21,24 +21,31 @@
 void write_cats(void)
 {
     struct Categories cats;
+    CELL cat;
 
     /*------------------------------------------------------------------------*/
     /*                            INITIALISE                                  */
 
     /*------------------------------------------------------------------------*/
-    Rast_init_cats((CELL) 0, "", &cats);
-    Rast_set_raster_cats_title("Surface Features", &cats);
+    Rast_init_cats("", &cats);
+    Rast_set_cats_title("Surface Features", &cats);
 
     /*------------------------------------------------------------------------*/
     /*                      FILL OUT CATEGORIES STRUCTURE                     */
 
     /*------------------------------------------------------------------------*/
-    Rast_set_cat(FLAT, " Planar", &cats);
-    Rast_set_cat(PIT, " Pit", &cats);
-    Rast_set_cat(PEAK, " Peak", &cats);
-    Rast_set_cat(RIDGE, " Ridge", &cats);
-    Rast_set_cat(CHANNEL, " Channel", &cats);
-    Rast_set_cat(PASS, " Pass (saddle)", &cats);
+    cat = FLAT;
+    Rast_set_c_cat(&cat, &cat, " Planar", &cats);
+    cat = PIT;
+    Rast_set_c_cat(&cat, &cat, " Pit", &cats);
+    cat = PEAK;
+    Rast_set_c_cat(&cat, &cat, " Peak", &cats);
+    cat = RIDGE;
+    Rast_set_c_cat(&cat, &cat, " Ridge", &cats);
+    cat = CHANNEL;
+    Rast_set_c_cat(&cat, &cat, " Channel", &cats);
+    cat = PASS;
+    Rast_set_c_cat(&cat, &cat, " Pass (saddle)", &cats);
 
     /*------------------------------------------------------------------------*/
     /*                     WRITE OUT CATEGORIES STRUCTURE                     */

raster/r.patch/support.c

@@ -50,7 +50,7 @@ int support(char **names,
 		if (n && !Rast_find_cell_stat(n, &count, statf)) {
 		    if (do_cats) {
 			Rast_update_cell_stats(&n, 1, statf);
-			Rast_set_cat(n, Rast_get_cat(n, &pcats), cats);
+			Rast_set_c_cat(&n, &n, Rast_get_c_cat((CELL *) &n, &pcats), cats);
 		    }
 		    if (do_colr) {
 			Rast_get_color(n, &red, &grn, &blu, &pcolr);

raster/r.random.surface/save.c

@@ -15,7 +15,8 @@ void SaveMap(int NumMap, int MapSeed)
     struct Colors Colr;
     char String[80], Label[240];
     struct History history;
-
+    CELL cat;
+    
     G_debug(2, "SaveMap()");
 
     OutFD = Rast_open_cell_new(OutNames[NumMap]);
@@ -187,14 +188,15 @@ void SaveMap(int NumMap, int MapSeed)
        TheoryCovariance( TheoryName, Label);
      */
 
-    Rast_init_cats(CatInfo.NumCat, Label, &Cats);
+    Rast_init_cats(Label, &Cats);
     for (Index = 0; Index < CatInfo.NumCat; Index++) {
 	if (CatInfo.NumValue[Index] != 0) {
 	    CatInfo.Average[Index] /= CatInfo.NumValue[Index];
 	    sprintf(Label, "%+lf %+lf to %+lf",
 		    CatInfo.Average[Index],
 		    CatInfo.Min[Index], CatInfo.Max[Index]);
-	    Rast_set_cat(1 + Index, Label, &Cats);
+	    cat = Index + 1;
+	    Rast_set_c_cat(&cat, &cat, Label, &Cats);
 	}
     }
 

raster/r.random/support.c

@@ -24,15 +24,15 @@ int make_support(struct rr_state *theState, int percent, double percentage)
 	inraster = theState->inraster;
 	nulls = theState->nulls;
     }
-    if (Rast_read_raster_cats(inraster, "", &cats) >= 0) {
+    if (Rast_read_cats(inraster, "", &cats) >= 0) {
 	sprintf(title, "Random points on <%s>", inraster);
 	Rast_set_cats_title(title, &cats);
 	if (theState->use_nulls)
-	    Rast_set_raster_cat(nulls.data.v,
+	    Rast_set_cat(nulls.data.v,
 			     nulls.data.v,
 			     "Points with NULL values in original",
 			     &cats, nulls.type);
-	Rast_write_raster_cats(theState->outraster, &cats);
+	Rast_write_cats(theState->outraster, &cats);
     }
 
     /* write history for output raster */

raster/r.reclass/parse.c

@@ -142,7 +142,7 @@ int parse(const char *line, RULE ** rules, RULE ** tail, struct Categories *cats
 	if (*rules == NULL)
 	    *rules = *tail;
 	if (*label)
-	    Rast_set_cat(new, label, cats);
+	    Rast_set_c_cat(&new, &new, label, cats);
     }
     return count;
 }

raster/r.reclass/reclass.c

@@ -161,13 +161,13 @@ static void set_cats(struct Categories *cats, /* const */ int *is_default,
 	for (i = 0; i < rec->num; i++)
 	    if (is_default[i]) {
 		int x = i + rec->min;
-		char *label = Rast_get_cat(x, &old_cats);
+		char *label = Rast_get_c_cat(&x, &old_cats);
 
-		Rast_set_cat(x, label, cats);
+		Rast_set_c_cat(&x, &x, label, cats);
 	    }
     }
     else if (default_rule)
-	Rast_set_cat(DEFAULT, default_label, cats);
+	Rast_set_c_cat(&DEFAULT, &DEFAULT, default_label, cats);
 }
 
 static int _reclass( /* const */ RULE * rules, struct Categories *cats,

raster/r.report/prt_report.c

@@ -270,7 +270,7 @@ int construct_val_str(int nl, CELL * pval, char *str)
     else {			/* find out which floating point range to print */
 
 	if (cat_ranges)
-	    descr = Rast_get_ith_d_raster_cat(&layers[nl].labels, *pval,
+	    descr = Rast_get_ith_d_cat(&layers[nl].labels, *pval,
 					   &dLow, &dHigh);
 	else {
 	    dLow = (DMAX[nl] - DMIN[nl]) / nsteps *
@@ -296,13 +296,13 @@ char *construct_cat_label(int nl, CELL cat)
     static char str[500];
 
     if (!is_fp[nl] || as_int)
-	return Rast_get_cat(cat, &layers[nl].labels);
+	return Rast_get_c_cat(&cat, &layers[nl].labels);
     else {			/* find or construct the label for
 				   floating point range to print */
 	if (Rast_is_c_null_value(&tmp))
 	    return G_store("no data");
 	if (cat_ranges)
-	    return Rast_get_ith_d_raster_cat(&layers[nl].labels, cat,
+	    return Rast_get_ith_d_cat(&layers[nl].labels, cat,
 					  &dLow, &dHigh);
 	else {
 	    dLow = (DMAX[nl] - DMIN[nl]) / (double)nsteps *
@@ -310,8 +310,8 @@ char *construct_cat_label(int nl, CELL cat)
 	    dHigh = (DMAX[nl] - DMIN[nl]) / (double)nsteps *
 		(double)cat + DMIN[nl];
 	    sprintf(str, "from %s to %s",
-		    Rast_get_d_raster_cat(&dLow, &layers[nl].labels),
-		    Rast_get_d_raster_cat(&dHigh, &layers[nl].labels));
+		    Rast_get_d_cat(&dLow, &layers[nl].labels),
+		    Rast_get_d_cat(&dHigh, &layers[nl].labels));
 	    return str;
 	}
     }				/* fp label */

raster/r.resample/main.c

@@ -83,8 +83,8 @@ int main(int argc, char *argv[])
     colr_ok = Rast_read_colors(name, "", &colr) > 0;
     cats_ok = Rast_read_cats(name, "", &cats) >= 0;
     if (cats_ok) {
-	Rast_unmark_raster_cats(&cats);
-	Rast_init_cats((CELL) 0, Rast_get_cats_title(&cats), &newcats);
+	Rast_unmark_cats(&cats);
+	Rast_init_cats(Rast_get_cats_title(&cats), &newcats);
     }
 
     infd = Rast_open_cell_old(name, "");
@@ -122,7 +122,7 @@ int main(int argc, char *argv[])
 	    G_fatal_error(_("Error reading row %d"), row);
 	if (Rast_put_raster_row(outfd, rast, out_type) < 0)
 	    G_fatal_error(_("Error writing row %d"), row);
-	Rast_mark_raster_cats(rast, ncols, &cats, data_type);
+	Rast_mark_cats(rast, ncols, &cats, data_type);
     }
 
     G_percent(row, nrows, 2);
@@ -133,7 +133,7 @@ int main(int argc, char *argv[])
 
     Rast_close_cell(outfd);
 
-    Rast_rewind_raster_cats(&cats);
+    Rast_rewind_cats(&cats);
 
     if (cats_ok) {
 	long count;
@@ -143,10 +143,10 @@ int main(int argc, char *argv[])
 	rast2 = G_incr_void_ptr(rast, Rast_cell_size(data_type));
 
 	G_message(_("Creating new cats file..."));
-	while (Rast_get_next_marked_raster_cat(&cats,
+	while (Rast_get_next_marked_cat(&cats,
 					    rast1, rast2, &count, data_type))
-	    Rast_set_raster_cat(rast1, rast2,
-			     Rast_get_raster_cat(rast1, &cats, data_type),
+	    Rast_set_cat(rast1, rast2,
+			     Rast_get_cat(rast1, &cats, data_type),
 			     &newcats, data_type);
 
 	Rast_write_cats(result, &newcats);

raster/r.slope.aspect/main.c

@@ -75,6 +75,7 @@ int main(int argc, char *argv[])
     DCELL *c1, *c2, *c3, *c4, *c5, *c6, *c7, *c8, *c9;
     DCELL tmp1, tmp2;
     FCELL dat1, dat2;
+    CELL cat;
     void *asp_raster, *asp_ptr = NULL;
     void *slp_raster, *slp_ptr = NULL;
     void *pcurv_raster, *pcurv_ptr = NULL;
@@ -1008,8 +1009,8 @@ int main(int argc, char *argv[])
 	    Rast_quantize_fp_map_range(aspect_name, G_mapset(), 0., 360., 0,
 				    360);
 
-	Rast_read_raster_cats(aspect_name, G_mapset(), &cats);
-	Rast_set_raster_cats_title
+	Rast_read_cats(aspect_name, G_mapset(), &cats);
+	Rast_set_cats_title
 	    ("Aspect counterclockwise in degrees from east", &cats);
 
 	G_verbose_message(_("Min computed aspect %.4f, max computed aspect %.4f"),
@@ -1041,22 +1042,24 @@ int main(int argc, char *argv[])
 		sprintf(buf, "%d degree%s ccw from east", i,
 			i == 1 ? "" : "s");
 	    if (data_type == CELL_TYPE) {
-		Rast_set_cat(i, buf, &cats);
+	      Rast_set_c_cat((CELL *) &i, (CELL *) &i, buf, &cats);
 		continue;
 	    }
 	    tmp1 = (double)i - .5;
 	    tmp2 = (double)i + .5;
-	    Rast_set_d_raster_cat(&tmp1, &tmp2, buf, &cats);
+	    Rast_set_d_cat(&tmp1, &tmp2, buf, &cats);
+	}
+	if (data_type == CELL_TYPE) {
+	    cat = 0;
+	    Rast_set_c_cat(&cat, &cat, "no aspect", &cats);
 	}
-	if (data_type == CELL_TYPE)
-	    Rast_set_cat(0, "no aspect", &cats);
 	else {
 	    tmp1 = 0.;
 	    tmp2 = .5;
-	    Rast_set_d_raster_cat(&tmp1, &tmp2, "no aspect", &cats);
+	    Rast_set_d_cat(&tmp1, &tmp2, "no aspect", &cats);
 	}
-	Rast_write_raster_cats(aspect_name, &cats);
-	Rast_free_raster_cats(&cats);
+	Rast_write_cats(aspect_name, &cats);
+	Rast_free_cats(&cats);
 
 	/* write colors for aspect file */
 	Rast_init_colors(&colors);
@@ -1110,11 +1113,11 @@ int main(int argc, char *argv[])
 					(CELL) ceil(max_slp));
 	}
 
-	Rast_read_raster_cats(slope_name, G_mapset(), &cats);
+	Rast_read_cats(slope_name, G_mapset(), &cats);
 	if (deg)
-	    Rast_set_raster_cats_title("slope in degrees", &cats);
+	    Rast_set_cats_title("slope in degrees", &cats);
 	else if (perc)
-	    Rast_set_raster_cats_title("percent slope", &cats);
+	    Rast_set_cats_title("percent slope", &cats);
 
 	G_verbose_message(_("Min computed slope %.4f, max computed slope %.4f"),
 			  min_slp, max_slp);
@@ -1129,9 +1132,9 @@ int main(int argc, char *argv[])
 		sprintf(buf, "%d percent", i);
 	    if (data_type == CELL_TYPE) {
 		/* INCR_BY_ONE
-		   Rast_set_cat(i+1, buf, &cats);
+		   Rast_set_c_cat(i+1, buf, &cats);
 		 */
-		Rast_set_cat(i, buf, &cats);
+		Rast_set_c_cat(&i, &i, buf, &cats);
 		continue;
 	    }
 	    /* INCR_BY_ONE
@@ -1140,22 +1143,24 @@ int main(int argc, char *argv[])
 	     */
 	    tmp1 = (DCELL) i - .5;
 	    tmp2 = (DCELL) i + .5;
-	    Rast_set_d_raster_cat(&tmp1, &tmp2, buf, &cats);
+	    Rast_set_d_cat(&tmp1, &tmp2, buf, &cats);
+	}
+	if (data_type == CELL_TYPE) {
+	    cat = 0;
+	    Rast_set_c_cat(&cat, &cat, "zero slope", &cats);
 	}
-	if (data_type == CELL_TYPE)
-	    Rast_set_cat(0, "zero slope", &cats);
 	/* INCR_BY_ONE
-	   Rast_set_cat(0, "no data", &cats);
+	   Rast_set_c_cat(0, "no data", &cats);
 	 */
 	else {
 	    tmp1 = 0;
 	    tmp2 = 0.5;
-	    Rast_set_d_raster_cat(&tmp1, &tmp2, "zero slope", &cats);
+	    Rast_set_d_cat(&tmp1, &tmp2, "zero slope", &cats);
 	}
 	/* INCR_BY_ONE
-	   Rast_set_d_raster_cat (&tmp1, &tmp1, "no data", &cats);
+	   Rast_set_d_cat (&tmp1, &tmp1, "no data", &cats);
 	 */
-	Rast_write_raster_cats(slope_name, &cats);
+	Rast_write_cats(slope_name, &cats);
 
 	/* writing history file */
 	Rast_short_history(slope_name, "raster", &hist);
@@ -1227,7 +1232,8 @@ int main(int argc, char *argv[])
 
 	Rast_read_cats(pcurv_name, G_mapset(), &cats);
 	Rast_set_cats_title("profile curvature", &cats);
-	Rast_set_cat((CELL) 0, "no profile curve", &cats);
+	cat = 0;
+	Rast_set_c_cat(&cat, &cat, "no profile curve", &cats);
 
 	/* writing history file */
 	Rast_short_history(pcurv_name, "raster", &hist);
@@ -1253,7 +1259,8 @@ int main(int argc, char *argv[])
 
 	Rast_read_cats(tcurv_name, G_mapset(), &cats);
 	Rast_set_cats_title("tangential curvature", &cats);
-	Rast_set_cat((CELL) 0, "no tangential curve", &cats);
+	cat = 0;
+	Rast_set_c_cat(&cat, &cat, "no tangential curve", &cats);
 
 	/* writing history file */
 	Rast_short_history(tcurv_name, "raster", &hist);
@@ -1277,7 +1284,8 @@ int main(int argc, char *argv[])
 
 	Rast_read_cats(dx_name, G_mapset(), &cats);
 	Rast_set_cats_title("E-W slope", &cats);
-	Rast_set_cat((CELL) 0, "no E-W slope", &cats);
+	cat = 0;	
+	Rast_set_c_cat(&cat, &cat, "no E-W slope", &cats);
 
 	/* writing history file */
 	Rast_short_history(dx_name, "raster", &hist);
@@ -1301,7 +1309,8 @@ int main(int argc, char *argv[])
 
 	Rast_read_cats(dy_name, G_mapset(), &cats);
 	Rast_set_cats_title("N-S slope", &cats);
-	Rast_set_cat((CELL) 0, "no N-S slope", &cats);
+	cat = 0;
+	Rast_set_c_cat(&cat, &cat, "no N-S slope", &cats);
 
 	/* writing history file */
 	Rast_short_history(dy_name, "raster", &hist);
@@ -1325,7 +1334,8 @@ int main(int argc, char *argv[])
 
 	Rast_read_cats(dxx_name, G_mapset(), &cats);
 	Rast_set_cats_title("DXX", &cats);
-	Rast_set_cat((CELL) 0, "DXX", &cats);
+	cat = 0;
+	Rast_set_c_cat(&cat, &cat, "DXX", &cats);
 
 	/* writing history file */
 	Rast_short_history(dxx_name, "raster", &hist);
@@ -1349,7 +1359,8 @@ int main(int argc, char *argv[])
 
 	Rast_read_cats(dyy_name, G_mapset(), &cats);
 	Rast_set_cats_title("DYY", &cats);
-	Rast_set_cat((CELL) 0, "DYY", &cats);
+	cat = 0;
+	Rast_set_c_cat(&cat, &cat, "DYY", &cats);
 
 	/* writing history file */
 	Rast_short_history(dyy_name, "raster", &hist);
@@ -1373,7 +1384,8 @@ int main(int argc, char *argv[])
 
 	Rast_read_cats(dxy_name, G_mapset(), &cats);
 	Rast_set_cats_title("DXY", &cats);
-	Rast_set_cat((CELL) 0, "DXY", &cats);
+	cat = 0;
+	Rast_set_c_cat(&cat, &cat, "DXY", &cats);
 
 	/* writing history file */
 	Rast_short_history(dxy_name, "raster", &hist);

raster/r.statistics/o_adev.c

@@ -54,7 +54,7 @@ o_adev(const char *basemap, const char *covermap, const char *outputmap, int use
 	}
 
 	if (usecats)
-	    sscanf(Rast_get_cat((CELL) covercat, cats), "%lf", &x);
+	    sscanf(Rast_get_c_cat((CELL *) &covercat, cats), "%lf", &x);
 	else
 	    x = covercat;
 

raster/r.statistics/o_average.c

@@ -54,7 +54,7 @@ o_average(const char *basemap, const char *covermap, const char *outputmap, int
 	    catb = basecat;
 	}
 	if (usecats)
-	    sscanf(Rast_get_cat((CELL) covercat, cats), "%lf", &x);
+	    sscanf(Rast_get_c_cat((CELL *) &covercat, cats), "%lf", &x);
 	else
 	    x = covercat;
 	sum1 += x * area;

raster/r.statistics/o_divr.c

@@ -31,7 +31,7 @@ o_divr(const char *basemap, const char *covermap, const char *outputmap, int use
 	    catc = 0;
 	}
 	if (basecat != catb) {
-	    write_reclass(reclass_fd, catb, catc, Rast_get_cat(catc, cats),
+	  write_reclass(reclass_fd, catb, catc, Rast_get_c_cat((CELL *) &catc, cats),
 			  usecats);
 	    catb = basecat;
 	    catc = 0;
@@ -39,7 +39,7 @@ o_divr(const char *basemap, const char *covermap, const char *outputmap, int use
 	catc++;
     }
     if (!first)
-	write_reclass(reclass_fd, catb, catc, Rast_get_cat(catc, cats), usecats);
+      write_reclass(reclass_fd, catb, catc, Rast_get_c_cat((CELL *) &catc, cats), usecats);
 
     pclose(stats_fd);
     pclose(reclass_fd);

raster/r.statistics/o_kurt.c

@@ -53,7 +53,7 @@ o_kurt(const char *basemap, const char *covermap, const char *outputmap, int use
 	}
 
 	if (usecats)
-	    sscanf(Rast_get_cat((CELL) covercat, cats), "%lf", &x);
+	    sscanf(Rast_get_c_cat((CELL *) &covercat, cats), "%lf", &x);
 	else
 	    x = covercat;
 

raster/r.statistics/o_max.c

@@ -30,7 +30,7 @@ o_max(const char *basemap, const char *covermap, const char *outputmap, int usec
 	}
 
 	if (basecat != catb) {
-	    write_reclass(reclass, catb, catc, Rast_get_cat(catc, cats),
+	  write_reclass(reclass, catb, catc, Rast_get_c_cat((CELL *) &catc, cats),
 			  usecats);
 	    catb = basecat;
 	    catc = covercat;
@@ -44,7 +44,7 @@ o_max(const char *basemap, const char *covermap, const char *outputmap, int usec
 	catb = catc = 0;
     }
 
-    write_reclass(reclass, catb, catc, Rast_get_cat(catc, cats), usecats);
+    write_reclass(reclass, catb, catc, Rast_get_c_cat((CELL *) &catc, cats), usecats);
 
     pclose(stats);
     pclose(reclass);

raster/r.statistics/o_median.c

@@ -42,7 +42,7 @@ o_median(const char *basemap, const char *covermap, const char *outputmap, int u
 	}
 	if (basecat != catb) {
 	    catc = median(&stats);
-	    write_reclass(reclass_fd, catb, catc, Rast_get_cat(catc, cats),
+	    write_reclass(reclass_fd, catb, catc, Rast_get_c_cat((CELL *) &catc, cats),
 			  usecats);
 	    catb = basecat;
 	    stats.n = 0;
@@ -60,7 +60,7 @@ o_median(const char *basemap, const char *covermap, const char *outputmap, int u
     }
     if (!first) {
 	catc = median(&stats);
-	write_reclass(reclass_fd, catb, catc, Rast_get_cat(catc, cats), usecats);
+	write_reclass(reclass_fd, catb, catc, Rast_get_c_cat((CELL *) &catc, cats), usecats);
     }
 
     pclose(stats_fd);

raster/r.statistics/o_min.c

@@ -30,7 +30,7 @@ o_min(const char *basemap, const char *covermap, const char *outputmap, int usec
 	}
 
 	if (basecat != catb) {
-	    write_reclass(reclass, catb, catc, Rast_get_cat(catc, cats),
+	  write_reclass(reclass, catb, catc, Rast_get_c_cat((CELL *) &catc, cats),
 			  usecats);
 	    catb = basecat;
 	    catc = covercat;
@@ -44,7 +44,7 @@ o_min(const char *basemap, const char *covermap, const char *outputmap, int usec
 	catb = catc = 0;
     }
 
-    write_reclass(reclass, catb, catc, Rast_get_cat(catc, cats), usecats);
+    write_reclass(reclass, catb, catc, Rast_get_c_cat((CELL *) &catc, cats), usecats);
 
     pclose(stats);
     pclose(reclass);

raster/r.statistics/o_mode.c

@@ -32,7 +32,7 @@ o_mode(const char *basemap, const char *covermap, const char *outputmap, int use
 	}
 
 	if (basecat != catb) {
-	    write_reclass(reclass, catb, catc, Rast_get_cat(catc, cats),
+	  write_reclass(reclass, catb, catc, Rast_get_c_cat((CELL *) &catc, cats),
 			  usecats);
 	    catb = basecat;
 	    catc = covercat;
@@ -49,7 +49,7 @@ o_mode(const char *basemap, const char *covermap, const char *outputmap, int use
 	catb = catc = 0;
     }
 
-    write_reclass(reclass, catb, catc, Rast_get_cat(catc, cats), usecats);
+    write_reclass(reclass, catb, catc, Rast_get_c_cat((CELL *) &catc, cats), usecats);
 
     pclose(stats);
     pclose(reclass);

raster/r.statistics/o_sdev.c

@@ -56,7 +56,7 @@ o_sdev(const char *basemap, const char *covermap, const char *outputmap, int use
 	}
 
 	if (usecats)
-	    sscanf(Rast_get_cat((CELL) covercat, cats), "%lf", &x);
+	    sscanf(Rast_get_c_cat((CELL *) &covercat, cats), "%lf", &x);
 	else
 	    x = covercat;
 

raster/r.statistics/o_skew.c

@@ -55,7 +55,7 @@ o_skew(const char *basemap, const char *covermap, const char *outputmap, int use
 	}
 
 	if (usecats)
-	    sscanf(Rast_get_cat((CELL) covercat, cats), "%lf", &x);
+	    sscanf(Rast_get_c_cat((CELL *) &covercat, cats), "%lf", &x);
 	else
 	    x = covercat;
 

raster/r.statistics/o_sum.c

@@ -56,7 +56,7 @@ o_sum(const char *basemap, const char *covermap, const char *outputmap, int usec
 	    catb = basecat;
 	}
 	if (usecats)
-	    sscanf(Rast_get_cat((CELL) covercat, cats), "%lf", &x);
+	    sscanf(Rast_get_c_cat((CELL *) &covercat, cats), "%lf", &x);
 	else
 	    x = covercat;
 	sum1 += x * area;

raster/r.statistics/o_var.c

@@ -56,7 +56,7 @@ o_var(const char *basemap, const char *covermap, const char *outputmap, int usec
 	}
 
 	if (usecats)
-	    sscanf(Rast_get_cat((CELL) covercat, cats), "%lf", &x);
+	    sscanf(Rast_get_c_cat((CELL *) &covercat, cats), "%lf", &x);
 	else
 	    x = covercat;
 

raster/r.statistics2/main.c

@@ -270,7 +270,7 @@ int main(int argc, char **argv)
 
 	    v = cover_buf[col];
 	    if (usecats)
-		sscanf(Rast_get_cat((CELL) v, &cats), "%lf", &v);
+		sscanf(Rast_get_c_cat((CELL *) &v, &cats), "%lf", &v);
 
 	    if (count)
 		count[n]++;
@@ -349,7 +349,7 @@ int main(int argc, char **argv)
 
 		v = cover_buf[col];
 		if (usecats)
-		    sscanf(Rast_get_cat((CELL) v, &cats), "%lf", &v);
+		    sscanf(Rast_get_c_cat((CELL *) &v, &cats), "%lf", &v);
 		d = v - mean[n];
 
 		if (sumu)

raster/r.stats/raw_stats.c

@@ -82,14 +82,14 @@ int raw_stats(int fd[], int with_coordinates, int with_xy, int with_labels)
 		    fprintf(stdout, "%s%s", i ? fs : "", no_data_str);
 		    if (with_labels)
 			fprintf(stdout, "%s%s", fs,
-				Rast_get_cat(null_cell, &labels[i]));
+				Rast_get_c_cat(&null_cell, &labels[i]));
 		}
 		else if (map_type[i] == CELL_TYPE) {
 		    fprintf(stdout, "%s%ld", i ? fs : "",
 			    (long)*((CELL *) rastp[i]));
 		    if (with_labels && !is_fp[i])
 			fprintf(stdout, "%s%s", fs,
-				Rast_get_cat(*((CELL *) rastp[i]), &labels[i]));
+				Rast_get_c_cat((CELL *) rastp[i], &labels[i]));
 		}
 		else {		/* floating point cell */
 
@@ -99,7 +99,7 @@ int raw_stats(int fd[], int with_coordinates, int with_xy, int with_labels)
 		    fprintf(stdout, "%s%s", i ? fs : "", str1);
 		    if (with_labels)
 			fprintf(stdout, "%s%s", fs,
-				Rast_get_d_raster_cat((DCELL *) rastp[i],
+				Rast_get_d_cat((DCELL *) rastp[i],
 						   &labels[i]));
 		}
 		rastp[i] =

raster/r.stats/stats.c

@@ -242,7 +242,7 @@ int print_cell_stats(char *fmt, int with_percents, int with_counts,
 	if (with_percents)
 	    fprintf(stdout, "%s0.00%%", fs);
 	if (with_labels)
-	    fprintf(stdout, "%s%s", fs, Rast_get_cat(null_cell, &labels[i]));
+	    fprintf(stdout, "%s%s", fs, Rast_get_c_cat(&null_cell, &labels[i]));
 	fprintf(stdout, "\n");
     }
     else {
@@ -271,14 +271,14 @@ int print_cell_stats(char *fmt, int with_percents, int with_counts,
 		    fprintf(stdout, "%s%s", i ? fs : "", no_data_str);
 		    if (with_labels && !(raw_output && is_fp[i]))
 			fprintf(stdout, "%s%s", fs,
-				Rast_get_cat(null_cell, &labels[i]));
+				Rast_get_c_cat(&null_cell, &labels[i]));
 		}
 		else if (raw_output || !is_fp[i] || as_int) {
 		    fprintf(stdout, "%s%ld", i ? fs : "",
 			    (long)node->values[i]);
 		    if (with_labels && !is_fp[i])
 			fprintf(stdout, "%s%s", fs,
-				Rast_get_cat((CELL) node->values[i],
+				Rast_get_c_cat((CELL*) &(node->values[i]),
 					  &labels[i]));
 		}
 		else {		/* find out which floating point range to print */
@@ -316,8 +316,8 @@ int print_cell_stats(char *fmt, int with_percents, int with_counts,
 				    labels[i].labels[node->values[i]]);
 			else
 			    fprintf(stdout, "%sfrom %s to %s", fs,
-				    Rast_get_d_raster_cat(&dLow, &labels[i]),
-				    Rast_get_d_raster_cat(&dHigh, &labels[i]));
+				    Rast_get_d_cat(&dLow, &labels[i]),
+				    Rast_get_d_cat(&dHigh, &labels[i]));
 		    }
 		}
 

raster/r.to.vect/areas_io.c

@@ -357,7 +357,7 @@ int write_area(struct area_table *a_list,	/* list of areas */
 		db_append_string(&sql, buf);
 
 		if (has_cats) {
-		    temp_buf = Rast_get_cat(p->cat, &RastCats);
+		    temp_buf = Rast_get_c_cat(&(p->cat), &RastCats);
 
 		    db_set_string(&label, temp_buf);
 		    db_double_quote_string(&label);

raster/r.to.vect/util.c

@@ -141,7 +141,7 @@ void insert_value(int cat, int val, double dval)
     if (has_cats) {
 	char *lab;
 
-	lab = Rast_get_cat(val, &RastCats);	/*cats are loaded only for CELL type */
+	lab = Rast_get_c_cat(&val, &RastCats);	/*cats are loaded only for CELL type */
 
 	db_set_string(&label, lab);
 	db_double_quote_string(&label);

raster/r.volume/main.c

@@ -133,7 +133,7 @@ int main(int argc, char *argv[])
     }
 
     /* initialize data accumulation arrays */
-    max = Rast_number_of_cats(clumpmap, clump_mapset);
+    max = Rast_get_max_c_cat(clumpmap, clump_mapset);
 
     sum = (double *)G_malloc((max + 1) * sizeof(double));
     count = (long int *)G_malloc((max + 1) * sizeof(long int));
@@ -164,7 +164,7 @@ int main(int argc, char *argv[])
 	    if (i > max)
 		G_fatal_error(
 		    "Row=%d Col=%d Cat=%d in clump map [%s]; max=%d.\n"
-		    "Cat value > max returned by Rast_number_of_cats.",
+		    "Cat value > max returned by Rast_get_max_c_cat.",
 		    row, col, i, clumpmap, max);
 	    if (i < 1)
 		continue;	/* ignore zeros and negs */

raster/r.watershed/shed/print.c

@@ -67,7 +67,7 @@ int print_output(OUTPUT * output)
 	    do_cat = &(output->maps[b].basins[c].first_cat);
 	    while ((output->maps[b].do_cats != 0) && do_cat) {
 		cat_name =
-		    Rast_get_cat(do_cat->cat_val, &(output->maps[b].cats));
+		    Rast_get_c_cat(&(do_cat->cat_val), &(output->maps[b].cats));
 		switch (output->type_area) {
 		case 1:
 		    sprintf(area, "%.3f acres",

raster/r.what/main.c

@@ -404,7 +404,7 @@ int main(int argc, char *argv[])
 		}
 		if (withcats)
 		    fprintf(stdout, "%c%s", fs,
-			    Rast_get_cat(cache[point].value[i], &cats[i]));
+			    Rast_get_c_cat(&(cache[point].value[i]), &cats[i]));
 		if (flag4->answer)
 		    fprintf(stdout, "%c%s", fs, cache[point].clr_buf[i]);
 	    }

swig/perl/R_slope_aspect/r_slope_aspect/r_slope_aspect.c

@@ -1035,8 +1035,8 @@ int r_slope_aspect(int argc, char *argv[])
 	    Rast_quantize_fp_map_range(aspect_name, G_mapset(), 0., 360., 0,
 				    360);
 
-	Rast_read_raster_cats(aspect_name, G_mapset(), &cats);
-	Rast_set_raster_cats_title
+	Rast_read_cats(aspect_name, G_mapset(), &cats);
+	Rast_set_cats_title
 	    ("Aspect counterclockwise in degrees from east", &cats);
 
 	G_message(_("Min computed aspect %.4f, max computed aspect %.4f"),
@@ -1068,22 +1068,22 @@ int r_slope_aspect(int argc, char *argv[])
 		sprintf(buf, "%d degree%s ccw from east", i,
 			i == 1 ? "" : "s");
 	    if (data_type == CELL_TYPE) {
-		Rast_set_cat(i, buf, &cats);
+		Rast_set_c_cat(i, buf, &cats);
 		continue;
 	    }
 	    tmp1 = (double)i - .5;
 	    tmp2 = (double)i + .5;
-	    Rast_set_d_raster_cat(&tmp1, &tmp2, buf, &cats);
+	    Rast_set_d_cat(&tmp1, &tmp2, buf, &cats);
 	}
 	if (data_type == CELL_TYPE)
-	    Rast_set_cat(0, "no aspect", &cats);
+	    Rast_set_c_cat(0, "no aspect", &cats);
 	else {
 	    tmp1 = 0.;
 	    tmp2 = .5;
-	    Rast_set_d_raster_cat(&tmp1, &tmp2, "no aspect", &cats);
+	    Rast_set_d_cat(&tmp1, &tmp2, "no aspect", &cats);
 	}
-	Rast_write_raster_cats(aspect_name, &cats);
-	Rast_free_raster_cats(&cats);
+	Rast_write_cats(aspect_name, &cats);
+	Rast_free_cats(&cats);
 
 	/* write colors for aspect file */
 	Rast_init_colors(&colors);
@@ -1137,11 +1137,11 @@ int r_slope_aspect(int argc, char *argv[])
 					(CELL) ceil(max_slp));
 	}
 
-	Rast_read_raster_cats(slope_name, G_mapset(), &cats);
+	Rast_read_cats(slope_name, G_mapset(), &cats);
 	if (deg)
-	    Rast_set_raster_cats_title("slope in degrees", &cats);
+	    Rast_set_cats_title("slope in degrees", &cats);
 	else if (perc)
-	    Rast_set_raster_cats_title("percent slope", &cats);
+	    Rast_set_cats_title("percent slope", &cats);
 
 	G_message(_("Min computed slope %.4f, max computed slope %.4f"),
 		  min_slp, max_slp);
@@ -1156,9 +1156,9 @@ int r_slope_aspect(int argc, char *argv[])
 		sprintf(buf, "%d percent", i);
 	    if (data_type == CELL_TYPE) {
 		/* INCR_BY_ONE
-		   Rast_set_cat(i+1, buf, &cats);
+		   Rast_set_c_cat(i+1, buf, &cats);
 		 */
-		Rast_set_cat(i, buf, &cats);
+		Rast_set_c_cat(i, buf, &cats);
 		continue;
 	    }
 	    /* INCR_BY_ONE
@@ -1167,22 +1167,22 @@ int r_slope_aspect(int argc, char *argv[])
 	     */
 	    tmp1 = (DCELL) i - .5;
 	    tmp2 = (DCELL) i + .5;
-	    Rast_set_d_raster_cat(&tmp1, &tmp2, buf, &cats);
+	    Rast_set_d_cat(&tmp1, &tmp2, buf, &cats);
 	}
 	if (data_type == CELL_TYPE)
-	    Rast_set_cat(0, "zero slope", &cats);
+	    Rast_set_c_cat(0, "zero slope", &cats);
 	/* INCR_BY_ONE
-	   Rast_set_cat(0, "no data", &cats);
+	   Rast_set_c_cat(0, "no data", &cats);
 	 */
 	else {
 	    tmp1 = 0;
 	    tmp2 = 0.5;
-	    Rast_set_d_raster_cat(&tmp1, &tmp2, "zero slope", &cats);
+	    Rast_set_d_cat(&tmp1, &tmp2, "zero slope", &cats);
 	}
 	/* INCR_BY_ONE
-	   Rast_set_d_raster_cat (&tmp1, &tmp1, "no data", &cats);
+	   Rast_set_d_cat (&tmp1, &tmp1, "no data", &cats);
 	 */
-	Rast_write_raster_cats(slope_name, &cats);
+	Rast_write_cats(slope_name, &cats);
 
 	/* writing history file */
 	Rast_short_history(slope_name, "raster", &hist);
@@ -1253,8 +1253,8 @@ int r_slope_aspect(int argc, char *argv[])
 	    Rast_round_fp_map(pcurv_name, G_mapset());
 
 	Rast_read_cats(pcurv_name, G_mapset(), &cats);
-	Rast_set_cats_title("profile curvature", &cats);
-	Rast_set_cat((CELL) 0, "no profile curve", &cats);
+	Rast_set_c_cats_title("profile curvature", &cats);
+	Rast_set_c_cat((CELL) 0, "no profile curve", &cats);
 
 	/* writing history file */
 	Rast_short_history(pcurv_name, "raster", &hist);
@@ -1279,8 +1279,8 @@ int r_slope_aspect(int argc, char *argv[])
 	    Rast_round_fp_map(tcurv_name, G_mapset());
 
 	Rast_read_cats(tcurv_name, G_mapset(), &cats);
-	Rast_set_cats_title("tangential curvature", &cats);
-	Rast_set_cat((CELL) 0, "no tangential curve", &cats);
+	Rast_set_c_cats_title("tangential curvature", &cats);
+	Rast_set_c_cat((CELL) 0, "no tangential curve", &cats);
 
 	/* writing history file */
 	Rast_short_history(tcurv_name, "raster", &hist);
@@ -1303,8 +1303,8 @@ int r_slope_aspect(int argc, char *argv[])
 	    Rast_round_fp_map(dx_name, G_mapset());
 
 	Rast_read_cats(dx_name, G_mapset(), &cats);
-	Rast_set_cats_title("E-W slope", &cats);
-	Rast_set_cat((CELL) 0, "no E-W slope", &cats);
+	Rast_set_c_cats_title("E-W slope", &cats);
+	Rast_set_c_cat((CELL) 0, "no E-W slope", &cats);
 
 	/* writing history file */
 	Rast_short_history(dx_name, "raster", &hist);
@@ -1327,8 +1327,8 @@ int r_slope_aspect(int argc, char *argv[])
 	    Rast_round_fp_map(dy_name, G_mapset());
 
 	Rast_read_cats(dy_name, G_mapset(), &cats);
-	Rast_set_cats_title("N-S slope", &cats);
-	Rast_set_cat((CELL) 0, "no N-S slope", &cats);
+	Rast_set_c_cats_title("N-S slope", &cats);
+	Rast_set_c_cat((CELL) 0, "no N-S slope", &cats);
 
 	/* writing history file */
 	Rast_short_history(dy_name, "raster", &hist);
@@ -1351,8 +1351,8 @@ int r_slope_aspect(int argc, char *argv[])
 	    Rast_round_fp_map(dxx_name, G_mapset());
 
 	Rast_read_cats(dxx_name, G_mapset(), &cats);
-	Rast_set_cats_title("DXX", &cats);
-	Rast_set_cat((CELL) 0, "DXX", &cats);
+	Rast_set_c_cats_title("DXX", &cats);
+	Rast_set_c_cat((CELL) 0, "DXX", &cats);
 
 	/* writing history file */
 	Rast_short_history(dxx_name, "raster", &hist);
@@ -1375,8 +1375,8 @@ int r_slope_aspect(int argc, char *argv[])
 	    Rast_round_fp_map(dyy_name, G_mapset());
 
 	Rast_read_cats(dyy_name, G_mapset(), &cats);
-	Rast_set_cats_title("DYY", &cats);
-	Rast_set_cat((CELL) 0, "DYY", &cats);
+	Rast_set_c_cats_title("DYY", &cats);
+	Rast_set_c_cat((CELL) 0, "DYY", &cats);
 
 	/* writing history file */
 	Rast_short_history(dyy_name, "raster", &hist);
@@ -1399,8 +1399,8 @@ int r_slope_aspect(int argc, char *argv[])
 	    Rast_round_fp_map(dxy_name, G_mapset());
 
 	Rast_read_cats(dxy_name, G_mapset(), &cats);
-	Rast_set_cats_title("DXY", &cats);
-	Rast_set_cat((CELL) 0, "DXY", &cats);
+	Rast_set_c_cats_title("DXY", &cats);
+	Rast_set_c_cat((CELL) 0, "DXY", &cats);
 
 	/* writing history file */
 	Rast_short_history(dxy_name, "raster", &hist);

vector/v.to.rast/support.c

@@ -71,11 +71,11 @@ int update_fcolors(const char *raster_name)
 int update_cats(const char *raster_name)
 {
     /* TODO: maybe attribute transfer from vector map? 
-       Use Rast_set_raster_cat() somewhere */
+       Use Rast_set_cat() somewhere */
 
     struct Categories cats;
 
-    Rast_init_cats((CELL) 0, raster_name, &cats);
+    Rast_init_cats(raster_name, &cats);
     Rast_write_cats(raster_name, &cats);
 
     return 0;
@@ -257,7 +257,7 @@ int update_labels(const char *rast_name, const char *vector_map, int field,
     } *my_labels_rules;
 
     /* init raster categories */
-    Rast_init_cats((CELL) 0, "Categories", &rast_cats);
+    Rast_init_cats("Categories", &rast_cats);
 
     if (!(fd = Rast_open_cell_old(rast_name, G_mapset())))
 	G_fatal_error(_("Unable to open raster map <%s>"), rast_name);
@@ -265,7 +265,7 @@ int update_labels(const char *rast_name, const char *vector_map, int field,
     switch (use) {
     case USE_ATTR:
 	{
-	    Rast_set_raster_cats_title("Labels", &rast_cats);
+	    Rast_set_cats_title("Labels", &rast_cats);
 	    int is_fp = Rast_raster_map_is_fp(rast_name, G_mapset());
 
 	    /* open vector map and database driver */
@@ -362,16 +362,17 @@ int update_labels(const char *rast_name, const char *vector_map, int field,
 	    if (is_fp) {
 		/* add label */
 		for (i = 0; i < labels_n_values - 1; i++)
-		    Rast_set_raster_cat(&my_labels_rules[i].d,
+		    Rast_set_cat(&my_labels_rules[i].d,
 				     &my_labels_rules[i + 1].d,
 				     db_get_string(&my_labels_rules[i].label),
 				     &rast_cats, DCELL_TYPE);
 	    }
 	    else {
 		for (i = 0; i < labels_n_values; i++)
-		    Rast_set_cat(my_labels_rules[i].i,
-			      db_get_string(&my_labels_rules[i].label),
-			      &rast_cats);
+		  Rast_set_c_cat(&(my_labels_rules[i].i),
+				 &(my_labels_rules[i].i),
+				 db_get_string(&my_labels_rules[i].label),
+				 &rast_cats);
 	    }
 	}
 	break;
@@ -383,7 +384,7 @@ int update_labels(const char *rast_name, const char *vector_map, int field,
 	    struct Range range;
 
 	    map_type = Rast_raster_map_type(rast_name, G_mapset());
-	    Rast_set_raster_cats_title("Values", &rast_cats);
+	    Rast_set_cats_title("Values", &rast_cats);
 
 	    if (map_type == CELL_TYPE) {
 		CELL min, max;
@@ -392,7 +393,7 @@ int update_labels(const char *rast_name, const char *vector_map, int field,
 		Rast_get_range_min_max(&range, &min, &max);
 
 		sprintf(msg, "Value %d", val);
-		Rast_set_raster_cat(&min, &max, msg, &rast_cats, map_type);
+		Rast_set_cat(&min, &max, msg, &rast_cats, map_type);
 	    }
 	    else {
 		DCELL fmin, fmax;
@@ -401,7 +402,7 @@ int update_labels(const char *rast_name, const char *vector_map, int field,
 		Rast_get_fp_range_min_max(&fprange, &fmin, &fmax);
 
 		sprintf(msg, "Value %.4f", (double)val);
-		Rast_set_raster_cat(&fmin, &fmax, msg, &rast_cats, map_type);
+		Rast_set_cat(&fmin, &fmax, msg, &rast_cats, map_type);
 	    }
 
 	}
@@ -424,7 +425,7 @@ int update_labels(const char *rast_name, const char *vector_map, int field,
 		G_fatal_error(_("Cannot allocate memory for row buffer"));
 
 	    Rast_init_cell_stats(&stats);
-	    Rast_set_raster_cats_title("Categories", &rast_cats);
+	    Rast_set_cats_title("Categories", &rast_cats);
 
 	    rows = G_window_rows();
 
@@ -442,7 +443,7 @@ int update_labels(const char *rast_name, const char *vector_map, int field,
 		char msg[80];
 
 		sprintf(msg, "Category %d", n);
-		Rast_set_raster_cat(&n, &n, msg, &rast_cats, map_type);
+		Rast_set_cat(&n, &n, msg, &rast_cats, map_type);
 	    }
 
 	    G_free(rowbuf);
@@ -456,7 +457,7 @@ int update_labels(const char *rast_name, const char *vector_map, int field,
 	    char msg[64];
 
 	    map_type = Rast_raster_map_type(rast_name, G_mapset());
-	    Rast_set_raster_cats_title("Degrees", &rast_cats);
+	    Rast_set_cats_title("Degrees", &rast_cats);
 
 	    for (i = 1; i <= 360; i++) {
 		sprintf(msg, "%d degrees", i);
@@ -464,7 +465,7 @@ int update_labels(const char *rast_name, const char *vector_map, int field,
 		if (i == 360) {
 		    fmin = 359.5;
 		    fmax = 360.0;
-		    Rast_set_raster_cat(&fmin, &fmax, msg, &rast_cats, map_type);
+		    Rast_set_cat(&fmin, &fmax, msg, &rast_cats, map_type);
 		    fmin = 0.0;
 		    fmax = 0.5;
 		}
@@ -473,7 +474,7 @@ int update_labels(const char *rast_name, const char *vector_map, int field,
 		    fmax = i + 0.5;
 		}
 
-		Rast_set_raster_cat(&fmin, &fmax, msg, &rast_cats, map_type);
+		Rast_set_cat(&fmin, &fmax, msg, &rast_cats, map_type);
 	    }
 	}
 	break;