SAGA API Version 9.14
Loading...
Searching...
No Matches
map_classify.cpp
Go to the documentation of this file.
1
3// //
4// SAGA //
5// //
6// System for Automated Geoscientific Analyses //
7// //
8// Application Programming Interface //
9// //
10// Library: SAGA API //
11// //
12//-------------------------------------------------------//
13// //
14// map_classify.cpp //
15// //
16// Copyright (C) 2025 by //
17// Olaf Conrad //
18// //
19//-------------------------------------------------------//
20// //
21// This file is part of 'SAGA - System for Automated //
22// Geoscientific Analyses'. SAGA is free software; you //
23// can redistribute it and/or modify it under the terms //
24// of the GNU General Public License as published by the //
25// Free Software Foundation, either version 2 of the //
26// License, or (at your option) any later version. //
27// //
28// SAGA is distributed in the hope that it will be //
29// useful, but WITHOUT ANY WARRANTY; without even the //
30// implied warranty of MERCHANTABILITY or FITNESS FOR A //
31// PARTICULAR PURPOSE. See the GNU General Public //
32// License for more details. //
33// //
34// You should have received a copy of the GNU General //
35// Public License along with this program; if not, see //
36// <http://www.gnu.org/licenses/>. //
37// //
38//-------------------------------------------------------//
39// //
40// contact: Olaf Conrad //
41// Institute of Geography //
42// University of Hamburg //
43// Germany //
44// //
45// e-mail: oconrad@saga-gis.org //
46// //
48
49//---------------------------------------------------------
50#include "map_classify.h"
51
52#include "../grids.h"
53
54
56// //
57// //
58// //
60
61//---------------------------------------------------------
62CSG_Map_Classify::CSG_Map_Classify(void)
63{
64 // nop
65}
66
67//---------------------------------------------------------
72
73//---------------------------------------------------------
74CSG_Map_Classify::CSG_Map_Classify(CSG_Table *pTable, int Field, int Normalize, bool bPercent)
75{
76 Create(pTable, Field, Normalize, bPercent);
77}
78
79//---------------------------------------------------------
84
85//---------------------------------------------------------
86bool CSG_Map_Classify::Destroy(void)
87{
88 m_pObject = NULL; m_nValues = 0; m_Field = -1; m_Normalized.Destroy(); m_bPercent = false;
89
90 m_Classes.Destroy(); m_Classifier = Classifier::NotSet;
91
92 return( true );
93}
94
95
97// //
99
100//---------------------------------------------------------
101bool CSG_Map_Classify::Create(CSG_Data_Object *pObject)
102{
103 Destroy();
104
105 //-----------------------------------------------------
106 if( pObject )
107 {
108 if( pObject->asGrid() )
109 {
110 m_pObject = pObject; m_nValues = pObject->asGrid()->Get_NCells();
111 }
112 else if( pObject->asGrids() )
113 {
114 m_pObject = pObject; m_nValues = pObject->asGrids()->Get_NCells();
115 }
116 }
117
118 //-----------------------------------------------------
119 if( is_Okay() )
120 {
121 return( true );
122 }
123
124 Destroy();
125
126 return( false );
127}
128
129//---------------------------------------------------------
130bool CSG_Map_Classify::Create(CSG_Table *pTable, int Field, int Normalize, bool bPercent)
131{
132 Destroy();
133
134 //-----------------------------------------------------
135 if( pTable && Field >= 0 && Field < pTable->Get_Field_Count() )
136 {
137 if( Normalize >= 0 && Normalize < pTable->Get_Field_Count() )
138 {
139 m_Normalized.Destroy(); m_Normalized.Add_Field("x", SG_DATATYPE_Double);
140
141 for(sLong i=0; i<pTable->Get_Count(); i++)
142 {
143 double Value, Divisor;
144
145 if( pTable->Get_Value(i, Normalize, Divisor) && Divisor && pTable->Get_Value(i, Field, Value) )
146 {
147 m_Normalized.Add_Record()->Set_Value(0, Value / Divisor);
148 }
149 }
150
151 m_pObject = &m_Normalized; m_Field = 0; m_nValues = m_Normalized.Get_Count(); m_bPercent = bPercent;
152 }
153 else
154 {
155 m_pObject = pTable; m_Field = Field; m_nValues = pTable->Get_Count();
156 }
157 }
158
159 //-----------------------------------------------------
160 if( is_Okay() )
161 {
162 return( true );
163 }
164
165 Destroy();
166
167 return( false );
168}
169
170
172// //
174
175//---------------------------------------------------------
176const CSG_String & CSG_Map_Classify::Get_Name(Classifier Classifier) const
177{
178 static const CSG_String Names[] =
179 {
180 _TL("Unique Values" ),
181 _TL("Equal Interval" ),
182 _TL("Defined Interval" ),
183 _TL("Quantile" ),
184 _TL("Geometric Interval"),
185 _TL("Natural Breaks" ),
186 _TL("Standard Deviation"),
187 _TL("Manual Interval" )
188 };
189
190 return( Names[(int)Classifier] );
191}
192
193
195// //
197
198//---------------------------------------------------------
199bool CSG_Map_Classify::Set_LUT(CSG_Table &Classes, CSG_Colors Colors, int Labeling, int NumPrecision) const
200{
201 if( !is_Okay() || m_Classes.Get_Count() < 1 )
202 {
203 return( false );
204 }
205
206 bool bNumeric = _is_Numeric() && m_Classifier != Classifier::Unique; Colors.Set_Count((int)m_Classes.Get_Count());
207
208 Classes.Del_Records();
209 Classes.Set_Field_Type((int)LUT_Fields::Minimum, bNumeric ? SG_DATATYPE_Double : SG_DATATYPE_String);
210 Classes.Set_Field_Type((int)LUT_Fields::Maximum, bNumeric ? SG_DATATYPE_Double : SG_DATATYPE_String);
211
212 for(int i=0; i<m_Classes.Get_Count(); i++)
213 {
214 CSG_Table_Record &Class = *Classes.Add_Record();
215
216 Class.Set_Value((int)LUT_Fields::Color, Colors[i]);
217 Class.Set_Value((int)LUT_Fields::Description, "");
218
219 if( bNumeric )
220 {
221 #define VALUE2STRING(value) (m_bPercent ? SG_Get_String(100. * value, NumPrecision) : SG_Get_String(value, NumPrecision))
222
223 double Minimum = m_Classes[i].asDouble(0);
224 double Maximum = m_Classes[i].asDouble(1);
225
226 CSG_String Name(Labeling == 0
227 ? VALUE2STRING(Minimum) + " - " + VALUE2STRING(Maximum) : i >= m_Classes.Get_Count() - 1
228 ? "> " + VALUE2STRING(Minimum) : "< " + VALUE2STRING(Maximum)
229 );
230
231 if( m_bPercent ) { Name += " %"; }
232
233 Class.Set_Value((int)LUT_Fields::Minimum, Minimum);
234 Class.Set_Value((int)LUT_Fields::Maximum, Maximum);
235 Class.Set_Value((int)LUT_Fields::Name , Name );
236 }
237 else
238 {
239 CSG_String Minimum = m_Classes[i].asString(0);
240 CSG_String Maximum = m_Classes[i].asString(1);
241
242 Class.Set_Value((int)LUT_Fields::Minimum, Minimum);
243 Class.Set_Value((int)LUT_Fields::Maximum, Maximum);
244 Class.Set_Value((int)LUT_Fields::Name , Minimum.Cmp(Maximum) ? Minimum + " - " + Maximum : Minimum);
245 }
246 }
247
248 if( bNumeric )
249 {
250 if( m_pObject->Get_Max_Samples() // statistics might be incomplete
251 && ((m_pObject->asTable(true) && m_pObject->Get_Max_Samples() < m_pObject->asTable(true)->Get_Count ())
252 || (m_pObject->asGrid (true) && m_pObject->Get_Max_Samples() < m_pObject->asGrid (true)->Get_NCells())
253 || (m_pObject->asGrids(true) && m_pObject->Get_Max_Samples() < m_pObject->asGrids(true)->Get_NCells())) )
254 {
255 double Minimum = m_Classes[0].asDouble(0), Maximum = m_Classes[m_Classes.Get_Count() - 1].asDouble(1);
256
257 Classes[ 0].Set_Value((int)LUT_Fields::Minimum, Minimum - 1000. * (Maximum - Minimum));
258 Classes[Classes.Get_Count() - 1].Set_Value((int)LUT_Fields::Maximum, Maximum + 1000. * (Maximum - Minimum));
259 }
260 else
261 {
262 const double Epsilon = 1.e-012; double Maximum = m_Classes[m_Classes.Get_Count() - 1].asDouble(1);
263
264 Classes[Classes.Get_Count() - 1].Set_Value((int)LUT_Fields::Maximum, Maximum + Epsilon);
265 }
266 }
267
268 return( true );
269}
270
271
273// //
275
276//---------------------------------------------------------
277bool CSG_Map_Classify::_is_Numeric(void) const
278{
279 return( m_Field < 0 || SG_Data_Type_is_Numeric(m_pObject->asTable(true)->Get_Field_Type(m_Field)) );
280}
281
282//---------------------------------------------------------
283bool CSG_Map_Classify::_Create_Classes(void)
284{
285 m_Classes.Destroy();
286
287 if( _is_Numeric() )
288 {
289 m_Classes.Add_Field("min", SG_DATATYPE_Double); m_Classes.Add_Field("max", SG_DATATYPE_Double);
290 }
291 else
292 {
293 m_Classes.Add_Field("min", SG_DATATYPE_String); m_Classes.Add_Field("max", SG_DATATYPE_String);
294 }
295
296 return( m_pObject && m_nValues > 0 );
297}
298
299//---------------------------------------------------------
300inline bool CSG_Map_Classify::_Set_Progress(sLong i) const
301{
302 if( m_Show_Progress )
303 {
304 return( SG_UI_Process_Set_Progress(i, m_nValues) );
305 }
306
307 return( true );
308}
309
310//---------------------------------------------------------
311inline bool CSG_Map_Classify::_Get_Value(sLong i, double &Value, bool bIndexed) const
312{
313 if( i >= 0 )
314 {
315 if( m_Field >= 0 )
316 {
317 if( i < m_pObject->asTable(true)->Get_Count() )
318 {
319 return( m_pObject->asTable(true)->Get_Value(bIndexed ? m_pObject->asTable(true)->Get_Index(i) : i, m_Field, Value) );
320 }
321 }
322
323 if( m_pObject->asGrid() )
324 {
325 if( i < m_pObject->asGrid ()->Get_NCells() )
326 {
327 if( bIndexed ) { i = m_pObject->asGrid ()->Get_Sorted(i, false, false); }
328
329 if( !m_pObject->asGrid ()->is_NoData(i) )
330 {
331 Value = m_pObject->asGrid ()->asDouble(i);
332
333 return( true );
334 }
335 }
336 }
337
338 if( m_pObject->asGrids() )
339 {
340 if( i < m_pObject->asGrids()->Get_NCells() )
341 {
342 if( bIndexed ) { i = m_pObject->asGrids()->Get_Sorted(i, false, false); }
343
344 if( !m_pObject->asGrids()->is_NoData(i) )
345 {
346 Value = m_pObject->asGrids()->asDouble(i);
347
348 return( true );
349 }
350 }
351 }
352 }
353
354 return( false );
355}
356
357//---------------------------------------------------------
358inline bool CSG_Map_Classify::_Get_Value(sLong i, CSG_String &Value, bool bIndexed) const
359{
360 return( m_Field >= 0 && m_pObject->asTable(true)->Get_Value(bIndexed ? m_pObject->asTable(true)->Get_Index(i) : i, m_Field, Value) );
361}
362
363//---------------------------------------------------------
364bool CSG_Map_Classify::_Get_Statistics(CSG_Simple_Statistics &Statistics) const
365{
366 if( m_Field >= 0 )
367 {
368 Statistics = m_pObject->asTable(true)->Get_Statistics(m_Field);
369 }
370 else if( m_pObject->asGrid () )
371 {
372 Statistics = m_pObject->asGrid ()->Get_Statistics();
373 }
374 else if( m_pObject->asGrids() )
375 {
376 Statistics = m_pObject->asGrids()->Get_Statistics();
377 }
378
379 return( Statistics.Get_Count() > 0 );
380}
381
382//---------------------------------------------------------
383bool CSG_Map_Classify::_Get_Histogram(CSG_Histogram &Histogram) const
384{
385 if( m_Field >= 0 )
386 {
387 Histogram = m_pObject->asTable(true)->Get_Histogram(m_Field);
388 }
389 else if( m_pObject->asGrid () )
390 {
391 Histogram = m_pObject->asGrid ()->Get_Histogram();
392 }
393 else if( m_pObject->asGrids() )
394 {
395 Histogram = m_pObject->asGrids()->Get_Histogram();
396 }
397
398 return( Histogram.Get_Class_Count() > 0 );
399}
400
401//---------------------------------------------------------
402bool CSG_Map_Classify::_Set_Index(void)
403{
404 if( m_Field >= 0 )
405 {
406 return( m_pObject->asTable(true)->Set_Index(m_Field) );
407 }
408 else if( m_pObject->asGrid () )
409 {
410 return( m_pObject->asGrid ()->Set_Index() );
411 }
412 else if( m_pObject->asGrids() )
413 {
414 return( m_pObject->asGrids()->Set_Index() );
415 }
416
417 return( false );
418}
419
420
422// //
424
425//---------------------------------------------------------
426bool CSG_Map_Classify::Classify_Unique(int maxCount)
427{
428 if( !is_Okay() )
429 {
430 return( false );
431 }
432
433 //-----------------------------------------------------
434 if( _is_Numeric() )
435 {
436 CSG_Unique_Number_Statistics Statistics;
437
438 for(sLong i=0; i<m_nValues && Statistics.Get_Count()<=maxCount && _Set_Progress(i); i++)
439 {
440 double Value; if( _Get_Value(i, Value) ) { Statistics += Value; }
441 }
442
443 _Create_Classes();
444
445 for(int i=0; i<Statistics.Get_Count(); i++)
446 {
447 CSG_Table_Record &Class = *m_Classes.Add_Record();
448
449 Class.Set_Value(0, Statistics.Get_Value(i)); // Minimum
450 Class.Set_Value(1, Statistics.Get_Value(i)); // Maximum
451 }
452 }
453
454 //-----------------------------------------------------
455 else
456 {
457 CSG_Unique_String_Statistics Statistics;
458
459 for(sLong i=0; i<m_nValues && Statistics.Get_Count()<=maxCount && _Set_Progress(i); i++)
460 {
461 CSG_String Value; if( _Get_Value(i, Value) ) { Statistics += Value; }
462 }
463
464 _Create_Classes();
465
466 for(int i=0; i<Statistics.Get_Count(); i++)
467 {
468 CSG_Table_Record &Class = *m_Classes.Add_Record();
469
470 Class.Set_Value(0, Statistics.Get_Value(i)); // Minimum
471 Class.Set_Value(1, Statistics.Get_Value(i)); // Maximum
472 }
473 }
474
475 //-----------------------------------------------------
476 m_Classifier = Classifier::Unique;
477
478 return( m_Classes.Get_Count() > 0 );
479}
480
481
483// //
485
486//---------------------------------------------------------
487bool CSG_Map_Classify::Classify_Equal(int Count, double _Minimum, double _Maximum)
488{
489 if( Count < 1 || _Minimum >= _Maximum )
490 {
491 return( false );
492 }
493
494 _Create_Classes();
495
496 double Maximum = _Minimum, Interval = (_Maximum - _Minimum) / Count;
497
498 for(int i=0; i<Count; i++)
499 {
500 double Minimum = Maximum; Maximum = _Minimum + (i + 1) * Interval;
501
502 CSG_Table_Record &Class = *m_Classes.Add_Record();
503
504 Class.Set_Value(0, Minimum); // Minimum
505 Class.Set_Value(1, Maximum); // Maximum
506 }
507
508 //-----------------------------------------------------
509 m_Classifier = Classifier::Equal;
510
511 return( true );
512}
513
514//---------------------------------------------------------
515bool CSG_Map_Classify::Classify_Equal(int Count)
516{
517 CSG_Simple_Statistics Statistics;
518
519 return( _Get_Statistics(Statistics) && Classify_Equal(Count, Statistics.Get_Minimum(), Statistics.Get_Maximum()) );
520}
521
522
524// //
526
527//---------------------------------------------------------
528bool CSG_Map_Classify::Classify_Defined(double Interval, double Offset)
529{
530 CSG_Simple_Statistics Statistics;
531
532 if( m_bPercent )
533 {
534 Interval /= 100.; Offset /= 100.;
535 }
536
537 if( Interval <= 0. || !_Get_Statistics(Statistics) || Offset >= Statistics.Get_Maximum() )
538 {
539 return( false );
540 }
541
542 _Create_Classes();
543
544 double Minimum = Offset;
545
546 for(double Maximum=Minimum+Interval; Minimum<Statistics.Get_Maximum(); Minimum=Maximum, Maximum+=Interval)
547 {
548 CSG_Table_Record &Class = *m_Classes.Add_Record();
549
550 Class.Set_Value(0, Minimum); // Minimum
551 Class.Set_Value(1, Maximum); // Maximum
552 }
553
554 //-----------------------------------------------------
555 m_Classifier = Classifier::Defined;
556
557 return( true );
558}
559
560//---------------------------------------------------------
561bool CSG_Map_Classify::Classify_Defined(double Interval)
562{
563 CSG_Simple_Statistics Statistics;
564
565 return( _Get_Statistics(Statistics) && Classify_Defined(Interval, Statistics.Get_Minimum() *(m_bPercent ? 100. : 1.)) );
566}
567
568
570// //
572
573//---------------------------------------------------------
574bool CSG_Map_Classify::Classify_Quantile(int Count, bool bHistogram)
575{
576 if( !is_Okay() || Count < 1 )
577 {
578 return( false );
579 }
580
581 if( m_nValues < Count )
582 {
583 Count = (int)m_nValues;
584 }
585
586 _Create_Classes();
587
588 if( bHistogram )
589 {
590 CSG_Histogram Histogram;
591
592 if( _Get_Histogram(Histogram) )
593 {
594 CSG_Simple_Statistics Statistics = Histogram.Get_Statistics();
595
596 double Minimum, Maximum = Statistics.Get_Minimum();
597
598 for(int i=0; i<Count; i++)
599 {
600 Minimum = Maximum; double Quantile = (1. + i) / (double)Count;
601 Maximum = Histogram.Get_Quantile(Quantile);
602
603 if( Minimum < Maximum )
604 {
605 CSG_Table_Record &Class = *m_Classes.Add_Record();
606
607 Class.Set_Value(0, Minimum);
608 Class.Set_Value(1, Maximum);
609 }
610 }
611 }
612 }
613 else
614 {
615 CSG_Simple_Statistics Statistics;
616
617 if( _Set_Index() && _Get_Statistics(Statistics) )
618 {
619 double Minimum, Maximum = Statistics.Get_Minimum();
620
621 for(int i=0; i<Count; i++)
622 {
623 double Value, Quantile = (1. + i) / (double)Count;
624
625 if( _Get_Value((sLong)(Quantile * (m_nValues - 1)), Value, true) )
626 {
627 Minimum = Maximum; Maximum = Value;
628
629 if( Minimum < Maximum )
630 {
631 CSG_Table_Record &Class = *m_Classes.Add_Record();
632
633 Class.Set_Value(0, Minimum);
634 Class.Set_Value(1, Maximum);
635 }
636 }
637 }
638 }
639 }
640
641 //-----------------------------------------------------
642 m_Classifier = Classifier::Quantile;
643
644 return( m_Classes.Get_Count() > 0 );
645}
646
647
649// //
651
652//---------------------------------------------------------
653bool CSG_Map_Classify::Classify_Geometric(int Count, bool bIncreasing)
654{
655 CSG_Simple_Statistics Statistics;
656
657 if( Count < 1 || !_Get_Statistics(Statistics) || !Statistics.Get_Range() )
658 {
659 return( false );
660 }
661
662 _Create_Classes();
663
664 double k = (log(1. + Statistics.Get_Range())) / Count;
665
666 double Minimum, Maximum = Statistics.Get_Minimum();
667
668 for(int i=0; i<Count; i++)
669 {
670 Minimum = Maximum; Maximum = bIncreasing
671 ? (Statistics.Get_Minimum() + (exp(k * (double)( i + 1)) - 1.))
672 : (Statistics.Get_Maximum() - (exp(k * (double)(Count - i - 1)) - 1.));
673
674 CSG_Table_Record &Class = *m_Classes.Add_Record();
675
676 Class.Set_Value(0, Minimum); // Minimum
677 Class.Set_Value(1, Maximum); // Maximum
678 }
679
680 //-----------------------------------------------------
681 m_Classifier = Classifier::Geometric;
682
683 return( true );
684}
685
686
688// //
690
691//---------------------------------------------------------
692bool CSG_Map_Classify::Classify_Natural(int Count)
693{
694 if( !is_Okay() || Count < 1 )
695 {
696 return( false );
697 }
698
699 CSG_Natural_Breaks Breaks;
700
701 if( m_Field >= 0 )
702 {
703 Breaks.Create(m_pObject->asTable(true), m_Field, Count, m_nValues > 4096 ? 256 : 0);
704 }
705 else if( m_pObject->asGrid () )
706 {
707 Breaks.Create(m_pObject->asGrid (), Count, m_nValues > 4096 ? 256 : 0);
708 }
709 else if( m_pObject->asGrids() )
710 {
711 Breaks.Create(m_pObject->asGrids(), Count, m_nValues > 4096 ? 256 : 0);
712 }
713 else
714 {
715 return( false );
716 }
717
718 if( Breaks.Get_Count() <= Count )
719 {
720 return( false );
721 }
722
723 _Create_Classes();
724
725 for(int i=0; i<Count; i++)
726 {
727 CSG_Table_Record &Class = *m_Classes.Add_Record();
728
729 Class.Set_Value(0, Breaks[i ]); // Minimum
730 Class.Set_Value(1, Breaks[i + 1]); // Maximum
731 }
732
733 //-----------------------------------------------------
734 m_Classifier = Classifier::Natural;
735
736 return( true );
737}
738
739
741// //
743
744//---------------------------------------------------------
745bool CSG_Map_Classify::Classify_StdDev(double StdDev, double StdDev_Max)
746{
747 CSG_Simple_Statistics Statistics;
748
749 if( StdDev <= 0. || !_Get_Statistics(Statistics) )
750 {
751 return( false );
752 }
753
754 if( StdDev_Max < StdDev )
755 {
756 StdDev_Max = StdDev;
757 }
758
759 StdDev *= Statistics.Get_StdDev(); double m = Statistics.Get_Mean(), s = StdDev / 2.;
760
761 double Minimum = Statistics.Get_Mean() - StdDev_Max; if( Minimum < Statistics.Get_Minimum() ) { Minimum = Statistics.Get_Minimum(); }
762 Minimum = (m - s) < Minimum ? (m - s) : (m - s) - ceil (((m - s) - Minimum) / StdDev) * StdDev;
763
764 double Maximum = Statistics.Get_Mean() + StdDev_Max; if( Maximum > Statistics.Get_Maximum() ) { Maximum = Statistics.Get_Maximum(); }
765 Maximum = (m + s) > Maximum ? (m + s) : (m + s) + floor(((m + s) + Maximum) / StdDev) * StdDev;
766
767 if( !Classify_Equal((int)((Maximum - Minimum) / StdDev), Minimum, Maximum) )
768 {
769 return( false );
770 }
771
772 //-----------------------------------------------------
773 m_Classifier = Classifier::StdDev;
774
775 return( true );
776}
777
778
780// //
781// //
782// //
784
785//---------------------------------------------------------
SG_UI_Process_Set_Progress
bool SG_UI_Process_Set_Progress(int Position, int Range)
Definition api_callback.cpp:255
SG_Data_Type_is_Numeric
bool SG_Data_Type_is_Numeric(TSG_Data_Type Type)
Definition api_core.cpp:199
sLong
signed long long sLong
Definition api_core.h:158
SG_DATATYPE_Double
@ SG_DATATYPE_Double
Definition api_core.h:1054
SG_DATATYPE_String
@ SG_DATATYPE_String
Definition api_core.h:1055
_TL
#define _TL(s)
Definition api_core.h:1619
CSG_Colors
Definition api_core.h:1460
CSG_Colors::Set_Count
bool Set_Count(int nColors)
Definition api_colors.cpp:279
CSG_Data_Object
Definition dataobject.h:180
CSG_Data_Object::asGrids
class CSG_Grids * asGrids(bool bPolymorph=false) const
Definition dataobject.cpp:585
CSG_Data_Object::asGrid
class CSG_Grid * asGrid(bool bPolymorph=false) const
Definition dataobject.cpp:574
CSG_Data_Object::asTable
class CSG_Table * asTable(bool bPolymorph=false) const
Definition dataobject.cpp:511
CSG_Grid::Get_NCells
sLong Get_NCells(void) const
Definition grid.h:565
CSG_Grids::Get_NCells
sLong Get_NCells(void) const
Definition grids.h:191
CSG_Histogram
Definition mat_tools.h:1013
CSG_Histogram::Get_Statistics
const CSG_Simple_Statistics & Get_Statistics(void) const
Definition mat_tools.h:1082
CSG_Histogram::Get_Class_Count
size_t Get_Class_Count(void) const
Definition mat_tools.h:1049
CSG_Histogram::Get_Quantile
double Get_Quantile(double Quantile) const
Definition mat_tools.cpp:1441
CSG_Map_Classify::Classifier
Classifier
Definition map_classify.h:76
CSG_Map_Classify::Classifier::Natural
@ Natural
Definition map_classify.h:77
CSG_Map_Classify::Classifier::StdDev
@ StdDev
Definition map_classify.h:77
CSG_Map_Classify::Classifier::Quantile
@ Quantile
Definition map_classify.h:77
CSG_Map_Classify::Classifier::Geometric
@ Geometric
Definition map_classify.h:77
CSG_Map_Classify::Classifier::Defined
@ Defined
Definition map_classify.h:77
CSG_Map_Classify::Classifier::Unique
@ Unique
Definition map_classify.h:77
CSG_Map_Classify::Classifier::Equal
@ Equal
Definition map_classify.h:77
CSG_Map_Classify::Classifier::NotSet
@ NotSet
Definition map_classify.h:77
CSG_Map_Classify::Classify_StdDev
bool Classify_StdDev(double StdDev, double StdDev_Max=4.)
Definition map_classify.cpp:745
CSG_Map_Classify::m_Show_Progress
bool m_Show_Progress
Definition map_classify.h:116
CSG_Map_Classify::Classify_Unique
bool Classify_Unique(int maxCount=1024)
Definition map_classify.cpp:426
CSG_Map_Classify::Classify_Equal
bool Classify_Equal(int Count, double Minimum, double Maximum)
Definition map_classify.cpp:487
CSG_Map_Classify::Set_LUT
bool Set_LUT(CSG_Table &LUT, CSG_Colors Colors, int Labeling, int NumPrecision=-2) const
Definition map_classify.cpp:199
CSG_Map_Classify::Get_Name
const CSG_String & Get_Name(Classifier Classifier) const
Definition map_classify.cpp:176
CSG_Map_Classify::Classify_Defined
bool Classify_Defined(double Interval, double Offset)
Definition map_classify.cpp:528
CSG_Map_Classify::is_Okay
bool is_Okay(void) const
Definition map_classify.h:100
CSG_Map_Classify::Create
bool Create(CSG_Data_Object *pObject)
Definition map_classify.cpp:101
CSG_Map_Classify::~CSG_Map_Classify
virtual ~CSG_Map_Classify(void)
Definition map_classify.cpp:80
CSG_Map_Classify::Destroy
bool Destroy(void)
Definition map_classify.cpp:86
CSG_Map_Classify::Classify_Geometric
bool Classify_Geometric(int Count, bool bIncreasing=true)
Definition map_classify.cpp:653
CSG_Map_Classify::LUT_Fields::Name
@ Name
Definition map_classify.h:82
CSG_Map_Classify::LUT_Fields::Maximum
@ Maximum
Definition map_classify.h:82
CSG_Map_Classify::LUT_Fields::Minimum
@ Minimum
Definition map_classify.h:82
CSG_Map_Classify::LUT_Fields::Description
@ Description
Definition map_classify.h:82
CSG_Map_Classify::LUT_Fields::Color
@ Color
Definition map_classify.h:82
CSG_Map_Classify::Classify_Quantile
bool Classify_Quantile(int Count, bool bHistogram=true)
Definition map_classify.cpp:574
CSG_Map_Classify::CSG_Map_Classify
CSG_Map_Classify(void)
Definition map_classify.cpp:62
CSG_Map_Classify::Classify_Natural
bool Classify_Natural(int Count)
Definition map_classify.cpp:692
CSG_Natural_Breaks
Definition mat_tools.h:1214
CSG_Natural_Breaks::Create
bool Create(class CSG_Table *pTable, int Field, int nClasses, int Histogram=0)
Definition mat_tools.cpp:2000
CSG_Natural_Breaks::Get_Count
int Get_Count(void) const
Definition mat_tools.h:1231
CSG_Simple_Statistics
Definition mat_tools.h:725
CSG_Simple_Statistics::Get_Maximum
double Get_Maximum(void)
Definition mat_tools.h:749
CSG_Simple_Statistics::Get_Mean
double Get_Mean(void)
Definition mat_tools.h:753
CSG_Simple_Statistics::Get_StdDev
double Get_StdDev(void)
Definition mat_tools.h:755
CSG_Simple_Statistics::Get_Count
sLong Get_Count(void) const
Definition mat_tools.h:745
CSG_Simple_Statistics::Get_Minimum
double Get_Minimum(void)
Definition mat_tools.h:748
CSG_Simple_Statistics::Get_Range
double Get_Range(void)
Definition mat_tools.h:750
CSG_String
Definition api_core.h:563
CSG_Table_Record
Definition table.h:130
CSG_Table_Record::Set_Value
bool Set_Value(int Field, const CSG_String &Value)
Definition table_record.cpp:241
CSG_Table
Definition table.h:295
CSG_Table::Set_Value
virtual bool Set_Value(sLong Index, int Field, const SG_Char *Value)
Definition table.h:429
CSG_Table::Get_Count
sLong Get_Count(void) const
Definition table.h:410
CSG_Table::Del_Records
virtual bool Del_Records(void)
Definition table.cpp:936
CSG_Table::Get_Value
virtual bool Get_Value(sLong Index, int Field, CSG_String &Value) const
Definition table.cpp:1159
CSG_Table::Add_Record
virtual CSG_Table_Record * Add_Record(CSG_Table_Record *pCopy=NULL)
Definition table.cpp:823
CSG_Table::Get_Field_Type
TSG_Data_Type Get_Field_Type(int Field) const
Definition table.h:373
CSG_Table::Set_Field_Type
virtual bool Set_Field_Type(int Field, TSG_Data_Type Type)
Definition table.cpp:610
CSG_Unique_Number_Statistics
Definition mat_tools.h:849
CSG_Unique_Number_Statistics::Get_Value
double Get_Value(int Index) const
Definition mat_tools.h:858
CSG_Unique_String_Statistics
Definition mat_tools.h:884
CSG_Unique_String_Statistics::Get_Value
const SG_Char * Get_Value(int Index) const
Definition mat_tools.h:893
CSG_Unique_Value_Statistics::Get_Count
int Get_Count(void) const
Definition mat_tools.h:819
VALUE2STRING
#define VALUE2STRING(value)
map_classify.h