SAGA API  v9.8
pointcloud.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 // pointcloud.cpp //
15 // //
16 // Copyright (C) 2009 by Olaf Conrad //
17 // //
18 //-------------------------------------------------------//
19 // //
20 // This file is part of 'SAGA - System for Automated //
21 // Geoscientific Analyses'. //
22 // //
23 // This library is free software; you can redistribute //
24 // it and/or modify it under the terms of the GNU Lesser //
25 // General Public License as published by the Free //
26 // Software Foundation, either version 2.1 of the //
27 // License, or (at your option) any later version. //
28 // //
29 // This library is distributed in the hope that it will //
30 // be useful, but WITHOUT ANY WARRANTY; without even the //
31 // implied warranty of MERCHANTABILITY or FITNESS FOR A //
32 // PARTICULAR PURPOSE. See the GNU Lesser General Public //
33 // License for more details. //
34 // //
35 // You should have received a copy of the GNU Lesser //
36 // General Public License along with this program; if //
37 // not, see <http://www.gnu.org/licenses/>. //
38 // //
39 //-------------------------------------------------------//
40 // //
41 // contact: Olaf Conrad //
42 // Institute of Geography //
43 // University of Hamburg //
44 // Germany //
45 // //
46 // e-mail: oconrad@saga-gis.org //
47 // //
49 
50 //---------------------------------------------------------
51 #include "pointcloud.h"
52 
53 
55 // //
56 // //
57 // //
59 
60 //---------------------------------------------------------
61 #define PC_FILE_VERSION "SGPC01"
62 
63 #define PC_STR_NBYTES 32
64 #define PC_DAT_NBYTES 32
65 
66 #define PC_GET_NBYTES(type) (type == SG_DATATYPE_String ? PC_STR_NBYTES : type == SG_DATATYPE_Date ? PC_DAT_NBYTES : (int)SG_Data_Type_Get_Size(type))
67 
68 
70 // //
71 // //
72 // //
74 
75 //---------------------------------------------------------
76 CSG_PointCloud * SG_Create_PointCloud(void)
77 {
78  return( new CSG_PointCloud );
79 }
80 
81 //---------------------------------------------------------
82 CSG_PointCloud * SG_Create_PointCloud(const CSG_PointCloud &PointCloud)
83 {
84  return( new CSG_PointCloud(PointCloud) );
85 }
86 
87 //---------------------------------------------------------
88 CSG_PointCloud * SG_Create_PointCloud(const char *File) { return( SG_Create_PointCloud(CSG_String(File)) ); }
89 CSG_PointCloud * SG_Create_PointCloud(const wchar_t *File) { return( SG_Create_PointCloud(CSG_String(File)) ); }
90 CSG_PointCloud * SG_Create_PointCloud(const CSG_String &File)
91 {
92  CSG_PointCloud *pPoints = new CSG_PointCloud();
93 
94  if( pPoints->Create(File) )
95  {
96  return( pPoints );
97  }
98 
99  delete(pPoints); return( NULL );
100 }
101 
102 //---------------------------------------------------------
103 CSG_PointCloud * SG_Create_PointCloud(CSG_PointCloud *pStructure)
104 {
105  return( new CSG_PointCloud(pStructure) );
106 }
107 
108 
110 // //
111 // //
112 // //
114 
115 //---------------------------------------------------------
116 CSG_PointCloud::CSG_PointCloud(void)
117  : CSG_Shapes()
118 {
119  _On_Construction();
120 
121  Create();
122 }
123 
124 bool CSG_PointCloud::Create(void)
125 {
126  Destroy();
127 
128  Add_Field("", SG_DATATYPE_Undefined); // add x, y, z fields
129 
130  return( true );
131 }
132 
133 //---------------------------------------------------------
134 CSG_PointCloud::CSG_PointCloud(const CSG_PointCloud &PointCloud)
135  : CSG_Shapes()
136 {
137  _On_Construction(); Create(PointCloud);
138 }
139 
140 bool CSG_PointCloud::Create(const CSG_PointCloud &PointCloud)
141 {
142  return( Assign((CSG_Data_Object *)&PointCloud) );
143 }
144 
145 //---------------------------------------------------------
146 CSG_PointCloud::CSG_PointCloud(const char *File) : CSG_PointCloud(CSG_String(File)) {}
147 CSG_PointCloud::CSG_PointCloud(const wchar_t *File) : CSG_PointCloud(CSG_String(File)) {}
148 CSG_PointCloud::CSG_PointCloud(const CSG_String &File)
149  : CSG_Shapes()
150 {
151  _On_Construction(); Create(File);
152 }
153 
154 bool CSG_PointCloud::Create(const char *File) { return( Create(CSG_String(File)) ); }
155 bool CSG_PointCloud::Create(const wchar_t *File) { return( Create(CSG_String(File)) ); }
156 bool CSG_PointCloud::Create(const CSG_String &File)
157 {
158  return( _Load(File) );
159 }
160 
161 //---------------------------------------------------------
162 CSG_PointCloud::CSG_PointCloud(CSG_PointCloud *pTemplate)
163  : CSG_Shapes()
164 {
165  _On_Construction(); Create(pTemplate);
166 }
167 
168 bool CSG_PointCloud::Create(CSG_PointCloud *pTemplate)
169 {
170  Destroy();
171 
172  if( pTemplate && pTemplate->m_nFields > 0 )
173  {
174  for(int iField=0; iField<pTemplate->m_nFields; iField++)
175  {
176  _Add_Field(pTemplate->Get_Field_Name(iField), pTemplate->Get_Field_Type(iField));
177  }
178 
179  return( true );
180  }
181 
182  return( false );
183 }
184 
185 //---------------------------------------------------------
186 void CSG_PointCloud::_On_Construction(void)
187 {
188  m_Type = SHAPE_TYPE_Point;
189  m_Vertex_Type = SG_VERTEX_TYPE_XYZ;
190 
191  m_nFields = 0;
192  m_Field_Name = NULL;
193  m_Field_Type = NULL;
194  m_Field_Stats = NULL;
195  m_Field_Offset = NULL;
196 
197  m_Points = NULL;
198  m_nRecords = 0;
199  m_nPointBytes = 0;
200 
201  m_Cursor = NULL;
202  m_bXYZPrecDbl = true;
203 
204  Set_NoData_Value(-999999);
205 
206  Set_Update_Flag();
207 
208  m_Shapes.Create(SHAPE_TYPE_Point, NULL, NULL, SG_VERTEX_TYPE_XYZ);
209  m_Shapes.Set_Count(SG_OMP_Get_Max_Num_Procs());
210  for(sLong i=0; i<m_Shapes.Get_Count(); i++)
211  {
212  m_Shapes[i].m_Index = -1;
213  }
214 
215  m_Array_Points.Create(sizeof(char *), 0, TSG_Array_Growth::SG_ARRAY_GROWTH_3);
216 }
217 
218 //---------------------------------------------------------
219 CSG_PointCloud::~CSG_PointCloud(void)
220 {
221  Destroy();
222 }
223 
224 bool CSG_PointCloud::Destroy(void)
225 {
226  Del_Points();
227 
228  if( m_nFields > 0 )
229  {
230  for(int iField=0; iField<m_nFields; iField++)
231  {
232  delete(m_Field_Name [iField]);
233  delete(m_Field_Stats[iField]);
234  }
235 
236  SG_Free(m_Field_Name );
237  SG_Free(m_Field_Type );
238  SG_Free(m_Field_Stats );
239  SG_Free(m_Field_Offset);
240 
241  _On_Construction();
242  }
243 
244  CSG_Data_Object::Destroy();
245 
246  return( true );
247 }
248 
249 
251 // //
252 // File //
253 // //
255 
256 //---------------------------------------------------------
257 bool CSG_PointCloud::_Load(const CSG_String &File)
258 {
259  SG_UI_Msg_Add(CSG_String::Format("%s %s: %s...", _TL("Loading"), _TL("point cloud"), File.c_str()), true);
260 
261  bool bResult = false;
262 
263  if( SG_File_Cmp_Extension(File, "sg-pts-z") ) // POINTCLOUD_FILE_FORMAT_Compressed
264  {
265  CSG_Archive Stream(File, SG_FILE_R);
266 
267  CSG_String _File(SG_File_Get_Name(File, false) + ".");
268 
269  if( (bResult = Stream.Get_File(_File + "sg-pts")) == false )
270  {
271  for(size_t i=0; i<Stream.Get_File_Count(); i++)
272  {
273  if( SG_File_Cmp_Extension(Stream.Get_File_Name(i), "sg-pts") )
274  {
275  _File = SG_File_Get_Name(Stream.Get_File_Name(i), false) + ".";
276 
277  break;
278  }
279  }
280 
281  bResult = Stream.Get_File(_File + "sg-pts");
282  }
283 
284  if( bResult && _Load(Stream) )
285  {
286  if( Stream.Get_File(_File + "sg-info") )
287  {
288  Load_MetaData(Stream);
289  }
290 
291  if( Stream.Get_File(_File + "sg-prj") )
292  {
293  Get_Projection().Load(Stream);
294  }
295  }
296  }
297  else // if( SG_File_Cmp_Extension(File, "sg-pts"/"spc") ) // POINTCLOUD_FILE_FORMAT_Normal
298  {
299  CSG_File Stream(File, SG_FILE_R, true);
300 
301  if( (bResult = _Load(Stream)) == true )
302  {
303  Load_MetaData(File);
304 
305  Get_Projection().Load(SG_File_Make_Path("", File, "sg-prj"));
306  }
307  }
308 
309  //-----------------------------------------------------
310  SG_UI_Process_Set_Ready();
311 
312  if( bResult )
313  {
314  Set_Modified(false);
315 
316  Set_File_Name(File, true);
317 
318  SG_UI_Msg_Add(_TL("okay"), false, SG_UI_MSG_STYLE_SUCCESS);
319 
320  return( true );
321  }
322 
323  SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
324 
325  return( false );
326 }
327 
328 //---------------------------------------------------------
329 bool CSG_PointCloud::Save(const CSG_String &_File, int Format)
330 {
331  if( _File.is_Empty() )
332  {
333  return( *Get_File_Name(false) ? Save(Get_File_Name(false), Format) : false );
334  }
335 
336  if( Format == POINTCLOUD_FILE_FORMAT_Undefined )
337  {
338  Format = SG_File_Cmp_Extension(_File, "sg-pts-z")
339  ? POINTCLOUD_FILE_FORMAT_Compressed
340  : POINTCLOUD_FILE_FORMAT_Normal;
341  }
342 
343  bool bResult = false;
344 
345  CSG_String File(_File);
346 
347  switch( Format )
348  {
349  //-----------------------------------------------------
350  case POINTCLOUD_FILE_FORMAT_Compressed: default:
351  {
352  SG_File_Set_Extension(File, "sg-pts-z");
353 
354  SG_UI_Msg_Add(CSG_String::Format("%s %s: %s...", _TL("Saving"), _TL("point cloud"), File.c_str()), true);
355 
356  CSG_Archive Stream(File, SG_FILE_W);
357 
358  CSG_String Name(SG_File_Get_Name(File, false) + ".");
359 
360  if( Stream.Add_File(Name + "sg-pts") && _Save(Stream) )
361  {
362  if( Stream.Add_File(Name + "sg-pts-hdr") )
363  {
364  CSG_MetaData Header = _Create_Header(); Header.Save(Stream);
365  }
366 
367  if( Stream.Add_File(Name + "sg-info") )
368  {
369  Save_MetaData(Stream);
370  }
371 
372  if( Get_Projection().is_Okay() && Stream.Add_File(Name + "sg-prj") )
373  {
374  Get_Projection().Save(Stream);
375  }
376 
377  bResult = true;
378  }
379  }
380  break;
381 
382  //-----------------------------------------------------
383  case POINTCLOUD_FILE_FORMAT_Normal:
384  {
385  SG_File_Set_Extension(File, "sg-pts");
386 
387  SG_UI_Msg_Add(CSG_String::Format("%s %s: %s...", _TL("Saving"), _TL("point cloud"), File.c_str()), true);
388 
389  CSG_File Stream(File, SG_FILE_W, true);
390 
391  if( _Save(Stream) )
392  {
393  CSG_MetaData Header = _Create_Header(); Header.Save(SG_File_Make_Path("", File, "sg-pts-hdr"));
394 
395  Save_MetaData(File);
396 
397  if( Get_Projection().is_Okay() )
398  {
399  Get_Projection().Save(SG_File_Make_Path("", File, "sg-prj"));
400  }
401 
402  bResult = true;
403  }
404  }
405  break;
406  }
407 
408  //-----------------------------------------------------
409  SG_UI_Process_Set_Ready();
410 
411  if( bResult )
412  {
413  Set_Modified(false);
414 
415  Set_File_Name(File, true);
416 
417  SG_UI_Msg_Add(_TL("okay"), false, SG_UI_MSG_STYLE_SUCCESS);
418 
419  return( true );
420  }
421 
422  SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
423 
424  return( false );
425 }
426 
427 //---------------------------------------------------------
428 bool CSG_PointCloud::Get_Header_Content(const CSG_String &File, CSG_MetaData &Header)
429 {
430  bool bResult = false;
431 
432  if( SG_File_Cmp_Extension(File, "sg-pts-z") ) // POINTCLOUD_FILE_FORMAT_Compressed
433  {
434  CSG_Archive Stream(File, SG_FILE_R);
435 
436  CSG_String _File(SG_File_Get_Name(File, false) + ".");
437 
438  if( Stream.Get_File(_File + "sg-pts-hdr") )
439  {
440  bResult = Header.Load(Stream);
441  }
442  }
443  else // if( SG_File_Cmp_Extension(File, "sg-pts"/"spc") ) // POINTCLOUD_FILE_FORMAT_Normal
444  {
445  bResult = Header.Load(File, SG_T("sg-pts-hdr"));
446  }
447 
448  return( bResult );
449 }
450 
452 // //
454 
455 //---------------------------------------------------------
456 bool CSG_PointCloud::_Load(CSG_File &Stream)
457 {
458  if( !Stream.is_Reading() )
459  {
460  return( false );
461  }
462 
463  //-----------------------------------------------------
464  char ID[6];
465 
466  if( !Stream.Read(ID, 6) || strncmp(ID, PC_FILE_VERSION, 5) != 0 )
467  {
468  return( false );
469  }
470 
471  int nPointBytes;
472 
473  if( !Stream.Read(&nPointBytes, sizeof(int)) || nPointBytes < (int)(3 * sizeof(float)) )
474  {
475  return( false );
476  }
477 
478  int nFields;
479 
480  if( !Stream.Read(&nFields, sizeof(int)) || nFields < 3 )
481  {
482  return( false );
483  }
484 
485  //-----------------------------------------------------
486  Destroy();
487 
488  for(int iField=0; iField<nFields; iField++)
489  {
490  TSG_Data_Type Type; int iBuffer; char Name[1024];
491 
492  if( !Stream.Read(&Type , sizeof(TSG_Data_Type))
493  || !Stream.Read(&iBuffer, sizeof(int)) || !(iBuffer > 0 && iBuffer < 1024)
494  || !Stream.Read(Name , iBuffer) )
495  {
496  return( false );
497  }
498 
499  if( ID[5] == '0' ) // Data Type Definition changed!!!
500  {
501  switch( Type )
502  {
503  default: Type = SG_DATATYPE_Undefined; break;
504  case 1: Type = SG_DATATYPE_Char ; break;
505  case 2: Type = SG_DATATYPE_Short ; break;
506  case 3: Type = SG_DATATYPE_Int ; break;
507  case 4: Type = SG_DATATYPE_Long ; break;
508  case 5: Type = SG_DATATYPE_Float ; break;
509  case 6: Type = SG_DATATYPE_Double ; break;
510  }
511  }
512 
513  Name[iBuffer] = '\0';
514 
515  if( !_Add_Field(CSG_String((const char *)Name), Type) )
516  {
517  return( false );
518  }
519  }
520 
521  //-----------------------------------------------------
522  sLong fLength = Stream.Length();
523 
524  while( _Inc_Array() && Stream.Read(m_Cursor + 1, nPointBytes) && SG_UI_Process_Set_Progress((double)Stream.Tell(), (double)fLength) )
525  {
526  // nop
527  }
528 
529  _Dec_Array();
530 
531  return( true );
532 }
533 
534 //---------------------------------------------------------
535 bool CSG_PointCloud::_Save(CSG_File &Stream)
536 {
537  if( !Stream.is_Writing() )
538  {
539  return( false );
540  }
541 
542  //-----------------------------------------------------
543  int iBuffer, nPointBytes = m_nPointBytes - 1;
544 
545  Stream.Write((void *)PC_FILE_VERSION, 6);
546  Stream.Write(&nPointBytes, sizeof(int));
547  Stream.Write(&m_nFields , sizeof(int));
548 
549  for(int iField=0; iField<m_nFields; iField++)
550  {
551  Stream.Write(&m_Field_Type[iField], sizeof(TSG_Data_Type));
552 
553  iBuffer = (int)m_Field_Name[iField]->Length(); if( iBuffer >= 1024 - 1 ) iBuffer = 1024 - 1;
554  Stream.Write(&iBuffer, sizeof(int));
555  Stream.Write((void *)m_Field_Name[iField]->b_str(), sizeof(char), iBuffer);
556  }
557 
558  _Shape_Flush();
559 
560  for(sLong i=0; i<m_nRecords && SG_UI_Process_Set_Progress(i, m_nRecords); i++)
561  {
562  Stream.Write(m_Points[i] + 1, nPointBytes);
563  }
564 
565  return( true );
566 }
567 
568 //---------------------------------------------------------
569 CSG_MetaData CSG_PointCloud::_Create_Header(void) const
570 {
571  CSG_MetaData Header;
572 
573  Header.Set_Name("PointCloudHeaderFile");
574  Header.Add_Property("Version", "1.0");
575 
576  CSG_MetaData *pPoints = Header.Add_Child("Points" );
577  CSG_MetaData *pBBox = Header.Add_Child("BBox" );
578  CSG_MetaData *pNoData = Header.Add_Child("NoData" );
579  CSG_MetaData *pAttr = Header.Add_Child("Attributes");
580 
581  pPoints->Add_Property("Value", Get_Count());
582  pBBox ->Add_Property("XMin" , Get_Minimum(0));
583  pBBox ->Add_Property("YMin" , Get_Minimum(1));
584  pBBox ->Add_Property("ZMin" , Get_Minimum(2));
585  pBBox ->Add_Property("XMax" , Get_Maximum(0));
586  pBBox ->Add_Property("YMax" , Get_Maximum(1));
587  pBBox ->Add_Property("ZMax" , Get_Maximum(2));
588  pNoData->Add_Property("Value", Get_NoData_Value());
589  pAttr ->Add_Property("Count", m_nFields);
590 
591  for(int iField=0; iField<m_nFields; iField++)
592  {
593  CSG_MetaData *pField = pAttr->Add_Child(CSG_String::Format("Field_%d", iField + 1));
594 
595  pField->Add_Property("Name", Get_Field_Name(iField));
596  pField->Add_Property("Type", gSG_Data_Type_Identifier[Get_Field_Type(iField)]);
597  }
598 
599  return( Header );
600 }
601 
602 
604 // //
605 // Assign //
606 // //
608 
609 //---------------------------------------------------------
610 bool CSG_PointCloud::Assign(CSG_Data_Object *pObject, bool bProgress)
611 {
612  if( pObject->asPointCloud() && CSG_Data_Object::Assign(pObject, bProgress) )
613  {
614  CSG_PointCloud *pPoints = pObject->asPointCloud();
615 
616  Create(pPoints);
617 
618  Get_Projection().Create(pPoints->Get_Projection());
619 
620  for(sLong i=0; i<pPoints->m_nRecords && (!bProgress || SG_UI_Process_Set_Progress(i, pPoints->m_nRecords)); i++)
621  {
622  if( _Inc_Array() )
623  {
624  memcpy(m_Points[i] + 1, pPoints->m_Points[i] + 1, m_nPointBytes - 1l);
625  }
626  }
627 
628  return( true );
629  }
630 
631  return( false );
632 }
633 
634 
636 // //
637 // Checks //
638 // //
640 
641 //---------------------------------------------------------
642 bool CSG_PointCloud::is_Compatible(CSG_PointCloud *pPointCloud) const
643 {
644  if( m_nFields == pPointCloud->m_nFields )
645  {
646  for(int iField=0; iField<m_nFields; iField++)
647  {
648  if( Get_Field_Type(iField) != pPointCloud->Get_Field_Type(iField) )
649  {
650  return( false );
651  }
652  }
653 
654  return( true );
655  }
656 
657  return( false );
658 }
659 
660 
662 // //
663 // Fields //
664 // //
666 
667 //---------------------------------------------------------
668 bool CSG_PointCloud::Add_Field(const CSG_String &Name, TSG_Data_Type Type, int iField)
669 {
670  if( m_nFields == 0 ) { _Add_Field(SG_T("X"), m_bXYZPrecDbl ? SG_DATATYPE_Double : SG_DATATYPE_Float); }
671  if( m_nFields == 1 ) { _Add_Field(SG_T("Y"), m_bXYZPrecDbl ? SG_DATATYPE_Double : SG_DATATYPE_Float); }
672  if( m_nFields == 2 ) { _Add_Field(SG_T("Z"), m_bXYZPrecDbl ? SG_DATATYPE_Double : SG_DATATYPE_Float); }
673 
674  return( m_nFields >= 3 && _Add_Field(Name, Type, iField) );
675 }
676 
677 //---------------------------------------------------------
678 bool CSG_PointCloud::_Add_Field(const SG_Char *Name, TSG_Data_Type Type, int Field)
679 {
680  #define m_Field_Size(FIELD) PC_GET_NBYTES(m_Field_Type[FIELD])
681 
682  //-----------------------------------------------------
683  if( !Name || PC_GET_NBYTES(Type) <= 0 )
684  {
685  return( false );
686  }
687 
688  if( Field < 0 || Field > m_nFields )
689  {
690  Field = m_nFields;
691  }
692 
693  if( Field < 3 && m_nFields >= 3 )
694  {
695  Field = 3; // (x, y, z) always have to stay in the first place
696  }
697 
698  //-----------------------------------------------------
699  int nFieldBytes = PC_GET_NBYTES(Type);
700 
701  if( m_nFields < 1 )
702  {
703  m_nPointBytes = 1;
704  }
705 
706  m_nFields++; m_nPointBytes += nFieldBytes;
707 
708  //-----------------------------------------------------
709  m_Field_Name = (CSG_String **)SG_Realloc(m_Field_Name , m_nFields * sizeof(CSG_String *));
710  m_Field_Type = (TSG_Data_Type *)SG_Realloc(m_Field_Type , m_nFields * sizeof(TSG_Data_Type ));
711  m_Field_Stats = (CSG_Simple_Statistics **)SG_Realloc(m_Field_Stats , m_nFields * sizeof(CSG_Simple_Statistics *));
712  m_Field_Offset = (int *)SG_Realloc(m_Field_Offset, m_nFields * sizeof(int ));
713 
714  for(int iField=m_nFields-1; iField>Field; iField--)
715  {
716  m_Field_Name [iField] = m_Field_Name [iField - 1];
717  m_Field_Type [iField] = m_Field_Type [iField - 1];
718  m_Field_Stats[iField] = m_Field_Stats[iField - 1];
719  }
720 
721  m_Field_Name [Field] = new CSG_String(Name);
722  m_Field_Type [Field] = Type;
723  m_Field_Stats[Field] = new CSG_Simple_Statistics();
724 
725  for(int iField=0, Offset=1; iField<m_nFields; iField++)
726  {
727  m_Field_Offset[iField] = Offset; Offset+=m_Field_Size(iField);
728  }
729 
730  //-----------------------------------------------------
731  int Offset = m_Field_Offset[Field], nMoveBytes = Field < m_nFields - 1 ? m_nPointBytes - m_Field_Offset[Field + 1] : 0;
732 
733  #pragma omp parallel for
734  for(sLong i=0; i<m_nRecords; i++)
735  {
736  m_Points[i] = (char *)SG_Realloc(m_Points[i], m_nPointBytes * sizeof(char));
737 
738  if( nMoveBytes > 0 )
739  {
740  memmove(m_Points[i] + Offset + nFieldBytes, m_Points[i] + Offset, nMoveBytes);
741  }
742 
743  memset(m_Points[i] + Offset, 0, nFieldBytes);
744  }
745 
746  //-----------------------------------------------------
747  m_Shapes.Add_Field(Name, Type, Field);
748 
749  Set_Modified();
750 
751  return( true );
752 }
753 
754 //---------------------------------------------------------
755 bool CSG_PointCloud::Del_Field(int Index)
756 {
757  #define m_Field_Size(FIELD) PC_GET_NBYTES(m_Field_Type[FIELD])
758 
759  //-----------------------------------------------------
760  if( Index < 3 || Index >= m_nFields )
761  {
762  return( false );
763  }
764 
765  //-----------------------------------------------------
766  int nFieldBytes = PC_GET_NBYTES(m_Field_Type[Index]);
767 
768  m_nFields--; m_nPointBytes -= nFieldBytes;
769 
770  //-----------------------------------------------------
771  int Offset = m_Field_Offset[Index], nMoveBytes = Index < m_nFields ? (m_nPointBytes + nFieldBytes) - m_Field_Offset[Index + 1] : 0;
772 
773  #pragma omp parallel for
774  for(sLong i=0; i<m_nRecords; i++)
775  {
776  if( nMoveBytes > 0 )
777  {
778  memmove(m_Points[i] + Offset, m_Points[i] + Offset + nFieldBytes, nMoveBytes);
779  }
780 
781  m_Points[i] = (char *)SG_Realloc(m_Points[i], m_nPointBytes * sizeof(char));
782  }
783 
784  //-----------------------------------------------------
785  delete(m_Field_Name [Index]);
786  delete(m_Field_Stats[Index]);
787 
788  for(int iField=Index, Offset=m_Field_Offset[Index]; iField<m_nFields; iField++)
789  {
790  m_Field_Name [iField] = m_Field_Name [iField + 1];
791  m_Field_Type [iField] = m_Field_Type [iField + 1];
792  m_Field_Stats [iField] = m_Field_Stats[iField + 1];
793  m_Field_Offset[iField] = Offset; Offset += m_Field_Size(iField);
794  }
795 
796  m_Field_Name = (CSG_String **)SG_Realloc(m_Field_Name , m_nFields * sizeof(CSG_String *));
797  m_Field_Type = (TSG_Data_Type *)SG_Realloc(m_Field_Type , m_nFields * sizeof(TSG_Data_Type ));
798  m_Field_Stats = (CSG_Simple_Statistics **)SG_Realloc(m_Field_Stats , m_nFields * sizeof(CSG_Simple_Statistics *));
799  m_Field_Offset = (int *)SG_Realloc(m_Field_Offset, m_nFields * sizeof(int ));
800 
801  //-----------------------------------------------------
802  m_Shapes.Del_Field(Index);
803 
804  Set_Modified();
805 
806  return( true );
807 }
808 
809 //---------------------------------------------------------
810 bool CSG_PointCloud::Mov_Field(int Index, int Position)
811 {
812  if( Position < 0 )
813  {
814  Position = 0;
815  }
816  else if( Position >= m_nFields - 1 )
817  {
818  Position = m_nFields - 1;
819  }
820 
821  if( Index < 3 || Index >= m_nFields || Index == Position )
822  {
823  return( false );
824  }
825 
826  //-----------------------------------------------------
827  if( Position > Index )
828  {
829  Position++;
830  }
831 
832  if( !Add_Field(Get_Field_Name(Index), Get_Field_Type(Index), Position) )
833  {
834  return( false );
835  }
836 
837  if( Position < Index )
838  {
839  Index++;
840  }
841 
842  size_t Size = PC_GET_NBYTES(m_Field_Type[Index]);
843 
844  #pragma omp parallel for
845  for(sLong i=0; i<m_nRecords; i++)
846  {
847  memcpy(m_Points[i] + m_Field_Offset[Position], m_Points[i] + m_Field_Offset[Index], Size);
848  }
849 
850  if( !Del_Field(Index) )
851  {
852  return( false );
853  }
854 
855  //-----------------------------------------------------
856  return( true );
857 }
858 
859 
861 // //
863 
864 //---------------------------------------------------------
869 //---------------------------------------------------------
870 int CSG_PointCloud::Get_Field_Length(int Field, int Encoding) const
871 {
872  size_t Length = 0;
873 
874  if( Field >= 0 && Field < m_nFields )
875  {
876  Length = (Field + 1 >= m_nFields ? m_nPointBytes : m_Field_Offset[Field + 1]) - m_Field_Offset[Field];
877  }
878 
879  return( (int)Length );
880 }
881 
882 //---------------------------------------------------------
883 bool CSG_PointCloud::Set_Field_Type(int iField, TSG_Data_Type Type)
884 {
885  if( iField < 3 || iField >= m_nFields )
886  {
887  return( false );
888  }
889 
890  if( Type == m_Field_Type[iField] )
891  {
892  return( true );
893  }
894 
895  //-----------------------------------------------------
896  Add_Field(Get_Field_Name(iField), Type, iField);
897 
898  #pragma omp parallel for
899  for(sLong i=0; i<m_nRecords; i++)
900  {
901  Set_Value(i, iField, Get_Value(i, iField + 1));
902  }
903 
904  Del_Field(iField + 1);
905 
906  //-----------------------------------------------------
907  m_Shapes.Set_Field_Type(iField, Type);
908 
909  Set_Modified();
910 
911  return( true );
912 }
913 
914 //---------------------------------------------------------
915 bool CSG_PointCloud::_Set_Field_Value(char *pPoint, int iField, double Value)
916 {
917  if( pPoint && iField >= 0 && iField < m_nFields )
918  {
919  pPoint = ((char *)pPoint) + m_Field_Offset[iField];
920 
921  switch( m_Field_Type[iField] )
922  {
923  case SG_DATATYPE_Byte : *((BYTE *)pPoint) = (BYTE )Value ; break;
924  case SG_DATATYPE_Char : *((char *)pPoint) = (char )Value ; break;
925  case SG_DATATYPE_Word : *((WORD *)pPoint) = (WORD )Value ; break;
926  case SG_DATATYPE_Short : *((short *)pPoint) = (short )Value ; break;
927  case SG_DATATYPE_DWord : *((DWORD *)pPoint) = (DWORD )Value ; break;
928  case SG_DATATYPE_Int : *((int *)pPoint) = (int )Value ; break;
929  case SG_DATATYPE_Long : *((sLong *)pPoint) = (sLong )Value ; break;
930  case SG_DATATYPE_ULong : *((uLong *)pPoint) = (uLong )Value ; break;
931  case SG_DATATYPE_Float : *((float *)pPoint) = (float )Value ; break;
932  case SG_DATATYPE_Double: *((double *)pPoint) = (double)Value ; break;
933  case SG_DATATYPE_Color : *((DWORD *)pPoint) = (DWORD )Value ; break;
934  case SG_DATATYPE_String: sprintf( pPoint, "%f" , Value); break;
935  default : break;
936  }
937 
938  m_Field_Stats[iField]->Invalidate();
939 
940  Set_Modified();
941 
942  if( iField < 3 )
943  {
944  Set_Update_Flag(); // extent might have changed
945  }
946 
947  return( true );
948  }
949 
950  return( false );
951 }
952 
953 //---------------------------------------------------------
954 double CSG_PointCloud::_Get_Field_Value(char *pPoint, int iField) const
955 {
956  if( pPoint && iField >= 0 && iField < m_nFields )
957  {
958  pPoint += m_Field_Offset[iField];
959 
960  switch( m_Field_Type[iField] )
961  {
962  case SG_DATATYPE_Byte : return( (double)*((BYTE *)pPoint) );
963  case SG_DATATYPE_Char : return( (double)*((char *)pPoint) );
964  case SG_DATATYPE_Word : return( (double)*((WORD *)pPoint) );
965  case SG_DATATYPE_Short : return( (double)*((short *)pPoint) );
966  case SG_DATATYPE_DWord : return( (double)*((DWORD *)pPoint) );
967  case SG_DATATYPE_Int : return( (double)*((int *)pPoint) );
968  case SG_DATATYPE_Long : return( (double)*((sLong *)pPoint) );
969  case SG_DATATYPE_ULong : return( (double)*((uLong *)pPoint) );
970  case SG_DATATYPE_Float : return( (double)*((float *)pPoint) );
971  case SG_DATATYPE_Double: return( (double)*((double *)pPoint) );
972  case SG_DATATYPE_Color : return( (double)*((DWORD *)pPoint) );
973  case SG_DATATYPE_String: return( (double)atof( pPoint) );
974  default : break;
975  }
976  }
977 
978  return( 0. );
979 }
980 
981 //---------------------------------------------------------
982 bool CSG_PointCloud::_Set_Field_Value(char *pPoint, int iField, const SG_Char *Value)
983 {
984  if( pPoint && iField >= 0 && iField < m_nFields && Value )
985  {
986  CSG_String s(Value);
987 
988  switch( m_Field_Type[iField] )
989  {
990  default: { double d; return( s.asDouble(d) && _Set_Field_Value(pPoint, iField, d) ); }
991 
992  case SG_DATATYPE_Date :
993  case SG_DATATYPE_String:
994  pPoint += m_Field_Offset[iField];
995  memset(pPoint, 0, PC_STR_NBYTES);
996  memcpy(pPoint, s.b_str(), s.Length() > PC_STR_NBYTES ? PC_STR_NBYTES : s.Length());
997  break;
998  }
999 
1000  return( true );
1001  }
1002 
1003  return( false );
1004 }
1005 
1006 //---------------------------------------------------------
1007 bool CSG_PointCloud::_Get_Field_Value(char *pPoint, int iField, CSG_String &Value) const
1008 {
1009  if( pPoint && iField >= 0 && iField < m_nFields )
1010  {
1011  switch( m_Field_Type[iField] )
1012  {
1013  default:
1014  Value.Printf("%f", _Get_Field_Value(pPoint, iField));
1015  break;
1016 
1017  case SG_DATATYPE_Date:
1018  case SG_DATATYPE_String:
1019  {
1020  char s[PC_STR_NBYTES + 1];
1021 
1022  memcpy(s, pPoint + m_Field_Offset[iField], PC_STR_NBYTES);
1023 
1024  s[PC_STR_NBYTES] = '\0';
1025 
1026  Value = s;
1027  }
1028  break;
1029  }
1030 
1031  return( true );
1032  }
1033 
1034  return( false );
1035 }
1036 
1037 
1039 // //
1040 // //
1041 // //
1043 
1044 //---------------------------------------------------------
1045 TSG_Point_3D CSG_PointCloud::Get_Point(void) const
1046 {
1047  TSG_Point_3D p;
1048 
1049  if( m_Cursor )
1050  {
1051  p.x = _Get_Field_Value(m_Cursor, 0);
1052  p.y = _Get_Field_Value(m_Cursor, 1);
1053  p.z = _Get_Field_Value(m_Cursor, 2);
1054  }
1055  else
1056  {
1057  p.x = p.y = p.z = 0.;
1058  }
1059 
1060  return( p );
1061 }
1062 
1063 //---------------------------------------------------------
1064 TSG_Point_3D CSG_PointCloud::Get_Point(sLong Index) const
1065 {
1066  TSG_Point_3D p;
1067 
1068  if( Index >= 0 && Index < m_nRecords )
1069  {
1070  char *pPoint = m_Points[Index];
1071 
1072  p.x = _Get_Field_Value(pPoint, 0);
1073  p.y = _Get_Field_Value(pPoint, 1);
1074  p.z = _Get_Field_Value(pPoint, 2);
1075  }
1076  else
1077  {
1078  p.x = p.y = p.z = 0.;
1079  }
1080 
1081  return( p );
1082 }
1083 
1084 //---------------------------------------------------------
1085 bool CSG_PointCloud::Set_Point(const TSG_Point_3D &Point)
1086 {
1087  return( _Set_Field_Value(m_Cursor, 0, Point.x)
1088  && _Set_Field_Value(m_Cursor, 1, Point.y)
1089  && _Set_Field_Value(m_Cursor, 2, Point.z)
1090  );
1091 }
1092 
1093 //---------------------------------------------------------
1094 bool CSG_PointCloud::Set_Point(sLong Index, const TSG_Point_3D &Point)
1095 {
1096  if( Index >= 0 && Index < m_nRecords )
1097  {
1098  return( _Set_Field_Value(m_Points[Index], 0, Point.x)
1099  && _Set_Field_Value(m_Points[Index], 1, Point.y)
1100  && _Set_Field_Value(m_Points[Index], 2, Point.z)
1101  );
1102  }
1103 
1104  return( false );
1105 }
1106 
1107 
1109 // //
1110 // //
1111 // //
1113 
1114 //---------------------------------------------------------
1115 bool CSG_PointCloud::Add_Point(double x, double y, double z)
1116 {
1117  if( _Inc_Array() )
1118  {
1119  _Set_Field_Value(m_Cursor, 0, x);
1120  _Set_Field_Value(m_Cursor, 1, y);
1121  _Set_Field_Value(m_Cursor, 2, z);
1122 
1123  Set_Modified();
1124  Set_Update_Flag();
1125  _Stats_Invalidate();
1126 
1127  return( true );
1128  }
1129 
1130  return( false );
1131 }
1132 
1133 //---------------------------------------------------------
1134 bool CSG_PointCloud::Add_Point(const CSG_Point_3D &Point)
1135 {
1136  return( Add_Point(Point.x, Point.y, Point.z) );
1137 }
1138 
1139 //---------------------------------------------------------
1140 bool CSG_PointCloud::Del_Point(sLong Index)
1141 {
1142  if( Index >= 0 && Index < m_nRecords )
1143  {
1144  if( is_Selected(Index) )
1145  {
1146  Select(Index, true);
1147  }
1148 
1149  m_Cursor = m_Points[Index];
1150 
1151  for(sLong i=Index, j=Index+1; j<m_nRecords; i++, j++)
1152  {
1153  m_Points[i] = m_Points[j];
1154  }
1155 
1156  m_Points[m_nRecords - 1] = m_Cursor;
1157 
1158  m_Cursor = NULL;
1159 
1160  _Dec_Array();
1161 
1162  Set_Modified();
1163  Set_Update_Flag();
1164  _Stats_Invalidate();
1165 
1166  return( true );
1167  }
1168 
1169  return( false );
1170 }
1171 
1172 //---------------------------------------------------------
1173 bool CSG_PointCloud::Del_Points(void)
1174 {
1175  for(sLong i=0; i<m_nRecords; i++)
1176  {
1177  SG_Free(m_Points[i]);
1178  }
1179 
1180  m_Array_Points.Destroy();
1181 
1182  m_nRecords = 0;
1183  m_Points = NULL;
1184  m_Cursor = NULL;
1185 
1186  m_Selection.Set_Array(0);
1187 
1188  Set_Modified();
1189  Set_Update_Flag();
1190  _Stats_Invalidate();
1191 
1192  return( true );
1193 }
1194 
1195 
1197 // //
1198 // //
1199 // //
1201 
1202 //---------------------------------------------------------
1203 bool CSG_PointCloud::_Inc_Array(void)
1204 {
1205  if( m_nFields > 0 && m_Array_Points.Set_Array(m_nRecords + 1, (void **)&m_Points) )
1206  {
1207  m_Points[m_nRecords++] = m_Cursor = (char *)SG_Calloc(m_nPointBytes, sizeof(char));
1208 
1209  return( true );
1210  }
1211 
1212  return( false );
1213 }
1214 
1215 //---------------------------------------------------------
1216 bool CSG_PointCloud::_Dec_Array(void)
1217 {
1218  if( m_nRecords > 0 )
1219  {
1220  m_nRecords --;
1221 
1222  m_Cursor = NULL;
1223 
1224  SG_Free(m_Points[m_nRecords]);
1225 
1226  m_Array_Points.Set_Array(m_nRecords, (void **)&m_Points);
1227  }
1228 
1229  return( true );
1230 }
1231 
1232 
1234 // //
1235 // Statistics //
1236 // //
1238 
1239 //---------------------------------------------------------
1240 bool CSG_PointCloud::On_Update(void)
1241 {
1242  if( m_nFields >= 2 )
1243  {
1244  _Shape_Flush();
1245 
1246  _Stats_Update(0);
1247  _Stats_Update(1);
1248  _Stats_Update(2);
1249 
1250  m_Extent.Assign(
1251  m_Field_Stats[0]->Get_Minimum(), m_Field_Stats[1]->Get_Minimum(),
1252  m_Field_Stats[0]->Get_Maximum(), m_Field_Stats[1]->Get_Maximum()
1253  );
1254 
1255  m_ZMin = m_Field_Stats[2]->Get_Minimum();
1256  m_ZMax = m_Field_Stats[2]->Get_Maximum();
1257 
1258  for(int iField=3; iField<m_nFields; iField++)
1259  {
1260  m_Field_Stats[iField]->Invalidate();
1261  }
1262  }
1263 
1264  return( true );
1265 }
1266 
1267 //---------------------------------------------------------
1268 bool CSG_PointCloud::_Stats_Update(int Field) const
1269 {
1270  if( Field < 0 || Field >= m_nFields || m_nRecords < 1 )
1271  {
1272  return( false );
1273  }
1274 
1275  CSG_Simple_Statistics &Statistics = *m_Field_Stats[Field];
1276 
1277  if( Statistics.is_Evaluated() )
1278  {
1279  return( true );
1280  }
1281 
1282  if( Field > 2 && Get_Max_Samples() > 0 && Get_Max_Samples() < m_nRecords )
1283  {
1284  double d = (double)m_nRecords / (double)Get_Max_Samples();
1285 
1286  for(double i=0; i<(double)m_nRecords; i+=d)
1287  {
1288  double Value = Get_Value((sLong)i, Field);
1289 
1290  if( Field < 3 || is_NoData_Value(Value) == false )
1291  {
1292  Statistics += Value;
1293  }
1294  }
1295 
1296  Statistics.Set_Count(Statistics.Get_Count() >= Get_Max_Samples() ? m_nRecords // any no-data cells ?
1297  : (sLong)(m_nRecords * (double)Statistics.Get_Count() / (double)Get_Max_Samples())
1298  );
1299  }
1300  else
1301  {
1302  char **pPoint = m_Points;
1303 
1304  for(sLong i=0; i<m_nRecords; i++, pPoint++)
1305  {
1306  double Value = _Get_Field_Value(*pPoint, Field);
1307 
1308  if( Field < 3 || is_NoData_Value(Value) == false )
1309  {
1310  Statistics += Value;
1311  }
1312  }
1313  }
1314 
1315  return( Statistics.Evaluate() ); // evaluate! prevent values to be added more than once!
1316 }
1317 
1318 
1320 // //
1321 // //
1322 // //
1324 
1325 //---------------------------------------------------------
1326 bool CSG_PointCloud::On_Reload(void)
1327 {
1328  return( Create(Get_File_Name(false)) );
1329 }
1330 
1331 //---------------------------------------------------------
1332 bool CSG_PointCloud::On_Delete(void)
1333 {
1334  return( SG_File_Delete(Get_File_Name(false)) );
1335 }
1336 
1337 
1339 // //
1340 // //
1341 // //
1343 
1344 //---------------------------------------------------------
1345 CSG_Shape * CSG_PointCloud::_Shape_Get(sLong Index)
1346 {
1347  SG_UI_Progress_Lock(true);
1348 
1349  CSG_Shape *pShape = m_Shapes.Get_Shape(SG_OMP_Get_Thread_Num());
1350 
1351  if( pShape->is_Modified() && pShape->m_Index >= 0 && pShape->m_Index < m_nRecords )
1352  {
1353  char *Point = m_Points[pShape->m_Index];
1354 
1355  for(int iField=0; iField<m_nFields; iField++)
1356  {
1357  switch( Get_Field_Type(iField) )
1358  {
1359  default : _Set_Field_Value(Point, iField, pShape->asDouble(iField)); break;
1360  case SG_DATATYPE_Date :
1361  case SG_DATATYPE_String: _Set_Field_Value(Point, iField, pShape->asString(iField)); break;
1362  }
1363  }
1364 
1365  Set_Value(0, pShape->Get_Point().x);
1366  Set_Value(1, pShape->Get_Point().y);
1367  Set_Value(2, pShape->Get_Z () );
1368  }
1369 
1370  if( Index >= 0 && Index < m_nRecords )
1371  {
1372  char *Point = m_Points[Index];
1373 
1374  for(int iField=0; iField<m_nFields; iField++)
1375  {
1376  switch( Get_Field_Type(iField) )
1377  {
1378  default: pShape->Set_Value(iField, _Get_Field_Value(Point, iField)); break;
1379 
1380  case SG_DATATYPE_Date :
1381  case SG_DATATYPE_String: {
1382  CSG_String s; _Get_Field_Value(Point, iField, s); pShape->Set_Value(iField, s);
1383  break; }
1384  }
1385  }
1386 
1387  pShape->Set_Point(Get_Point(Index));
1388  pShape->Set_Selected(is_Selected(Index));
1389  pShape->Set_Modified(false);
1390 
1391  pShape->m_Index = Index;
1392  }
1393  else
1394  {
1395  pShape->m_Index = -1;
1396  }
1397 
1398  SG_UI_Progress_Lock(false);
1399 
1400  return( pShape->m_Index >= 0 ? pShape : NULL );
1401 }
1402 
1403 //---------------------------------------------------------
1404 void CSG_PointCloud::_Shape_Flush(void)
1405 {
1406  for(sLong i=0; i<m_Shapes.Get_Count(); i++)
1407  {
1408  _Shape_Get(m_Shapes[i].m_Index); m_Shapes[i].m_Index = -1;
1409  }
1410 }
1411 
1412 //---------------------------------------------------------
1413 CSG_Table_Record * CSG_PointCloud::Get_Record(sLong Index) const
1414 {
1415  return( ((CSG_PointCloud *)this)->_Shape_Get(Index) );
1416 }
1417 
1418 
1420 // //
1421 // //
1422 // //
1424 
1425 //---------------------------------------------------------
1430 //---------------------------------------------------------
1431 sLong CSG_PointCloud::Get_Point(const CSG_Point &Point, double Epsilon)
1432 {
1433  sLong Index = -1; CSG_Rect r(Point.x - Epsilon, Point.y - Epsilon, Point.x + Epsilon, Point.y + Epsilon);
1434 
1435  if( r.Intersects(Get_Extent()) != INTERSECTION_None )
1436  {
1437  double Distance = -1.;
1438 
1439  for(sLong i=0; i<m_nRecords; i++)
1440  {
1441  double x = Get_X(i), y = Get_Y(i);
1442 
1443  if( r.Contains(x, y) )
1444  {
1445  if( Index < 0 || Distance > SG_Get_Distance(Point.x, Point.y, x, y) )
1446  {
1447  Index = i; Distance = SG_Get_Distance(Point.x, Point.y, x, y);
1448  }
1449  }
1450  }
1451  }
1452 
1453  return( Index );
1454 }
1455 
1456 //---------------------------------------------------------
1457 CSG_Shape * CSG_PointCloud::Get_Shape(const CSG_Point &Point, double Epsilon)
1458 {
1459  sLong Index = Get_Point(Point, Epsilon);
1460 
1461  return( Index < 0 ? NULL : CSG_Shapes::Get_Shape(Index) );
1462 }
1463 
1464 //---------------------------------------------------------
1465 CSG_Table_Record * CSG_PointCloud::Ins_Record(sLong Index, CSG_Table_Record *pCopy)
1466 {
1467  return( NULL );
1468 }
1469 
1470 //---------------------------------------------------------
1471 CSG_Table_Record * CSG_PointCloud::Add_Record(CSG_Table_Record *pCopy)
1472 {
1473  return( Add_Shape(pCopy, SHAPE_COPY) );
1474 }
1475 
1476 //---------------------------------------------------------
1477 CSG_Shape * CSG_PointCloud::Add_Shape(CSG_Table_Record *pCopy, TSG_ADD_Shape_Copy_Mode mCopy)
1478 {
1479  Add_Point(0., 0., 0.);
1480 
1481  if( pCopy && (mCopy == SHAPE_COPY_ATTR || mCopy == SHAPE_COPY) )
1482  {
1483  for(int iField=0; iField<m_nFields && iField<pCopy->Get_Table()->Get_Field_Count(); iField++)
1484  {
1485  if( Get_Field_Type(iField) == pCopy->Get_Table()->Get_Field_Type(iField) )
1486  {
1487  if( SG_Data_Type_is_Numeric(Get_Field_Type(iField)) )
1488  {
1489  Set_Value(iField, pCopy->asDouble(iField));
1490  }
1491  else
1492  {
1493  Set_Value(iField, pCopy->asString(iField));
1494  }
1495  }
1496  }
1497  }
1498 
1499  return( _Shape_Get(m_nRecords - 1) );
1500 }
1501 
1502 
1504 // //
1505 // //
1506 // //
1508 
1509 //---------------------------------------------------------
1510 bool CSG_PointCloud::Select(sLong Index, bool bInvert)
1511 {
1512  if( !bInvert && Get_Selection_Count() > 0 )
1513  {
1514  for(sLong i=0; i<Get_Selection_Count(); i++)
1515  {
1516  m_Points[Get_Selection_Index(i)][0] &= ~SG_TABLE_REC_FLAG_Selected;
1517  }
1518 
1519  m_Selection.Destroy();
1520  }
1521 
1522  if( Set_Cursor(Index) )
1523  {
1524  if( (m_Cursor[0] & SG_TABLE_REC_FLAG_Selected) == 0 ) // select
1525  {
1526  if( _Add_Selection(Index) )
1527  {
1528  m_Cursor[0] |= SG_TABLE_REC_FLAG_Selected;
1529 
1530  return( true );
1531  }
1532  }
1533  else // deselect
1534  {
1535  if( _Del_Selection(Index) )
1536  {
1537  m_Cursor[0] &= ~SG_TABLE_REC_FLAG_Selected;
1538 
1539  return( true );
1540  }
1541  }
1542  }
1543 
1544  return( false );
1545 }
1546 
1547 //---------------------------------------------------------
1548 bool CSG_PointCloud::Select(CSG_Table_Record *pShape, bool bInvert)
1549 {
1550  return( CSG_Table::Select(pShape, bInvert) );
1551 }
1552 
1553 //---------------------------------------------------------
1554 bool CSG_PointCloud::Select(const TSG_Rect &Extent, bool bInvert)
1555 {
1556  if( !bInvert ) // clear selection
1557  {
1558  Select(-1, false);
1559  }
1560 
1561  if( Get_Extent().Intersects(Extent) != INTERSECTION_None )
1562  {
1563  for(sLong i=0; i<m_nRecords; i++)
1564  {
1565  Set_Cursor(i);
1566 
1567  if( Extent.xMin <= Get_X() && Get_X() <= Extent.xMax
1568  && Extent.yMin <= Get_Y() && Get_Y() <= Extent.yMax )
1569  {
1570  Select(i, true);
1571  }
1572  }
1573  }
1574 
1575  return( Get_Selection_Count() > 0 );
1576 }
1577 
1578 //---------------------------------------------------------
1579 bool CSG_PointCloud::Select(const TSG_Point &Point, bool bInvert)
1580 {
1581  return( Select(CSG_Rect(Point.x, Point.y, Point.x, Point.y), bInvert) );
1582 }
1583 
1584 
1586 // //
1588 
1589 //---------------------------------------------------------
1590 bool CSG_PointCloud::is_Selected(sLong Index) const
1591 {
1592  return( Index >= 0 && Index < m_nRecords && (m_Points[Index][0] & SG_TABLE_REC_FLAG_Selected) != 0 );
1593 }
1594 
1595 
1597 // //
1599 
1600 //---------------------------------------------------------
1601 CSG_Shape * CSG_PointCloud::Get_Selection(sLong Index)
1602 {
1603  return( Index < Get_Selection_Count() ? _Shape_Get(Get_Selection_Index(Index)) : NULL );
1604 }
1605 
1606 //---------------------------------------------------------
1607 const CSG_Rect & CSG_PointCloud::Get_Selection_Extent(void)
1608 {
1609  if( Get_Selection_Count() > 0 && Set_Cursor((int)Get_Selection_Index(0)) )
1610  {
1611  TSG_Rect r;
1612 
1613  r.xMin = r.xMax = Get_X();
1614  r.yMin = r.yMax = Get_Y();
1615 
1616  for(sLong i=1; i<Get_Selection_Count(); i++)
1617  {
1618  if( Set_Cursor(Get_Selection_Index(i)) )
1619  {
1620  if( Get_X() < r.xMin ) { r.xMin = Get_X(); } else if( Get_X() > r.xMax ) { r.xMax = Get_X(); }
1621  if( Get_Y() < r.yMin ) { r.yMin = Get_Y(); } else if( Get_Y() > r.yMax ) { r.yMax = Get_Y(); }
1622  }
1623  }
1624 
1625  m_Extent_Selected.Assign(r);
1626  }
1627  else
1628  {
1629  m_Extent_Selected.Assign(0., 0., 0., 0.);
1630  }
1631 
1632  return( m_Extent_Selected );
1633 }
1634 
1635 
1637 // //
1639 
1640 //---------------------------------------------------------
1641 sLong CSG_PointCloud::Del_Selection(void)
1642 {
1643  sLong n = 0;
1644 
1645  if( Get_Selection_Count() > 0 )
1646  {
1647  m_Selection.Set_Array(0);
1648 
1649  m_Cursor = NULL;
1650 
1651  for(sLong i=0; i<m_nRecords; i++)
1652  {
1653  if( (m_Points[i][0] & SG_TABLE_REC_FLAG_Selected) != 0 )
1654  {
1655  SG_Free(m_Points[i]);
1656  }
1657  else
1658  {
1659  if( n < i )
1660  {
1661  m_Points[n] = m_Points[i];
1662  }
1663 
1664  n++;
1665  }
1666  }
1667 
1668  m_Array_Points.Set_Array(m_nRecords = n, (void **)&m_Points);
1669 
1670  Set_Modified();
1671  Set_Update_Flag();
1672  _Stats_Invalidate();
1673  }
1674 
1675  return( n );
1676 }
1677 
1678 //---------------------------------------------------------
1679 sLong CSG_PointCloud::Inv_Selection(void)
1680 {
1681  if( m_Selection.Set_Array(m_nRecords - Get_Selection_Count()) )
1682  {
1683  char **pPoint = m_Points;
1684 
1685  for(sLong i=0, n=0; i<m_nRecords && n<Get_Selection_Count(); i++, pPoint++)
1686  {
1687  if( ((*pPoint)[0] & SG_TABLE_REC_FLAG_Selected) != 0 )
1688  {
1689  (*pPoint)[0] &= ~SG_TABLE_REC_FLAG_Selected;
1690  }
1691  else
1692  {
1693  (*pPoint)[0] |= SG_TABLE_REC_FLAG_Selected;
1694 
1695  _Set_Selection(i, n++);
1696  }
1697  }
1698  }
1699 
1700  return( Get_Selection_Count() );
1701 }
1702 
1703 
1705 // //
1706 // //
1707 // //
1709 
1710 //---------------------------------------------------------
1711 bool CSG_PointCloud::Sort(const CSG_Index &Index)
1712 {
1713  m_Points[m_nRecords++] = (char *)SG_Calloc(m_nPointBytes, sizeof(char));
1714 
1715  if( Get_Count() > 0 && Get_Count() == Index.Get_Count() )
1716  {
1717  char **Points = (char **)SG_Malloc(m_nBuffer * sizeof(char *)); memcpy(Points, m_Points, Get_Count());
1718 
1719  for(sLong i=0; i<Get_Count(); i++)
1720  {
1721  m_Points[i] = Points[Index[i]];
1722  }
1723 
1724  SG_Free(Points);
1725 
1726  Del_Index(); m_Cursor = NULL;
1727 
1728  return( true );
1729  }
1730 
1731  return( false );
1732 }
1733 
1734 
1736 // //
1737 // //
1738 // //
1740 
1741 //---------------------------------------------------------
CSG_Index
Definition: mat_tools.h:200
CSG_PointCloud::Add_Record
virtual CSG_Table_Record * Add_Record(CSG_Table_Record *pCopy=NULL)
Definition: pointcloud.cpp:1471
CSG_Data_Object::Assign
virtual bool Assign(CSG_Data_Object *pObject, bool bProgress=false)
Definition: dataobject.cpp:797
CSG_Rect
Definition: geo_tools.h:474
SG_DATATYPE_Color
@ SG_DATATYPE_Color
Definition: api_core.h:1009
SG_DATATYPE_Int
@ SG_DATATYPE_Int
Definition: api_core.h:1002
CSG_Table_Record::asDouble
double asDouble(int Field) const
Definition: table_record.cpp:527
SHAPE_COPY_ATTR
@ SHAPE_COPY_ATTR
Definition: shapes.h:127
CSG_Array::Set_Array
bool Set_Array(sLong nValues, bool bShrink=true)
Definition: api_memory.cpp:310
CSG_PointCloud::Get_Y
double Get_Y(void) const
Definition: pointcloud.h:169
CSG_PointCloud::Get_X
double Get_X(void) const
Definition: pointcloud.h:168
CSG_Rect::Assign
CSG_Rect & Assign(double xMin, double yMin, double xMax, double yMax)
Definition: geo_classes.cpp:727
CSG_Shapes::m_Extent_Selected
CSG_Rect m_Extent_Selected
Definition: shapes.h:849
CSG_Shapes::m_ZMin
double m_ZMin
Definition: shapes.h:843
SG_DATATYPE_Undefined
@ SG_DATATYPE_Undefined
Definition: api_core.h:1011
CSG_PointCloud::Destroy
virtual bool Destroy(void)
Definition: pointcloud.cpp:224
CSG_Data_Object::Get_Max_Samples
sLong Get_Max_Samples(void) const
Definition: dataobject.h:263
CSG_Projection::Save
bool Save(const CSG_String &File, ESG_CRS_Format Format=ESG_CRS_Format::WKT) const
Definition: projections.cpp:261
SG_T
#define SG_T(s)
Definition: api_core.h:537
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_Table::Set_Count
virtual bool Set_Count(sLong nRecords)
Definition: table.cpp:950
SG_DATATYPE_String
@ SG_DATATYPE_String
Definition: api_core.h:1007
_TL
#define _TL(s)
Definition: api_core.h:1556
SG_DATATYPE_DWord
@ SG_DATATYPE_DWord
Definition: api_core.h:1001
PC_STR_NBYTES
#define PC_STR_NBYTES
Definition: pointcloud.cpp:63
CSG_Data_Object::Set_File_Name
void Set_File_Name(const CSG_String &FileName)
Definition: dataobject.cpp:366
POINTCLOUD_FILE_FORMAT_Normal
@ POINTCLOUD_FILE_FORMAT_Normal
Definition: pointcloud.h:91
CSG_Shapes::Get_Shape
virtual CSG_Shape * Get_Shape(const CSG_Point &Point, double Epsilon=0.)
Definition: shapes.cpp:483
CSG_String::b_str
const char * b_str(void) const
Definition: api_string.cpp:242
CSG_PointCloud::Set_Point
virtual bool Set_Point(const TSG_Point_3D &Point)
Definition: pointcloud.cpp:1085
CSG_PointCloud::Set_Field_Type
virtual bool Set_Field_Type(int Field, TSG_Data_Type Type)
Definition: pointcloud.cpp:883
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
CSG_Table_Record
Definition: table.h:130
CSG_Shape::Get_Z
virtual double Get_Z(int iPoint=0, int iPart=0, bool bAscending=true) const
Definition: shapes.h:193
CSG_Table_Record::Set_Selected
void Set_Selected(bool bOn=true)
Definition: table_record.cpp:204
CSG_Data_Object::Get_NoData_Value
double Get_NoData_Value(bool bUpper=false) const
Definition: dataobject.h:253
TSG_ADD_Shape_Copy_Mode
TSG_ADD_Shape_Copy_Mode
Definition: shapes.h:124
SG_Create_PointCloud
CSG_PointCloud * SG_Create_PointCloud(void)
Definition: pointcloud.cpp:76
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
CSG_Table::m_Selection
CSG_Array m_Selection
Definition: table.h:470
CSG_Table::Set_Field_Type
virtual bool Set_Field_Type(int Field, TSG_Data_Type Type)
Definition: table.cpp:610
CSG_Table::Get_Maximum
double Get_Maximum(int Field) const
Definition: table.h:381
CSG_Shapes::Create
bool Create(const CSG_Shapes &Shapes)
Definition: shapes.cpp:209
m_Field_Size
#define m_Field_Size(FIELD)
SG_Malloc
SAGA_API_DLL_EXPORT void * SG_Malloc(size_t size)
Definition: api_memory.cpp:65
SG_TABLE_REC_FLAG_Selected
#define SG_TABLE_REC_FLAG_Selected
Definition: table.h:119
CSG_Table::m_Field_Name
CSG_String ** m_Field_Name
Definition: table.h:466
CSG_Data_Object::Save_MetaData
bool Save_MetaData(const CSG_String &FileName)
Definition: dataobject.cpp:681
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
SG_DATATYPE_Byte
@ SG_DATATYPE_Byte
Definition: api_core.h:997
CSG_Archive
Definition: api_core.h:1201
CSG_Rect::Intersects
TSG_Intersection Intersects(const CSG_Rect &Rect) const
Definition: geo_classes.cpp:881
CSG_PointCloud::Get_Selection_Extent
virtual const CSG_Rect & Get_Selection_Extent(void)
Definition: pointcloud.cpp:1607
CSG_Shapes::m_ZMax
double m_ZMax
Definition: shapes.h:843
SSG_Point_3D::x
double x
Definition: geo_tools.h:266
SSG_Rect::xMax
double xMax
Definition: geo_tools.h:468
CSG_PointCloud::Select
virtual bool Select(sLong Index, bool bInvert=false)
Definition: pointcloud.cpp:1510
CSG_PointCloud::On_Reload
virtual bool On_Reload(void)
Definition: pointcloud.cpp:1326
CSG_Table::Get_Field_Count
int Get_Field_Count(void) const
Definition: table.h:361
SG_File_Delete
SAGA_API_DLL_EXPORT bool SG_File_Delete(const CSG_String &FileName)
Definition: api_file.cpp:1084
CSG_Simple_Statistics::Evaluate
bool Evaluate(void)
Definition: mat_tools.cpp:473
SG_Free
SAGA_API_DLL_EXPORT void SG_Free(void *memblock)
Definition: api_memory.cpp:83
CSG_Shapes::m_Type
TSG_Shape_Type m_Type
Definition: shapes.h:845
SHAPE_COPY
@ SHAPE_COPY
Definition: shapes.h:128
CSG_MetaData::Save
bool Save(const CSG_String &File, const SG_Char *Extension=NULL) const
Definition: metadata.cpp:879
CSG_Table::m_Extent
CSG_Rect m_Extent
Definition: table.h:472
SG_FILE_R
@ SG_FILE_R
Definition: api_core.h:1112
SSG_Point
Definition: geo_tools.h:128
CSG_Table_Record::Get_Table
class CSG_Table * Get_Table(void)
Definition: table.h:135
CSG_PointCloud::Add_Field
virtual bool Add_Field(const CSG_String &Name, TSG_Data_Type Type, int Field=-1)
Definition: pointcloud.cpp:668
CSG_Table_Record::m_Index
sLong m_Index
Definition: table.h:256
PC_GET_NBYTES
#define PC_GET_NBYTES(type)
Definition: pointcloud.cpp:66
CSG_File::Read
size_t Read(void *Buffer, size_t Size, size_t Count=1) const
Definition: api_file.cpp:338
CSG_Data_Object::Set_Update_Flag
void Set_Update_Flag(bool bOn=true)
Definition: dataobject.h:285
SG_Calloc
SAGA_API_DLL_EXPORT void * SG_Calloc(size_t num, size_t size)
Definition: api_memory.cpp:71
CSG_File
Definition: api_core.h:1127
CSG_Table::_Stats_Invalidate
bool _Stats_Invalidate(void) const
Definition: table.cpp:1224
SSG_Rect::xMin
double xMin
Definition: geo_tools.h:468
CSG_Rect::Contains
bool Contains(double x, double y) const
Definition: geo_classes.cpp:870
CSG_Table::m_Field_Type
TSG_Data_Type * m_Field_Type
Definition: table.h:464
SSG_Rect
Definition: geo_tools.h:467
CSG_Shape::Get_Point
virtual TSG_Point Get_Point(int iPoint=0) const =0
CSG_PointCloud::Set_Value
virtual bool Set_Value(int Field, double Value)
Definition: pointcloud.h:166
CSG_PointCloud::is_Compatible
bool is_Compatible(CSG_PointCloud *pPointCloud) const
Definition: pointcloud.cpp:642
CSG_PointCloud::Del_Selection
virtual sLong Del_Selection(void)
Definition: pointcloud.cpp:1641
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
CSG_PointCloud::~CSG_PointCloud
virtual ~CSG_PointCloud(void)
Definition: pointcloud.cpp:219
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_PointCloud::Get_Field_Length
virtual int Get_Field_Length(int Field, int Encoding=SG_FILE_ENCODING_UNDEFINED) const
Definition: pointcloud.cpp:870
CSG_Table::m_Field_Stats
CSG_Simple_Statistics ** m_Field_Stats
Definition: table.h:468
SG_DATATYPE_Long
@ SG_DATATYPE_Long
Definition: api_core.h:1004
CSG_PointCloud::Sort
virtual bool Sort(const CSG_Index &Index)
Definition: pointcloud.cpp:1711
CSG_Table_Record::asString
const SG_Char * asString(int Field, int Decimals=-99) const
Definition: table_record.cpp:461
CSG_Data_Object
Definition: dataobject.h:180
CSG_Point
Definition: geo_tools.h:135
CSG_PointCloud::Del_Points
bool Del_Points(void)
Definition: pointcloud.cpp:1173
CSG_PointCloud::Del_Point
bool Del_Point(sLong Index)
Definition: pointcloud.cpp:1140
CSG_Simple_Statistics::Get_Count
sLong Get_Count(void) const
Definition: mat_tools.h:743
CSG_Table::Get_Selection_Count
sLong Get_Selection_Count(void) const
Definition: table.h:425
CSG_Simple_Statistics::Get_Minimum
double Get_Minimum(void)
Definition: mat_tools.h:746
CSG_Array::Destroy
bool Destroy(void)
Definition: api_memory.cpp:291
CSG_PointCloud::Get_Record
virtual CSG_Table_Record * Get_Record(sLong Index) const
Definition: pointcloud.cpp:1413
INTERSECTION_None
@ INTERSECTION_None
Definition: geo_tools.h:102
CSG_Table::_Set_Selection
bool _Set_Selection(sLong Index, sLong Selected)
Definition: table_selection.cpp:74
CSG_PointCloud::Get_Value
virtual double Get_Value(int Field) const
Definition: pointcloud.h:167
CSG_File::is_Writing
bool is_Writing(void) const
Definition: api_core.h:1148
CSG_Point_3D
Definition: geo_tools.h:272
CSG_PointCloud::_Stats_Update
virtual bool _Stats_Update(int Field) const
Definition: pointcloud.cpp:1268
SG_Get_Distance
double SG_Get_Distance(double ax, double ay, double bx, double by, bool bPolar)
Definition: geo_functions.cpp:103
CSG_Table::Get_Field_Name
const SG_Char * Get_Field_Name(int Field) const
Definition: table.h:362
sLong
signed long long sLong
Definition: api_core.h:158
CSG_MetaData::Add_Property
bool Add_Property(const CSG_String &Name, const CSG_String &Value)
Definition: metadata.cpp:559
SG_Data_Type_is_Numeric
bool SG_Data_Type_is_Numeric(TSG_Data_Type Type)
Definition: api_core.cpp:198
CSG_Table::Get_Count
sLong Get_Count(void) const
Definition: table.h:397
SG_OMP_Get_Max_Num_Procs
int SG_OMP_Get_Max_Num_Procs(void)
Definition: api_core.cpp:111
SG_DATATYPE_Float
@ SG_DATATYPE_Float
Definition: api_core.h:1005
CSG_Simple_Statistics::Invalidate
void Invalidate(void)
Definition: mat_tools.cpp:447
CSG_PointCloud::Get_Shape
virtual CSG_Shape * Get_Shape(const CSG_Point &Point, double Epsilon=0.)
Definition: pointcloud.cpp:1457
CSG_PointCloud::Del_Field
virtual bool Del_Field(int Field)
Definition: pointcloud.cpp:755
CSG_Simple_Statistics::is_Evaluated
int is_Evaluated(void) const
Definition: mat_tools.h:739
SG_UI_Progress_Lock
int SG_UI_Progress_Lock(bool bOn)
Definition: api_callback.cpp:176
CSG_Data_Object::Get_File_Name
const SG_Char * Get_File_Name(bool bNative=true) const
Definition: dataobject.cpp:390
CSG_Table::Del_Index
bool Del_Index(void)
Definition: table.cpp:1399
CSG_PointCloud::Get_Header_Content
static bool Get_Header_Content(const CSG_String &FileName, CSG_MetaData &Header)
Definition: pointcloud.cpp:428
CSG_Archive::Get_File
bool Get_File(const SG_Char *Name)
Definition: api_file.cpp:765
CSG_Table::m_nBuffer
sLong m_nBuffer
Definition: table.h:462
CSG_PointCloud::Inv_Selection
virtual sLong Inv_Selection(void)
Definition: pointcloud.cpp:1679
pointcloud.h
CSG_Array::Create
void * Create(const CSG_Array &Array)
Definition: api_memory.cpp:250
CSG_PointCloud::Set_Modified
virtual void Set_Modified(bool bModified=true)
Definition: pointcloud.h:201
SG_FILE_W
@ SG_FILE_W
Definition: api_core.h:1113
SSG_Rect::yMax
double yMax
Definition: geo_tools.h:468
CSG_Projection::Load
bool Load(const CSG_String &File)
Definition: projections.cpp:253
SG_DATATYPE_Date
@ SG_DATATYPE_Date
Definition: api_core.h:1008
SG_DATATYPE_Word
@ SG_DATATYPE_Word
Definition: api_core.h:999
CSG_Shapes::Get_Extent
virtual const CSG_Rect & Get_Extent(void)
Definition: shapes.h:811
CSG_Shapes::m_Vertex_Type
TSG_Vertex_Type m_Vertex_Type
Definition: shapes.h:847
CSG_Table_Record::Set_Modified
void Set_Modified(bool bOn=true)
Definition: table_record.cpp:220
CSG_Simple_Statistics::Set_Count
bool Set_Count(sLong Count)
Definition: mat_tools.cpp:424
CSG_PointCloud::Set_Cursor
bool Set_Cursor(sLong Index)
Definition: pointcloud.h:165
CSG_PointCloud::is_Selected
virtual bool is_Selected(sLong Index) const
Definition: pointcloud.cpp:1590
CSG_String::Format
static CSG_String Format(const char *Format,...)
Definition: api_string.cpp:270
CSG_Table::_Del_Selection
bool _Del_Selection(sLong Index)
Definition: table_selection.cpp:87
CSG_Table::Add_Field
virtual bool Add_Field(const CSG_String &Name, TSG_Data_Type Type, int Position=-1)
Definition: table.cpp:465
gSG_Data_Type_Identifier
const char gSG_Data_Type_Identifier[][32]
Definition: api_core.h:1041
CSG_File::Length
sLong Length(void) const
Definition: api_file.cpp:230
CSG_Archive::Add_File
bool Add_File(const SG_Char *Name, bool bBinary=true)
Definition: api_file.cpp:705
CSG_Table::_Add_Selection
bool _Add_Selection(sLong Index)
Definition: table_selection.cpp:63
SG_Char
#define SG_Char
Definition: api_core.h:536
CSG_PointCloud::Mov_Field
virtual bool Mov_Field(int Field, int Position)
Definition: pointcloud.cpp:810
CSG_PointCloud::Create
bool Create(void)
Definition: pointcloud.cpp:124
CSG_PointCloud::On_Update
virtual bool On_Update(void)
Definition: pointcloud.cpp:1240
CSG_String
Definition: api_core.h:563
SHAPE_TYPE_Point
@ SHAPE_TYPE_Point
Definition: shapes.h:102
CSG_Shape::Set_Point
virtual int Set_Point(double x, double y, int iPoint=0, int iPart=0)=0
CSG_MetaData
Definition: metadata.h:88
POINTCLOUD_FILE_FORMAT_Compressed
@ POINTCLOUD_FILE_FORMAT_Compressed
Definition: pointcloud.h:92
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_String::is_Empty
bool is_Empty(void) const
Definition: api_string.cpp:178
SG_UI_Process_Set_Progress
bool SG_UI_Process_Set_Progress(int Position, int Range)
Definition: api_callback.cpp:255
CSG_PointCloud::Get_Point
TSG_Point_3D Get_Point(void) const
Definition: pointcloud.cpp:1045
SSG_Point::x
double x
Definition: geo_tools.h:129
CSG_Table_Record::Set_Value
bool Set_Value(int Field, const CSG_String &Value)
Definition: table_record.cpp:270
POINTCLOUD_FILE_FORMAT_Undefined
@ POINTCLOUD_FILE_FORMAT_Undefined
Definition: pointcloud.h:90
CSG_Table::Del_Field
virtual bool Del_Field(int Field)
Definition: table.cpp:504
SSG_Rect::yMin
double yMin
Definition: geo_tools.h:468
CSG_Table::Get_Minimum
double Get_Minimum(int Field) const
Definition: table.h:380
SG_DATATYPE_Short
@ SG_DATATYPE_Short
Definition: api_core.h:1000
SG_OMP_Get_Thread_Num
int SG_OMP_Get_Thread_Num(void)
Definition: api_core.cpp:112
CSG_Data_Object::Load_MetaData
bool Load_MetaData(const CSG_String &FileName)
Definition: dataobject.cpp:654
CSG_Table::Get_Selection_Index
sLong Get_Selection_Index(sLong Index=0) const
Definition: table.h:426
CSG_Table::m_nFields
int m_nFields
Definition: table.h:460
CSG_PointCloud::CSG_PointCloud
CSG_PointCloud(void)
Definition: pointcloud.cpp:116
CSG_Data_Object::asPointCloud
class CSG_PointCloud * asPointCloud(bool bPolymorph=false) const
Definition: dataobject.cpp:539
CSG_Data_Manager::PointCloud
CSG_Data_Collection & PointCloud(void) const
Definition: data_manager.h:136
SSG_Point::y
double y
Definition: geo_tools.h:129
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
SSG_Point_3D::z
double z
Definition: geo_tools.h:266
CSG_PointCloud::_On_Construction
virtual void _On_Construction(void)
Definition: pointcloud.cpp:186
CSG_PointCloud::Get_Selection
virtual CSG_Shape * Get_Selection(sLong Index=0)
Definition: pointcloud.cpp:1601
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_Shapes
Definition: shapes.h:773
CSG_String::c_str
const SG_Char * c_str(void) const
Definition: api_string.cpp:236
CSG_File::Write
size_t Write(void *Buffer, size_t Size, size_t Count=1) const
Definition: api_file.cpp:370
CSG_PointCloud
Definition: pointcloud.h:105
SG_UI_Process_Set_Ready
bool SG_UI_Process_Set_Ready(void)
Definition: api_callback.cpp:305
TSG_Data_Type
TSG_Data_Type
Definition: api_core.h:995
CSG_Table::Select
virtual bool Select(sLong Index, bool bInvert=false)
Definition: table_selection.cpp:136
SG_Realloc
SAGA_API_DLL_EXPORT void * SG_Realloc(void *memblock, size_t size)
Definition: api_memory.cpp:77
CSG_MetaData::Add_Child
CSG_MetaData * Add_Child(void)
Definition: metadata.cpp:166
CSG_Index::Get_Count
sLong Get_Count(void) const
Definition: mat_tools.h:239
CSG_Projection::Create
bool Create(const CSG_Projection &Projection)
Definition: projections.cpp:96
CSG_PointCloud::On_Delete
virtual bool On_Delete(void)
Definition: pointcloud.cpp:1332
CSG_PointCloud::Add_Point
bool Add_Point(double x, double y, double z)
Definition: pointcloud.cpp:1115
CSG_PointCloud::Assign
virtual bool Assign(CSG_Data_Object *pSource, bool bProgress=false)
Definition: pointcloud.cpp:610
CSG_Simple_Statistics
Definition: mat_tools.h:723
uLong
unsigned long long uLong
Definition: api_core.h:159
CSG_Shape
Definition: shapes.h:141
SG_DATATYPE_Char
@ SG_DATATYPE_Char
Definition: api_core.h:998
CSG_Table_Record::is_Modified
bool is_Modified(void) const
Definition: table.h:245
CSG_Data_Object::Get_Projection
CSG_Projection & Get_Projection(void)
Definition: dataobject.cpp:637
CSG_PointCloud::Ins_Record
virtual CSG_Table_Record * Ins_Record(sLong Index, CSG_Table_Record *pCopy=NULL)
Definition: pointcloud.cpp:1465
CSG_Data_Object::Destroy
virtual bool Destroy(void)
Definition: dataobject.cpp:281
SG_VERTEX_TYPE_XYZ
@ SG_VERTEX_TYPE_XYZ
Definition: shapes.h:93
CSG_File::is_Reading
bool is_Reading(void) const
Definition: api_core.h:1147
CSG_PointCloud::Save
virtual bool Save(const CSG_String &File, int Format=0)
Definition: pointcloud.cpp:329
SG_DATATYPE_ULong
@ SG_DATATYPE_ULong
Definition: api_core.h:1003
CSG_Table::m_nRecords
sLong m_nRecords
Definition: table.h:462
CSG_File::Tell
sLong Tell(void) const
Definition: api_file.cpp:265
PC_FILE_VERSION
#define PC_FILE_VERSION
Definition: pointcloud.cpp:61
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_PointCloud::Add_Shape
virtual CSG_Shape * Add_Shape(CSG_Table_Record *pCopy=NULL, TSG_ADD_Shape_Copy_Mode mCopy=SHAPE_COPY)
Definition: pointcloud.cpp:1477
SG_DATATYPE_Double
@ SG_DATATYPE_Double
Definition: api_core.h:1006