GRASS GIS 7 Programmer's Manual  7.5.svn(2017)-r71790
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
iclass_statistics.c
Go to the documentation of this file.
1 /*!
2  \file lib/imagery/iclass_statistics.c
3 
4  \brief Imagery library - functions for wx.iclass
5 
6  Computation based on training areas for supervised classification.
7  Based on i.class module (GRASS 6).
8 
9  Computing statistical values (mean, min, max, ...) from given area
10  perimeters for each band.
11 
12  Copyright (C) 1999-2007, 2011 by the GRASS Development Team
13 
14  This program is free software under the GNU General Public License
15  (>=v2). Read the file COPYING that comes with GRASS for details.
16 
17  \author David Satnik, Central Washington University (original author)
18  \author Markus Neteler <neteler itc.it> (i.class module)
19  \author Bernhard Reiter <bernhard intevation.de> (i.class module)
20  \author Brad Douglas <rez touchofmadness.com>(i.class module)
21  \author Glynn Clements <glynn gclements.plus.com> (i.class module)
22  \author Hamish Bowman <hamish_b yahoo.com> (i.class module)
23  \author Jan-Oliver Wagner <jan intevation.de> (i.class module)
24  \author Anna Kratochvilova <kratochanna gmail.com> (rewriting for wx.iclass)
25  \author Vaclav Petras <wenzeslaus gmail.com> (rewriting for wx.iclass)
26  */
27 
28 #include <math.h>
29 
30 #include <grass/imagery.h>
31 #include <grass/glocale.h>
32 #include <grass/colors.h>
33 
34 #include "iclass_local_proto.h"
35 
36 /*!
37  \brief Initialize statistics.
38 
39  \param[out] statistics pointer to statistics structure
40  \param category category (class)
41  \param name class name
42  \param color class color
43  \param nstd standard deviation
44  */
45 void I_iclass_init_statistics(IClass_statistics * statistics, int category,
46  const char *name, const char *color, float nstd)
47 {
48  G_debug(4, "init_statistics() category=%d, name=%s, color=%s, nstd=%f",
49  category, name, color, nstd);
50 
51  statistics->cat = category;
52  statistics->name = G_store(name);
53  statistics->color = G_store(color);
54  statistics->nstd = nstd;
55 
56  statistics->ncells = 0;
57  statistics->nbands = 0;
58 
59  statistics->band_min = NULL;
60  statistics->band_max = NULL;
61  statistics->band_sum = NULL;
62  statistics->band_mean = NULL;
63  statistics->band_stddev = NULL;
64  statistics->band_product = NULL;
65  statistics->band_histo = NULL;
66  statistics->band_range_min = NULL;
67  statistics->band_range_max = NULL;
68 }
69 
70 /*!
71  \brief Allocate space for statistics.
72 
73  \param statistics pointer to statistics structure
74  \param nbands number of band files
75  */
76 void alloc_statistics(IClass_statistics * statistics, int nbands)
77 {
78  int i;
79 
80  G_debug(4, "alloc_statistics()");
81 
82  statistics->nbands = nbands;
83 
84  statistics->band_min = (int *)G_calloc(nbands, sizeof(int));
85  statistics->band_max = (int *)G_calloc(nbands, sizeof(int));
86  statistics->band_sum = (float *)G_calloc(nbands, sizeof(float));
87  statistics->band_mean = (float *)G_calloc(nbands, sizeof(float));
88  statistics->band_stddev = (float *)G_calloc(nbands, sizeof(float));
89  statistics->band_product = (float **)G_calloc(nbands, sizeof(float *));
90  statistics->band_histo = (int **)G_calloc(nbands, sizeof(int *));
91  statistics->band_range_min = (int *)G_calloc(nbands, sizeof(int));
92  statistics->band_range_max = (int *)G_calloc(nbands, sizeof(int));
93 
94  for (i = 0; i < nbands; i++) {
95  statistics->band_product[i] =
96  (float *)G_calloc(nbands, sizeof(float));
97  statistics->band_histo[i] = (int *)G_calloc(MAX_CATS, sizeof(int));
98  }
99 }
100 
101 /*!
102  \brief Free space allocated for statistics attributes.
103 
104  Frees all allocated arrays in statistics structure.
105 
106  \param statistics pointer to statistics structure
107  */
109 {
110  int i;
111 
112  G_debug(4, "free_statistics()");
113 
114  G_free((char *) statistics->name);
115  G_free((char *) statistics->color);
116  G_free(statistics->band_min);
117  G_free(statistics->band_max);
118  G_free(statistics->band_sum);
119  G_free(statistics->band_mean);
120  G_free(statistics->band_stddev);
121  G_free(statistics->band_range_max);
122  G_free(statistics->band_range_min);
123 
124 
125  for (i = 0; i < statistics->nbands; i++) {
126  G_free(statistics->band_histo[i]);
127  G_free(statistics->band_product[i]);
128  }
129  G_free(statistics->band_histo);
130  G_free(statistics->band_product);
131 }
132 
133 /*!
134  \brief Calculate statistics for all training areas.
135 
136  \param statistics pointer to statistics structure
137  \param perimeters list of all area perimeters
138  \param band_buffer buffer to read band rows into
139  \param band_fd band files descriptors
140 
141  \return 1 on succes
142  \return 0 on failure
143  */
145  IClass_perimeter_list * perimeters,
146  CELL ** band_buffer, int *band_fd)
147 {
148  int i, b, b2, nbands;
149 
150  float mean_value, stddev_value;
151 
152  G_debug(5, "make_all_statistics()");
153 
154  nbands = statistics->nbands;
155  for (b = 0; b < nbands; b++) {
156  statistics->band_sum[b] = 0.0;
157  statistics->band_min[b] = MAX_CATS;
158  statistics->band_max[b] = 0;
159  for (b2 = 0; b2 < nbands; b2++)
160  statistics->band_product[b][b2] = 0.0;
161  for (b2 = 0; b2 < MAX_CATS; b2++)
162  statistics->band_histo[b][b2] = 0;
163  }
164 
165  for (i = 0; i < perimeters->nperimeters; i++) {
166  if (!make_statistics
167  (statistics, &perimeters->perimeters[i], band_buffer, band_fd)) {
168  return 0;
169  }
170  }
171  for (b = 0; b < statistics->nbands; b++) {
172  mean_value = mean(statistics, b);
173  stddev_value = stddev(statistics, b);
174 
175  statistics->band_stddev[b] = stddev_value;
176  statistics->band_mean[b] = mean_value;
177 
178  band_range(statistics, b);
179  }
180 
181  return 1;
182 }
183 
184 /*!
185  \brief Calculate statistics for one training area.
186 
187  \param[out] statistics pointer to statistics structure
188  \param perimeter area perimeter
189  \param band_buffer buffer to read band rows into
190  \param band_fd band files descriptors
191 
192  \return 1 on succes
193  \return 0 on failure
194  */
196  IClass_perimeter * perimeter, CELL ** band_buffer,
197  int *band_fd)
198 {
199  int b, b2;
200 
201  int value;
202 
203  int i;
204 
205  int x0, x1;
206 
207  int x, y;
208 
209  int ncells;
210 
211  int nbands;
212 
213  G_debug(5, "make_statistics()");
214 
215  nbands = statistics->nbands;
216 
217  if (perimeter->npoints % 2) {
218  G_warning(_("prepare_signature: outline has odd number of points."));
219  return 0;
220  }
221 
222  ncells = 0;
223 
224  for (i = 1; i < perimeter->npoints; i += 2) {
225  y = perimeter->points[i].y;
226  if (y != perimeter->points[i - 1].y) {
227  G_warning(_("prepare_signature: scan line %d has odd number of points."),
228  (i + 1) / 2);
229  return 0;
230  }
231  read_band_row(band_buffer, band_fd, nbands, y);
232 
233  x0 = perimeter->points[i - 1].x - 1;
234  x1 = perimeter->points[i].x - 1;
235 
236  if (x0 > x1) {
237  G_warning(_("signature: perimeter points out of order."));
238  return 0;
239  }
240 
241  for (x = x0; x <= x1; x++) {
242  ncells++; /* count interior points */
243  for (b = 0; b < nbands; b++) {
244  value = band_buffer[b][x];
245  G_debug(5, "make_statistics() band: %d, read value: %d (max: %d)",
246  b, value, MAX_CATS);
247  if (value < 0 || value > MAX_CATS - 1) {
248  G_warning(_("Data error preparing signatures: value (%d) > num of cats (%d)"),
249  value, MAX_CATS);
250  return 0;
251  }
252  statistics->band_sum[b] += value; /* sum for means */
253  statistics->band_histo[b][value]++; /* histogram */
254  if (statistics->band_min[b] > value)
255  statistics->band_min[b] = value; /* absolute min, max */
256  if (statistics->band_max[b] < value) {
257  statistics->band_max[b] = value;
258  G_debug(5,
259  "make_statistics() statistics->band_max[%d]: %d",
260  b, statistics->band_max[b]);
261  }
262 
263  for (b2 = 0; b2 <= b; b2++) /* products for variance */
264  statistics->band_product[b][b2] +=
265  value * band_buffer[b2][x];
266  }
267  }
268  }
269  statistics->ncells += ncells;
270 
271  return 1;
272 }
273 
274 /*!
275  \brief Create raster map based on statistics.
276 
277  \param statistics pointer to statistics structure
278  \param band_buffer buffer to read band rows into
279  \param band_fd band files descriptors
280  \param raster_name name of new raster map
281  */
282 void create_raster(IClass_statistics * statistics, CELL ** band_buffer,
283  int *band_fd, const char *raster_name)
284 {
285  int fd;
286 
287  CELL *buffer;
288 
289  int n;
290 
291  int col;
292 
293  int nbands;
294 
295  int row, nrows, ncols;
296 
297  struct Colors raster_colors;
298 
299  int r, g, b;
300 
301  int cell_in_ranges;
302 
303  nbands = statistics->nbands;
304 
305  /* build new raster based on current signature and Nstd */
306 
307  fd = Rast_open_c_new(raster_name);
308  buffer = Rast_allocate_c_buf();
309  nrows = Rast_window_rows();
310  ncols = Rast_window_cols();
311 
312  for (row = 0; row < nrows; row++) {
313  read_band_row(band_buffer, band_fd, nbands, row);
314  for (col = 0; col < ncols; col++) {
315  buffer[col] = (CELL) 0;
316  cell_in_ranges = 1;
317  for (n = 0; n < nbands; n++) {
318  if (band_buffer[n][col] < statistics->band_range_min[n] ||
319  band_buffer[n][col] > statistics->band_range_max[n]) {
320  /* out of at least 1 range */
321  cell_in_ranges = 0;
322  }
323  }
324  if (cell_in_ranges) {
325  /* if in range do the assignment */
326  buffer[col] = (CELL) 1;
327  }
328  }
329  Rast_put_row(fd, buffer, CELL_TYPE);
330  }
331  Rast_close(fd);
332 
333  /* generate and write the color table for the mask */
334  Rast_init_colors(&raster_colors);
335  G_str_to_color(statistics->color, &r, &g, &b);
336  Rast_set_c_color((CELL) 1, r, g, b, &raster_colors);
337  Rast_write_colors(raster_name, G_mapset(), &raster_colors);
338 }
339 
340 /* helpers */
341 /*!
342  \brief Helper function for computing min and max range in one band.
343 
344  Computing min and max range value (distance from mean
345  dependent on number od std ddevs).
346 
347  \param statistics pointer to statistics structure
348  \param band band index
349  */
350 void band_range(IClass_statistics * statistics, int band)
351 {
352  float dist;
353 
354  dist = statistics->nstd * statistics->band_stddev[band];
355  statistics->band_range_min[band] =
356  statistics->band_mean[band] - dist + 0.5;
357  statistics->band_range_max[band] =
358  statistics->band_mean[band] + dist + 0.5;
359 }
360 
361 /*!
362  \brief Helper function for computing mean.
363 
364  Computing mean value of cell category values
365  in one band within training area.
366 
367  \param statistics pointer to statistics structure
368  \param band band index
369 
370  \return mean value
371  */
372 float mean(IClass_statistics * statistics, int band)
373 {
374  return statistics->band_sum[band] / statistics->ncells;
375 }
376 
377 /*!
378  \brief Helper function for standard deviation.
379 
380  Computing standard deviation of cell category values
381  in one band within training area.
382 
383  \param statistics pointer to statistics structure
384  \param band band index
385 
386  \return standard deviation
387  */
388 float stddev(IClass_statistics * statistics, int band)
389 {
390  return sqrt(var(statistics, band, band));
391 }
392 
393 /*!
394  \brief Helper function for computing variance.
395 
396  Computing variance of cell category values
397  in one band within training area.
398 
399  \param statistics pointer to statistics structure
400  \param band1 band index
401  \param band2 band index
402 
403  \return variance
404 
405  \see var_signature
406  */
407 float var(IClass_statistics * statistics, int band1, int band2)
408 {
409  float product;
410 
411  float mean1, mean2;
412 
413  int n;
414 
415  product = statistics->band_product[band1][band2];
416  mean1 = mean(statistics, band1);
417  mean2 = mean(statistics, band2);
418  n = statistics->ncells;
419 
420  return product / n - mean1 * mean2;
421 }
422 
423 /*!
424  \brief Helper function for computing variance for signature file.
425 
426  Computing variance of cell category values
427  in one band within training area. Variance is computed
428  in special way.
429 
430  \param statistics pointer to statistics structure
431  \param band1 band index
432  \param band2 band index
433 
434  \return variance
435 
436  \see var
437 
438  \todo verify the computation
439  */
440 float var_signature(IClass_statistics * statistics, int band1, int band2)
441 {
442  float product;
443 
444  float sum1, sum2;
445 
446  int n;
447 
448  product = statistics->band_product[band1][band2];
449  sum1 = statistics->band_sum[band1];
450  sum2 = statistics->band_sum[band2];
451  n = statistics->ncells;
452 
453  return (product - sum1 * sum2 / n) / (n - 1);
454 }
455 
456 /* getters */
457 /*!
458  \brief Get number of bands.
459 
460  \param statistics pointer to statistics structure
461  \param[out] nbands number of bands
462  */
464  int *nbands)
465 {
466  *nbands = statistics->nbands;
467 }
468 
469 /*!
470  \brief Get category (class).
471 
472  \param statistics pointer to statistics structure
473  \param[out] cat category
474  */
476 {
477  *cat = statistics->cat;
478 }
479 
480 /*!
481  \brief Get category (class) name.
482 
483  \note \a name is pointer to already allocated
484  const char * in \a statistics.
485  You should not free it.
486 
487  \param statistics pointer to statistics structure
488  \param[out] name category name
489  */
491  const char **name)
492 {
493  *name = statistics->name;
494 }
495 
496 /*!
497  \brief Get category (class) color.
498 
499  \note \a color is pointer to already allocated
500  const char * in \a statistics.
501  You should not free it.
502 
503  \param statistics pointer to statistics structure
504  \param[out] color category color
505  */
507  const char **color)
508 {
509  *color = statistics->color;
510 }
511 
512 
513 /*!
514  \brief Get number of cells in training areas.
515 
516  \param statistics pointer to statistics structure
517  \param[out] ncells number of cells
518  */
520  int *ncells)
521 {
522  *ncells = statistics->ncells;
523 }
524 
525 /*!
526  \brief Get the multiplier of standard deviation.
527 
528  \param statistics pointer to statistics structure
529  \param[out] nstd multiplier of standard deviation
530  */
531 void I_iclass_statistics_get_nstd(IClass_statistics * statistics, float *nstd)
532 {
533  *nstd = statistics->nstd;
534 }
535 
536 /*!
537  \brief Set the multiplier of standard deviation.
538 
539  \param statistics pointer to statistics structure
540  \param nstd multiplier of standard deviation
541  */
542 void I_iclass_statistics_set_nstd(IClass_statistics * statistics, float nstd)
543 {
544  statistics->nstd = nstd;
545 }
546 
547 /*!
548  \brief Get minimum value in band.
549 
550  \param statistics pointer to statistics structure
551  \param band band index
552  \param[out] min minimum value
553 
554  \return 1 on success
555  \return 0 band index out of range
556  */
558  int *min)
559 {
560  if (band >= statistics->nbands) {
561  G_warning(_("Band index out of range"));
562  return 0;
563  }
564 
565  *min = statistics->band_min[band];
566 
567  return 1;
568 }
569 
570 /*!
571  \brief Get maximum value in band.
572 
573  \param statistics pointer to statistics structure
574  \param band band index
575  \param[out] max maximum value
576 
577  \return 1 on success
578  \return 0 band index out of range
579  */
581  int *max)
582 {
583  if (band >= statistics->nbands) {
584  G_warning(_("Band index out of range"));
585  return 0;
586  }
587 
588  *max = statistics->band_max[band];
589 
590  return 1;
591 }
592 
593 /*!
594  \brief Get sum of values in band.
595 
596  \param statistics pointer to statistics structure
597  \param band band index
598  \param[out] sum sum
599 
600  \return 1 on success
601  \return 0 band index out of range
602  */
604  float *sum)
605 {
606  if (band >= statistics->nbands) {
607  G_warning(_("Band index out of range"));
608  return 0;
609  }
610 
611  *sum = statistics->band_sum[band];
612 
613  return 1;
614 }
615 
616 /*!
617  \brief Get mean of cell category values in band.
618 
619  \param statistics pointer to statistics structure
620  \param band band index
621  \param[out] mean mean
622 
623  \return 1 on success
624  \return 0 band index out of range
625  */
627  float *mean)
628 {
629  if (band >= statistics->nbands) {
630  G_warning(_("Band index out of range"));
631  return 0;
632  }
633 
634  *mean = statistics->band_mean[band];
635 
636  return 1;
637 }
638 
639 /*!
640  \brief Get standard deviation of cell category values in band.
641 
642  \param statistics pointer to statistics structure
643  \param band band index
644  \param[out] stddev standard deviation
645 
646  \return 1 on success
647  \return 0 band index out of range
648  */
650  float *stddev)
651 {
652  if (band >= statistics->nbands) {
653  G_warning(_("Band index out of range"));
654  return 0;
655  }
656 
657  *stddev = statistics->band_stddev[band];
658 
659  return 1;
660 }
661 
662 /*!
663  \brief Get histogram value in band.
664 
665  Each band has one value for each raster cell category.
666  Value is number of cells in category.
667 
668  \param statistics pointer to statistics structure
669  \param band band index
670  \param cat raster cell category
671  \param[out] value number of cells in category
672 
673  \return 1 on success
674  \return 0 band index or cell category value out of range
675  */
677  int cat, int *value)
678 {
679  if (band >= statistics->nbands) {
680  G_warning(_("Band index out of range"));
681  return 0;
682  }
683  if (cat >= MAX_CATS) {
684  G_warning(_("Cell category value out of range"));
685  return 0;
686  }
687 
688  *value = statistics->band_histo[band][cat];
689 
690  return 1;
691 }
692 
693 /*!
694  \brief Get product value
695 
696  Product value of two bands is sum of products
697  of cell category values of two bands.
698  Only cells from training areas are taken into account.
699 
700  \param statistics statistics object
701  \param band1 index of first band
702  \param band2 index of second band
703  \param[out] value product value
704 
705  \return 1 on success
706  \return 0 band index out of range
707  */
709  int band2, float *value)
710 {
711  if (band1 >= statistics->nbands || band2 >= statistics->nbands) {
712  G_warning(_("Band index out of range"));
713  return 0;
714  }
715 
716  *value = statistics->band_product[band1][band2];
717 
718  return 1;
719 }
720 
721 /*!
722  \brief Get minimum cell value based on mean and standard deviation for band.
723 
724  \param statistics pointer to statistics structure
725  \param band band index
726  \param[out] min minimum value
727 
728  \return 1 on success
729  \return 0 band index out of range
730  */
732  int band, int *min)
733 {
734  if (band >= statistics->nbands) {
735  G_warning(_("Band index out of range"));
736  return 0;
737  }
738 
739  *min = statistics->band_range_min[band];
740 
741  return 1;
742 }
743 
744 /*!
745  \brief Get maximum cell value based on mean and standard deviation for band.
746 
747  \param statistics pointer to statistics structure
748  \param band band index
749  \param[out] max maximum value
750 
751  \return 1 on success
752  \return 0 band index out of range
753  */
755  int band, int *max)
756 {
757  if (band >= statistics->nbands) {
758  G_warning(_("Band index out of range"));
759  return 0;
760  }
761 
762  *max = statistics->band_range_max[band];
763 
764  return 1;
765 }
#define CELL_TYPE
Definition: raster.h:11
int I_iclass_statistics_get_product(IClass_statistics *statistics, int band1, int band2, float *value)
Get product value.
CELL cat
Definition: raster3d/cats.c:82
void G_free(void *buf)
Free allocated memory.
Definition: gis/alloc.c:149
void I_iclass_statistics_get_nbands(IClass_statistics *statistics, int *nbands)
Get number of bands.
const char * color
Definition: imagery.h:119
void Rast_close(int fd)
Close a raster map.
Definition: raster/close.c:72
int I_iclass_statistics_get_mean(IClass_statistics *statistics, int band, float *mean)
Get mean of cell category values in band.
CELL * Rast_allocate_c_buf(void)
Allocate memory for a CELL type raster map.
Definition: alloc_cell.c:82
#define min(x, y)
Definition: draw2.c:31
int * band_range_min
Definition: imagery.h:133
void I_iclass_statistics_get_ncells(IClass_statistics *statistics, int *ncells)
Get number of cells in training areas.
int I_iclass_statistics_get_sum(IClass_statistics *statistics, int band, float *sum)
Get sum of values in band.
int I_iclass_statistics_get_stddev(IClass_statistics *statistics, int band, float *stddev)
Get standard deviation of cell category values in band.
char * G_store(const char *s)
Copy string to allocated memory.
Definition: strings.c:86
int Rast_window_rows(void)
Number of rows in active window.
Definition: raster/window.c:85
void create_raster(IClass_statistics *statistics, CELL **band_buffer, int *band_fd, const char *raster_name)
Create raster map based on statistics.
void alloc_statistics(IClass_statistics *statistics, int nbands)
Allocate space for statistics.
int I_iclass_statistics_get_max(IClass_statistics *statistics, int band, int *max)
Get maximum value in band.
#define NULL
Definition: ccmath.h:32
void Rast_init_colors(struct Colors *colors)
Initialize color structure.
Definition: color_init.c:25
#define x
#define max(x, y)
Definition: draw2.c:32
void band_range(IClass_statistics *statistics, int band)
Helper function for computing min and max range in one band.
int I_iclass_statistics_get_range_max(IClass_statistics *statistics, int band, int *max)
Get maximum cell value based on mean and standard deviation for band.
float ** band_product
Definition: imagery.h:130
fd
Definition: d/range.c:69
const char * name
Definition: imagery.h:118
void I_iclass_statistics_get_name(IClass_statistics *statistics, const char **name)
Get category (class) name.
int * band_range_max
Definition: imagery.h:134
void I_iclass_free_statistics(IClass_statistics *statistics)
Free space allocated for statistics attributes.
float * band_stddev
Definition: imagery.h:128
void Rast_write_colors(const char *name, const char *mapset, struct Colors *colors)
Write map layer color table.
int I_iclass_statistics_get_range_min(IClass_statistics *statistics, int band, int *min)
Get minimum cell value based on mean and standard deviation for band.
void Rast_set_c_color(CELL cat, int r, int g, int b, struct Colors *colors)
Set a category color (CELL)
Definition: color_set.c:41
double b
Definition: r_raster.c:39
int make_all_statistics(IClass_statistics *statistics, IClass_perimeter_list *perimeters, CELL **band_buffer, int *band_fd)
Calculate statistics for all training areas.
int I_iclass_statistics_get_histo(IClass_statistics *statistics, int band, int cat, int *value)
Get histogram value in band.
for(cat=0;;cat++)
int G_debug(int level, const char *msg,...)
Print debugging message.
Definition: debug.c:65
float g
Definition: named_colr.c:8
int Rast_open_c_new(const char *name)
Opens a new cell file in a database (compressed)
Definition: raster/open.c:402
int Rast_window_cols(void)
Number of columns in active window.
float var_signature(IClass_statistics *statistics, int band1, int band2)
Helper function for computing variance for signature file.
void I_iclass_init_statistics(IClass_statistics *statistics, int category, const char *name, const char *color, float nstd)
Initialize statistics.
int I_iclass_statistics_get_min(IClass_statistics *statistics, int band, int *min)
Get minimum value in band.
float stddev(IClass_statistics *statistics, int band)
Helper function for standard deviation.
Definition: gis.h:626
double * y
Array of Y coordinates.
Definition: dig_structs.h:1684
float * band_mean
Definition: imagery.h:127
void I_iclass_statistics_get_nstd(IClass_statistics *statistics, float *nstd)
Get the multiplier of standard deviation.
int ** band_histo
Definition: imagery.h:131
float var(IClass_statistics *statistics, int band1, int band2)
Helper function for computing variance.
int CELL
Definition: gis.h:580
#define _(str)
Definition: glocale.h:13
int make_statistics(IClass_statistics *statistics, IClass_perimeter *perimeter, CELL **band_buffer, int *band_fd)
Calculate statistics for one training area.
void I_iclass_statistics_get_color(IClass_statistics *statistics, const char **color)
Get category (class) color.
const char * G_mapset(void)
Get current mapset name.
Definition: gis/mapset.c:33
int G_str_to_color(const char *str, int *red, int *grn, int *blu)
Parse color string and set red,green,blue.
Definition: color_str.c:112
float mean(IClass_statistics *statistics, int band)
Helper function for computing mean.
const char * name
Definition: named_colr.c:7
float * band_sum
Definition: imagery.h:126
void Rast_put_row(int fd, const void *buf, RASTER_MAP_TYPE data_type)
Writes the next row for cell/fcell/dcell file.
void I_iclass_statistics_set_nstd(IClass_statistics *statistics, float nstd)
Set the multiplier of standard deviation.
void read_band_row(CELL **band_buffer, int *band_fd, int nbands, int row)
Read one row of each band.
Definition: iclass_bands.c:91
void G_warning(const char *msg,...)
Print a warning message to stderr.
Definition: gis/error.c:203
double r
Definition: r_raster.c:39
void I_iclass_statistics_get_cat(IClass_statistics *statistics, int *cat)
Get category (class).