SAGA API  v9.8
grids.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 // grids.cpp //
15 // //
16 // Copyright (C) 2017 by //
17 // Olaf Conrad //
18 // //
19 //-------------------------------------------------------//
20 // //
21 // This file is part of 'SAGA - System for Automated //
22 // Geoscientific Analyses'. //
23 // //
24 // This library is free software; you can redistribute //
25 // it and/or modify it under the terms of the GNU Lesser //
26 // General Public License as published by the Free //
27 // Software Foundation, either version 2.1 of the //
28 // License, or (at your option) any later version. //
29 // //
30 // This library is distributed in the hope that it will //
31 // be useful, but WITHOUT ANY WARRANTY; without even the //
32 // implied warranty of MERCHANTABILITY or FITNESS FOR A //
33 // PARTICULAR PURPOSE. See the GNU Lesser General Public //
34 // License for more details. //
35 // //
36 // You should have received a copy of the GNU Lesser //
37 // General Public License along with this program; if //
38 // not, see <http://www.gnu.org/licenses/>. //
39 // //
40 //-------------------------------------------------------//
41 // //
42 // e-mail: oconrad@saga-gis.org //
43 // //
44 // contact: Olaf Conrad //
45 // Institute of Geography //
46 // University of Hamburg //
47 // Germany //
48 // //
50 
51 //---------------------------------------------------------
52 #include "saga_api.h"
53 #include "grids.h"
54 #include "data_manager.h"
55 #include "tool_library.h"
56 
57 
59 // //
60 // //
61 // //
63 
64 //---------------------------------------------------------
65 CSG_Grids * SG_Create_Grids(void)
66 {
67  return( new CSG_Grids );
68 }
69 
70 //---------------------------------------------------------
71 CSG_Grids * SG_Create_Grids(const CSG_Grids &Grids)
72 {
73  CSG_Grids *pGrids = new CSG_Grids(Grids);
74 
75  if( !pGrids->is_Valid() ) { delete(pGrids); pGrids = NULL; } return( pGrids );
76 }
77 
78 //---------------------------------------------------------
79 CSG_Grids * SG_Create_Grids(const CSG_Grids *_pGrids, bool bCopyData)
80 {
81  CSG_Grids *pGrids = new CSG_Grids(_pGrids, bCopyData);
82 
83  if( !pGrids->is_Valid() ) { delete(pGrids); pGrids = NULL; } return( pGrids );
84 }
85 
86 //---------------------------------------------------------
87 CSG_Grids * SG_Create_Grids(const char *File, bool bLoadData) { return( SG_Create_Grids(CSG_String(File), bLoadData) ); }
88 CSG_Grids * SG_Create_Grids(const wchar_t *File, bool bLoadData) { return( SG_Create_Grids(CSG_String(File), bLoadData) ); }
89 CSG_Grids * SG_Create_Grids(const CSG_String &File, bool bLoadData)
90 {
91  CSG_Grids *pGrids = new CSG_Grids();
92 
93  if( pGrids->Create(File, bLoadData) )
94  {
95  return( pGrids );
96  }
97 
98  delete(pGrids); return( NULL );
99 }
100 
101 //---------------------------------------------------------
102 CSG_Grids * SG_Create_Grids(const CSG_Grid_System &System, int NZ, double zMin, TSG_Data_Type Type)
103 {
104  CSG_Grids *pGrids = new CSG_Grids(System, NZ, zMin, Type);
105 
106  if( !pGrids->is_Valid() ) { delete(pGrids); pGrids = NULL; } return( pGrids );
107 }
108 
109 //---------------------------------------------------------
110 CSG_Grids * SG_Create_Grids(const CSG_Grid_System &System, const CSG_Table &Attributes, int zAttribute, TSG_Data_Type Type, bool bCreateGrids)
111 {
112  CSG_Grids *pGrids = new CSG_Grids(System, Attributes, zAttribute, Type, bCreateGrids);
113 
114  if( bCreateGrids && !pGrids->is_Valid() ) { delete(pGrids); pGrids = NULL; } return( pGrids );
115 }
116 
117 //---------------------------------------------------------
118 CSG_Grids * SG_Create_Grids(int NX, int NY, int NZ, double Cellsize, double xMin, double yMin, double zMin, TSG_Data_Type Type)
119 {
120  CSG_Grids *pGrids = new CSG_Grids(NX, NY, NZ, Cellsize, xMin, yMin, zMin, Type);
121 
122  if( !pGrids->is_Valid() ) { delete(pGrids); pGrids = NULL; } return( pGrids );
123 }
124 
125 
127 // //
128 // //
129 // //
131 
132 //---------------------------------------------------------
136 //---------------------------------------------------------
137 CSG_Grids::CSG_Grids(void)
138 {
139  _On_Construction();
140 }
141 
142 //---------------------------------------------------------
146 CSG_Grids::~CSG_Grids(void)
147 {
148  Destroy();
149 
150  delete(m_pGrids[0]); // The Dummy
151 }
152 
153 //---------------------------------------------------------
157 //---------------------------------------------------------
158 CSG_Grids::CSG_Grids(const CSG_Grids &Grids)
159 {
160  _On_Construction();
161 
162  Create(Grids);
163 }
164 
165 //---------------------------------------------------------
172 //---------------------------------------------------------
173 CSG_Grids::CSG_Grids(const CSG_Grids *pGrids, bool bCopyData)
174 {
175  _On_Construction();
176 
177  Create(pGrids, bCopyData);
178 }
179 
180 //---------------------------------------------------------
184 //---------------------------------------------------------
185 CSG_Grids::CSG_Grids(const char *File, bool bLoadData) { _On_Construction(); Create(File, bLoadData); }
186 CSG_Grids::CSG_Grids(const wchar_t *File, bool bLoadData) { _On_Construction(); Create(File, bLoadData); }
187 CSG_Grids::CSG_Grids(const CSG_String &File, bool bLoadData) { _On_Construction(); Create(File, bLoadData); }
188 
189 //---------------------------------------------------------
193 //---------------------------------------------------------
194 CSG_Grids::CSG_Grids(int NX, int NY, int NZ, double Cellsize, double xMin, double yMin, double zMin, TSG_Data_Type Type)
195 {
196  _On_Construction();
197 
198  Create(NX, NY, NZ, Cellsize, xMin, yMin, zMin, Type);
199 }
200 
201 //---------------------------------------------------------
205 //---------------------------------------------------------
206 CSG_Grids::CSG_Grids(const CSG_Grid_System &System, int NZ, double zMin, TSG_Data_Type Type)
207 {
208  _On_Construction();
209 
210  Create(System, NZ, zMin, Type);
211 }
212 
213 //---------------------------------------------------------
217 //---------------------------------------------------------
218 CSG_Grids::CSG_Grids(const CSG_Grid_System &System, const CSG_Table &Attributes, int zAttribute, TSG_Data_Type Type, bool bCreateGrids)
219 {
220  _On_Construction();
221 
222  Create(System, Attributes, zAttribute, Type, bCreateGrids);
223 }
224 
225 
227 // //
229 
230 //---------------------------------------------------------
231 void CSG_Grids::_On_Construction(void)
232 {
233  m_pGrids = (CSG_Grid **)m_Grids.Create(1);
234  m_pGrids[0] = SG_Create_Grid(); // The Dummy
235  m_pGrids[0]->Set_Owner(this);
236 
237  m_Attributes.Set_Owner(this);
238 
239  m_Index = NULL;
240 
241  Destroy();
242 
243  Set_Update_Flag();
244 }
245 
246 //---------------------------------------------------------
250 bool CSG_Grids::Destroy(void)
251 {
252  for(size_t i=1; i<m_Grids.Get_uSize(); i++)
253  {
254  delete(m_pGrids[i]); // do not delete the dummy before deconstruction
255  }
256 
257  m_pGrids = (CSG_Grid **)m_Grids.Get_Array(1);
258 
259  m_pGrids[0]->Destroy(); // The Dummy
260 
261  SG_FREE_SAFE(m_Index);
262 
263  m_Attributes.Destroy();
264  m_Attributes.Add_Field("Z", SG_DATATYPE_Double);
265  m_Z_Attribute = m_Z_Name = 0;
266 
267  return( CSG_Data_Object::Destroy() );
268 }
269 
270 
272 // //
274 
275 //---------------------------------------------------------
276 bool CSG_Grids::Create(const CSG_Grids &Grids)
277 {
278  return( Create((CSG_Grids *)&Grids, true) );
279 }
280 
281 //---------------------------------------------------------
282 bool CSG_Grids::Create(const CSG_Grids *pGrids, bool bCopyData)
283 {
284  if( pGrids && pGrids->is_Valid() && Create(pGrids->Get_System(), 0, 0., pGrids->Get_Type()) )
285  {
286  Set_NoData_Value_Range(pGrids->Get_NoData_Value(), pGrids->Get_NoData_Value(true));
287 
288  m_Attributes.Create(&pGrids->m_Attributes);
289  Set_Z_Attribute (pGrids->Get_Z_Attribute ());
290  Set_Z_Name_Field(pGrids->Get_Z_Name_Field());
291 
292  if( bCopyData )
293  {
294  for(int i=0; i<pGrids->Get_NZ(); i++)
295  {
296  Add_Grid(pGrids->Get_Attributes(i), pGrids->Get_Grid_Ptr(i));
297  }
298  }
299 
300  Get_MetaData_DB().Del_Children();
301  Get_MetaData_DB().Add_Children(pGrids->Get_MetaData_DB());
302 
303  Get_Projection().Create(pGrids->Get_Projection());
304 
305  return( true );
306  }
307 
308  return( false );
309 }
310 
311 //---------------------------------------------------------
312 bool CSG_Grids::Create(const char *File, bool bLoadData) { return( Load(CSG_String(File), bLoadData) ); }
313 bool CSG_Grids::Create(const wchar_t *File, bool bLoadData) { return( Load(CSG_String(File), bLoadData) ); }
314 bool CSG_Grids::Create(const CSG_String &File, bool bLoadData) { return( Load( File , bLoadData) ); }
315 
316 //---------------------------------------------------------
317 bool CSG_Grids::Create(const CSG_Grid_System &System, int NZ, double zMin, TSG_Data_Type Type)
318 {
319  Destroy();
320 
321  if( m_pGrids[0]->Create(System, Type) )
322  {
323  Set_NoData_Value_Range(m_pGrids[0]->Get_NoData_Value(), m_pGrids[0]->Get_NoData_Value(true));
324 
325  for(int i=0; i<NZ; i++, zMin+=System.Get_Cellsize())
326  {
327  if( !Add_Grid(zMin) )
328  {
329  return( false );
330  }
331  }
332 
333  return( true );
334  }
335 
336  return( false );
337 }
338 
339 //---------------------------------------------------------
340 bool CSG_Grids::Create(const CSG_Grid_System &System, const CSG_Table &Attributes, int zAttribute, TSG_Data_Type Type, bool bCreateGrids)
341 {
342  Destroy();
343 
344  if( m_Attributes.Create(&Attributes) && m_pGrids[0]->Create(System, Type) )
345  {
346  Set_Z_Attribute(zAttribute);
347 
348  if( bCreateGrids )
349  {
350  for(int i=0; i<Attributes.Get_Count(); i++)
351  {
352  if( !Add_Grid(Attributes[i]) )
353  {
354  return( false );
355  }
356  }
357  }
358 
359  return( true );
360  }
361 
362  return( false );
363 }
364 
365 //---------------------------------------------------------
366 bool CSG_Grids::Create(int NX, int NY, int NZ, double Cellsize, double xMin, double yMin, double zMin, TSG_Data_Type Type)
367 {
368  return( Create(CSG_Grid_System(Cellsize, xMin, yMin, NX, NY), NZ, zMin, Type) );
369 }
370 
371 
373 // //
374 // Header //
375 // //
377 
378 //---------------------------------------------------------
379 void CSG_Grids::Set_Unit(const CSG_String &Unit)
380 {
381  m_pGrids[0]->Set_Unit(Unit);
382 }
383 
384 //---------------------------------------------------------
385 void CSG_Grids::Set_Scaling(double Scale, double Offset)
386 {
387  m_pGrids[0]->Set_Scaling(Scale, Offset);
388 
389  for(int i=1; i<Get_Grid_Count(); i++)
390  {
391  m_pGrids[i]->Set_Scaling(Scale, Offset);
392  }
393 
394  Set_Update_Flag();
395 }
396 
397 //---------------------------------------------------------
398 bool CSG_Grids::Set_NoData_Value_Range(double loValue, double hiValue)
399 {
400  if( CSG_Data_Object::Set_NoData_Value_Range(loValue, hiValue) ) // this is a CSG_Data_Object base class property
401  {
402  m_pGrids[0]->Set_NoData_Value_Range(loValue, hiValue);
403 
404  for(int i=1; i<Get_Grid_Count(); i++)
405  {
406  m_pGrids[i]->Set_NoData_Value_Range(loValue, hiValue);
407  }
408 
409  return( true );
410  }
411 
412  return( false );
413 }
414 
415 //---------------------------------------------------------
416 void CSG_Grids::_Synchronize(CSG_Grid *pGrid)
417 {
418  if( !Get_Projection().is_Okay() && pGrid->Get_Projection().is_Okay() )
419  {
420  Get_Projection().Create(pGrid->Get_Projection());
421  }
422 
423  pGrid->Set_Owner(this);
424 
425  if( pGrid == m_pGrids[0] )
426  {
427  Set_Scaling(pGrid->Get_Scaling(), pGrid->Get_Offset());
428  Set_NoData_Value_Range(pGrid->Get_NoData_Value(), pGrid->Get_NoData_Value(true));
429  }
430  else // if( pGrid != m_pGrids[0] )
431  {
432  pGrid->Set_Scaling(Get_Scaling(), Get_Offset());
433  pGrid->Set_NoData_Value_Range(Get_NoData_Value(), Get_NoData_Value(true));
434  }
435 }
436 
437 
439 // //
440 // Checks //
441 // //
443 
444 //---------------------------------------------------------
445 bool CSG_Grids::is_Valid(void) const
446 {
447  return( Get_System().is_Valid() );
448 }
449 
450 //---------------------------------------------------------
451 bool CSG_Grids::is_Compatible(CSG_Grid *pGrid) const
452 {
453  return( pGrid && is_Compatible(pGrid->Get_System()) && Get_Type() == pGrid->Get_Type() );
454 }
455 
456 bool CSG_Grids::is_Compatible(CSG_Grids *pGrids) const
457 {
458  return( pGrids && is_Compatible(pGrids->Get_System()) && Get_NZ() == pGrids->Get_NZ() );//&& Get_Type() == pGrids->Get_Type() );
459 }
460 
461 bool CSG_Grids::is_Compatible(const CSG_Grid_System &System) const
462 {
463  return( Get_System() == System );
464 }
465 
466 bool CSG_Grids::is_Compatible(int NX, int NY, double Cellsize, double xMin, double yMin) const
467 {
468  return( is_Compatible(CSG_Grid_System(Cellsize, xMin, yMin, NX, NY)) );
469 }
470 
471 
473 // //
474 // Attributes //
475 // //
477 
478 //---------------------------------------------------------
479 bool CSG_Grids::Set_Z_Attribute(int i)
480 {
481  if( i >= 0 && i < m_Attributes.Get_Field_Count() )
482  {
483  m_Z_Attribute = i;
484 
485  return( Update_Z_Order() );
486  }
487 
488  return( false );
489 }
490 
491 //---------------------------------------------------------
492 bool CSG_Grids::Set_Z_Name_Field(int i)
493 {
494  if( i >= 0 && i < m_Attributes.Get_Field_Count() )
495  {
496  m_Z_Name = i;
497 
498  return( true );
499  }
500 
501  return( false );
502 }
503 
504 int CSG_Grids::Get_Z_Name_Field(void) const
505 {
506  return( m_Z_Name >= 0 && m_Z_Name < m_Attributes.Get_Field_Count() ? m_Z_Name : m_Z_Attribute );
507 }
508 
509 //---------------------------------------------------------
510 bool CSG_Grids::Add_Attribute(const char *Name, TSG_Data_Type Type, int Insert) { return( Add_Attribute(CSG_String(Name), Type, Insert) ); }
511 bool CSG_Grids::Add_Attribute(const wchar_t *Name, TSG_Data_Type Type, int Insert) { return( Add_Attribute(CSG_String(Name), Type, Insert) ); }
512 bool CSG_Grids::Add_Attribute(const CSG_String &Name, TSG_Data_Type Type, int Insert)
513 {
514  return( m_Attributes.Add_Field(Name, Type, Insert) );
515 }
516 
517 //---------------------------------------------------------
518 bool CSG_Grids::Del_Attribute(int i)
519 {
520  if( i != m_Z_Attribute && m_Attributes.Get_Field_Count() > 0 && m_Attributes.Del_Field(i) )
521  {
522  if( m_Z_Attribute > i )
523  {
524  m_Z_Attribute--;
525  }
526 
527  if( m_Z_Name > i )
528  {
529  m_Z_Name--;
530  }
531  else if( m_Z_Name == i )
532  {
533  m_Z_Name = -1; // same as m_Z_Attribute
534  }
535 
536  return( true );
537  }
538 
539  return( false );
540 }
541 
542 //---------------------------------------------------------
543 bool CSG_Grids::Set_Attribute(int i, const char *Field, const char *Value) { return( Set_Attribute(i, m_Attributes.Get_Field(Field), CSG_String(Value)) ); }
544 bool CSG_Grids::Set_Attribute(int i, const wchar_t *Field, const wchar_t *Value) { return( Set_Attribute(i, m_Attributes.Get_Field(Field), CSG_String(Value)) ); }
545 bool CSG_Grids::Set_Attribute(int i, const CSG_String &Field, const CSG_String &Value) { return( Set_Attribute(i, m_Attributes.Get_Field(Field), Value ) ); }
546 bool CSG_Grids::Set_Attribute(int i, int Field, const CSG_String &Value)
547 {
548  return( i >= 0 && i < (int)m_Attributes.Get_Count() && m_Attributes[i].Set_Value(Field, Value) );
549 }
550 
551 //---------------------------------------------------------
552 bool CSG_Grids::Set_Attribute(int i, const char *Field, double Value) { return( Set_Attribute(i, m_Attributes.Get_Field(Field), Value) ); }
553 bool CSG_Grids::Set_Attribute(int i, const wchar_t *Field, double Value) { return( Set_Attribute(i, m_Attributes.Get_Field(Field), Value) ); }
554 bool CSG_Grids::Set_Attribute(int i, const CSG_String &Field, double Value) { return( Set_Attribute(i, m_Attributes.Get_Field(Field), Value) ); }
555 bool CSG_Grids::Set_Attribute(int i, int Field, double Value)
556 {
557  return( i >= 0 && i < (int)m_Attributes.Get_Count() && m_Attributes[i].Set_Value(Field, Value) );
558 }
559 
560 //---------------------------------------------------------
561 bool CSG_Grids::Set_Z(int i, double Value)
562 {
563  return( i >= 0 && i < Get_NZ() && m_Attributes[i].Set_Value(m_Z_Attribute, Value) );
564 }
565 
566 //---------------------------------------------------------
567 bool CSG_Grids::Update_Z_Order(void)
568 {
569  bool bChanged = false;
570 
571  CSG_Table Attributes(m_Attributes);
572 
573  if( Attributes.Set_Index(m_Z_Attribute, TABLE_INDEX_Ascending) )
574  {
575  CSG_Array_Pointer Grids; CSG_Grid **pGrids = (CSG_Grid **)Grids.Create(m_Grids);
576 
577  for(int i=0; i<Get_Grid_Count(); i++)
578  {
579  int Index = (int)Attributes[i].Get_Index();
580 
581  if( Index != i )
582  {
583  bChanged = true;
584 
585  m_pGrids[i] = pGrids[Index];
586 
587  m_Attributes[i].Assign(&Attributes[i]);
588  }
589  }
590 
591  for(int i=0; i<Get_Grid_Count(); i++)
592  {
593  pGrids[i]->Set_Name(Get_Grid_Name(i));
594  }
595  }
596 
597  return( bChanged );
598 }
599 
600 
602 // //
603 // //
604 // //
606 
607 //---------------------------------------------------------
608 bool CSG_Grids::Set_Grid_Count(int Count)
609 {
610  if( Count == Get_NZ() )
611  {
612  return( true );
613  }
614 
615  if( Count < 0 || !Get_System().is_Valid() ) // only allowed for initialized grid systems)
616  {
617  return( false );
618  }
619 
620  if( Count == 0 )
621  {
622  return( Del_Grids() );
623  }
624 
625  //-----------------------------------------------------
626  SG_FREE_SAFE(m_Index); // invalidate index
627 
628  if( Count < Get_NZ() )
629  {
630  for(int i=Count; i<Get_NZ(); i++)
631  {
632  delete(m_pGrids[i]);
633  }
634 
635  m_pGrids = (CSG_Grid **)m_Grids.Get_Array(Count);
636 
637  m_Attributes.Set_Count(Count);
638  }
639 
640  //-----------------------------------------------------
641  else if( Count > Get_NZ() )
642  {
643  double z = Get_ZMax();
644 
645  for(int i=Get_NZ(); i<=Count; i++, z+=Get_Cellsize())
646  {
647  if( !Add_Grid(z) )
648  {
649  return( false );
650  }
651  }
652  }
653 
654  return( true );
655 }
656 
657 
659 // //
661 
662 //---------------------------------------------------------
663 bool CSG_Grids::Add_Grid(double Z)
664 {
665  CSG_Table Attributes(&m_Attributes);
666 
667  Attributes.Add_Record();
668 
669  Attributes[0].Set_Value(m_Z_Attribute, Z);
670 
671  return( Add_Grid(Attributes[0]) );
672 }
673 
674 //---------------------------------------------------------
675 bool CSG_Grids::Add_Grid(double Z, CSG_Grid *pGrid, bool bAttach)
676 {
677  CSG_Table Attributes(&m_Attributes);
678 
679  Attributes.Add_Record();
680 
681  Attributes[0].Set_Value(m_Z_Attribute, Z);
682 
683  return( Add_Grid(Attributes[0], pGrid, bAttach) );
684 }
685 
686 //---------------------------------------------------------
687 bool CSG_Grids::Add_Grid(CSG_Table_Record &Attributes)
688 {
689  if( !Get_System().is_Valid() ) // only allowed for initialized grid systems
690  {
691  return( false );
692  }
693 
694  //-----------------------------------------------------
695  int n = Get_NZ();
696 
697  if( n < 1 ) // do some initializations
698  {
699  _Synchronize(m_pGrids[0]);
700  }
701  else // use dummy grid (m_pGrids[0] is always present)
702  {
703  CSG_Grid *pGrid = SG_Create_Grid(Get_System(), Get_Type());
704 
705  if( !pGrid )
706  {
707  return( false );
708  }
709 
710  m_pGrids = (CSG_Grid **)m_Grids.Get_Array(n + 1);
711  m_pGrids[n] = pGrid;
712 
713  _Synchronize(pGrid);
714  }
715 
716  //-----------------------------------------------------
717  m_Attributes.Add_Record(&Attributes);
718 
719  SG_FREE_SAFE(m_Index); // invalidate index
720 
721  Update_Z_Order();
722 
723  return( true );
724 }
725 
726 //---------------------------------------------------------
727 bool CSG_Grids::Add_Grid(CSG_Table_Record &Attributes, CSG_Grid *pGrid, bool bAttach)
728 {
729  if( !pGrid || !pGrid->is_Valid() )
730  {
731  return( false );
732  }
733 
734  if( Get_NZ() > 0 && !is_Compatible(pGrid) ) // not allowed
735  {
736  return( false );
737  }
738 
739  //-----------------------------------------------------
740  int n = Get_NZ();
741 
742  if( n > 0 )
743  {
744  if( !bAttach && (pGrid = SG_Create_Grid(*pGrid)) == NULL ) // get a copy
745  {
746  return( false );
747  }
748 
749  m_pGrids = (CSG_Grid **)m_Grids.Get_Array(n + 1);
750  m_pGrids[n] = pGrid;
751  }
752  else if( bAttach ) // if( n == 0 )
753  {
754  delete(m_pGrids[0]);
755 
756  m_pGrids[0] = pGrid; // simply replace dummy
757  }
758  else if( m_pGrids[0]->Create(*pGrid) ) // make dummy a copy of grid
759  {
760  pGrid = m_pGrids[0];
761  }
762  else
763  {
764  return( false );
765  }
766 
767  _Synchronize(pGrid);
768 
769  //-----------------------------------------------------
770  m_Attributes.Add_Record(&Attributes);
771 
772  if( !Get_Projection().is_Okay() && pGrid->Get_Projection().is_Okay() )
773  {
774  Get_Projection() = pGrid->Get_Projection();
775  }
776 
777  SG_FREE_SAFE(m_Index); // invalidate index
778 
779  Update_Z_Order();
780 
781  return( true );
782 }
783 
784 
786 // //
788 
789 //---------------------------------------------------------
790 bool CSG_Grids::Del_Grid(int i, bool bDetach)
791 {
792  if( m_Attributes.Del_Record(i) ) // Get_NZ() is now decreased by one
793  {
794  SG_FREE_SAFE(m_Index); // invalidate index
795 
796  if( Get_NZ() > 0 )
797  {
798  if( bDetach )
799  {
800  m_pGrids[i]->Set_Owner(NULL);
801  }
802  else
803  {
804  delete(m_pGrids[i]);
805  }
806 
807  for( ; i<Get_NZ(); i++)
808  {
809  m_pGrids[i] = m_pGrids[i + 1];
810  }
811 
812  m_pGrids = (CSG_Grid **)m_Grids.Get_Array(Get_NZ());
813  }
814  else if( bDetach ) // if( Get_NZ() == 0 )
815  {
816  m_pGrids[0]->Set_Owner(NULL);
817  m_pGrids[0] = SG_Create_Grid(*m_pGrids[0]); // needs a new dummy
818  m_pGrids[0]->Set_Owner(this);
819  }
820 
821  return( true );
822  }
823 
824  return( false );
825 }
826 
827 //---------------------------------------------------------
828 bool CSG_Grids::Del_Grids(bool bDetach)
829 {
830  SG_FREE_SAFE(m_Index); // invalidate index
831 
832  if( bDetach )
833  {
834  for(size_t i=0; i<m_Grids.Get_uSize(); i++)
835  {
836  if( m_pGrids[i]->Get_Owner() == this )
837  {
838  m_pGrids[i]->Set_Owner(NULL);
839  }
840  }
841 
842  m_pGrids[0] = SG_Create_Grid(*m_pGrids[0]); // needs a new dummy
843  m_pGrids[0]->Set_Owner(this);
844  }
845  else
846  {
847  for(size_t i=1; i<m_Grids.Get_uSize(); i++)
848  {
849  delete(m_pGrids[i]); // do not delete the dummy before deconstruction
850  }
851  }
852 
853  m_pGrids = (CSG_Grid **)m_Grids.Get_Array(1);
854 
855  m_Attributes.Del_Records();
856 
857  return( true );
858 }
859 
860 
862 // //
864 
865 //---------------------------------------------------------
866 CSG_String CSG_Grids::Get_Grid_Name(int i, int Style) const
867 {
868  CSG_String s;
869 
870  if( i >= 0 && i < Get_Grid_Count() )
871  {
872  if( Style == 0 )
873  {
874  Style = SG_GRIDS_NAME_OWNER|SG_GRIDS_NAME_GRID;
875  }
876 
877  if( (Style & SG_GRIDS_NAME_OWNER) != 0 )
878  {
879  s = CSG_String(Get_Name());
880  }
881 
882  if( (Style & SG_GRIDS_NAME_INDEX) != 0 )
883  {
884  if( !s.is_Empty() ) s += ".";
885 
886  s.Printf("%s %d", _TL("Band"), i + 1);
887  }
888 
889  if( (Style & SG_GRIDS_NAME_VALUE) != 0 )
890  {
891  if( !s.is_Empty() ) s += ".";
892 
893  s += SG_Get_String(Get_Z(i), -10);
894  }
895 
896  if( (Style & SG_GRIDS_NAME_GRID ) != 0 )
897  {
898  if( !s.is_Empty() ) s += ".";
899 
900  s += m_Attributes[i].asString(Get_Z_Name_Field());
901  }
902  }
903 
904  return( s );
905 }
906 
907 
909 // //
910 // //
911 // //
913 
914 //---------------------------------------------------------
915 void CSG_Grids::Assign_NoData(void)
916 {
917  for(int i=0; i<Get_Grid_Count(); i++)
918  {
919  m_pGrids[i]->Assign_NoData();
920  }
921 }
922 
923 //---------------------------------------------------------
924 bool CSG_Grids::Assign(double Value)
925 {
926  for(int i=0; i<Get_Grid_Count(); i++)
927  {
928  m_pGrids[i]->Assign(Value);
929  }
930 
931  return( true );
932 }
933 
934 //---------------------------------------------------------
935 bool CSG_Grids::Assign(CSG_Data_Object *pObject, bool bProgress)
936 {
937  if( pObject )
938  {
939  switch( pObject->Get_ObjectType() )
940  {
941  case SG_DATAOBJECT_TYPE_Grid :
942  for(int i=0; i<Get_Grid_Count() && (!bProgress || SG_UI_Process_Get_Okay()); i++)
943  {
944  if( !m_pGrids[i]->Assign(pObject->asGrid(), bProgress) )
945  {
946  return( false );
947  }
948  }
949 
950  return( true );
951 
952  case SG_DATAOBJECT_TYPE_Grids:
953  return( Assign(pObject->asGrids(), GRID_RESAMPLING_Undefined, bProgress) );
954 
955  default:
956  break;
957  }
958  }
959 
960  return( false );
961 }
962 
963 //---------------------------------------------------------
964 bool CSG_Grids::Assign(CSG_Grids *pGrids, TSG_Grid_Resampling Interpolation, bool bProgress)
965 {
966  if( pGrids && Get_Grid_Count() == pGrids->Get_Grid_Count() )
967  {
968  bool bResult = true;
969 
970  for(int i=0; i<Get_Grid_Count() && (!bProgress || SG_UI_Process_Get_Okay()); i++)
971  {
972  if( !m_pGrids[i]->Assign(pGrids->m_pGrids[i], Interpolation, bProgress) )
973  {
974  bResult = false;
975  }
976  }
977 
978  return( bResult );
979  }
980 
981  return( false );
982 }
983 
984 
986 // //
988 
989 //---------------------------------------------------------
990 CSG_Grids & CSG_Grids::operator = (const CSG_Grids &Grids)
991 {
992  Create(Grids); return( *this );
993 }
994 
995 CSG_Grids & CSG_Grids::operator = (double Value)
996 {
997  Assign(Value); return( *this );
998 }
999 
1000 //---------------------------------------------------------
1001 CSG_Grids & CSG_Grids::operator += (double Value)
1002 {
1003  return( Add(Value) );
1004 }
1005 
1006 CSG_Grids & CSG_Grids::Add(double Value)
1007 {
1008  for(int i=0; i<Get_Grid_Count(); i++)
1009  {
1010  m_pGrids[i]->Add(Value);
1011  }
1012 
1013  return( *this );
1014 }
1015 
1016 //---------------------------------------------------------
1017 CSG_Grids & CSG_Grids::operator -= (double Value)
1018 {
1019  return( Subtract(Value) );
1020 }
1021 
1022 CSG_Grids & CSG_Grids::Subtract(double Value)
1023 {
1024  for(int i=0; i<Get_Grid_Count(); i++)
1025  {
1026  m_pGrids[i]->Subtract(Value);
1027  }
1028 
1029  return( *this );
1030 }
1031 
1032 //---------------------------------------------------------
1033 CSG_Grids & CSG_Grids::operator *= (double Value)
1034 {
1035  return( Multiply(Value) );
1036 }
1037 
1038 CSG_Grids & CSG_Grids::Multiply(double Value)
1039 {
1040  for(int i=0; i<Get_Grid_Count(); i++)
1041  {
1042  m_pGrids[i]->Multiply(Value);
1043  }
1044 
1045  return( *this );
1046 }
1047 
1048 //---------------------------------------------------------
1049 CSG_Grids & CSG_Grids::operator /= (double Value)
1050 {
1051  return( Divide(Value) );
1052 }
1053 
1054 CSG_Grids & CSG_Grids::Divide(double Value)
1055 {
1056  for(int i=0; i<Get_Grid_Count(); i++)
1057  {
1058  m_pGrids[i]->Divide(Value);
1059  }
1060 
1061  return( *this );
1062 }
1063 
1064 
1066 // //
1067 // Value access by Position (-> Interpolation) //
1068 // //
1070 
1071 //---------------------------------------------------------
1072 double CSG_Grids::Get_Value(const TSG_Point_3D &p, TSG_Grid_Resampling Resampling, TSG_Grid_Resampling ZResampling) const
1073 {
1074  double Value;
1075 
1076  return( Get_Value(p.x, p.y, p.z, Value, Resampling, ZResampling) ? Value : Get_NoData_Value() );
1077 }
1078 
1079 double CSG_Grids::Get_Value(double x, double y, double z, TSG_Grid_Resampling Resampling, TSG_Grid_Resampling ZResampling) const
1080 {
1081  double Value;
1082 
1083  return( Get_Value(x, y, z, Value, Resampling, ZResampling) ? Value : Get_NoData_Value() );
1084 }
1085 
1086 bool CSG_Grids::Get_Value(const TSG_Point_3D &p, double &Value, TSG_Grid_Resampling Resampling, TSG_Grid_Resampling ZResampling) const
1087 {
1088  return( Get_Value(p.x, p.y, p.z, Value, Resampling, ZResampling) );
1089 }
1090 
1091 //---------------------------------------------------------
1092 bool CSG_Grids::Get_Value(double x, double y, double z, double &Value, TSG_Grid_Resampling Resampling, TSG_Grid_Resampling ZResampling) const
1093 {
1094  if( !Get_System().Get_Extent(true).Contains(x, y) )
1095  {
1096  return( false );
1097  }
1098 
1099  int iz; double dz;
1100 
1101  if( !_Get_Z(z, iz, dz) )
1102  {
1103  return( false );
1104  }
1105 
1106  if( dz == 0. )
1107  {
1108  return( m_pGrids[iz]->Get_Value(x, y, Value, Resampling) );
1109  }
1110 
1111  if( ZResampling == GRID_RESAMPLING_Undefined )
1112  {
1113  ZResampling = Resampling;
1114  }
1115 
1116  if( (ZResampling == GRID_RESAMPLING_BicubicSpline || ZResampling == GRID_RESAMPLING_BSpline)
1117  && (iz < 1 || iz >= m_Attributes.Get_Count() - 2) )
1118  {
1119  ZResampling = GRID_RESAMPLING_Bilinear;
1120  }
1121 
1122  switch( ZResampling )
1123  {
1124  case GRID_RESAMPLING_NearestNeighbour: default:
1125  return( m_pGrids[dz < 0.5 ? iz : iz + 1]->Get_Value(x, y, Value, Resampling) );
1126 
1127  case GRID_RESAMPLING_Bilinear:
1128  {
1129  double v[2];
1130 
1131  if( m_pGrids[iz ]->Get_Value(x, y, v[0], Resampling)
1132  && m_pGrids[iz + 1]->Get_Value(x, y, v[1], Resampling) )
1133  {
1134  Value = v[0] + dz * (v[1] - v[0]);
1135 
1136  return( true );
1137  }
1138 
1139  return( false );
1140  }
1141 
1142  case GRID_RESAMPLING_BicubicSpline:
1143  case GRID_RESAMPLING_BSpline:
1144  {
1145  CSG_Spline s;
1146 
1147  #define ADD_TO_SPLINE(i) if( i < 0 || i >= Get_NZ() || !m_pGrids[i]->Get_Value(x, y, Value, Resampling) ) return( false ); s.Add(Get_Z(i), Value);
1148 
1149  ADD_TO_SPLINE(iz - 1);
1150  ADD_TO_SPLINE(iz );
1151  ADD_TO_SPLINE(iz + 1);
1152  ADD_TO_SPLINE(iz + 2);
1153 
1154  return( s.Get_Value(z, Value) );
1155  }
1156  break;
1157  }
1158 
1159  return( false );
1160 }
1161 
1162 //---------------------------------------------------------
1163 bool CSG_Grids::_Get_Z(double z, int &iz, double &dz) const
1164 {
1165  if( z < m_Attributes[0 ].asDouble(m_Z_Attribute)
1166  || z > m_Attributes[m_Attributes.Get_Count() - 1].asDouble(m_Z_Attribute) )
1167  {
1168  return( false );
1169  }
1170 
1171  double z0, z1 = m_Attributes[0].asDouble(m_Z_Attribute);
1172 
1173  for(iz=0; iz<m_Attributes.Get_Count()-1; iz++)
1174  {
1175  z0 = z1; z1 = m_Attributes[iz + 1].asDouble(m_Z_Attribute);
1176 
1177  if( z < z1 )
1178  {
1179  dz = z0 < z1 ? (z - z0) / (z1 - z0) : 0.;
1180 
1181  return( true );
1182  }
1183  }
1184 
1185  return( (dz = z - z1) == 0. );
1186 }
1187 
1188 
1190 // //
1191 // Index //
1192 // //
1194 
1195 //---------------------------------------------------------
1196 #define SORT_SWAP(a,b) {itemp=(a);(a)=(b);(b)=itemp;}
1197 
1198 bool CSG_Grids::_Set_Index(void)
1199 {
1200  //-----------------------------------------------------
1201  if( m_Index == NULL && (m_Index = (sLong *)SG_Malloc((size_t)Get_NCells() * sizeof(sLong))) == NULL )
1202  {
1203  SG_UI_Msg_Add_Error(_TL("could not create index: insufficient memory"));
1204 
1205  return( false );
1206  }
1207 
1208  //-----------------------------------------------------
1209  const sLong M = 7;
1210 
1211  sLong i, j, k, l, ir, n, *istack, jstack, nstack, indxt, itemp, nData;
1212  double a;
1213 
1214  //-----------------------------------------------------
1215  SG_UI_Process_Set_Text(CSG_String::Format("%s: %s", _TL("Create index"), Get_Name()));
1216 
1217  for(i=0, j=0, nData=Get_NCells(); i<Get_NCells(); i++)
1218  {
1219  if( is_NoData(i) )
1220  {
1221  m_Index[--nData] = i;
1222  }
1223  else // if( !is_NoData(i) )
1224  {
1225  m_Index[j++] = i;
1226  }
1227  }
1228 
1229  //-----------------------------------------------------
1230  l = 0;
1231  n = 0;
1232  ir = nData - 1;
1233 
1234  nstack = 64;
1235  istack = (sLong *)SG_Malloc((size_t)nstack * sizeof(sLong));
1236  jstack = 0;
1237 
1238  for(;;)
1239  {
1240  if( ir - l < M )
1241  {
1242  if( !SG_UI_Process_Set_Progress((double)(n += M - 1), (double)nData) )
1243  {
1244  SG_FREE_SAFE(istack);
1245  SG_FREE_SAFE(m_Index);
1246 
1247  SG_UI_Msg_Add_Error(_TL("index creation stopped by user"));
1248  SG_UI_Process_Set_Ready();
1249 
1250  return( false );
1251  }
1252 
1253  for(j=l+1; j<=ir; j++)
1254  {
1255  indxt = m_Index[j];
1256  a = asDouble(indxt);
1257 
1258  for(i=j-1; i>=0; i--)
1259  {
1260  if( asDouble(m_Index[i]) <= a )
1261  {
1262  break;
1263  }
1264 
1265  m_Index[i + 1] = m_Index[i];
1266  }
1267 
1268  m_Index[i + 1] = indxt;
1269  }
1270 
1271  if( jstack == 0 )
1272  {
1273  break;
1274  }
1275 
1276  ir = istack[jstack--];
1277  l = istack[jstack--];
1278  }
1279 
1280  //-------------------------------------------------
1281  else
1282  {
1283  k = (l + ir) >> 1;
1284 
1285  SORT_SWAP(m_Index[k], m_Index[l + 1]);
1286 
1287  if( asDouble( m_Index[l + 1]) > asDouble(m_Index[ir]) )
1288  SORT_SWAP(m_Index[l + 1], m_Index[ir]);
1289 
1290  if( asDouble( m_Index[l ]) > asDouble(m_Index[ir]) )
1291  SORT_SWAP(m_Index[l ], m_Index[ir]);
1292 
1293  if( asDouble( m_Index[l + 1]) > asDouble(m_Index[l ]) )
1294  SORT_SWAP(m_Index[l + 1], m_Index[l ]);
1295 
1296  i = l + 1;
1297  j = ir;
1298  indxt = m_Index[l];
1299  a = asDouble(indxt);
1300 
1301  for(;;)
1302  {
1303  do i++; while(asDouble(m_Index[i]) < a);
1304  do j--; while(asDouble(m_Index[j]) > a);
1305 
1306  if( j < i )
1307  {
1308  break;
1309  }
1310 
1311  SORT_SWAP(m_Index[i], m_Index[j]);
1312  }
1313 
1314  m_Index[l] = m_Index[j];
1315  m_Index[j] = indxt;
1316  jstack += 2;
1317 
1318  if( jstack >= nstack )
1319  {
1320  nstack += 64;
1321  istack = (sLong *)SG_Realloc(istack, (size_t)nstack * sizeof(int));
1322  }
1323 
1324  if( ir - i + 1 >= j - l )
1325  {
1326  istack[jstack] = ir;
1327  istack[jstack - 1] = i;
1328  ir = j - 1;
1329  }
1330  else
1331  {
1332  istack[jstack] = j - 1;
1333  istack[jstack - 1] = l;
1334  l = i;
1335  }
1336  }
1337  }
1338 
1339  //-----------------------------------------------------
1340  SG_Free(istack);
1341 
1342  SG_UI_Process_Set_Ready();
1343 
1344  return( true );
1345 }
1346 #undef SORT_SWAP
1347 
1348 
1350 // //
1351 // Statistics //
1352 // //
1354 
1355 //---------------------------------------------------------
1356 bool CSG_Grids::On_Update(void)
1357 {
1358  if( is_Valid() )
1359  {
1360  SG_FREE_SAFE(m_Index);
1361 
1362  m_Statistics.Invalidate();
1363  m_Histogram.Destroy();
1364 
1365  double Offset = Get_Offset(), Scaling = is_Scaled() ? Get_Scaling() : 0.;
1366 
1367  if( Get_Max_Samples() > 0 && Get_Max_Samples() < Get_NCells() )
1368  {
1369  double d = (double)Get_NCells() / (double)Get_Max_Samples();
1370 
1371  for(double i=0; i<(double)Get_NCells(); i+=d)
1372  {
1373  double Value = asDouble((sLong)i, false);
1374 
1375  if( !is_NoData_Value(Value) )
1376  {
1377  m_Statistics += Scaling ? Offset + Scaling * Value : Value;
1378  }
1379  }
1380 
1381  m_Statistics.Set_Count(m_Statistics.Get_Count() >= Get_Max_Samples() ? Get_NCells() // any no-data cells ?
1382  : (sLong)(Get_NCells() * (double)m_Statistics.Get_Count() / (double)Get_Max_Samples())
1383  );
1384  }
1385  else
1386  {
1387  for(sLong i=0; i<Get_NCells(); i++)
1388  {
1389  double Value = asDouble(i, false);
1390 
1391  if( !is_NoData_Value(Value) )
1392  {
1393  m_Statistics += Scaling ? Offset + Scaling * Value : Value;
1394  }
1395  }
1396  }
1397  }
1398 
1399  return( true );
1400 }
1401 
1402 //---------------------------------------------------------
1403 double CSG_Grids::Get_Mean(void)
1404 {
1405  Update(); return( m_Statistics.Get_Mean() );
1406 }
1407 
1408 double CSG_Grids::Get_Min(void)
1409 {
1410  Update(); return( m_Statistics.Get_Minimum() );
1411 }
1412 
1413 double CSG_Grids::Get_Max(void)
1414 {
1415  Update(); return( m_Statistics.Get_Maximum() );
1416 }
1417 
1418 double CSG_Grids::Get_Range(void)
1419 {
1420  Update(); return( m_Statistics.Get_Range() );
1421 }
1422 
1423 double CSG_Grids::Get_StdDev(void)
1424 {
1425  Update(); return( m_Statistics.Get_StdDev() );
1426 }
1427 
1428 double CSG_Grids::Get_Variance(void)
1429 {
1430  Update(); return( m_Statistics.Get_Variance() );
1431 }
1432 
1433 //---------------------------------------------------------
1434 sLong CSG_Grids::Get_Data_Count(void)
1435 {
1436  Update(); return( m_Statistics.Get_Count() );
1437 }
1438 
1439 sLong CSG_Grids::Get_NoData_Count(void)
1440 {
1441  Update(); return( Get_NCells() - m_Statistics.Get_Count() );
1442 }
1443 
1444 //---------------------------------------------------------
1445 double CSG_Grids::Get_Quantile(double Quantile, bool bFromHistogram)
1446 {
1447  if( Quantile <= 0. ) { return( Get_Min() ); }
1448  if( Quantile >= 1. ) { return( Get_Max() ); }
1449 
1450  if( bFromHistogram )
1451  {
1452  return( Get_Histogram().Get_Quantile(Quantile) );
1453  }
1454  else
1455  {
1456  sLong n = (sLong)(Quantile * (Get_Data_Count() - 1));
1457 
1458  if( Get_Sorted(n, n, false) )
1459  {
1460  return( asDouble(n) );
1461  }
1462  }
1463 
1464  return( Get_NoData_Value() );
1465 }
1466 
1467 //---------------------------------------------------------
1468 double CSG_Grids::Get_Percentile(double Percentile, bool bFromHistogram)
1469 {
1470  return( Get_Quantile(0.01 * Percentile, bFromHistogram) );
1471 }
1472 
1473 
1475 // //
1477 
1478 //---------------------------------------------------------
1485 const CSG_Simple_Statistics & CSG_Grids::Get_Statistics(void)
1486 {
1487  Update(); return( m_Statistics );
1488 }
1489 
1490 //---------------------------------------------------------
1496 //---------------------------------------------------------
1497 bool CSG_Grids::Get_Statistics(const CSG_Rect &rWorld, CSG_Simple_Statistics &Statistics, bool bHoldValues) const
1498 {
1499  int xMin = Get_System().Get_xWorld_to_Grid(rWorld.Get_XMin()); if( xMin < 0 ) xMin = 0;
1500  int yMin = Get_System().Get_yWorld_to_Grid(rWorld.Get_YMin()); if( yMin < 0 ) yMin = 0;
1501  int xMax = Get_System().Get_xWorld_to_Grid(rWorld.Get_XMax()); if( xMax >= Get_NX() ) xMax = Get_NX() - 1;
1502  int yMax = Get_System().Get_yWorld_to_Grid(rWorld.Get_YMax()); if( yMax >= Get_NY() ) yMax = Get_NY() - 1;
1503 
1504  if( xMin > xMax || yMin > yMax )
1505  {
1506  return( false ); // no overlap
1507  }
1508 
1509  Statistics.Create(bHoldValues);
1510 
1511  int nx = 1 + (xMax - xMin);
1512  int ny = 1 + (yMax - yMin);
1513  sLong nCells = nx * ny;
1514 
1515  double Offset = Get_Offset(), Scaling = is_Scaled() ? Get_Scaling() : 0.;
1516 
1517  if( Get_Max_Samples() > 0 && Get_Max_Samples() < nCells )
1518  {
1519  double d = (double)nCells / (double)Get_Max_Samples();
1520 
1521  for(double i=0; i<(double)nCells; i+=d)
1522  {
1523  int y = yMin + (int)i / nx;
1524  int x = xMin + (int)i % nx;
1525 
1526  for(int z=0; z<Get_NZ(); z++)
1527  {
1528  double Value = asDouble(x, y, z, false);
1529 
1530  if( !is_NoData_Value(Value) )
1531  {
1532  Statistics += Scaling ? Offset + Scaling * Value : Value;
1533  }
1534  }
1535  }
1536  }
1537  else
1538  {
1539  for(int x=xMin; x<=xMax; x++)
1540  {
1541  for(int y=yMin; y<=yMax; y++)
1542  {
1543  for(int z=0; z<Get_NZ(); z++)
1544  {
1545  double Value = asDouble(x, y, z, false);
1546 
1547  if( !is_NoData_Value(Value) )
1548  {
1549  Statistics += Scaling ? Offset + Scaling * Value : Value;
1550  }
1551  }
1552  }
1553  }
1554  }
1555 
1556  return( Statistics.Get_Count() > 0 );
1557 }
1558 
1559 //---------------------------------------------------------
1560 bool CSG_Grids::Set_Max_Samples(sLong Max_Samples)
1561 {
1562  if( CSG_Data_Object::Set_Max_Samples(Max_Samples) )
1563  {
1564  for(int i=0; i<Get_Grid_Count(); i++)
1565  {
1566  Get_Grid_Ptr(i)->Set_Max_Samples(Max_Samples);
1567  }
1568 
1569  return( true );
1570  }
1571 
1572  return( false );
1573 }
1574 
1575 //---------------------------------------------------------
1576 #define SG_GRID_HISTOGRAM_CLASSES_DEFAULT 255
1577 
1578 //---------------------------------------------------------
1583 const CSG_Histogram & CSG_Grids::Get_Histogram(size_t nClasses)
1584 {
1585  Update();
1586 
1587  if( nClasses > 1 && nClasses != m_Histogram.Get_Class_Count() )
1588  {
1589  m_Histogram.Destroy();
1590  }
1591 
1592  if( m_Histogram.Get_Statistics().Get_Count() < 1 )
1593  {
1594  m_Histogram.Create(nClasses > 1 ? nClasses : SG_GRID_HISTOGRAM_CLASSES_DEFAULT, Get_Min(), Get_Max(), this, (size_t)Get_Max_Samples());
1595  }
1596 
1597  return( m_Histogram );
1598 }
1599 
1600 //---------------------------------------------------------
1601 bool CSG_Grids::Get_Histogram(const CSG_Rect &rWorld, CSG_Histogram &Histogram, size_t nClasses) const
1602 {
1603  CSG_Simple_Statistics Statistics;
1604 
1605  if( !Get_Statistics(rWorld, Statistics) )
1606  {
1607  return( false );
1608  }
1609 
1610  int xMin = Get_System().Get_xWorld_to_Grid(rWorld.Get_XMin()); if( xMin < 0 ) xMin = 0;
1611  int yMin = Get_System().Get_yWorld_to_Grid(rWorld.Get_YMin()); if( yMin < 0 ) yMin = 0;
1612  int xMax = Get_System().Get_xWorld_to_Grid(rWorld.Get_XMax()); if( xMax >= Get_NX() ) xMax = Get_NX() - 1;
1613  int yMax = Get_System().Get_yWorld_to_Grid(rWorld.Get_YMax()); if( yMax >= Get_NY() ) yMax = Get_NY() - 1;
1614 
1615  if( xMin > xMax || yMin > yMax )
1616  {
1617  return( false ); // no overlap
1618  }
1619 
1620  Histogram.Create(nClasses > 1 ? nClasses : SG_GRID_HISTOGRAM_CLASSES_DEFAULT, Statistics.Get_Minimum(), Statistics.Get_Maximum());
1621 
1622  int nx = 1 + (xMax - xMin);
1623  int ny = 1 + (yMax - yMin);
1624  sLong nCells = nx * ny;
1625 
1626  double Offset = Get_Offset(), Scaling = is_Scaled() ? Get_Scaling() : 0.;
1627 
1628  if( Get_Max_Samples() > 0 && Get_Max_Samples() < nCells )
1629  {
1630  double d = (double)nCells / (double)Get_Max_Samples();
1631 
1632  for(double i=0; i<(double)nCells; i+=d)
1633  {
1634  int y = yMin + (int)i / nx;
1635  int x = xMin + (int)i % nx;
1636 
1637  for(int z=0; z<Get_NZ(); z++)
1638  {
1639  double Value = asDouble(x, y, z, false);
1640 
1641  if( !is_NoData_Value(Value) )
1642  {
1643  Histogram += Scaling ? Offset + Scaling * Value : Value;
1644  }
1645  }
1646  }
1647  }
1648  else
1649  {
1650  for(int x=xMin; x<=xMax; x++)
1651  {
1652  for(int y=yMin; y<=yMax; y++)
1653  {
1654  for(int z=0; z<Get_NZ(); z++)
1655  {
1656  double Value = asDouble(x, y, z, false);
1657 
1658  if( !is_NoData_Value(Value) )
1659  {
1660  Histogram += Scaling ? Offset + Scaling * Value : Value;
1661  }
1662  }
1663  }
1664  }
1665  }
1666 
1667  return( Histogram.Update() );
1668 }
1669 
1670 
1672 // //
1673 // //
1674 // //
1676 
1677 //---------------------------------------------------------
1678 bool CSG_Grids::On_Reload(void)
1679 {
1680  return( Create(Get_File_Name(false)) );
1681 }
1682 
1683 //---------------------------------------------------------
1684 bool CSG_Grids::On_Delete(void)
1685 {
1686  CSG_String File = Get_File_Name(true);
1687 
1688  SG_File_Set_Extension(File, "sg-gds-z"); SG_File_Delete(File);
1689  SG_File_Set_Extension(File, "sg-gds" ); SG_File_Delete(File);
1690  SG_File_Set_Extension(File, "sg-info" ); SG_File_Delete(File);
1691  SG_File_Set_Extension(File, "sg-prj" ); SG_File_Delete(File);
1692 
1693  int i = 0;
1694 
1695  do
1696  {
1697  SG_File_Set_Extension(File, CSG_String::Format("sg-%03d", ++i));
1698  }
1699  while( SG_File_Delete(File) );
1700 
1701  return( true );
1702 }
1703 
1704 
1706 // //
1708 
1709 //---------------------------------------------------------
1710 bool CSG_Grids::Load(const CSG_String &File, bool bLoadData)
1711 {
1712  Destroy();
1713 
1714  SG_UI_Msg_Add(CSG_String::Format("%s: %s...", _TL("Loading grid collection"), File.c_str()), true);
1715 
1716  if( _Load_PGSQL (File)
1717  || _Load_Normal (File)
1718  || _Load_Compressed(File)
1719  || _Load_External (File) )
1720  {
1721  Set_Modified(false);
1722 
1723  Set_Name(SG_File_Get_Name(File, false));
1724 
1725  SG_UI_Process_Set_Ready();
1726  SG_UI_Msg_Add(_TL("okay"), false, SG_UI_MSG_STYLE_SUCCESS);
1727 
1728  return( true );
1729  }
1730 
1731  SG_UI_Process_Set_Ready();
1732  SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
1733 
1734  return( false );
1735 }
1736 
1737 //---------------------------------------------------------
1738 bool CSG_Grids::Save(const CSG_String &File, int Format)
1739 {
1740  if( File.is_Empty() )
1741  {
1742  return( *Get_File_Name(false) ? Save(Get_File_Name(false), Format) : false );
1743  }
1744 
1745  SG_UI_Msg_Add(CSG_String::Format("%s %s: %s...", _TL("Saving"), _TL("grid collection"), File.c_str()), true);
1746 
1747  if( Format == GRIDS_FILE_FORMAT_Undefined )
1748  {
1749  Format = GRIDS_FILE_FORMAT_Compressed; // default
1750 
1751  if( SG_File_Cmp_Extension(File, "sg-gds" ) ) Format = GRIDS_FILE_FORMAT_Normal ;
1752  if( SG_File_Cmp_Extension(File, "sg-gds-z") ) Format = GRIDS_FILE_FORMAT_Compressed;
1753  if( SG_File_Cmp_Extension(File, "tif" ) ) Format = GRIDS_FILE_FORMAT_GeoTIFF ;
1754  }
1755 
1756  bool bResult = false;
1757 
1758  switch( Format )
1759  {
1760  case GRIDS_FILE_FORMAT_Normal :
1761  bResult = _Save_Normal (File);
1762  break;
1763 
1764  case GRIDS_FILE_FORMAT_Compressed: default:
1765  bResult = _Save_Compressed(File);
1766  break;
1767 
1768  case GRIDS_FILE_FORMAT_GeoTIFF :
1769  SG_RUN_TOOL(bResult, "io_gdal", 2, // Export GeoTIFF
1770  SG_TOOL_PARAMLIST_ADD("GRIDS", this)
1771  && SG_TOOL_PARAMETER_SET("FILE" , File)
1772  );
1773  break;
1774  }
1775 
1776  //-----------------------------------------------------
1777  SG_UI_Process_Set_Ready();
1778 
1779  if( bResult )
1780  {
1781  Set_Modified(false);
1782 
1783  Set_File_Name(File, true);
1784 
1785  SG_UI_Msg_Add(_TL("okay"), false, SG_UI_MSG_STYLE_SUCCESS);
1786 
1787  return( true );
1788  }
1789 
1790  SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
1791 
1792  return( false );
1793 }
1794 
1795 
1797 // //
1799 
1800 //---------------------------------------------------------
1801 bool CSG_Grids::_Load_External(const CSG_String &File)
1802 {
1803  bool bResult = false; CSG_Data_Manager Manager;
1804 
1805  CSG_Tool *pTool = SG_Get_Tool_Library_Manager().Create_Tool("io_gdal", 0); // import raster
1806 
1807  SG_UI_Msg_Lock(true);
1808 
1809  if( pTool && pTool->On_Before_Execution() && pTool->Settings_Push(&Manager)
1810  && pTool->Set_Parameter("FILES" , File)
1811  && pTool->Set_Parameter("MULTIPLE", 1 ) // output as grid collection
1812  && pTool->Execute()
1813  && Manager.Grids().Count() && Manager.Grids(0).is_Valid() )
1814  {
1815  CSG_Grids *pGrids = Manager.Grids(0).asGrids();
1816 
1817  m_Attributes.Create(&pGrids->m_Attributes);
1818 
1819  for(int i=0; i<pGrids->Get_Grid_Count(); i++)
1820  {
1821  Add_Grid(pGrids->Get_Attributes(i), pGrids->Get_Grid_Ptr(i), true);
1822  }
1823 
1824  Set_File_Name(File, false);
1825 
1826  Set_Name (pGrids->Get_Name ());
1827  Set_Description (pGrids->Get_Description ());
1828  Set_Z_Attribute (pGrids->Get_Z_Attribute ());
1829  Set_Z_Name_Field(pGrids->Get_Z_Name_Field());
1830 
1831  pGrids->Del_Grids(true);
1832 
1833  bResult = true;
1834  }
1835 
1836  SG_UI_Msg_Lock(false);
1837 
1838  SG_Get_Tool_Library_Manager().Delete_Tool(pTool);
1839 
1840  return( bResult );
1841 }
1842 
1843 //---------------------------------------------------------
1844 bool CSG_Grids::_Load_PGSQL(const CSG_String &File)
1845 {
1846  bool bResult = false;
1847 
1848  if( File.BeforeFirst(':').Cmp("PGSQL") == 0 ) // database source
1849  {
1850  CSG_String s(File);
1851 
1852  s = s.AfterFirst(':'); CSG_String Host (s.BeforeFirst(':'));
1853  s = s.AfterFirst(':'); CSG_String Port (s.BeforeFirst(':'));
1854  s = s.AfterFirst(':'); CSG_String DBase(s.BeforeFirst(':'));
1855  s = s.AfterFirst(':'); CSG_String Table(s.BeforeFirst(':'));
1856  s = s.AfterFirst(':'); CSG_String rid (s.BeforeFirst(':').AfterFirst('='));
1857 
1858  //-------------------------------------------------
1859  CSG_Strings rids(SG_String_Tokenize(rid, ",")); rid.Clear();
1860 
1861  for(int i=0; i<rids.Get_Count(); i++)
1862  {
1863  if( !rid.is_Empty() )
1864  {
1865  rid += " OR ";
1866  }
1867 
1868  rid += "rid=\'" + rids[i] + "\'";
1869  }
1870 
1871  //-------------------------------------------------
1872  CSG_Tool *pTool = SG_Get_Tool_Library_Manager().Create_Tool("db_pgsql", 30); // CPGIS_Raster_Load
1873 
1874  if( pTool )
1875  {
1876  SG_UI_ProgressAndMsg_Lock(true);
1877 
1878  CSG_String Connection(DBase + " [" + Host + ":" + Port + "]"); CSG_Data_Manager Manager;
1879 
1880  bResult = pTool->Settings_Push(&Manager) && pTool->On_Before_Execution()
1881  && pTool->Set_Parameter("CONNECTION", Connection)
1882  && pTool->Set_Parameter("DB_TABLE" , Table )
1883  && pTool->Set_Parameter("WHERE" , rid )
1884  && pTool->Set_Parameter("MULTIPLE" , 1 ) // grid collection
1885  && pTool->Execute();
1886 
1887  SG_Get_Tool_Library_Manager().Delete_Tool(pTool);
1888 
1889  //-----------------------------------------
1890  if( Manager.Grids().Count() && Manager.Grids(0).is_Valid() )
1891  {
1892  CSG_Grids *pGrids = Manager.Grids(0).asGrids();
1893 
1894  Set_File_Name(File);
1895 
1896  Create(pGrids);
1897 
1898  for(int i=0; i<pGrids->Get_Grid_Count(); i++)
1899  {
1900  Add_Grid(pGrids->Get_Attributes(i), pGrids->Get_Grid_Ptr(i), true);
1901  }
1902 
1903  pGrids->Del_Grids(true);
1904 
1905  bResult = Get_NZ() > 0;
1906  }
1907 
1908  SG_UI_ProgressAndMsg_Lock(false);
1909  }
1910  }
1911 
1912  return( bResult );
1913 }
1914 
1915 
1917 // //
1919 
1920 //---------------------------------------------------------
1921 bool CSG_Grids::_Load_Normal(const CSG_String &_File)
1922 {
1923  if( !SG_File_Cmp_Extension(_File, "sg-gds") ) // GRIDS_FILETYPE_Normal
1924  {
1925  return( false );
1926  }
1927 
1928  CSG_String File(_File); CSG_File Stream;
1929 
1930  //-----------------------------------------------------
1931  if( !Stream.Open(File, SG_FILE_R, false) || !_Load_Header(Stream) )
1932  {
1933  return( false );
1934  }
1935 
1936  SG_File_Set_Extension(File, "sg-att");
1937 
1938  if( m_Attributes.Get_Count() <= 0 ) // <<< DEPRECATED
1939  if( !Stream.Open(File, SG_FILE_R, false) || !_Load_Attributes(Stream) )
1940  {
1941  return( false );
1942  }
1943 
1944  //-----------------------------------------------------
1945  for(int i=0; i<Get_NZ() && SG_UI_Process_Set_Progress(i, Get_NZ()); i++)
1946  {
1947  SG_File_Set_Extension(File, CSG_String::Format("sg-%03d", i + 1));
1948 
1949  if( !Stream.Open(File, SG_FILE_R, true) || !_Load_Data(Stream, m_pGrids[i]) )
1950  {
1951  return( false );
1952  }
1953  }
1954 
1955  //-----------------------------------------------------
1956  Set_File_Name(_File, true);
1957 
1958  Load_MetaData(File);
1959 
1960  Get_Projection().Load(SG_File_Make_Path("", File, "sg-prj"));
1961 
1962  return( true );
1963 }
1964 
1965 //---------------------------------------------------------
1966 bool CSG_Grids::_Save_Normal(const CSG_String &_File)
1967 {
1968  CSG_String File(_File); CSG_File Stream;
1969 
1970  //-----------------------------------------------------
1971  SG_File_Set_Extension(File, "sg-gds");
1972 
1973  if( !Stream.Open(File, SG_FILE_W, false) || !_Save_Header(Stream) )
1974  {
1975  return( false );
1976  }
1977 
1978  SG_File_Set_Extension(File, "sg-att");
1979 
1980  if( !Stream.Open(File, SG_FILE_W, false) || !_Save_Attributes(Stream) )
1981  {
1982  return( false );
1983  }
1984 
1985  //-----------------------------------------------------
1986  for(int i=0; i<Get_NZ() && SG_UI_Process_Set_Progress(i, Get_NZ()); i++)
1987  {
1988  SG_File_Set_Extension(File, CSG_String::Format("sg-%03d", i + 1));
1989 
1990  if( !Stream.Open(File, SG_FILE_W, true) || !_Save_Data(Stream, m_pGrids[i]) )
1991  {
1992  return( false );
1993  }
1994  }
1995 
1996  //-----------------------------------------------------
1997  Save_MetaData(File);
1998 
1999  Get_Projection().Save(SG_File_Make_Path("", File, "sg-prj"));
2000 
2001  return( true );
2002 }
2003 
2004 
2006 // //
2008 
2009 //---------------------------------------------------------
2010 bool CSG_Grids::_Load_Compressed(const CSG_String &_File)
2011 {
2012  if( !SG_File_Cmp_Extension(_File, "sg-gds-z") ) // GRIDS_FILETYPE_Compressed
2013  {
2014  return( false );
2015  }
2016 
2017  CSG_Archive Stream(_File, SG_FILE_R);
2018 
2019  CSG_String File(SG_File_Get_Name(_File, false) + ".");
2020 
2021  //-----------------------------------------------------
2022  if( !Stream.Get_File(File + "sg-gds") || !_Load_Header(Stream) )
2023  {
2024  return( false );
2025  }
2026 
2027  if( m_Attributes.Get_Count() <= 0 ) // <<< DEPRECATED
2028  if( !Stream.Get_File(File + "sg-att") || !_Load_Attributes(Stream) )
2029  {
2030  return( false );
2031  }
2032 
2033  //-----------------------------------------------------
2034  for(int i=0; i<Get_NZ() && SG_UI_Process_Set_Progress(i, Get_NZ()); i++)
2035  {
2036  if( !Stream.Get_File(File + CSG_String::Format("sg-%03d", i + 1)) || !_Load_Data(Stream, m_pGrids[i]) )
2037  {
2038  return( false );
2039  }
2040  }
2041 
2042  //-----------------------------------------------------
2043  Set_File_Name(_File, true);
2044 
2045  if( Stream.Get_File(File + "sg-info") )
2046  {
2047  Load_MetaData(Stream);
2048  }
2049 
2050  if( Stream.Get_File(File + "sg-prj") )
2051  {
2052  Get_Projection().Load(Stream);
2053  }
2054 
2055  return( true );
2056 }
2057 
2058 //---------------------------------------------------------
2059 bool CSG_Grids::_Save_Compressed(const CSG_String &_File)
2060 {
2061  CSG_Archive Stream(_File, SG_FILE_W);
2062 
2063  CSG_String File(SG_File_Get_Name(_File, false) + ".");
2064 
2065  //-----------------------------------------------------
2066  if( !Stream.Add_File(File + "sg-gds") || !_Save_Header(Stream) )
2067  {
2068  return( false );
2069  }
2070 
2071  if( !Stream.Add_File(File + "sg-att") || !_Save_Attributes(Stream) )
2072  {
2073  return( false );
2074  }
2075 
2076  //-----------------------------------------------------
2077  for(int i=0; i<Get_NZ() && SG_UI_Process_Set_Progress(i, Get_NZ()); i++)
2078  {
2079  if( !Stream.Add_File(File + CSG_String::Format("sg-%03d", i + 1)) || !_Save_Data(Stream, m_pGrids[i]) )
2080  {
2081  return( false );
2082  }
2083  }
2084 
2085  //-----------------------------------------------------
2086  if( Stream.Add_File(File + "sg-info") )
2087  {
2088  Save_MetaData(Stream);
2089  }
2090 
2091  if( Stream.Add_File(File + "sg-prj") )
2092  {
2093  Get_Projection().Save(Stream);
2094  }
2095 
2096  return( true );
2097 }
2098 
2099 
2101 // //
2103 
2104 //---------------------------------------------------------
2105 bool CSG_Grids::_Load_Header(CSG_File &Stream)
2106 {
2107  CSG_MetaData Header;
2108 
2109  if( !Header.Load(Stream) )
2110  {
2111  return( false );
2112  }
2113 
2114  //-----------------------------------------------------
2115  if( !Header("NX") || !Header("NY") || !Header("XMIN") || !Header("YMIN") || !Header("CELLSIZE") || !Header("TYPE") ) // necessary minimum information !!!
2116  {
2117  return( false );
2118  }
2119 
2120  CSG_Grid_System System(Header["CELLSIZE"].Get_Content().asDouble(),
2121  Header["XMIN"].Get_Content().asDouble(), Header["YMIN"].Get_Content().asDouble(),
2122  Header["NX" ].Get_Content().asInt (), Header["NY" ].Get_Content().asInt ()
2123  );
2124 
2125  TSG_Data_Type Type = SG_Data_Type_Get_Type(Header["TYPE"].Get_Content());
2126 
2127  if( !System.is_Valid() || Type == SG_DATATYPE_Undefined || !m_pGrids[0]->Create(System, Type) )
2128  {
2129  return( false );
2130  }
2131 
2132  //-----------------------------------------------------
2133  if( Header("NAME" ) ) Set_Name (Header["NAME" ].Get_Content());
2134  if( Header("DESCRIPTION") ) Set_Description(Header["DESCRIPTION"].Get_Content());
2135  if( Header("UNIT" ) ) Set_Unit (Header["UNIT" ].Get_Content());
2136 
2137  Set_Scaling(
2138  Header("SCALE" ) ? Header["SCALE" ].Get_Content().asDouble() : 1.,
2139  Header("OFFSET") ? Header["OFFSET"].Get_Content().asDouble() : 0.
2140  );
2141 
2142  if( Header("NODATA_MIN") )
2143  {
2144  if( Header("NODATA_MAX") )
2145  {
2146  Set_NoData_Value_Range(
2147  Header["NODATA_MIN"].Get_Content().asDouble(),
2148  Header["NODATA_MAX"].Get_Content().asDouble()
2149  );
2150  }
2151  else
2152  {
2153  Set_NoData_Value(
2154  Header["NODATA_MIN"].Get_Content().asDouble()
2155  );
2156  }
2157  }
2158 
2159  //-----------------------------------------------------
2160  m_Attributes.Destroy();
2161 
2162  if( Header("ATTRIBUTES") && Header["ATTRIBUTES"]("FIELDS") == NULL )
2163  {
2164  const CSG_MetaData &Fields = Header["ATTRIBUTES"];
2165 
2166  for(int iField=0; iField<Fields.Get_Children_Count(); iField++)
2167  {
2168  if( Fields[iField].Cmp_Name("FIELD") && Fields[iField].Get_Property("TYPE") )
2169  {
2170  m_Attributes.Add_Field(Fields[iField].Get_Content(), SG_Data_Type_Get_Type(Fields[iField].Get_Property("TYPE")));
2171  }
2172  }
2173 
2174  if( !Fields.Get_Property("Z_FIELD", m_Z_Attribute) || m_Z_Attribute >= m_Attributes.Get_Field_Count() )
2175  {
2176  m_Z_Attribute = 0;
2177  }
2178 
2179  if( !Fields.Get_Property("Z_NAME", m_Z_Name ) || m_Z_Name >= m_Attributes.Get_Field_Count() )
2180  {
2181  m_Z_Name = -1; // same as m_Z_Attribute
2182  }
2183  }
2184 
2185  //-----------------------------------------------------
2186  // >>> DEPRECATED >>> //
2187  if( Header("ATTRIBUTES") && Header["ATTRIBUTES"]("FIELDS") != NULL )
2188  {
2189  if( !Header["ATTRIBUTES"].Get_Property("ZATTRIBUTE", m_Z_Attribute) )
2190  {
2191  m_Z_Attribute = 0;
2192  }
2193 
2194  int iField;
2195 
2196  const CSG_MetaData &Fields = Header["ATTRIBUTES"]["FIELDS"];
2197 
2198  for(iField=0; iField<Fields.Get_Children_Count(); iField++)
2199  {
2200  if( Fields[iField].Cmp_Name("FIELD") && Fields[iField].Get_Property("TYPE") )
2201  {
2202  m_Attributes.Add_Field(Fields[iField].Get_Content(), SG_Data_Type_Get_Type(Fields[iField].Get_Property("TYPE")));
2203  }
2204  }
2205 
2206  if( m_Attributes.Get_Field_Count() > 0 && Header["ATTRIBUTES"]("RECORDS") )
2207  {
2208  CSG_Table Attributes(m_Attributes);
2209 
2210  const CSG_MetaData &Records = Header["ATTRIBUTES"]["RECORDS"];
2211 
2212  for(int iRecord=0; iRecord<Records.Get_Children_Count(); iRecord++)
2213  {
2214  if( Records[iRecord].Cmp_Name("RECORD") )
2215  {
2216  CSG_String_Tokenizer Values(Records[iRecord].Get_Content(), ";");
2217 
2218  if( Values.Get_Tokens_Count() == (size_t)Attributes.Get_Field_Count() )
2219  {
2220  CSG_Table_Record *pRecord = Attributes.Add_Record();
2221 
2222  for(int iField=0; iField<m_Attributes.Get_Field_Count(); iField++)
2223  {
2224  pRecord->Set_Value(iField, Values.Get_Next_Token());
2225  }
2226 
2227  if( !Add_Grid(*pRecord) )
2228  {
2229  return( false );
2230  }
2231  }
2232  }
2233  }
2234  }
2235  }
2236  else if( Header("NZ") && Header["NZ"].Get_Content().asInt() > 0 )
2237  {
2238  m_Attributes.Add_Field("ID", SG_DATATYPE_Int);
2239 
2240  for(int i=0, n=Header["NZ"].Get_Content().asInt(); i<n; i++)
2241  {
2242  if( !Add_Grid(i + 1.) )
2243  {
2244  return( false );
2245  }
2246  }
2247  }
2248  // <<< DEPRECATED <<< //
2249 
2250  //-----------------------------------------------------
2251  return( m_Attributes.Get_Field_Count() > 0 );
2252 }
2253 
2254 //---------------------------------------------------------
2255 bool CSG_Grids::_Save_Header(CSG_File &Stream)
2256 {
2257  CSG_MetaData Header;
2258 
2259  Header.Set_Name("GRIDS");
2260 
2261  Header.Add_Property("saga-version", SAGA_VERSION);
2262 
2263  //-----------------------------------------------------
2264  // general
2265 
2266  Header.Add_Child("NAME" , Get_Name ());
2267  Header.Add_Child("DESCRIPTION", Get_Description());
2268  Header.Add_Child("UNIT" , Get_Unit ());
2269 
2270  Header.Add_Child("SCALE" , Get_Scaling ());
2271  Header.Add_Child("OFFSET" , Get_Offset ());
2272 
2273  Header.Add_Child("NODATA_MIN" , Get_NoData_Value(false));
2274  Header.Add_Child("NODATA_MAX" , Get_NoData_Value(true ));
2275 
2276  Header.Add_Child("TYPE" , SG_Data_Type_Get_Identifier(Get_Type()));
2277 
2278  //-----------------------------------------------------
2279  // grid system
2280 
2281  Header.Add_Child("NX" , Get_NX ());
2282  Header.Add_Child("NY" , Get_NY ());
2283  Header.Add_Child("CELLSIZE" , Get_Cellsize());
2284  Header.Add_Child("XMIN" , Get_XMin ());
2285  Header.Add_Child("YMIN" , Get_YMin ());
2286 
2287  //-----------------------------------------------------
2288  // attributes
2289 
2290  CSG_MetaData &Attributes = *Header.Add_Child("ATTRIBUTES");
2291 
2292  Attributes.Add_Property("Z_FIELD", m_Z_Attribute);
2293  Attributes.Add_Property("Z_NAME" , m_Z_Name );
2294 
2295  for(int iField=0; iField<m_Attributes.Get_Field_Count(); iField++)
2296  {
2297  Attributes.Add_Child("FIELD", m_Attributes.Get_Field_Name(iField))->Add_Property(
2298  "TYPE", SG_Data_Type_Get_Identifier(m_Attributes.Get_Field_Type(iField))
2299  );
2300  }
2301 
2302  //-----------------------------------------------------
2303  return( Header.Save(Stream) );
2304 }
2305 
2306 
2308 // //
2310 
2311 //---------------------------------------------------------
2312 bool CSG_Grids::_Load_Attributes(CSG_File &Stream)
2313 {
2314  CSG_Table Attributes(m_Attributes);
2315 
2316  CSG_String sLine;
2317 
2318  while( Stream.Read_Line(sLine) && !sLine.is_Empty() )
2319  {
2320  CSG_String_Tokenizer Values(sLine, "\t", SG_TOKEN_RET_EMPTY_ALL);
2321 
2322  if( Values.Get_Tokens_Count() == (size_t)Attributes.Get_Field_Count() )
2323  {
2324  CSG_Table_Record *pRecord = Attributes.Add_Record();
2325 
2326  for(int iField=0; iField<m_Attributes.Get_Field_Count(); iField++)
2327  {
2328  pRecord->Set_Value(iField, Values.Get_Next_Token());
2329  }
2330 
2331  if( !Add_Grid(*pRecord) )
2332  {
2333  return( false );
2334  }
2335  }
2336  }
2337 
2338  return( true );
2339 }
2340 
2341 //---------------------------------------------------------
2342 bool CSG_Grids::_Save_Attributes(CSG_File &Stream)
2343 {
2344  for(int iRecord=0; iRecord<m_Attributes.Get_Count(); iRecord++)
2345  {
2346  for(int iField=0; iField<m_Attributes.Get_Field_Count(); iField++)
2347  {
2348  Stream.Write(m_Attributes[iRecord].asString(iField));
2349  Stream.Write(iField < m_Attributes.Get_Field_Count() - 1 ? "\t" : "\n");
2350  }
2351  }
2352 
2353  return( true );
2354 }
2355 
2356 
2358 // //
2360 
2361 //---------------------------------------------------------
2362 bool CSG_Grids::_Load_Data(CSG_File &Stream, CSG_Grid *pGrid)
2363 {
2364  if( !pGrid )
2365  {
2366  return( false );
2367  }
2368 
2369  TSG_Data_Type Type = Get_Type();
2370 
2371  CSG_Array Line(1, Get_nLineBytes());
2372 
2373  for(int y=0; y<Get_NY(); y++)
2374  {
2375  if( !Stream.Read(Line.Get_Array(), Get_nLineBytes()) )
2376  {
2377  return( false );
2378  }
2379 
2380  char *pValue = (char *)Line.Get_Array();
2381 
2382  for(int x=0, n=Get_nValueBytes(); x<Get_NX(); x++, pValue+=n)
2383  {
2384  switch( Type )
2385  {
2386  case SG_DATATYPE_Byte : pGrid->Set_Value(x, y, *(BYTE *)pValue, false); break;
2387  case SG_DATATYPE_Char : pGrid->Set_Value(x, y, *(char *)pValue, false); break;
2388  case SG_DATATYPE_Word : pGrid->Set_Value(x, y, *(WORD *)pValue, false); break;
2389  case SG_DATATYPE_Short : pGrid->Set_Value(x, y, *(short *)pValue, false); break;
2390  case SG_DATATYPE_DWord : pGrid->Set_Value(x, y, *(DWORD *)pValue, false); break;
2391  case SG_DATATYPE_Int : pGrid->Set_Value(x, y, *(int *)pValue, false); break;
2392  case SG_DATATYPE_Float : pGrid->Set_Value(x, y, *(float *)pValue, false); break;
2393  case SG_DATATYPE_Double: pGrid->Set_Value(x, y, *(double *)pValue, false); break;
2394  default: break;
2395  }
2396  }
2397  }
2398 
2399  return( true );
2400 }
2401 
2402 //---------------------------------------------------------
2403 bool CSG_Grids::_Save_Data(CSG_File &Stream, CSG_Grid *pGrid)
2404 {
2405  TSG_Data_Type Type = Get_Type();
2406 
2407  CSG_Array Line(1, Get_nLineBytes());
2408 
2409  for(int y=0; y<Get_NY(); y++)
2410  {
2411  char *pValue = (char *)Line.Get_Array();
2412 
2413  for(int x=0, n=Get_nValueBytes(); x<Get_NX(); x++, pValue+=n)
2414  {
2415  switch( Type )
2416  {
2417  case SG_DATATYPE_Byte : *(BYTE *)pValue = pGrid->asByte (x, y, false); break;
2418  case SG_DATATYPE_Char : *(char *)pValue = pGrid->asChar (x, y, false); break;
2419  case SG_DATATYPE_Word : *(WORD *)pValue = pGrid->asShort (x, y, false); break;
2420  case SG_DATATYPE_Short : *(short *)pValue = pGrid->asShort (x, y, false); break;
2421  case SG_DATATYPE_DWord : *(DWORD *)pValue = pGrid->asInt (x, y, false); break;
2422  case SG_DATATYPE_Int : *(int *)pValue = pGrid->asInt (x, y, false); break;
2423  case SG_DATATYPE_Float : *(float *)pValue = pGrid->asFloat (x, y, false); break;
2424  case SG_DATATYPE_Double: *(double *)pValue = pGrid->asDouble(x, y, false); break;
2425  default: break;
2426  }
2427  }
2428 
2429  if( !Stream.Write(Line.Get_Array(), Get_nLineBytes()) )
2430  {
2431  return( false );
2432  }
2433  }
2434 
2435  return( true );
2436 }
2437 
2438 
2440 // //
2442 
2443 //-----------------------------------------------------
2444 bool CSG_Grids::_Assign_Interpolated (CSG_Grids *pSource, TSG_Grid_Resampling Interpolation) { return( false ); }
2445 bool CSG_Grids::_Assign_MeanValue (CSG_Grids *pSource, bool bVolumeProportional ) { return( false ); }
2446 bool CSG_Grids::_Assign_ExtremeValue (CSG_Grids *pSource, bool bMaximum ) { return( false ); }
2447 bool CSG_Grids::_Assign_Majority (CSG_Grids *pSource ) { return( false ); }
2448 
2449 
2451 // //
2453 
2454 //-----------------------------------------------------
2455 CSG_Grids & CSG_Grids::_Operation_Arithmetic(const CSG_Grids &Grids, TSG_Grid_Operation Operation) { return( *this ); }
2456 CSG_Grids & CSG_Grids::_Operation_Arithmetic(double Value , TSG_Grid_Operation Operation) { return( *this ); }
2457 
2458 
2460 // //
2461 // //
2462 // //
2464 
2465 //---------------------------------------------------------
CSG_Grids::Set_Unit
void Set_Unit(const CSG_String &Unit)
Definition: grids.cpp:379
CSG_Grid::Get_Type
TSG_Data_Type Get_Type(void) const
Definition: grid.h:527
CSG_String::BeforeFirst
CSG_String BeforeFirst(char Character) const
Definition: api_string.cpp:713
CSG_Rect
Definition: geo_tools.h:474
CSG_Grids::Subtract
virtual CSG_Grids & Subtract(double Value)
Definition: grids.cpp:1022
GRIDS_FILE_FORMAT_Normal
@ GRIDS_FILE_FORMAT_Normal
Definition: grids.h:93
CSG_Grids::Get_NY
int Get_NY(void) const
Definition: grids.h:186
SG_DATATYPE_Int
@ SG_DATATYPE_Int
Definition: api_core.h:1002
CSG_Grids::Multiply
virtual CSG_Grids & Multiply(double Value)
Definition: grids.cpp:1038
CSG_Grids::CSG_Grids
CSG_Grids(void)
Definition: grids.cpp:137
SG_DATATYPE_Undefined
@ SG_DATATYPE_Undefined
Definition: api_core.h:1011
CSG_Data_Object::Get_Max_Samples
sLong Get_Max_Samples(void) const
Definition: dataobject.h:263
SG_FREE_SAFE
#define SG_FREE_SAFE(PTR)
Definition: api_core.h:205
CSG_Grids::Set_Z
bool Set_Z(int i, double Value)
Definition: grids.cpp:561
GRID_RESAMPLING_NearestNeighbour
@ GRID_RESAMPLING_NearestNeighbour
Definition: grid.h:157
CSG_Projection::Save
bool Save(const CSG_String &File, ESG_CRS_Format Format=ESG_CRS_Format::WKT) const
Definition: projections.cpp:261
CSG_Grids::asInt
virtual int asInt(int x, int y, int z, bool bScaled=true) const
Definition: grids.h:391
CSG_Grids::Get_Data_Count
sLong Get_Data_Count(void)
Definition: grids.cpp:1434
CSG_String::Printf
int Printf(const char *Format,...)
Definition: api_string.cpp:308
CSG_Table::Get_Field_Type
TSG_Data_Type Get_Field_Type(int Field) const
Definition: table.h:363
CSG_Grid_System::Get_Cellsize
double Get_Cellsize(void) const
Definition: grid.h:235
CSG_Table::Set_Count
virtual bool Set_Count(sLong nRecords)
Definition: table.cpp:950
CSG_Histogram::Update
bool Update(void)
Definition: mat_tools.cpp:1366
_TL
#define _TL(s)
Definition: api_core.h:1556
SG_DATATYPE_DWord
@ SG_DATATYPE_DWord
Definition: api_core.h:1001
CSG_Table::Del_Records
virtual bool Del_Records(void)
Definition: table.cpp:932
CSG_Grids::Get_Sorted
sLong Get_Sorted(sLong Position, bool bDown=true, bool bCheckNoData=true)
Definition: grids.h:450
CSG_Grids::Get_Offset
double Get_Offset(void) const
Definition: grids.h:271
CSG_Data_Object::Set_File_Name
void Set_File_Name(const CSG_String &FileName)
Definition: dataobject.cpp:366
SAGA_VERSION
#define SAGA_VERSION
Definition: saga_api.h:90
CSG_Grids::Set_Value
virtual void Set_Value(sLong i, double Value, bool bScaled=true)
Definition: grids.h:422
CSG_Data_Object::Get_Description
const SG_Char * Get_Description(void) const
Definition: dataobject.cpp:360
CSG_Data_Object::Update
bool Update(bool bForce=false)
Definition: dataobject.cpp:777
CSG_MetaData::Get_Children_Count
int Get_Children_Count(void) const
Definition: metadata.h:148
CSG_Grids::~CSG_Grids
virtual ~CSG_Grids(void)
Definition: grids.cpp:146
CSG_Grids::operator=
virtual CSG_Grids & operator=(const CSG_Grids &Grids)
Definition: grids.cpp:990
CSG_Data_Collection::Count
size_t Count(void) const
Definition: data_manager.h:94
GRID_RESAMPLING_BicubicSpline
@ GRID_RESAMPLING_BicubicSpline
Definition: grid.h:159
CSG_Grids::Set_Z_Attribute
bool Set_Z_Attribute(int Field)
Definition: grids.cpp:479
SG_File_Set_Extension
SAGA_API_DLL_EXPORT bool SG_File_Set_Extension(CSG_String &File, const CSG_String &Extension)
Definition: api_file.cpp:1186
SG_TOKEN_RET_EMPTY_ALL
@ SG_TOKEN_RET_EMPTY_ALL
Definition: api_core.h:754
CSG_Table_Record
Definition: table.h:130
CSG_Grids::Set_Attribute
bool Set_Attribute(int i, int Field, const CSG_String &Value)
Definition: grids.cpp:546
CSG_Grids::Assign
virtual bool Assign(double Value=0.)
Definition: grids.cpp:924
CSG_Grids::Get_Scaling
double Get_Scaling(void) const
Definition: grids.h:270
CSG_Simple_Statistics::Get_Variance
double Get_Variance(void)
Definition: mat_tools.h:752
data_manager.h
CSG_Data_Object::Get_NoData_Value
double Get_NoData_Value(bool bUpper=false) const
Definition: dataobject.h:253
CSG_Rect::Get_XMax
double Get_XMax(void) const
Definition: geo_tools.h:506
CSG_Grids::Get_Attributes
const CSG_Table & Get_Attributes(void) const
Definition: grids.h:224
CSG_Grids::Get_Range
double Get_Range(void)
Definition: grids.cpp:1418
SG_File_Cmp_Extension
SAGA_API_DLL_EXPORT bool SG_File_Cmp_Extension(const CSG_String &File, const CSG_String &Extension)
Definition: api_file.cpp:1180
SG_UI_MSG_STYLE_SUCCESS
@ SG_UI_MSG_STYLE_SUCCESS
Definition: api_core.h:1572
SG_Get_String
SAGA_API_DLL_EXPORT CSG_String SG_Get_String(double Value, int Precision=-99)
Definition: api_string.cpp:1367
CSG_Grid_System
Definition: grid.h:200
TSG_Grid_Resampling
TSG_Grid_Resampling
Definition: grid.h:156
CSG_Grid::Create
bool Create(const CSG_Grid &Grid)
Definition: grid.cpp:235
CSG_Histogram
Definition: mat_tools.h:1011
SG_Malloc
SAGA_API_DLL_EXPORT void * SG_Malloc(size_t size)
Definition: api_memory.cpp:65
CSG_Grids::Get_Grid_Name
CSG_String Get_Grid_Name(int i, int Style=0) const
Definition: grids.cpp:866
CSG_Grids::On_Update
virtual bool On_Update(void)
Definition: grids.cpp:1356
SG_UI_Process_Get_Okay
bool SG_UI_Process_Get_Okay(bool bBlink)
Definition: api_callback.cpp:207
CSG_Grids::Get_Grid_Count
int Get_Grid_Count(void) const
Definition: grids.h:249
CSG_Grids::Save
virtual bool Save(const CSG_String &File, int Format=0)
Definition: grids.cpp:1738
CSG_Data_Object::Save_MetaData
bool Save_MetaData(const CSG_String &FileName)
Definition: dataobject.cpp:681
CSG_Grid_System::Get_yWorld_to_Grid
int Get_yWorld_to_Grid(double yWorld) const
Definition: grid.h:299
CSG_Grids::Add_Attribute
bool Add_Attribute(const char *Name, TSG_Data_Type Type, int Insert=-1)
Definition: grids.cpp:510
SSG_Point_3D
Definition: geo_tools.h:265
CSG_Data_Object::is_NoData_Value
bool is_NoData_Value(double Value) const
Definition: dataobject.h:255
GRID_RESAMPLING_Undefined
@ GRID_RESAMPLING_Undefined
Definition: grid.h:168
SG_DATATYPE_Byte
@ SG_DATATYPE_Byte
Definition: api_core.h:997
CSG_Archive
Definition: api_core.h:1201
CSG_Grids::Get_Extent
virtual const CSG_Rect & Get_Extent(void)
Definition: grids.h:183
CSG_Projection::is_Okay
bool is_Okay(void) const
Definition: geo_tools.h:863
saga_api.h
CSG_Grid::Assign
virtual bool Assign(double Value=0.)
Definition: grid_operation.cpp:79
CSG_Tool
Definition: tool.h:135
CSG_Table::Destroy
virtual bool Destroy(void)
Definition: table.cpp:325
CSG_Grids::On_Delete
virtual bool On_Delete(void)
Definition: grids.cpp:1684
CSG_Grid::Set_Scaling
void Set_Scaling(double Scale=1., double Offset=0.)
Definition: grid.cpp:406
CSG_Data_Object::Get_Name
const SG_Char * Get_Name(void) const
Definition: dataobject.cpp:349
CSG_Tool::Execute
bool Execute(bool bAddHistory=false)
Definition: tool.cpp:258
SSG_Point_3D::x
double x
Definition: geo_tools.h:266
CSG_Histogram::Create
bool Create(const CSG_Histogram &Histogram)
Definition: mat_tools.cpp:1498
CSG_Grids::Get_NCells
sLong Get_NCells(void) const
Definition: grids.h:188
SG_DATAOBJECT_TYPE_Grids
@ SG_DATAOBJECT_TYPE_Grids
Definition: dataobject.h:119
CSG_Grids::is_Valid
virtual bool is_Valid(void) const
Definition: grids.cpp:445
CSG_Grids::Get_Type
TSG_Data_Type Get_Type(void) const
Definition: grids.h:169
SG_RUN_TOOL
#define SG_RUN_TOOL(bRetVal, LIBRARY, TOOL, CONDITION)
Definition: tool_library.h:260
CSG_Grids::Get_Z_Attribute
int Get_Z_Attribute(void) const
Definition: grids.h:214
CSG_Table::Get_Field_Count
int Get_Field_Count(void) const
Definition: table.h:361
CSG_Grids::is_Scaled
bool is_Scaled(void) const
Definition: grids.h:272
SG_File_Delete
SAGA_API_DLL_EXPORT bool SG_File_Delete(const CSG_String &FileName)
Definition: api_file.cpp:1084
SG_Free
SAGA_API_DLL_EXPORT void SG_Free(void *memblock)
Definition: api_memory.cpp:83
CSG_Data_Object::Get_ObjectType
virtual TSG_Data_Object_Type Get_ObjectType(void) const =0
Returns the object type as defined by TSG_Data_Object_Type. Used for run time type checking.
CSG_Data_Object::Set_Max_Samples
virtual bool Set_Max_Samples(sLong Max_Samples)
Definition: dataobject.cpp:617
CSG_Grids::Get_Percentile
double Get_Percentile(double Percentile, bool bFromHistogram=true)
Definition: grids.cpp:1468
CSG_Grids::operator/=
virtual CSG_Grids & operator/=(double Value)
Definition: grids.cpp:1049
CSG_MetaData::Save
bool Save(const CSG_String &File, const SG_Char *Extension=NULL) const
Definition: metadata.cpp:879
SG_FILE_R
@ SG_FILE_R
Definition: api_core.h:1112
CSG_Grids::Del_Attribute
bool Del_Attribute(int Field)
Definition: grids.cpp:518
CSG_Grids::operator+=
virtual CSG_Grids & operator+=(double Value)
Definition: grids.cpp:1001
CSG_Array_Pointer::Create
void ** Create(const CSG_Array_Pointer &Array)
Definition: api_memory.cpp:469
CSG_File::Read
size_t Read(void *Buffer, size_t Size, size_t Count=1) const
Definition: api_file.cpp:338
SG_GRIDS_NAME_INDEX
#define SG_GRIDS_NAME_INDEX
Definition: grids.h:101
CSG_Tool_Library_Manager::Delete_Tool
bool Delete_Tool(CSG_Tool *pTool) const
Definition: tool_library.cpp:865
CSG_Grids::On_Reload
virtual bool On_Reload(void)
Definition: grids.cpp:1678
CSG_Data_Object::Set_Update_Flag
void Set_Update_Flag(bool bOn=true)
Definition: dataobject.h:285
CSG_Grid::Get_System
const CSG_Grid_System & Get_System(void) const
Definition: grid.h:539
CSG_File
Definition: api_core.h:1127
CSG_String::Cmp
int Cmp(const CSG_String &String) const
Definition: api_string.cpp:515
CSG_Data_Object::Get_Owner
CSG_Data_Object * Get_Owner(void) const
Definition: dataobject.h:231
CSG_Grids::Set_Max_Samples
virtual bool Set_Max_Samples(sLong Max_Samples)
Definition: grids.cpp:1560
GRIDS_FILE_FORMAT_Undefined
@ GRIDS_FILE_FORMAT_Undefined
Definition: grids.h:92
SG_Data_Type_Get_Identifier
CSG_String SG_Data_Type_Get_Identifier(TSG_Data_Type Type)
Definition: api_core.cpp:147
CSG_Grid::Destroy
virtual bool Destroy(void)
Definition: grid.cpp:379
CSG_Grids::is_Compatible
bool is_Compatible(CSG_Grid *pGrid) const
Definition: grids.cpp:451
CSG_Tool::Set_Parameter
bool Set_Parameter(const CSG_String &ID, CSG_Parameter *pValue)
Definition: tool.cpp:1140
SG_UI_MSG_STYLE_FAILURE
@ SG_UI_MSG_STYLE_FAILURE
Definition: api_core.h:1573
CSG_Simple_Statistics::Get_Maximum
double Get_Maximum(void)
Definition: mat_tools.h:747
SG_File_Get_Name
SAGA_API_DLL_EXPORT CSG_String SG_File_Get_Name(const CSG_String &full_Path, bool bExtension)
Definition: api_file.cpp:1106
CSG_Grids::Get_Unit
const SG_Char * Get_Unit(void) const
Definition: grids.h:175
CSG_Grid::Get_Scaling
double Get_Scaling(void) const
Definition: grid.cpp:422
SG_TOOL_PARAMLIST_ADD
#define SG_TOOL_PARAMLIST_ADD(IDENTIFIER, VALUE)
Definition: tool_library.h:356
CSG_Grids::Get_NX
int Get_NX(void) const
Definition: grids.h:185
CSG_Grid::Multiply
virtual CSG_Grid & Multiply(const CSG_Grid &Grid)
Definition: grid_operation.cpp:534
SG_TOOL_PARAMETER_SET
#define SG_TOOL_PARAMETER_SET(IDENTIFIER, VALUE)
Definition: tool_library.h:354
CSG_Grids::Create
virtual bool Create(const CSG_Grids &Grids)
Definition: grids.cpp:276
CSG_Grid::Add
virtual CSG_Grid & Add(const CSG_Grid &Grid)
Definition: grid_operation.cpp:464
SG_GRIDS_NAME_VALUE
#define SG_GRIDS_NAME_VALUE
Definition: grids.h:102
CSG_Data_Object
Definition: dataobject.h:180
GRID_RESAMPLING_Bilinear
@ GRID_RESAMPLING_Bilinear
Definition: grid.h:158
CSG_Rect::Get_YMin
double Get_YMin(void) const
Definition: geo_tools.h:507
CSG_Grids::Get_System
const CSG_Grid_System & Get_System(void) const
Definition: grids.h:181
CSG_Grid::Subtract
virtual CSG_Grid & Subtract(const CSG_Grid &Grid)
Definition: grid_operation.cpp:499
CSG_Simple_Statistics::Get_Count
sLong Get_Count(void) const
Definition: mat_tools.h:743
CSG_Grid::is_Valid
virtual bool is_Valid(void) const
Definition: grid.cpp:441
CSG_Data_Object::asGrids
class CSG_Grids * asGrids(bool bPolymorph=false) const
Definition: dataobject.cpp:561
CSG_Grids::Get_nLineBytes
int Get_nLineBytes(void) const
Definition: grids.h:172
CSG_Simple_Statistics::Get_Minimum
double Get_Minimum(void)
Definition: mat_tools.h:746
CSG_Grids::Get_YMin
double Get_YMin(bool bCells=false) const
Definition: grids.h:201
CSG_Array_Pointer::Get_uSize
size_t Get_uSize(void) const
Definition: api_core.h:382
CSG_Grids::Get_Value
double Get_Value(double x, double y, double z, TSG_Grid_Resampling Resampling=GRID_RESAMPLING_BSpline, TSG_Grid_Resampling ZResampling=GRID_RESAMPLING_Undefined) const
Definition: grids.cpp:1079
CSG_MetaData::Del_Children
bool Del_Children(int Depth=0, const SG_Char *Name=NULL)
Definition: metadata.cpp:381
SG_UI_Msg_Lock
int SG_UI_Msg_Lock(bool bOn)
Definition: api_callback.cpp:471
CSG_Grid::Set_Value
virtual void Set_Value(sLong i, double Value, bool bScaled=true)
Definition: grid.h:823
CSG_Table::Get_Field_Name
const SG_Char * Get_Field_Name(int Field) const
Definition: table.h:362
CSG_Grids::is_NoData
virtual bool is_NoData(int x, int y, int z) const
Definition: grids.h:370
sLong
signed long long sLong
Definition: api_core.h:158
CSG_Grids::Get_StdDev
double Get_StdDev(void)
Definition: grids.cpp:1423
SG_Get_Tool_Library_Manager
CSG_Tool_Library_Manager & SG_Get_Tool_Library_Manager(void)
Definition: tool_library.cpp:286
CSG_MetaData::Add_Property
bool Add_Property(const CSG_String &Name, const CSG_String &Value)
Definition: metadata.cpp:559
CSG_Grids::operator-=
virtual CSG_Grids & operator-=(double Value)
Definition: grids.cpp:1017
CSG_Simple_Statistics::Get_StdDev
double Get_StdDev(void)
Definition: mat_tools.h:753
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
CSG_Grids::Update_Z_Order
bool Update_Z_Order(void)
Definition: grids.cpp:567
CSG_Grids::Get_Grid_Ptr
CSG_Grid * Get_Grid_Ptr(int i) const
Definition: grids.h:260
GRIDS_FILE_FORMAT_Compressed
@ GRIDS_FILE_FORMAT_Compressed
Definition: grids.h:94
CSG_Table::Get_Count
sLong Get_Count(void) const
Definition: table.h:397
CSG_Grids::Get_Histogram
const CSG_Histogram & Get_Histogram(size_t nClasses=0)
Definition: grids.cpp:1583
SG_DATATYPE_Float
@ SG_DATATYPE_Float
Definition: api_core.h:1005
CSG_Grids::Set_Scaling
void Set_Scaling(double Scale=1., double Offset=0.)
Definition: grids.cpp:385
CSG_Simple_Statistics::Invalidate
void Invalidate(void)
Definition: mat_tools.cpp:447
CSG_Grid::Get_Offset
double Get_Offset(void) const
Definition: grid.cpp:428
SG_UI_Process_Set_Text
void SG_UI_Process_Set_Text(const CSG_String &Text)
Definition: api_callback.cpp:323
SG_String_Tokenize
SAGA_API_DLL_EXPORT CSG_Strings SG_String_Tokenize(const CSG_String &String, const CSG_String &Delimiters=SG_DEFAULT_DELIMITERS, TSG_String_Tokenizer_Mode Mode=SG_TOKEN_DEFAULT)
Definition: api_string.cpp:1597
CSG_Data_Object::Get_File_Name
const SG_Char * Get_File_Name(bool bNative=true) const
Definition: dataobject.cpp:390
CSG_Grids::Destroy
virtual bool Destroy(void)
Definition: grids.cpp:250
GRID_RESAMPLING_BSpline
@ GRID_RESAMPLING_BSpline
Definition: grid.h:160
CSG_Grid::asShort
virtual short asShort(int x, int y, bool bScaled=true) const
Definition: grid.h:763
SG_GRIDS_NAME_GRID
#define SG_GRIDS_NAME_GRID
Definition: grids.h:103
SG_FILE_W
@ SG_FILE_W
Definition: api_core.h:1113
CSG_Grids::Set_Grid_Count
bool Set_Grid_Count(int Count)
Definition: grids.cpp:608
CSG_Grids::Assign_NoData
void Assign_NoData(void)
Definition: grids.cpp:915
CSG_Grids::Set_Z_Name_Field
bool Set_Z_Name_Field(int Field)
Definition: grids.cpp:492
CSG_Projection::Load
bool Load(const CSG_String &File)
Definition: projections.cpp:253
CSG_Grids::Get_Min
double Get_Min(void)
Definition: grids.cpp:1408
CSG_Simple_Statistics::Get_Mean
double Get_Mean(void)
Definition: mat_tools.h:751
CSG_Strings
Definition: api_core.h:701
SG_DATATYPE_Word
@ SG_DATATYPE_Word
Definition: api_core.h:999
SG_DATAOBJECT_TYPE_Grid
@ SG_DATAOBJECT_TYPE_Grid
Definition: dataobject.h:118
CSG_Data_Object::Set_Name
void Set_Name(const CSG_String &Name)
Definition: dataobject.cpp:300
CSG_MetaData::Add_Children
bool Add_Children(const CSG_MetaData &MetaData)
Definition: metadata.cpp:359
CSG_Histogram::Get_Class_Count
size_t Get_Class_Count(void) const
Definition: mat_tools.h:1043
CSG_Simple_Statistics::Set_Count
bool Set_Count(sLong Count)
Definition: mat_tools.cpp:424
SG_Create_Grids
CSG_Grids * SG_Create_Grids(void)
Definition: grids.cpp:65
CSG_String::Format
static CSG_String Format(const char *Format,...)
Definition: api_string.cpp:270
CSG_Grids::Get_ZMax
double Get_ZMax(bool bCells=false) const
Definition: grids.h:206
CSG_Table::Assign
virtual bool Assign(CSG_Data_Object *pTable, bool bProgress=false)
Definition: table.cpp:370
CSG_Grids::Get_XMin
double Get_XMin(bool bCells=false) const
Definition: grids.h:197
CSG_Table::Add_Field
virtual bool Add_Field(const CSG_String &Name, TSG_Data_Type Type, int Position=-1)
Definition: table.cpp:465
CSG_Tool_Library_Manager::Create_Tool
CSG_Tool * Create_Tool(const CSG_String &Library, int Index, bool bWithGUI=false, bool bWithCMD=true) const
Definition: tool_library.cpp:836
CSG_Table
Definition: table.h:285
CSG_Grids::Load
virtual bool Load(const CSG_String &File, bool bLoadData=true)
Definition: grids.cpp:1710
CSG_Grids::asDouble
virtual double asDouble(sLong i, bool bScaled=true) const
Definition: grids.h:399
CSG_Table::Del_Record
virtual bool Del_Record(sLong Index)
Definition: table.cpp:893
CSG_Spline
Definition: mat_tools.h:1424
CSG_Spline::Get_Value
bool Get_Value(double x, double &y)
Definition: mat_spline.cpp:206
CSG_Array
Definition: api_core.h:308
CSG_String
Definition: api_core.h:563
CSG_Grids::Get_Z
double Get_Z(int i) const
Definition: grids.h:240
CSG_Grids::Add
virtual CSG_Grids & Add(double Value)
Definition: grids.cpp:1006
CSG_Data_Object::asGrid
class CSG_Grid * asGrid(bool bPolymorph=false) const
Definition: dataobject.cpp:550
CSG_Array_Pointer
Definition: api_core.h:368
CSG_Histogram::Destroy
bool Destroy(void)
Definition: mat_tools.cpp:1275
CSG_Grid::asDouble
virtual double asDouble(sLong i, bool bScaled=true) const
Definition: grid.h:773
CSG_Data_Manager
Definition: data_manager.h:129
CSG_MetaData
Definition: metadata.h:88
CSG_Data_Object::Set_Description
void Set_Description(const CSG_String &Description)
Definition: dataobject.cpp:355
CSG_Simple_Statistics::Get_Range
double Get_Range(void)
Definition: mat_tools.h:748
CSG_Data_Object::Get_MetaData_DB
CSG_MetaData & Get_MetaData_DB(void) const
Definition: dataobject.h:235
CSG_Grid::asFloat
virtual float asFloat(int x, int y, bool bScaled=true) const
Definition: grid.h:769
SSG_Point_3D::y
double y
Definition: geo_tools.h:266
CSG_MetaData::Load
bool Load(const CSG_String &File, const SG_Char *Extension=NULL)
Definition: metadata.cpp:786
CSG_Tool::Settings_Push
bool Settings_Push(class CSG_Data_Manager *pManager=NULL)
Definition: tool.cpp:621
ADD_TO_SPLINE
#define ADD_TO_SPLINE(i)
CSG_String::is_Empty
bool is_Empty(void) const
Definition: api_string.cpp:178
SG_GRIDS_NAME_OWNER
#define SG_GRIDS_NAME_OWNER
Definition: grids.h:100
SG_UI_Process_Set_Progress
bool SG_UI_Process_Set_Progress(int Position, int Range)
Definition: api_callback.cpp:255
CSG_Table_Record::Set_Value
bool Set_Value(int Field, const CSG_String &Value)
Definition: table_record.cpp:270
CSG_File::Read_Line
bool Read_Line(CSG_String &Line) const
Definition: api_file.cpp:399
CSG_Table::Del_Field
virtual bool Del_Field(int Field)
Definition: table.cpp:504
SG_DATATYPE_Short
@ SG_DATATYPE_Short
Definition: api_core.h:1000
CSG_Simple_Statistics::Create
bool Create(bool bHoldValues=false)
Definition: mat_tools.cpp:350
CSG_Grid_System::Get_xWorld_to_Grid
int Get_xWorld_to_Grid(double xWorld) const
Definition: grid.h:298
CSG_Rect::Get_YMax
double Get_YMax(void) const
Definition: geo_tools.h:508
CSG_Data_Object::Load_MetaData
bool Load_MetaData(const CSG_String &FileName)
Definition: dataobject.cpp:654
CSG_Grids::Get_Mean
double Get_Mean(void)
Definition: grids.cpp:1403
SORT_SWAP
#define SORT_SWAP(a, b)
Definition: grids.cpp:1196
CSG_Rect::Get_XMin
double Get_XMin(void) const
Definition: geo_tools.h:505
CSG_Data_Object::Set_Owner
void Set_Owner(CSG_Data_Object *pOwner)
Definition: dataobject.h:232
CSG_Grids::Get_Z_Name_Field
int Get_Z_Name_Field(void) const
Definition: grids.cpp:504
CSG_Grid::Divide
virtual CSG_Grid & Divide(const CSG_Grid &Grid)
Definition: grid_operation.cpp:569
CSG_Grid
Definition: grid.h:481
CSG_Grids::Get_Variance
double Get_Variance(void)
Definition: grids.cpp:1428
CSG_Grids::Get_Cellsize
double Get_Cellsize(void) const
Definition: grids.h:192
CSG_Array_Pointer::Get_Array
void ** Get_Array(void) const
Definition: api_core.h:384
CSG_Grids::Get_Max
double Get_Max(void)
Definition: grids.cpp:1413
CSG_MetaData::Set_Name
void Set_Name(const CSG_String &Name)
Definition: metadata.h:130
CSG_Data_Object::Set_NoData_Value
virtual bool Set_NoData_Value(double Value)
Definition: dataobject.cpp:572
CSG_Data_Manager::Grids
CSG_Data_Collection & Grids(void) const
Definition: data_manager.h:139
SSG_Point_3D::z
double z
Definition: geo_tools.h:266
TABLE_INDEX_Ascending
@ TABLE_INDEX_Ascending
Definition: table.h:105
CSG_Grids::Set_Modified
virtual void Set_Modified(bool bModified=true)
Definition: grids.h:314
CSG_Grid::asByte
virtual BYTE asByte(int x, int y, bool bScaled=true) const
Definition: grid.h:759
CSG_Table::Set_Value
virtual bool Set_Value(sLong Index, int Field, const SG_Char *Value)
Definition: table.cpp:1155
CSG_Table::Create
bool Create(void)
Definition: table.cpp:153
CSG_Tool::On_Before_Execution
virtual bool On_Before_Execution(void)
Definition: tool.h:229
SG_File_Make_Path
SAGA_API_DLL_EXPORT CSG_String SG_File_Make_Path(const CSG_String &Directory, const CSG_String &Name)
Definition: api_file.cpp:1147
CSG_Grids::Set_NoData_Value_Range
virtual bool Set_NoData_Value_Range(double loValue, double hiValue)
Definition: grids.cpp:398
SG_UI_ProgressAndMsg_Lock
void SG_UI_ProgressAndMsg_Lock(bool bOn)
Definition: api_callback.cpp:589
CSG_String::c_str
const SG_Char * c_str(void) const
Definition: api_string.cpp:236
tool_library.h
CSG_Grids::Add_Grid
bool Add_Grid(double Z)
Definition: grids.cpp:663
CSG_File::Write
size_t Write(void *Buffer, size_t Size, size_t Count=1) const
Definition: api_file.cpp:370
CSG_Grid::asChar
virtual char asChar(int x, int y, bool bScaled=true) const
Definition: grid.h:761
CSG_Grids::Get_NoData_Count
sLong Get_NoData_Count(void)
Definition: grids.cpp:1439
CSG_Grid::Assign_NoData
bool Assign_NoData(void)
Definition: grid_operation.cpp:65
SG_UI_Process_Set_Ready
bool SG_UI_Process_Set_Ready(void)
Definition: api_callback.cpp:305
SG_Create_Grid
CSG_Grid * SG_Create_Grid(void)
Definition: grid.cpp:72
SG_Data_Type_Get_Type
TSG_Data_Type SG_Data_Type_Get_Type(const CSG_String &Identifier)
Definition: api_core.cpp:153
TSG_Data_Type
TSG_Data_Type
Definition: api_core.h:995
SG_Realloc
SAGA_API_DLL_EXPORT void * SG_Realloc(void *memblock, size_t size)
Definition: api_memory.cpp:77
CSG_Table::Set_Index
bool Set_Index(CSG_Index &Index, int Field, bool bAscending=true) const
Definition: table.cpp:1488
CSG_MetaData::Add_Child
CSG_MetaData * Add_Child(void)
Definition: metadata.cpp:166
SG_UI_Msg_Add_Error
void SG_UI_Msg_Add_Error(const char *Message)
Definition: api_callback.cpp:556
SG_GRID_HISTOGRAM_CLASSES_DEFAULT
#define SG_GRID_HISTOGRAM_CLASSES_DEFAULT
Definition: grids.cpp:1576
CSG_Grid::Set_Unit
void Set_Unit(const CSG_String &Unit)
Definition: grid.cpp:400
CSG_Table::Add_Record
virtual CSG_Table_Record * Add_Record(CSG_Table_Record *pCopy=NULL)
Definition: table.cpp:819
CSG_String_Tokenizer
Definition: api_core.h:762
CSG_Grids::Del_Grid
bool Del_Grid(int i, bool bDetach=false)
Definition: grids.cpp:790
CSG_Projection::Create
bool Create(const CSG_Projection &Projection)
Definition: projections.cpp:96
CSG_Table::Get_Field
int Get_Field(const CSG_String &Name) const
Definition: table.cpp:719
CSG_Grids
Definition: grids.h:119
CSG_Grids::Get_nValueBytes
int Get_nValueBytes(void) const
Definition: grids.h:171
CSG_Simple_Statistics
Definition: mat_tools.h:723
CSG_Grids::Get_Quantile
double Get_Quantile(double Quantile, bool bFromHistogram=true)
Definition: grids.cpp:1445
CSG_Data_Object::Set_NoData_Value_Range
virtual bool Set_NoData_Value_Range(double Lower, double Upper)
Definition: dataobject.cpp:578
SG_DATATYPE_Char
@ SG_DATATYPE_Char
Definition: api_core.h:998
CSG_Data_Object::Get_Projection
CSG_Projection & Get_Projection(void)
Definition: dataobject.cpp:637
CSG_Grids::Get_Statistics
const CSG_Simple_Statistics & Get_Statistics(void)
Definition: grids.cpp:1485
CSG_Data_Object::Destroy
virtual bool Destroy(void)
Definition: dataobject.cpp:281
CSG_MetaData::Get_Property
const SG_Char * Get_Property(int Index) const
Definition: metadata.h:181
CSG_Grid::asInt
virtual int asInt(int x, int y, bool bScaled=true) const
Definition: grid.h:765
CSG_Grids::operator*=
virtual CSG_Grids & operator*=(double Value)
Definition: grids.cpp:1033
CSG_Grids::Divide
virtual CSG_Grids & Divide(double Value)
Definition: grids.cpp:1054
CSG_Histogram::Get_Statistics
const CSG_Simple_Statistics & Get_Statistics(void) const
Definition: mat_tools.h:1076
CSG_Grids::Del_Grids
bool Del_Grids(bool bDetach=false)
Definition: grids.cpp:828
TSG_Grid_Operation
TSG_Grid_Operation
Definition: grid.h:174
SG_UI_Msg_Add
void SG_UI_Msg_Add(const char *Message, bool bNewLine, TSG_UI_MSG_STYLE Style)
Definition: api_callback.cpp:502
CSG_Grids::Get_NZ
int Get_NZ(void) const
Definition: grids.h:187
GRIDS_FILE_FORMAT_GeoTIFF
@ GRIDS_FILE_FORMAT_GeoTIFF
Definition: grids.h:95
grids.h
SG_DATATYPE_Double
@ SG_DATATYPE_Double
Definition: api_core.h:1006