SAGA API  v9.8
api_colors.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 // api_colors.cpp //
15 // //
16 // Copyright (C) 2005 by Olaf Conrad //
17 // //
18 //-------------------------------------------------------//
19 // //
20 // This file is part of 'SAGA - System for Automated //
21 // Geoscientific Analyses'. //
22 // //
23 // This library is free software; you can redistribute //
24 // it and/or modify it under the terms of the GNU Lesser //
25 // General Public License as published by the Free //
26 // Software Foundation, either version 2.1 of the //
27 // License, or (at your option) any later version. //
28 // //
29 // This library is distributed in the hope that it will //
30 // be useful, but WITHOUT ANY WARRANTY; without even the //
31 // implied warranty of MERCHANTABILITY or FITNESS FOR A //
32 // PARTICULAR PURPOSE. See the GNU Lesser General Public //
33 // License for more details. //
34 // //
35 // You should have received a copy of the GNU Lesser //
36 // General Public License along with this program; if //
37 // not, see <http://www.gnu.org/licenses/>. //
38 // //
39 //-------------------------------------------------------//
40 // //
41 // contact: Olaf Conrad //
42 // Institute of Geography //
43 // University of Goettingen //
44 // Goldschmidtstr. 5 //
45 // 37077 Goettingen //
46 // Germany //
47 // //
48 // e-mail: oconrad@saga-gis.org //
49 // //
51 
52 //---------------------------------------------------------
53 #include <stdlib.h>
54 #include <string.h>
55 
56 #include "api_core.h"
57 #include "mat_tools.h"
58 
59 
61 // //
62 // //
63 // //
65 
66 //---------------------------------------------------------
67 CSG_String SG_Colors_Get_Name (int Index)
68 {
69  return( CSG_Colors::Get_Predefined_Name(Index) );
70 }
71 
72 //---------------------------------------------------------
73 long SG_Color_Get_Random (void)
74 {
75  return( SG_GET_RGB(CSG_Random::Get_Uniform(0, 255), CSG_Random::Get_Uniform(0, 255), CSG_Random::Get_Uniform(0, 255)) );
76 }
77 
78 //---------------------------------------------------------
79 long SG_Color_From_RGB (int Red, int Green, int Blue, int Alpha)
80 {
81  return( SG_GET_RGBA(Red, Green, Blue, Alpha) );
82 }
83 
84 //---------------------------------------------------------
85 bool SG_Color_From_Text (const CSG_String &Text, long &Color)
86 { // from wx/src/common/colourcmn.cpp, hexadecimal prefixed with # ("HTML syntax") see https://drafts.csswg.org/css-color/#hex-notation
87 
88  if( Text.is_Empty() || Text.Get_Char(0) != L'#' )
89  {
90  return( false );
91  }
92 
93  const char *s = Text.b_str(); unsigned long c;
94 
95  if( sscanf(s + 1, "%lx", &c) == 1 )
96  {
97  switch( Text.Length() - 1 )
98  {
99  case 6: // #rrggbb
100  c = (c << 8) + 0xFF;
101  Color = SG_GET_RGB(
102  (unsigned char)((c >> 24) & 0xFF),
103  (unsigned char)((c >> 16) & 0xFF),
104  (unsigned char)((c >> 8) & 0xFF)
105  );
106  return( true );
107 
108  case 8: // #rrggbbaa
109  Color = SG_GET_RGBA(
110  (unsigned char)((c >> 24) & 0xFF),
111  (unsigned char)((c >> 16) & 0xFF),
112  (unsigned char)((c >> 8) & 0xFF),
113  (unsigned char)((c ) & 0xFF)
114  );
115  return( true );
116 
117  case 3: // #rgb
118  c = (c << 4) + 0xF;
119  Color = SG_GET_RGB(
120  (unsigned char)(((c >> 12) & 0xF) * 0x11),
121  (unsigned char)(((c >> 8) & 0xF) * 0x11),
122  (unsigned char)(((c >> 4) & 0xF) * 0x11)
123  );
124  return( true );
125 
126  case 4: // #rgba
127  Color = SG_GET_RGBA(
128  (unsigned char)(((c >> 12) & 0xF) * 0x11),
129  (unsigned char)(((c >> 8) & 0xF) * 0x11),
130  (unsigned char)(((c >> 4) & 0xF) * 0x11),
131  (unsigned char)(((c ) & 0xF) * 0x11)
132  );
133  return( true );
134 
135  default:
136  return( false ); // unrecognized
137  }
138  }
139 
140  return( false );
141 }
142 
143 //---------------------------------------------------------
144 CSG_String SG_Color_To_Text (long Color, bool bHexadecimal)
145 {
146  CSG_String Text;
147 
148  if( bHexadecimal )
149  {
150  Text.Printf("#%02X%02X%02X",
151  SG_GET_R(Color),
152  SG_GET_G(Color),
153  SG_GET_B(Color)
154  );
155  }
156  else
157  {
158  Text.Printf("%ld", Color);
159  }
160 
161  return( Text );
162 }
163 
164 
166 // //
167 // //
168 // //
170 
171 //---------------------------------------------------------
172 CSG_Colors::CSG_Colors(void)
173 {
174  m_Colors = NULL;
175  m_nColors = 0;
176 
177  Create();
178 }
179 
180 //---------------------------------------------------------
181 CSG_Colors::CSG_Colors(const CSG_Colors &Colors)
182 {
183  m_Colors = NULL;
184  m_nColors = 0;
185 
186  Create(Colors);
187 }
188 
189 //---------------------------------------------------------
190 CSG_Colors::CSG_Colors(int nColors, int Palette, bool bRevert)
191 {
192  m_Colors = NULL;
193  m_nColors = 0;
194 
195  Create(nColors, Palette, bRevert);
196 }
197 
198 //---------------------------------------------------------
199 CSG_Colors::~CSG_Colors(void)
200 {
201  Destroy();
202 }
203 
204 
206 // //
208 
209 //---------------------------------------------------------
210 bool CSG_Colors::Create(void)
211 {
212  return( Create(11) );
213 }
214 
215 //---------------------------------------------------------
216 bool CSG_Colors::Create(const CSG_Colors &Colors)
217 {
218  if( Colors.m_nColors > 0 )
219  {
220  m_nColors = Colors.m_nColors;
221  m_Colors = (long *)SG_Realloc(m_Colors, m_nColors * sizeof(long));
222 
223  memcpy(m_Colors, Colors.m_Colors, m_nColors * sizeof(long));
224 
225  return( true );
226  }
227 
228  return( false );
229 }
230 
231 //---------------------------------------------------------
232 bool CSG_Colors::Create(int nColors, int Palette, bool bRevert)
233 {
234  if( nColors <= 1 )
235  {
236  nColors = 11;
237  }
238 
239  Set_Count(nColors);
240 
241  Set_Palette(Palette, bRevert, nColors);
242 
243  return( true );
244 }
245 
246 //---------------------------------------------------------
247 void CSG_Colors::Destroy(void)
248 {
249  if( m_nColors > 0 )
250  {
251  SG_Free(m_Colors);
252 
253  m_Colors = NULL;
254  m_nColors = 0;
255  }
256 }
257 
258 
260 // //
262 
263 //---------------------------------------------------------
264 bool CSG_Colors::Set_Count(int nColors)
265 {
266  if( nColors == m_nColors )
267  {
268  return( true );
269  }
270 
271  if( nColors < 1 )
272  {
273  return( false );
274  }
275 
276  if( m_nColors == 0 )
277  {
278  return( Set_Default(nColors) );
279  }
280 
281  //-----------------------------------------------------
282  CSG_Colors Colors(*this);
283 
284  m_nColors = nColors;
285  m_Colors = (long *)SG_Realloc(m_Colors, m_nColors * sizeof(long));
286 
287  double dStep = Get_Count() > 1 ? (Colors.Get_Count() - 1.0) / (Get_Count() - 1.0) : 0.0;
288 
289  for(int i=0; i<Get_Count(); i++)
290  {
291  if( Get_Count() < Colors.Get_Count() )
292  {
293  m_Colors[i] = Colors[(int)(i * dStep)];
294  }
295  else // if( Get_Count() > Colors.Get_Count() )
296  {
297  m_Colors[i] = Colors.Get_Interpolated(i * dStep);
298  }
299  }
300 
301  //-----------------------------------------------------
302  return( true );
303 }
304 
305 
307 // //
309 
310 //---------------------------------------------------------
311 bool CSG_Colors::Set_Color(int Index, long Color)
312 {
313  if( Index >= 0 && Index < m_nColors )
314  {
315  m_Colors[Index] = Color;
316 
317  return( true );
318  }
319 
320  return( false );
321 }
322 
323 //---------------------------------------------------------
324 bool CSG_Colors::Set_Color(int Index, int Red, int Green, int Blue)
325 {
326  return( Set_Color(Index, SG_GET_RGB(Red, Green, Blue)) );
327 }
328 
329 //---------------------------------------------------------
330 bool CSG_Colors::Set_Red(int Index, int Value)
331 {
332  return( Set_Color(Index, Value , Get_Green(Index) , Get_Blue(Index)) );
333 }
334 
335 //---------------------------------------------------------
336 bool CSG_Colors::Set_Green(int Index, int Value)
337 {
338  return( Set_Color(Index, Get_Red(Index) , Value , Get_Blue(Index)) );
339 }
340 
341 //---------------------------------------------------------
342 bool CSG_Colors::Set_Blue(int Index, int Value)
343 {
344  return( Set_Color(Index, Get_Red(Index) , Get_Green(Index) , Value) );
345 }
346 
347 //---------------------------------------------------------
348 bool CSG_Colors::Set_Brightness(int Index, int Value)
349 {
350  double r, g, b, ds;
351 
352  //-----------------------------------------------------
353  if( Value < 0 )
354  {
355  Value = 0;
356  }
357  else if( Value > 255 )
358  {
359  Value = 255;
360  }
361 
362  //-----------------------------------------------------
363  r = Get_Red (Index);
364  g = Get_Green(Index);
365  b = Get_Blue (Index);
366  ds = (r + g + b) / 3.0;
367 
368  if( ds > 0.0 )
369  {
370  ds = Value / ds;
371  r *= ds;
372  g *= ds;
373  b *= ds;
374 
375  _Set_Brightness(r, g, b);
376  }
377  else
378  {
379  r = g = b = Value / 3.0;
380  }
381 
382  return( Set_Color(Index, (int)r, (int)g, (int)b) );
383 }
384 
385 //---------------------------------------------------------
386 void CSG_Colors::_Set_Brightness(double &a, double &b, double &c, int Pass)
387 {
388  if( a > 255 )
389  {
390  int addSum;
391 
392  addSum = (int)((a - 255) / 2.0);
393  a = 255;
394 
395  b += addSum;
396  c += addSum;
397 
398  if( b > 255 )
399  {
400  addSum = (int)(b - 255);
401  b = 255;
402 
403  c += addSum;
404 
405  if( c > 255 )
406  {
407  c = 255;
408  }
409  }
410  else if( c > 255 )
411  {
412  addSum = (int)(c - 255);
413  c = 255;
414 
415  b += addSum;
416 
417  if( b > 255 )
418  {
419  b = 255;
420  }
421  }
422  }
423  else if( Pass < 2 )
424  {
425  _Set_Brightness(b, c, a, Pass + 1);
426  }
427 }
428 
429 
431 // //
433 
434 //---------------------------------------------------------
435 int CSG_Colors::Get_Predefined_Count(void)
436 {
437  return( SG_COLORS_COUNT );
438 }
439 
440 //---------------------------------------------------------
441 CSG_String CSG_Colors::Get_Predefined_Name(int Index)
442 {
443  #define MAKE_NAME(name) CSG_String::Format("[%d] %s", Index, name)
444 
445  switch( Index )
446  {
447  case SG_COLORS_DEFAULT : return( MAKE_NAME(_TL("blue-green-red" )) );
448  case SG_COLORS_DEFAULT_BRIGHT : return( MAKE_NAME(_TL("blue-green-red" )) );
449  case SG_COLORS_RAINBOW : return( MAKE_NAME(_TL("rainbow" )) );
450  case SG_COLORS_RAINBOW_2 : return( MAKE_NAME(_TL("rainbow" )) );
451 
452  case SG_COLORS_BLACK_WHITE : return( MAKE_NAME(_TL("greyscale" )) );
453  case SG_COLORS_BLACK_RED : return( MAKE_NAME(_TL("black-red" )) );
454  case SG_COLORS_BLACK_GREEN : return( MAKE_NAME(_TL("black-green" )) );
455  case SG_COLORS_BLACK_BLUE : return( MAKE_NAME(_TL("black-blue" )) );
456 
457  case SG_COLORS_WHITE_RED : return( MAKE_NAME(_TL("white-red" )) );
458  case SG_COLORS_WHITE_GREEN : return( MAKE_NAME(_TL("white-green" )) );
459  case SG_COLORS_WHITE_BLUE : return( MAKE_NAME(_TL("white-blue" )) );
460 
461  case SG_COLORS_YELLOW_RED : return( MAKE_NAME(_TL("yellow-red" )) );
462  case SG_COLORS_YELLOW_GREEN : return( MAKE_NAME(_TL("yellow-green" )) );
463  case SG_COLORS_YELLOW_BLUE : return( MAKE_NAME(_TL("yellow-blue" )) );
464 
465  case SG_COLORS_BLUE_RED : return( MAKE_NAME(_TL("blue-red" )) );
466  case SG_COLORS_GREEN_RED : return( MAKE_NAME(_TL("green-red" )) );
467  case SG_COLORS_GREEN_BLUE : return( MAKE_NAME(_TL("green-blue" )) );
468 
469  case SG_COLORS_BLUE_WHITE_RED : return( MAKE_NAME(_TL("blue-white-red" )) );
470  case SG_COLORS_GREEN_WHITE_RED : return( MAKE_NAME(_TL("green-white-red" )) );
471  case SG_COLORS_GREEN_WHITE_BLUE : return( MAKE_NAME(_TL("green-white-blue" )) );
472 
473  case SG_COLORS_BLUE_GREY_RED : return( MAKE_NAME(_TL("blue-grey-red" )) );
474  case SG_COLORS_RED_GREY_BLUE : return( MAKE_NAME(_TL("red-grey-blue" )) );
475  case SG_COLORS_GREEN_GREY_RED : return( MAKE_NAME(_TL("green-grey-red" )) );
476  case SG_COLORS_RED_GREY_GREEN : return( MAKE_NAME(_TL("red-grey-green" )) );
477  case SG_COLORS_GREEN_GREY_BLUE : return( MAKE_NAME(_TL("green-grey-blue" )) );
478 
479  case SG_COLORS_BLUE_YELLOW_RED : return( MAKE_NAME(_TL("blue-yellow-red" )) );
480  case SG_COLORS_GREEN_YELLOW_RED : return( MAKE_NAME(_TL("green-yellow-red" )) );
481  case SG_COLORS_RED_YELLOW_GREEN : return( MAKE_NAME(_TL("red-yellow-green" )) );
482  case SG_COLORS_GREEN_YELLOW_BLUE: return( MAKE_NAME(_TL("green-yellow-blue")) );
483 
484  case SG_COLORS_RED_GREEN_BLUE : return( MAKE_NAME(_TL("red-green-blue" )) );
485  case SG_COLORS_RED_BLUE_GREEN : return( MAKE_NAME(_TL("red-blue-green" )) );
486  case SG_COLORS_GREEN_RED_BLUE : return( MAKE_NAME(_TL("green-red-blue" )) );
487  case SG_COLORS_NEON : return( MAKE_NAME(_TL("neon" )) );
488 
489  case SG_COLORS_TOPOGRAPHY : return( MAKE_NAME(_TL("topography" )) );
490  case SG_COLORS_TOPOGRAPHY_2 : return( MAKE_NAME(_TL("topography" )) );
491  case SG_COLORS_TOPOGRAPHY_3 : return( MAKE_NAME(_TL("topography" )) );
492  case SG_COLORS_TOPOGRAPHY_4 : return( MAKE_NAME(_TL("topography" )) );
493 
494  case SG_COLORS_ASPECT_1 : return( MAKE_NAME(_TL("aspect" )) );
495  case SG_COLORS_ASPECT_2 : return( MAKE_NAME(_TL("aspect" )) );
496  case SG_COLORS_ASPECT_3 : return( MAKE_NAME(_TL("aspect" )) );
497 
498  case SG_COLORS_THERMAL_1 : return( MAKE_NAME(_TL("thermal" )) );
499  case SG_COLORS_THERMAL_2 : return( MAKE_NAME(_TL("thermal" )) );
500 
501  case SG_COLORS_PRECIPITATION_1 : return( MAKE_NAME(_TL("precipitation" )) );
502  case SG_COLORS_PRECIPITATION_2 : return( MAKE_NAME(_TL("precipitation" )) );
503  case SG_COLORS_PRECIPITATION_3 : return( MAKE_NAME(_TL("precipitation" )) );
504  case SG_COLORS_PRECIPITATION_4 : return( MAKE_NAME(_TL("precipitation" )) );
505  case SG_COLORS_PRECIPITATION_5 : return( MAKE_NAME(_TL("precipitation" )) );
506 
507  case SG_COLORS_VEGETATION : return( MAKE_NAME(_TL("vegetation" )) );
508 
509  case SG_COLORS_SPECTRUM_1 : return( MAKE_NAME(_TL("spectrum" )) );
510  case SG_COLORS_SPECTRUM_2 : return( MAKE_NAME(_TL("spectrum" )) );
511  case SG_COLORS_SPECTRUM_3 : return( MAKE_NAME(_TL("spectrum" )) );
512 
513  default : return( _TL("") );
514  }
515 }
516 
517 //---------------------------------------------------------
518 bool CSG_Colors::Set_Predefined(int Index, bool bRevert, int nColors)
519 {
520  switch( Index )
521  {
522  case SG_COLORS_DEFAULT:
523  Set_Default(nColors < 17 ? 17 : nColors);
524  break;
525 
526  case SG_COLORS_DEFAULT_BRIGHT:
527  Set_Default(nColors < 17 ? 17 : nColors);
528  Set_Ramp_Brighness(127, 127);
529  break;
530 
531  case SG_COLORS_RAINBOW:
532  Set_Count(8);
533  Set_Color(0, SG_GET_RGB( 64, 0, 127));
534  Set_Color(1, SG_GET_RGB( 0, 0, 255));
535  Set_Color(2, SG_GET_RGB( 0, 255, 255));
536  Set_Color(3, SG_GET_RGB( 0, 191, 0));
537  Set_Color(4, SG_GET_RGB(255, 255, 0));
538  Set_Color(5, SG_GET_RGB(255, 127, 0));
539  Set_Color(6, SG_GET_RGB(255, 0, 0));
540  Set_Color(7, SG_GET_RGB(127, 0, 0));
541  break;
542 
543  case SG_COLORS_RAINBOW_2:
544  Set_Count(4);
545  Set_Color(0, SG_GET_RGB( 0, 0, 255));
546  Set_Color(1, SG_GET_RGB( 0, 255, 0));
547  Set_Color(2, SG_GET_RGB(255, 255, 0));
548  Set_Color(3, SG_GET_RGB(255, 0, 0));
549  break;
550 
551  //-----------------------------------------------------
552  case SG_COLORS_BLACK_WHITE:
553  Set_Count(2);
554  Set_Ramp(SG_GET_RGB( 0, 0, 0), SG_GET_RGB(255, 255, 255));
555  break;
556 
557  case SG_COLORS_BLACK_RED:
558  Set_Count(2);
559  Set_Ramp(SG_GET_RGB( 0, 0, 0), SG_GET_RGB(255, 0, 0));
560  break;
561 
562  case SG_COLORS_BLACK_GREEN:
563  Set_Count(2);
564  Set_Ramp(SG_GET_RGB( 0, 0, 0), SG_GET_RGB( 0, 255, 0));
565  break;
566 
567  case SG_COLORS_BLACK_BLUE:
568  Set_Count(2);
569  Set_Ramp(SG_GET_RGB( 0, 0, 0), SG_GET_RGB( 0, 0, 255));
570  break;
571 
572  //-----------------------------------------------------
573  case SG_COLORS_WHITE_RED:
574  Set_Count(3);
575  Set_Color(0, SG_GET_RGB(255, 255, 255));
576  Set_Color(1, SG_GET_RGB(255, 127, 0));
577  Set_Color(2, SG_GET_RGB(159, 0, 0));
578  break;
579 
580  case SG_COLORS_WHITE_GREEN:
581  Set_Count(2);
582  Set_Ramp(SG_GET_RGB(255, 255, 255), SG_GET_RGB( 0, 127, 0));
583  break;
584 
585  case SG_COLORS_WHITE_BLUE:
586  Set_Count(3);
587  Set_Color(0, SG_GET_RGB(255, 255, 255));
588  Set_Color(1, SG_GET_RGB( 0, 127, 255));
589  Set_Color(2, SG_GET_RGB( 0, 0, 159));
590  break;
591 
592  //-----------------------------------------------------
593  case SG_COLORS_YELLOW_RED:
594  Set_Count(3);
595  Set_Color(0, SG_GET_RGB(255, 255, 127));
596  Set_Color(1, SG_GET_RGB(255, 127, 0));
597  Set_Color(2, SG_GET_RGB(127, 0, 0));
598  break;
599 
600  case SG_COLORS_YELLOW_GREEN:
601  Set_Count(3);
602  Set_Color(0, SG_GET_RGB(255, 255, 127));
603  Set_Color(1, SG_GET_RGB(127, 255, 0));
604  Set_Color(2, SG_GET_RGB( 0, 127, 0));
605  break;
606 
607  case SG_COLORS_YELLOW_BLUE:
608  Set_Count(3);
609  Set_Color(0, SG_GET_RGB(255, 255, 200));
610  Set_Color(1, SG_GET_RGB(127, 192, 255));
611  Set_Color(2, SG_GET_RGB( 0, 64, 127));
612  break;
613 
614  //-----------------------------------------------------
615  case SG_COLORS_BLUE_RED:
616  Set_Count(2);
617  Set_Ramp(SG_GET_RGB( 0, 0, 255), SG_GET_RGB(255, 0, 0));
618  break;
619 
620  case SG_COLORS_GREEN_RED:
621  Set_Count(2);
622  Set_Ramp(SG_GET_RGB( 0, 255, 0), SG_GET_RGB(255, 0, 0));
623  break;
624 
625  case SG_COLORS_GREEN_BLUE:
626  Set_Count(2);
627  Set_Ramp(SG_GET_RGB( 0, 255, 0), SG_GET_RGB( 0, 0, 255));
628  break;
629 
630  //-----------------------------------------------------
631  case SG_COLORS_BLUE_WHITE_RED:
632  Set_Count(3);
633  Set_Color(0, SG_GET_RGB( 0, 0, 127));
634  Set_Color(1, SG_GET_RGB(255, 255, 255));
635  Set_Color(2, SG_GET_RGB(255, 0, 0));
636  break;
637 
638  case SG_COLORS_GREEN_WHITE_RED:
639  Set_Count(3);
640  Set_Color(0, SG_GET_RGB( 0, 127, 0));
641  Set_Color(1, SG_GET_RGB(255, 255, 255));
642  Set_Color(2, SG_GET_RGB(255, 0, 0));
643  break;
644 
645  case SG_COLORS_GREEN_WHITE_BLUE:
646  Set_Count(3);
647  Set_Color(0, SG_GET_RGB( 0, 127, 0));
648  Set_Color(1, SG_GET_RGB(255, 255, 255));
649  Set_Color(2, SG_GET_RGB( 0, 0, 255));
650  break;
651 
652  //-----------------------------------------------------
653  case SG_COLORS_BLUE_GREY_RED:
654  Set_Count(3);
655  Set_Color(0, SG_GET_RGB( 0, 0, 127));
656  Set_Color(1, SG_GET_RGB(191, 191, 191));
657  Set_Color(2, SG_GET_RGB(127, 0, 0));
658  break;
659 
660  case SG_COLORS_RED_GREY_BLUE:
661  Set_Count(5);
662  Set_Color(0, SG_GET_RGB(127, 0, 0));
663  Set_Color(1, SG_GET_RGB(255, 127, 0));
664  Set_Color(2, SG_GET_RGB(239, 239, 239));
665  Set_Color(3, SG_GET_RGB( 0, 127, 255));
666  Set_Color(4, SG_GET_RGB( 0, 0, 127));
667  break;
668 
669  case SG_COLORS_GREEN_GREY_RED:
670  Set_Count(3);
671  Set_Color(0, SG_GET_RGB( 0, 127, 0));
672  Set_Color(1, SG_GET_RGB(191, 191, 191));
673  Set_Color(2, SG_GET_RGB(127, 0, 0));
674  break;
675 
676  case SG_COLORS_RED_GREY_GREEN:
677  Set_Count(5);
678  Set_Color(0, SG_GET_RGB(127, 0, 0));
679  Set_Color(1, SG_GET_RGB(255, 127, 0));
680  Set_Color(2, SG_GET_RGB(239, 239, 239));
681  Set_Color(3, SG_GET_RGB( 0, 255, 127));
682  Set_Color(4, SG_GET_RGB( 0, 127, 0));
683  break;
684 
685  case SG_COLORS_GREEN_GREY_BLUE:
686  Set_Count(5);
687  Set_Color(0, SG_GET_RGB( 0, 127, 0));
688  Set_Color(1, SG_GET_RGB(127, 255, 0));
689  Set_Color(2, SG_GET_RGB(191, 191, 191));
690  Set_Color(3, SG_GET_RGB( 0, 127, 255));
691  Set_Color(4, SG_GET_RGB( 0, 0, 127));
692  break;
693 
694  //-----------------------------------------------------
695  case SG_COLORS_BLUE_YELLOW_RED:
696  Set_Count(3);
697  Set_Color(0, SG_GET_RGB( 0, 0, 255));
698  Set_Color(1, SG_GET_RGB(255, 255, 0));
699  Set_Color(2, SG_GET_RGB(255, 0, 0));
700  break;
701 
702  case SG_COLORS_GREEN_YELLOW_RED:
703  Set_Count(3);
704  Set_Color(0, SG_GET_RGB( 0, 127, 0));
705  Set_Color(1, SG_GET_RGB(255, 255, 0));
706  Set_Color(2, SG_GET_RGB(255, 0, 0));
707  break;
708 
709  case SG_COLORS_RED_YELLOW_GREEN:
710  Set_Count(3);
711  Set_Color(0, SG_GET_RGB(200, 0, 0));
712  Set_Color(1, SG_GET_RGB(255, 255, 127));
713  Set_Color(2, SG_GET_RGB( 0, 63, 0));
714  break;
715 
716  case SG_COLORS_GREEN_YELLOW_BLUE:
717  Set_Count(3);
718  Set_Color(0, SG_GET_RGB( 0, 127, 0));
719  Set_Color(1, SG_GET_RGB(255, 255, 0));
720  Set_Color(2, SG_GET_RGB( 0, 0, 255));
721  break;
722 
723  //-----------------------------------------------------
724  case SG_COLORS_RED_GREEN_BLUE:
725  Set_Count(5);
726  Set_Color(0, SG_GET_RGB(127, 0, 127));
727  Set_Color(1, SG_GET_RGB(255, 0, 0));
728  Set_Color(2, SG_GET_RGB( 0, 255, 0));
729  Set_Color(3, SG_GET_RGB( 0, 0, 255));
730  Set_Color(4, SG_GET_RGB(127, 0, 127));
731  break;
732 
733  case SG_COLORS_RED_BLUE_GREEN:
734  Set_Count(5);
735  Set_Color(0, SG_GET_RGB(127, 127, 0));
736  Set_Color(1, SG_GET_RGB(255, 0, 0));
737  Set_Color(2, SG_GET_RGB( 0, 0, 255));
738  Set_Color(3, SG_GET_RGB( 0, 255, 0));
739  Set_Color(4, SG_GET_RGB(127, 127, 0));
740  break;
741 
742  case SG_COLORS_GREEN_RED_BLUE:
743  Set_Count(5);
744  Set_Color(0, SG_GET_RGB( 0, 127, 127));
745  Set_Color(1, SG_GET_RGB( 0, 255, 0));
746  Set_Color(2, SG_GET_RGB(255, 0, 0));
747  Set_Color(3, SG_GET_RGB( 0, 0, 255));
748  Set_Color(4, SG_GET_RGB( 0, 127, 127));
749  break;
750 
751  case SG_COLORS_NEON:
752  Set_Count(7);
753  Set_Color(0, SG_GET_RGB( 0, 0, 0));
754  Set_Color(1, SG_GET_RGB(255, 0, 0));
755  Set_Color(2, SG_GET_RGB( 0, 0, 0));
756  Set_Color(3, SG_GET_RGB(255, 255, 0));
757  Set_Color(4, SG_GET_RGB( 0, 0, 0));
758  Set_Color(5, SG_GET_RGB( 0, 255, 0));
759  Set_Color(6, SG_GET_RGB( 0, 0, 0));
760  break;
761 
762  //-----------------------------------------------------
763  case SG_COLORS_TOPOGRAPHY:
764  Set_Count(5);
765  Set_Color(0, SG_GET_RGB( 0, 143, 127));
766  Set_Color(1, SG_GET_RGB(127, 255, 0));
767  Set_Color(2, SG_GET_RGB(255, 255, 127));
768  Set_Color(3, SG_GET_RGB(255, 192, 0));
769  Set_Color(4, SG_GET_RGB(192, 143, 0));
770  break;
771 
772  case SG_COLORS_TOPOGRAPHY_2:
773  Set_Count(3);
774  Set_Color(0, SG_GET_RGB( 0, 128, 0));
775  Set_Color(1, SG_GET_RGB(255, 255, 127));
776  Set_Color(2, SG_GET_RGB(127, 63, 63));
777  break;
778 
779  case SG_COLORS_TOPOGRAPHY_3:
780  Set_Count(6);
781  Set_Color(0, SG_GET_RGB( 0, 191, 191));
782  Set_Color(1, SG_GET_RGB( 0, 255, 0));
783  Set_Color(2, SG_GET_RGB(255, 255, 0));
784  Set_Color(3, SG_GET_RGB(255, 127, 0));
785  Set_Color(4, SG_GET_RGB(191, 152, 110));
786  Set_Color(5, SG_GET_RGB(199, 199, 199));
787  break;
788 
789  case SG_COLORS_TOPOGRAPHY_4:
790  Set_Count(9);
791  Set_Color(0, SG_GET_RGB(177, 242, 212));
792  Set_Color(1, SG_GET_RGB(248, 252, 179));
793  Set_Color(2, SG_GET_RGB( 11, 128, 064));
794  Set_Color(3, SG_GET_RGB(248, 202, 80));
795  Set_Color(4, SG_GET_RGB(158, 30, 0));
796  Set_Color(5, SG_GET_RGB(128, 064, 064));
797  Set_Color(6, SG_GET_RGB(185, 121, 076));
798  Set_Color(7, SG_GET_RGB(179, 179, 179));
799  Set_Color(8, SG_GET_RGB(255, 255, 255));
800  break;
801 
802  //-----------------------------------------------------
803  case SG_COLORS_ASPECT_1:
804  Set_Count(5);
805  Set_Color(0, SG_GET_RGB(225, 225, 225));
806  Set_Color(1, SG_GET_RGB(127, 127, 255));
807  Set_Color(2, SG_GET_RGB( 20, 20, 20));
808  Set_Color(3, SG_GET_RGB(127, 255, 127));
809  Set_Color(4, SG_GET_RGB(225, 225, 225));
810  break;
811 
812  case SG_COLORS_ASPECT_2:
813  Set_Count(5);
814  Set_Color(0, SG_GET_RGB(225, 225, 225));
815  Set_Color(1, SG_GET_RGB(255, 127, 127));
816  Set_Color(2, SG_GET_RGB( 20, 20, 20));
817  Set_Color(3, SG_GET_RGB(127, 255, 127));
818  Set_Color(4, SG_GET_RGB(225, 225, 225));
819  break;
820 
821  case SG_COLORS_ASPECT_3:
822  Set_Count(5);
823  Set_Color(0, SG_GET_RGB(225, 225, 225));
824  Set_Color(1, SG_GET_RGB(255, 127, 127));
825  Set_Color(2, SG_GET_RGB( 20, 20, 20));
826  Set_Color(3, SG_GET_RGB(127, 127, 255));
827  Set_Color(4, SG_GET_RGB(225, 225, 225));
828  break;
829 
830  //-----------------------------------------------------
831  case SG_COLORS_THERMAL_1:
832  Set_Count(5);
833  Set_Color(0, SG_GET_RGB( 0, 0, 191));
834  Set_Color(1, SG_GET_RGB(255, 0, 255));
835  Set_Color(2, SG_GET_RGB(255, 0, 0));
836  Set_Color(3, SG_GET_RGB(255, 255, 0));
837  Set_Color(4, SG_GET_RGB(245, 245, 163));
838  break;
839 
840  case SG_COLORS_THERMAL_2:
841  Set_Count(6);
842  Set_Color(0, SG_GET_RGB(127, 255, 255));
843  Set_Color(1, SG_GET_RGB( 0, 0, 255));
844  Set_Color(2, SG_GET_RGB(127, 0, 255));
845  Set_Color(3, SG_GET_RGB(255, 0, 0));
846  Set_Color(4, SG_GET_RGB(255, 255, 0));
847  Set_Color(5, SG_GET_RGB(255, 255, 127));
848  break;
849 
850  //-----------------------------------------------------
851  case SG_COLORS_PRECIPITATION_1:
852  Set_Count(5);
853  Set_Color(0, SG_GET_RGB(255, 255, 127));
854  Set_Color(1, SG_GET_RGB(191, 255, 0));
855  Set_Color(2, SG_GET_RGB( 0, 191, 0));
856  Set_Color(3, SG_GET_RGB( 0, 127, 255));
857  Set_Color(4, SG_GET_RGB( 0, 0, 127));
858  break;
859 
860  case SG_COLORS_PRECIPITATION_2: // juergen's favorite precipitation colour ramp
861  Set_Count(22);
862  Set_Color( 0, SG_GET_RGB(216, 204, 131));
863  Set_Color( 1, SG_GET_RGB(196, 208, 111));
864  Set_Color( 2, SG_GET_RGB(184, 210, 101));
865  Set_Color( 3, SG_GET_RGB(172, 212, 91));
866  Set_Color( 4, SG_GET_RGB(139, 212, 99));
867  Set_Color( 5, SG_GET_RGB(107, 212, 107));
868  Set_Color( 6, SG_GET_RGB( 75, 212, 119));
869  Set_Color( 7, SG_GET_RGB( 42, 212, 131));
870  Set_Color( 8, SG_GET_RGB( 26, 212, 151));
871  Set_Color( 9, SG_GET_RGB( 10, 212, 172));
872  Set_Color(10, SG_GET_RGB( 30, 192, 192));
873  Set_Color(11, SG_GET_RGB( 50, 172, 212));
874  Set_Color(12, SG_GET_RGB( 70, 151, 214));
875  Set_Color(13, SG_GET_RGB( 91, 131, 216));
876  Set_Color(14, SG_GET_RGB( 75, 115, 198));
877  Set_Color(15, SG_GET_RGB( 58, 99, 180));
878  Set_Color(16, SG_GET_RGB( 42, 83, 184));
879  Set_Color(17, SG_GET_RGB( 26, 066, 188));
880  Set_Color(18, SG_GET_RGB( 26, 046, 180));
881  Set_Color(19, SG_GET_RGB( 26, 026, 166));
882  Set_Color(20, SG_GET_RGB( 38, 18, 151));
883  Set_Color(21, SG_GET_RGB( 50, 010, 131));
884  break;
885 
886  case SG_COLORS_PRECIPITATION_3:
887  Set_Count(10);
888  Set_Color( 0, SG_GET_RGB(255, 255, 185));
889  Set_Color( 1, SG_GET_RGB(229, 253, 139));
890  Set_Color( 2, SG_GET_RGB(204, 252, 94));
891  Set_Color( 3, SG_GET_RGB(178, 251, 49));
892  Set_Color( 4, SG_GET_RGB(153, 251, 0));
893  Set_Color( 5, SG_GET_RGB(128, 212, 43));
894  Set_Color( 6, SG_GET_RGB( 96, 159, 88));
895  Set_Color( 7, SG_GET_RGB( 64, 106, 133));
896  Set_Color( 8, SG_GET_RGB( 32, 53, 179));
897  Set_Color( 9, SG_GET_RGB( 0, 0, 123));
898  break;
899 
900  case SG_COLORS_PRECIPITATION_4:
901  Set_Count(10);
902  Set_Color( 0, SG_GET_RGB(255, 255, 200));
903  Set_Color( 1, SG_GET_RGB(227, 254, 145));
904  Set_Color( 2, SG_GET_RGB(160, 254, 125));
905  Set_Color( 3, SG_GET_RGB( 93, 254, 168));
906  Set_Color( 4, SG_GET_RGB(027, 237, 211));
907  Set_Color( 5, SG_GET_RGB( 0, 191, 254));
908  Set_Color( 6, SG_GET_RGB( 0, 146, 245));
909  Set_Color( 7, SG_GET_RGB( 0, 100, 210));
910  Set_Color( 8, SG_GET_RGB( 0, 55, 176));
911  Set_Color( 9, SG_GET_RGB( 62, 0, 142));
912  break;
913 
914  case SG_COLORS_PRECIPITATION_5:
915  Set_Count(10);
916  Set_Color( 0, SG_GET_RGB(254, 135, 000));
917  Set_Color( 1, SG_GET_RGB(254, 194, 063));
918  Set_Color( 2, SG_GET_RGB(254, 254, 126));
919  Set_Color( 3, SG_GET_RGB(231, 231, 227));
920  Set_Color( 4, SG_GET_RGB(132, 222, 254));
921  Set_Color( 5, SG_GET_RGB(042, 163, 239));
922  Set_Color( 6, SG_GET_RGB(000, 105, 224));
923  Set_Color( 7, SG_GET_RGB(000, 047, 210));
924  Set_Color( 8, SG_GET_RGB(000, 001, 156));
925  Set_Color( 9, SG_GET_RGB(000, 000, 103));
926  break;
927 
928  //-----------------------------------------------------
929  case SG_COLORS_VEGETATION:
930  Set_Count(5);
931  Set_Color(0, SG_GET_RGB(255, 252, 158));
932  Set_Color(1, SG_GET_RGB(192, 212, 100));
933  Set_Color(2, SG_GET_RGB(128, 172, 58));
934  Set_Color(3, SG_GET_RGB( 64, 132, 88));
935  Set_Color(4, SG_GET_RGB( 0, 94, 118));
936  break;
937 
938  //-----------------------------------------------------
939  case SG_COLORS_SPECTRUM_1:
940  Set_Count(11);
941  Set_Color( 0, SG_GET_RGB( 37, 57, 175));
942  Set_Color( 1, SG_GET_RGB( 40, 127, 251));
943  Set_Color( 2, SG_GET_RGB( 50, 190, 255));
944  Set_Color( 3, SG_GET_RGB(106, 235, 255));
945  Set_Color( 4, SG_GET_RGB(138, 236, 174));
946  Set_Color( 5, SG_GET_RGB(205, 255, 162));
947  Set_Color( 6, SG_GET_RGB(240, 236, 121));
948  Set_Color( 7, SG_GET_RGB(255, 189, 87));
949  Set_Color( 8, SG_GET_RGB(255, 161, 68));
950  Set_Color( 9, SG_GET_RGB(255, 186, 133));
951  Set_Color(10, SG_GET_RGB(255, 255, 255));
952  break;
953 
954  case SG_COLORS_SPECTRUM_2:
955  Set_Count(8);
956  Set_Color(0, SG_GET_RGB(171, 43, 0));
957  Set_Color(1, SG_GET_RGB(255, 127, 0));
958  Set_Color(2, SG_GET_RGB(255, 255, 0));
959  Set_Color(3, SG_GET_RGB( 0, 255, 0));
960  Set_Color(4, SG_GET_RGB( 0, 255, 255));
961  Set_Color(5, SG_GET_RGB( 0, 0, 255));
962  Set_Color(6, SG_GET_RGB(255, 0, 255));
963  Set_Color(7, SG_GET_RGB(255, 255, 255));
964  break;
965 
966  case SG_COLORS_SPECTRUM_3:
967  Set_Count(9);
968  Set_Color(0, SG_GET_RGB(000, 001, 205));
969  Set_Color(1, SG_GET_RGB(000, 132, 254));
970  Set_Color(1, SG_GET_RGB(000, 227, 254));
971  Set_Color(1, SG_GET_RGB(001, 167, 076));
972  Set_Color(1, SG_GET_RGB(118, 218, 076));
973  Set_Color(1, SG_GET_RGB(186, 255, 127));
974  Set_Color(1, SG_GET_RGB(254, 244, 152));
975  Set_Color(1, SG_GET_RGB(254, 203, 128));
976  Set_Color(1, SG_GET_RGB(254, 172, 000));
977  break;
978 
979  //-----------------------------------------------------
980 // case SG_COLORS_COUNT:
981 // Set_Count(nColors);
982 // Random();
983 // break;
984 
985  default:
986  return( false );
987  }
988 
989  //-----------------------------------------------------
990  if( bRevert )
991  {
992  Revert();
993  }
994 
995  if( nColors > 0 )
996  {
997  Set_Count(nColors);
998  }
999 
1000  return( true );
1001 }
1002 
1003 //---------------------------------------------------------
1004 bool CSG_Colors::Set_Default(int nColors)
1005 {
1006  if( nColors > 1 )
1007  {
1008  m_nColors = nColors;
1009  m_Colors = (long *)SG_Realloc(m_Colors, m_nColors * sizeof(long));
1010 
1011  double d = 0., dStep = 2. * M_PI / (m_nColors - 1.);
1012 
1013  for(int i=0; i<m_nColors; i++, d+=dStep)
1014  {
1015  Set_Color(i,
1016  (int)(d < M_PI / 2 ? 0 : 128 - 127 * sin(M_PI - d)),
1017  (int)(128 - 127 * cos(d)),
1018  (int)(d > M_PI * 3 / 2 ? 0 : 128 + 127 * sin(d))
1019  );
1020  }
1021 
1022  return( true );
1023  }
1024 
1025  return( false );
1026 }
1027 
1028 //---------------------------------------------------------
1029 bool CSG_Colors::Set_Ramp(long Color_A, long Color_B)
1030 {
1031  return( Set_Ramp(Color_A, Color_B, 0, Get_Count() - 1) );
1032 }
1033 
1034 //---------------------------------------------------------
1035 bool CSG_Colors::Set_Ramp(long Color_A, long Color_B, int iColor_A, int iColor_B)
1036 {
1037  if( iColor_A > iColor_B )
1038  {
1039  int i = iColor_A;
1040  iColor_A = iColor_B;
1041  iColor_B = i;
1042  }
1043 
1044  if( iColor_A < 0 )
1045  {
1046  iColor_A = 0;
1047  }
1048 
1049  if( iColor_B >= Get_Count() )
1050  {
1051  iColor_B = Get_Count() - 1;
1052  }
1053 
1054  //-----------------------------------------------------
1055  int n = iColor_B - iColor_A;
1056 
1057  if( n > 0 )
1058  {
1059  int ar = SG_GET_R(Color_A);
1060  double dr = (double)(SG_GET_R(Color_B) - ar) / (double)n;
1061 
1062  int ag = SG_GET_G(Color_A);
1063  double dg = (double)(SG_GET_G(Color_B) - ag) / (double)n;
1064 
1065  int ab = SG_GET_B(Color_A);
1066  double db = (double)(SG_GET_B(Color_B) - ab) / (double)n;
1067 
1068  for(int i=0; i<=n; i++)
1069  {
1070  Set_Color(iColor_A + i,
1071  (int)(ar + i * dr),
1072  (int)(ag + i * dg),
1073  (int)(ab + i * db)
1074  );
1075  }
1076 
1077  return( true );
1078  }
1079 
1080  return( false );
1081 }
1082 
1083 //---------------------------------------------------------
1084 bool CSG_Colors::Set_Ramp_Brighness(int Brightness_A, int Brightness_B)
1085 {
1086  return( Set_Ramp_Brighness(Brightness_A, Brightness_B, 0, Get_Count() - 1) );
1087 }
1088 
1089 //---------------------------------------------------------
1090 bool CSG_Colors::Set_Ramp_Brighness(int Brightness_A, int Brightness_B, int iColor_A, int iColor_B)
1091 {
1092  if( iColor_A > iColor_B )
1093  {
1094  int i = iColor_A;
1095  iColor_A = iColor_B;
1096  iColor_B = i;
1097  }
1098 
1099  if( iColor_A < 0 )
1100  {
1101  iColor_A = 0;
1102  }
1103 
1104  if( iColor_B >= Get_Count() )
1105  {
1106  iColor_B = Get_Count() - 1;
1107  }
1108 
1109  //-----------------------------------------------------
1110  int n = iColor_B - iColor_A;
1111 
1112  if( n > 0 )
1113  {
1114  double dBrightness = (double)(Brightness_B - Brightness_A) / (double)n;
1115 
1116  for(int i=0; i<=n; i++)
1117  {
1118  Set_Brightness(iColor_A + i, (int)(Brightness_A + i * dBrightness));
1119  }
1120 
1121  return( true );
1122  }
1123 
1124  return( false );
1125 }
1126 
1127 
1129 // //
1131 
1132 //---------------------------------------------------------
1133 bool CSG_Colors::Random(void)
1134 {
1135  for(int i=0; i<Get_Count(); i++)
1136  {
1137  Set_Color(i,
1138  (int)(255.0 * (double)rand() / (double)RAND_MAX),
1139  (int)(255.0 * (double)rand() / (double)RAND_MAX),
1140  (int)(255.0 * (double)rand() / (double)RAND_MAX)
1141  );
1142  }
1143 
1144  return( Get_Count() > 0 );
1145 }
1146 
1147 //---------------------------------------------------------
1148 bool CSG_Colors::Invert(void)
1149 {
1150  for(int i=0; i<Get_Count(); i++)
1151  {
1152  Set_Color(i, 255 - Get_Red(i), 255 - Get_Green(i), 255 - Get_Blue(i));
1153  }
1154 
1155  return( Get_Count() > 0 );
1156 }
1157 
1158 //---------------------------------------------------------
1159 bool CSG_Colors::Revert(void)
1160 {
1161  for(int i=0, j=Get_Count()-1; i<j; i++, j--)
1162  {
1163  long c = Get_Color(j);
1164  Set_Color(j, Get_Color(i));
1165  Set_Color(i, c);
1166  }
1167 
1168  return( Get_Count() > 0 );
1169 }
1170 
1171 //---------------------------------------------------------
1172 bool CSG_Colors::Greyscale(void)
1173 {
1174  for(int i=0; i<Get_Count(); i++)
1175  {
1176  long c = Get_Brightness(i);
1177 
1178  Set_Color(i, c, c, c);
1179  }
1180 
1181  return( Get_Count() > 0 );
1182 }
1183 
1184 
1186 // //
1188 
1189 //---------------------------------------------------------
1190 CSG_Colors & CSG_Colors::operator = (const CSG_Colors &Colors)
1191 {
1192  Create(Colors);
1193 
1194  return( *this );
1195 }
1196 
1197 //---------------------------------------------------------
1198 bool CSG_Colors::Assign(const CSG_Colors &Colors)
1199 {
1200  return( Create(Colors) );
1201 }
1202 
1203 //---------------------------------------------------------
1204 bool CSG_Colors::Assign(CSG_Colors *pColors)
1205 {
1206  return( pColors ? Create(*pColors) : false );
1207 }
1208 
1209 
1211 // //
1213 
1214 //---------------------------------------------------------
1215 #define COLORS_SERIAL_VERSION_BINARY "SAGA_COLORPALETTE_VERSION_0.100_BINARY"
1216 #define COLORS_SERIAL_VERSION__ASCII "SAGA_COLORPALETTE_VERSION_0.100__ASCII"
1217 
1218 //---------------------------------------------------------
1219 bool CSG_Colors::Load(const CSG_String &File_Name)
1220 {
1221  CSG_File Stream;
1222 
1223  if( !Stream.Open(File_Name, SG_FILE_R, true) )
1224  {
1225  return( false );
1226  }
1227 
1228  CSG_String Version;
1229 
1230  Stream.Read(Version, sizeof(COLORS_SERIAL_VERSION__ASCII));
1231 
1232  //-----------------------------------------------------
1233  if( Version.Find(COLORS_SERIAL_VERSION__ASCII) == 0 )
1234  {
1235  return( Serialize(Stream, false, false) );
1236  }
1237 
1238  //-----------------------------------------------------
1239  Stream.Seek_Start();
1240  Stream.Read(Version, sizeof(COLORS_SERIAL_VERSION_BINARY));
1241 
1242  if( Version.Find(COLORS_SERIAL_VERSION_BINARY) == 0 )
1243  {
1244  int nColors;
1245 
1246  Stream.Read(&nColors, sizeof(nColors));
1247 
1248  if( Set_Count(nColors) ) // different os, different sizeof(long) !!
1249  {
1250  size_t ValueSize = (size_t)((Stream.Length() - (sizeof(COLORS_SERIAL_VERSION_BINARY) + sizeof(int))) / nColors);
1251 
1252  if( ValueSize > 0 )
1253  {
1254  BYTE *c = (BYTE *)SG_Malloc(ValueSize);
1255 
1256  for(int i=0; i<nColors; i++)
1257  {
1258  Stream.Read(c, ValueSize);
1259 
1260  Set_Color(i, c[0], c[1], c[2]);
1261  }
1262 
1263  SG_Free(c);
1264  }
1265 
1266  return( true );
1267  }
1268  }
1269 
1270  //-----------------------------------------------------
1271  else // SAGA 1.x compatibility...
1272  {
1273  short nColors;
1274 
1275  Stream.Seek_Start();
1276  Stream.Read(&nColors, sizeof(short));
1277 
1278  if( Stream.Length() == (int)(sizeof(short) + 3 * nColors) && Set_Count(nColors) )
1279  {
1280  BYTE *R = (BYTE *)SG_Malloc(nColors * sizeof(BYTE)); Stream.Read(R, nColors * sizeof(BYTE));
1281  BYTE *G = (BYTE *)SG_Malloc(nColors * sizeof(BYTE)); Stream.Read(G, nColors * sizeof(BYTE));
1282  BYTE *B = (BYTE *)SG_Malloc(nColors * sizeof(BYTE)); Stream.Read(B, nColors * sizeof(BYTE));
1283 
1284  for(int i=0; i<nColors; i++)
1285  {
1286  Set_Color(i, R[i], G[i], B[i]);
1287  }
1288 
1289  SG_Free(R); SG_Free(G); SG_Free(B);
1290 
1291  return( true );
1292  }
1293  }
1294 
1295  //-----------------------------------------------------
1296  return( false );
1297 }
1298 
1299 //---------------------------------------------------------
1300 bool CSG_Colors::Save(const CSG_String &File_Name, bool bBinary)
1301 {
1302  CSG_File Stream;
1303 
1304  if( Stream.Open(File_Name, SG_FILE_W, bBinary) )
1305  {
1306  if( bBinary )
1307  {
1308  Stream.Write((void *)COLORS_SERIAL_VERSION_BINARY, sizeof(COLORS_SERIAL_VERSION_BINARY));
1309  }
1310  else
1311  {
1312  Stream.Write(COLORS_SERIAL_VERSION__ASCII); Stream.Write("\n");
1313  }
1314 
1315  Serialize(Stream, true, bBinary);
1316 
1317  return( true );
1318  }
1319 
1320  return( false );
1321 }
1322 
1323 
1325 // //
1327 
1328 //---------------------------------------------------------
1329 bool CSG_Colors::Serialize(CSG_File &Stream, bool bSave, bool bBinary)
1330 {
1331  if( Stream.is_Open() )
1332  {
1333  //-------------------------------------------------
1334  if( bBinary )
1335  {
1336  if( bSave )
1337  {
1338  if( m_nColors > 0 )
1339  {
1340  Stream.Write(&m_nColors, sizeof(m_nColors));
1341  Stream.Write(m_Colors, sizeof(long), m_nColors);
1342  }
1343  }
1344  else
1345  {
1346  int nColors;
1347 
1348  Stream.Read(&nColors, sizeof(m_nColors));
1349 
1350  if( Set_Count(nColors) )
1351  {
1352  Stream.Read(m_Colors, sizeof(long), m_nColors);
1353  }
1354  }
1355 
1356  return( true );
1357  }
1358 
1359  //-------------------------------------------------
1360  else
1361  {
1362  if( bSave )
1363  {
1364  if( Get_Count() > 0 )
1365  {
1366  Stream.Printf("%d\n", Get_Count());
1367 
1368  for(int i=0; i<Get_Count(); i++)
1369  {
1370  Stream.Printf("%03d %03d %03d\n", (int)Get_Red(i), (int)Get_Green(i), (int)Get_Blue(i));
1371  }
1372  }
1373  }
1374  else
1375  {
1376  CSG_String sLine;
1377 
1378  while( Stream.Read_Line(sLine) && sLine.is_Empty() ) {} // skip empty lines
1379 
1380  if( Set_Count(sLine.asInt()) )
1381  {
1382  for(int i=0; i<Get_Count(); i++)
1383  {
1384  Stream.Read_Line(sLine);
1385 
1386  Set_Color(i,
1387  sLine .asInt(),
1388  sLine.AfterFirst(' ').asInt(),
1389  sLine.AfterLast (' ').asInt()
1390  );
1391  }
1392  }
1393  }
1394 
1395  return( true );
1396  }
1397  }
1398 
1399  return( false );
1400 }
1401 
1402 //---------------------------------------------------------
1403 bool CSG_Colors::to_Text(CSG_String &String)
1404 {
1405  if( Get_Count() > 0 )
1406  {
1407  String.Clear();
1408 
1409  for(int i=0; i<Get_Count(); i++)
1410  {
1411  String += CSG_String::Format("%03d %03d %03d;", (int)Get_Red(i), (int)Get_Green(i), (int)Get_Blue(i));
1412  }
1413 
1414  return( true );
1415  }
1416 
1417  return( false );
1418 }
1419 
1420 //---------------------------------------------------------
1421 bool CSG_Colors::from_Text(const CSG_String &String)
1422 {
1423  if( Set_Count((int)String.Length() / 12) )
1424  {
1425  for(int i=0, j=0; i<Get_Count(); i++, j+=12)
1426  {
1427  Set_Color(i,
1428  String.Mid(j + 0, 4).asInt(),
1429  String.Mid(j + 4, 4).asInt(),
1430  String.Mid(j + 8, 4).asInt()
1431  );
1432  }
1433 
1434  return( true );
1435  }
1436 
1437  return( false );
1438 }
1439 
1440 
1442 // //
1443 // //
1444 // //
1446 
1447 //---------------------------------------------------------
SG_COLORS_RAINBOW_2
@ SG_COLORS_RAINBOW_2
Definition: api_core.h:1329
CSG_Colors::Set_Brightness
bool Set_Brightness(int Index, int Value)
Definition: api_colors.cpp:348
CSG_Colors::Set_Color
bool Set_Color(int Index, long Color)
Definition: api_colors.cpp:311
CSG_Colors::from_Text
bool from_Text(const CSG_String &String)
Definition: api_colors.cpp:1421
SG_GET_RGB
#define SG_GET_RGB(r, g, b)
Definition: api_core.h:1294
SG_COLORS_RED_BLUE_GREEN
@ SG_COLORS_RED_BLUE_GREEN
Definition: api_core.h:1364
CSG_String::Printf
int Printf(const char *Format,...)
Definition: api_string.cpp:308
CSG_File::Seek_Start
bool Seek_Start(void) const
Definition: api_file.cpp:261
_TL
#define _TL(s)
Definition: api_core.h:1556
CSG_Colors::Greyscale
bool Greyscale(void)
Definition: api_colors.cpp:1172
SG_GET_B
#define SG_GET_B(rgb)
Definition: api_core.h:1299
CSG_String::Length
size_t Length(void) const
Definition: api_string.cpp:172
SG_Color_From_Text
bool SG_Color_From_Text(const CSG_String &Text, long &Color)
Definition: api_colors.cpp:85
SG_Colors_Get_Name
CSG_String SG_Colors_Get_Name(int Index)
Definition: api_colors.cpp:67
CSG_String::b_str
const char * b_str(void) const
Definition: api_string.cpp:242
CSG_Colors::Load
bool Load(const CSG_String &File_Name)
Definition: api_colors.cpp:1219
SG_COLORS_GREEN_BLUE
@ SG_COLORS_GREEN_BLUE
Definition: api_core.h:1346
SG_COLORS_VEGETATION
@ SG_COLORS_VEGETATION
Definition: api_core.h:1386
CSG_Colors::Revert
bool Revert(void)
Definition: api_colors.cpp:1159
CSG_String::Mid
CSG_String Mid(size_t first, size_t count=0) const
Definition: api_string.cpp:746
CSG_Colors::Set_Palette
bool Set_Palette(int Index, bool bRevert=false, int nColors=0)
Definition: api_core.h:1456
SG_COLORS_RED_GREY_BLUE
@ SG_COLORS_RED_GREY_BLUE
Definition: api_core.h:1353
CSG_Colors::Get_Predefined_Name
static CSG_String Get_Predefined_Name(int Identifier)
Definition: api_colors.cpp:441
CSG_Colors::Get_Blue
long Get_Blue(int Index) const
Definition: api_core.h:1436
CSG_Colors::Destroy
void Destroy(void)
Definition: api_colors.cpp:247
CSG_String::asInt
int asInt(void) const
Definition: api_string.cpp:769
SG_COLORS_BLACK_BLUE
@ SG_COLORS_BLACK_BLUE
Definition: api_core.h:1334
CSG_Random::Get_Uniform
static double Get_Uniform(void)
Definition: mat_tools.cpp:274
SG_Malloc
SAGA_API_DLL_EXPORT void * SG_Malloc(size_t size)
Definition: api_memory.cpp:65
SG_COLORS_SPECTRUM_1
@ SG_COLORS_SPECTRUM_1
Definition: api_core.h:1388
CSG_Colors::Invert
bool Invert(void)
Definition: api_colors.cpp:1148
SG_COLORS_SPECTRUM_2
@ SG_COLORS_SPECTRUM_2
Definition: api_core.h:1389
SG_Color_Get_Random
long SG_Color_Get_Random(void)
Definition: api_colors.cpp:73
SG_COLORS_TOPOGRAPHY
@ SG_COLORS_TOPOGRAPHY
Definition: api_core.h:1368
CSG_String::Get_Char
SG_Char Get_Char(size_t i) const
Definition: api_string.cpp:209
api_core.h
SG_COLORS_WHITE_GREEN
@ SG_COLORS_WHITE_GREEN
Definition: api_core.h:1337
SG_COLORS_GREEN_WHITE_BLUE
@ SG_COLORS_GREEN_WHITE_BLUE
Definition: api_core.h:1350
SG_COLORS_RAINBOW
@ SG_COLORS_RAINBOW
Definition: api_core.h:1328
SG_COLORS_BLACK_RED
@ SG_COLORS_BLACK_RED
Definition: api_core.h:1332
SG_COLORS_BLUE_WHITE_RED
@ SG_COLORS_BLUE_WHITE_RED
Definition: api_core.h:1348
SG_Free
SAGA_API_DLL_EXPORT void SG_Free(void *memblock)
Definition: api_memory.cpp:83
SG_COLORS_PRECIPITATION_4
@ SG_COLORS_PRECIPITATION_4
Definition: api_core.h:1383
SG_FILE_R
@ SG_FILE_R
Definition: api_core.h:1112
CSG_Colors::Set_Blue
bool Set_Blue(int Index, int Value)
Definition: api_colors.cpp:342
CSG_Colors::Get_Red
long Get_Red(int Index) const
Definition: api_core.h:1434
SG_COLORS_ASPECT_2
@ SG_COLORS_ASPECT_2
Definition: api_core.h:1374
SG_COLORS_PRECIPITATION_1
@ SG_COLORS_PRECIPITATION_1
Definition: api_core.h:1380
CSG_File::Read
size_t Read(void *Buffer, size_t Size, size_t Count=1) const
Definition: api_file.cpp:338
CSG_Colors::Set_Ramp
bool Set_Ramp(long Color_A, long Color_B)
Definition: api_colors.cpp:1029
CSG_File
Definition: api_core.h:1127
SG_COLORS_SPECTRUM_3
@ SG_COLORS_SPECTRUM_3
Definition: api_core.h:1390
SG_GET_R
#define SG_GET_R(rgb)
Definition: api_core.h:1297
SG_COLORS_NEON
@ SG_COLORS_NEON
Definition: api_core.h:1366
mat_tools.h
CSG_Colors::Get_Predefined_Count
static int Get_Predefined_Count(void)
Definition: api_colors.cpp:435
SG_COLORS_GREEN_GREY_RED
@ SG_COLORS_GREEN_GREY_RED
Definition: api_core.h:1354
COLORS_SERIAL_VERSION__ASCII
#define COLORS_SERIAL_VERSION__ASCII
Definition: api_colors.cpp:1216
SG_COLORS_YELLOW_BLUE
@ SG_COLORS_YELLOW_BLUE
Definition: api_core.h:1342
SG_COLORS_BLACK_WHITE
@ SG_COLORS_BLACK_WHITE
Definition: api_core.h:1331
SG_COLORS_YELLOW_RED
@ SG_COLORS_YELLOW_RED
Definition: api_core.h:1340
CSG_Colors::Get_Count
int Get_Count(void) const
Definition: api_core.h:1421
SG_COLORS_YELLOW_GREEN
@ SG_COLORS_YELLOW_GREEN
Definition: api_core.h:1341
CSG_Colors::Create
bool Create(void)
Definition: api_colors.cpp:210
CSG_Colors::Get_Color
long Get_Color(int Index) const
Definition: api_core.h:1433
SG_COLORS_GREEN_YELLOW_RED
@ SG_COLORS_GREEN_YELLOW_RED
Definition: api_core.h:1359
SG_GET_G
#define SG_GET_G(rgb)
Definition: api_core.h:1298
SG_COLORS_DEFAULT
@ SG_COLORS_DEFAULT
Definition: api_core.h:1326
CSG_Colors::Set_Red
bool Set_Red(int Index, int Value)
Definition: api_colors.cpp:330
SG_Color_From_RGB
long SG_Color_From_RGB(int Red, int Green, int Blue, int Alpha)
Definition: api_colors.cpp:79
SG_COLORS_ASPECT_1
@ SG_COLORS_ASPECT_1
Definition: api_core.h:1373
SG_COLORS_WHITE_BLUE
@ SG_COLORS_WHITE_BLUE
Definition: api_core.h:1338
CSG_Colors::Get_Interpolated
long Get_Interpolated(double Index) const
Definition: api_core.h:1439
MAKE_NAME
#define MAKE_NAME(name)
CSG_File::Open
virtual bool Open(const SG_Char *FileName, int Mode=SG_FILE_R, bool bBinary=true, int Encoding=SG_FILE_ENCODING_ANSI)
Definition: api_file.cpp:113
SG_COLORS_GREEN_RED
@ SG_COLORS_GREEN_RED
Definition: api_core.h:1345
CSG_Colors::Set_Green
bool Set_Green(int Index, int Value)
Definition: api_colors.cpp:336
CSG_Colors::Set_Count
bool Set_Count(int nColors)
Definition: api_colors.cpp:264
SG_COLORS_DEFAULT_BRIGHT
@ SG_COLORS_DEFAULT_BRIGHT
Definition: api_core.h:1327
CSG_Colors::CSG_Colors
CSG_Colors(void)
Definition: api_colors.cpp:172
SG_Color_To_Text
CSG_String SG_Color_To_Text(long Color, bool bHexadecimal)
Definition: api_colors.cpp:144
SG_FILE_W
@ SG_FILE_W
Definition: api_core.h:1113
SG_COLORS_GREEN_YELLOW_BLUE
@ SG_COLORS_GREEN_YELLOW_BLUE
Definition: api_core.h:1361
CSG_Colors::Set_Predefined
bool Set_Predefined(int Index, bool bRevert=false, int nColors=0)
Definition: api_colors.cpp:518
CSG_File::is_Open
bool is_Open(void) const
Definition: api_core.h:1146
SG_COLORS_RED_YELLOW_GREEN
@ SG_COLORS_RED_YELLOW_GREEN
Definition: api_core.h:1360
SG_COLORS_BLACK_GREEN
@ SG_COLORS_BLACK_GREEN
Definition: api_core.h:1333
SG_COLORS_PRECIPITATION_3
@ SG_COLORS_PRECIPITATION_3
Definition: api_core.h:1382
CSG_Colors::operator=
CSG_Colors & operator=(const CSG_Colors &Colors)
Definition: api_colors.cpp:1190
SG_COLORS_BLUE_GREY_RED
@ SG_COLORS_BLUE_GREY_RED
Definition: api_core.h:1352
SG_COLORS_TOPOGRAPHY_4
@ SG_COLORS_TOPOGRAPHY_4
Definition: api_core.h:1371
CSG_String::Format
static CSG_String Format(const char *Format,...)
Definition: api_string.cpp:270
SG_COLORS_GREEN_GREY_BLUE
@ SG_COLORS_GREEN_GREY_BLUE
Definition: api_core.h:1356
SG_COLORS_THERMAL_1
@ SG_COLORS_THERMAL_1
Definition: api_core.h:1377
CSG_String::Find
int Find(char Character, bool fromEnd=false) const
Definition: api_string.cpp:663
SG_COLORS_TOPOGRAPHY_3
@ SG_COLORS_TOPOGRAPHY_3
Definition: api_core.h:1370
CSG_File::Length
sLong Length(void) const
Definition: api_file.cpp:230
CSG_Colors::Set_Default
bool Set_Default(int nColors=11)
Definition: api_colors.cpp:1004
SG_COLORS_ASPECT_3
@ SG_COLORS_ASPECT_3
Definition: api_core.h:1375
SG_COLORS_RED_GREY_GREEN
@ SG_COLORS_RED_GREY_GREEN
Definition: api_core.h:1355
CSG_String::AfterFirst
CSG_String AfterFirst(char Character) const
Definition: api_string.cpp:691
CSG_String::Clear
void Clear(void)
Definition: api_string.cpp:259
COLORS_SERIAL_VERSION_BINARY
#define COLORS_SERIAL_VERSION_BINARY
Definition: api_colors.cpp:1215
CSG_Colors::Get_Brightness
long Get_Brightness(int Index) const
Definition: api_core.h:1437
M_PI
#define M_PI
Definition: mat_tools.h:96
B
#define B
CSG_String
Definition: api_core.h:563
SG_COLORS_PRECIPITATION_5
@ SG_COLORS_PRECIPITATION_5
Definition: api_core.h:1384
CSG_Colors::Get_Green
long Get_Green(int Index) const
Definition: api_core.h:1435
SG_COLORS_GREEN_WHITE_RED
@ SG_COLORS_GREEN_WHITE_RED
Definition: api_core.h:1349
CSG_Colors::Serialize
bool Serialize(CSG_File &Stream, bool bSave, bool bBinary)
Definition: api_colors.cpp:1329
CSG_File::Printf
int Printf(const char *Format,...)
Definition: api_file.cpp:287
CSG_String::is_Empty
bool is_Empty(void) const
Definition: api_string.cpp:178
CSG_Colors::to_Text
bool to_Text(CSG_String &String)
Definition: api_colors.cpp:1403
SG_COLORS_BLUE_YELLOW_RED
@ SG_COLORS_BLUE_YELLOW_RED
Definition: api_core.h:1358
SG_COLORS_COUNT
@ SG_COLORS_COUNT
Definition: api_core.h:1392
CSG_File::Read_Line
bool Read_Line(CSG_String &Line) const
Definition: api_file.cpp:399
CSG_String::AfterLast
CSG_String AfterLast(char Character) const
Definition: api_string.cpp:702
SG_COLORS_WHITE_RED
@ SG_COLORS_WHITE_RED
Definition: api_core.h:1336
SG_COLORS_THERMAL_2
@ SG_COLORS_THERMAL_2
Definition: api_core.h:1378
SG_COLORS_PRECIPITATION_2
@ SG_COLORS_PRECIPITATION_2
Definition: api_core.h:1381
SG_COLORS_RED_GREEN_BLUE
@ SG_COLORS_RED_GREEN_BLUE
Definition: api_core.h:1363
CSG_Colors::~CSG_Colors
virtual ~CSG_Colors(void)
Definition: api_colors.cpp:199
CSG_File::Write
size_t Write(void *Buffer, size_t Size, size_t Count=1) const
Definition: api_file.cpp:370
CSG_Colors::Random
bool Random(void)
Definition: api_colors.cpp:1133
SG_Realloc
SAGA_API_DLL_EXPORT void * SG_Realloc(void *memblock, size_t size)
Definition: api_memory.cpp:77
SG_COLORS_GREEN_RED_BLUE
@ SG_COLORS_GREEN_RED_BLUE
Definition: api_core.h:1365
CSG_Colors::Save
bool Save(const CSG_String &File_Name, bool bBinary)
Definition: api_colors.cpp:1300
SG_COLORS_BLUE_RED
@ SG_COLORS_BLUE_RED
Definition: api_core.h:1344
CSG_Colors::Assign
bool Assign(const CSG_Colors &Colors)
Definition: api_colors.cpp:1198
SG_COLORS_TOPOGRAPHY_2
@ SG_COLORS_TOPOGRAPHY_2
Definition: api_core.h:1369
SG_GET_RGBA
#define SG_GET_RGBA(r, g, b, a)
Definition: api_core.h:1295
CSG_Colors
Definition: api_core.h:1405
CSG_Colors::Set_Ramp_Brighness
bool Set_Ramp_Brighness(int Brightness_A, int Brightness_B)
Definition: api_colors.cpp:1084