SAGA API  v9.8
shapes_io.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 // shapes_io.cpp //
15 // //
16 // Copyright (C) 2005 by Olaf Conrad //
17 // //
18 //-------------------------------------------------------//
19 // //
20 // This file is part of 'SAGA - System for Automated //
21 // Geoscientific Analyses'. //
22 // //
23 // This library is free software; you can redistribute //
24 // it and/or modify it under the terms of the GNU Lesser //
25 // General Public License as published by the Free //
26 // Software Foundation, either version 2.1 of the //
27 // License, or (at your option) any later version. //
28 // //
29 // This library is distributed in the hope that it will //
30 // be useful, but WITHOUT ANY WARRANTY; without even the //
31 // implied warranty of MERCHANTABILITY or FITNESS FOR A //
32 // PARTICULAR PURPOSE. See the GNU Lesser General Public //
33 // License for more details. //
34 // //
35 // You should have received a copy of the GNU Lesser //
36 // General Public License along with this program; if //
37 // not, see <http://www.gnu.org/licenses/>. //
38 // //
39 //-------------------------------------------------------//
40 // //
41 // contact: Olaf Conrad //
42 // Institute of Geography //
43 // University of Goettingen //
44 // Goldschmidtstr. 5 //
45 // 37077 Goettingen //
46 // Germany //
47 // //
48 // e-mail: oconrad@saga-gis.org //
49 // //
51 
52 //---------------------------------------------------------
53 #include "shapes.h"
54 #include "table_dbase.h"
55 #include "tool_library.h"
56 #include "data_manager.h"
57 
58 
60 // //
61 // //
62 // //
64 
65 //---------------------------------------------------------
66 bool CSG_Shapes::On_Reload(void)
67 {
68  return( Create(Get_File_Name(false)) );
69 }
70 
71 //---------------------------------------------------------
72 bool CSG_Shapes::On_Delete(void)
73 {
74  CSG_String File_Name = Get_File_Name(true);
75 
76  SG_File_Delete(File_Name);
77 
78  SG_File_Set_Extension(File_Name, "shp"); SG_File_Delete(File_Name); // shapes
79  SG_File_Set_Extension(File_Name, "shx"); SG_File_Delete(File_Name); // shape index
80  SG_File_Set_Extension(File_Name, "dbf"); SG_File_Delete(File_Name); // attributes
81  SG_File_Set_Extension(File_Name, "prj"); SG_File_Delete(File_Name); // projection
82  SG_File_Set_Extension(File_Name, "sbn"); SG_File_Delete(File_Name); // spatial index
83  SG_File_Set_Extension(File_Name, "sbx"); SG_File_Delete(File_Name); // spatial index
84  SG_File_Set_Extension(File_Name, "atx"); SG_File_Delete(File_Name); // attribute index
85  SG_File_Set_Extension(File_Name, "xml"); SG_File_Delete(File_Name); // metadata
86  SG_File_Set_Extension(File_Name, "cpg"); SG_File_Delete(File_Name); // code page
87  SG_File_Set_Extension(File_Name, "qix"); SG_File_Delete(File_Name); // quadtree spatial index
88 
89  return( true );
90 }
91 
92 
94 // //
95 // //
96 // //
98 
99 //---------------------------------------------------------
100 static TSG_Shape_File_Format gSG_Shape_File_Format_Default = SHAPE_FILE_FORMAT_ESRI;
101 
102 //---------------------------------------------------------
103 bool SG_Shapes_Set_File_Format_Default (int Format)
104 {
105  switch( Format )
106  {
107  case SHAPE_FILE_FORMAT_ESRI :
108  case SHAPE_FILE_FORMAT_GeoPackage:
109  case SHAPE_FILE_FORMAT_GeoJSON :
110  gSG_Shape_File_Format_Default = (TSG_Shape_File_Format)Format;
111  return( true );
112  }
113 
114  return( false );
115 }
116 
117 //---------------------------------------------------------
118 TSG_Shape_File_Format SG_Shapes_Get_File_Format_Default (void)
119 {
120  return( gSG_Shape_File_Format_Default );
121 }
122 
123 //---------------------------------------------------------
124 CSG_String SG_Shapes_Get_File_Extension_Default (void)
125 {
126  switch( gSG_Shape_File_Format_Default )
127  {
128  default:
129  case SHAPE_FILE_FORMAT_ESRI : return( "shp" );
130  case SHAPE_FILE_FORMAT_GeoPackage: return( "gpkg" );
131  case SHAPE_FILE_FORMAT_GeoJSON : return( "geojson" );
132  }
133 }
134 
135 
137 // //
139 
140 //---------------------------------------------------------
141 bool CSG_Shapes::Save(const CSG_String &File, int Format)
142 {
143  if( File.is_Empty() )
144  {
145  return( *Get_File_Name(false) ? Save(Get_File_Name(false), Format) : false );
146  }
147 
148  if( Format == SHAPE_FILE_FORMAT_Undefined )
149  {
150  Format = gSG_Shape_File_Format_Default;
151 
152  if( SG_File_Cmp_Extension(File, "shp" ) ) { Format = SHAPE_FILE_FORMAT_ESRI ; }
153  if( SG_File_Cmp_Extension(File, "gpkg" ) ) { Format = SHAPE_FILE_FORMAT_GeoPackage; }
154  if( SG_File_Cmp_Extension(File, "geojson") ) { Format = SHAPE_FILE_FORMAT_GeoJSON ; }
155 
156  if( SG_File_Cmp_Extension(File, "txt" ) ) { return( _Save_Text (File, true, '\t') ); }
157  if( SG_File_Cmp_Extension(File, "csv" ) ) { return( _Save_Text (File, true, ',') ); }
158  if( SG_File_Cmp_Extension(File, "dbf" ) ) { return( _Save_DBase(File) ); }
159  }
160 
161  //-----------------------------------------------------
162  bool bResult = false;
163 
164  SG_UI_Msg_Add(CSG_String::Format("%s %s: %s...", _TL("Saving"), _TL("shapes"), File.c_str()), true);
165 
166  switch( Format )
167  {
168  case SHAPE_FILE_FORMAT_ESRI : bResult = _Save_ESRI(File ); break;
169  case SHAPE_FILE_FORMAT_GeoPackage: bResult = _Save_GDAL(File, "GPKG" ); break;
170  case SHAPE_FILE_FORMAT_GeoJSON : bResult = _Save_GDAL(File, "GeoJSON"); break;
171  }
172 
173  //-----------------------------------------------------
174  if( bResult )
175  {
176  Set_Modified(false);
177 
178  Set_File_Name(File, true);
179 
180  SG_UI_Process_Set_Ready();
181  SG_UI_Msg_Add(_TL("okay"), false, SG_UI_MSG_STYLE_SUCCESS);
182 
183  return( true );
184  }
185 
186  SG_UI_Process_Set_Ready();
187  SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
188 
189  return( false );
190 }
191 
192 
194 // //
195 // //
196 // //
198 
199 //---------------------------------------------------------
200 bool CSG_Shapes::_Load_GDAL(const CSG_String &File_Name)
201 {
202  CSG_Data_Manager Manager;
203 
204  CSG_Tool *pTool = SG_Get_Tool_Library_Manager().Create_Tool("io_gdal", 3); // Import Shapes
205 
206  if( pTool )
207  {
208  if( pTool->Settings_Push(&Manager) && pTool->Set_Parameter("FILES", File_Name, PARAMETER_TYPE_FilePath) )
209  {
210  SG_UI_Msg_Lock(true);
211  pTool->Execute();
212  SG_UI_Msg_Lock(false);
213  }
214 
215  SG_Get_Tool_Library_Manager().Delete_Tool(pTool);
216  }
217 
218  //-----------------------------------------------------
219  CSG_Shapes *pShapes = Manager.Shapes().Count() ? Manager.Shapes()[0].asShapes() : NULL;
220 
221  if( !pShapes || !Create(*pShapes) )
222  {
223  return( false );
224  }
225 
226  Get_MetaData () = pShapes->Get_MetaData ();
227  Get_Projection() = pShapes->Get_Projection();
228 
229  //-----------------------------------------------------
230  if( SG_File_Cmp_Extension(File_Name, "gpkg" )
231  || SG_File_Cmp_Extension(File_Name, "GeoJSON") )
232  {
233  Set_File_Name(File_Name, true);
234  }
235  else
236  {
237  Set_File_Name(File_Name, false);
238  }
239 
240  return( true );
241 }
242 
243 //---------------------------------------------------------
244 bool CSG_Shapes::_Save_GDAL(const CSG_String &File_Name, const CSG_String &Driver)
245 {
246  bool bResult;
247 
248  SG_UI_Msg_Lock(true);
249 
250  SG_RUN_TOOL(bResult, "io_gdal", 4, // Export Shapes
251  SG_TOOL_PARAMETER_SET("SHAPES", this)
252  && SG_TOOL_PARAMETER_SET("FORMAT", Driver)
253  && SG_TOOL_PARAMETER_SET("FILE" , File_Name)
254  );
255 
256  SG_UI_Msg_Lock(false);
257 
258  return( bResult );
259 }
260 
261 
263 // //
264 // //
265 // //
267 
268 //---------------------------------------------------------
269 bool CSG_Shapes::_Load_ESRI(const CSG_String &File_Name)
270 {
271  CSG_File Stream;
272 
273  //-----------------------------------------------------
274  // Open Encoding File...
275 
276  m_Encoding = SG_FILE_ENCODING_ANSI;
277 
278  if( Stream.Open(SG_File_Make_Path("", File_Name, "cpg")) )
279  {
280  CSG_String Line;
281 
282  if( Stream.Read_Line(Line) && Line.Find("UTF-8") >= 0 )
283  {
284  m_Encoding = SG_FILE_ENCODING_UTF8;
285  }
286 
287  Stream.Close();
288  }
289 
290  //-----------------------------------------------------
291  // Open DBase File...
292 
293  CSG_Table_DBase DBase(m_Encoding);
294 
295  if( DBase.Open_Read(SG_File_Make_Path("", File_Name, "dbf"), this, false) && DBase.Get_Field_Count() < 1 )
296  {
297  SG_UI_Msg_Add_Error(CSG_String::Format("[%s] DBase %s.", _TL("Warning"), _TL("file does not provide data.")));
298 
299  DBase.Close();
300  }
301 
302  if( DBase.is_Open() )
303  {
304  DBase.Move_First();
305  }
306  else
307  {
308  Add_Field("FID", SG_DATATYPE_Int);
309  }
310 
311  //-----------------------------------------------------
312  // Open Shapes File...
313 
314  if( !Stream.Open(SG_File_Make_Path("", File_Name, "shp"), SG_FILE_R, true) )
315  {
316  SG_UI_Msg_Add_Error(_TL("Shape file could not be opened."));
317 
318  return( false );
319  }
320 
321  //-----------------------------------------------------
322  // Read File Header (100 Bytes)...
323 
324  CSG_Buffer File_Header(100);
325 
326  if( Stream.Read(File_Header.Get_Data(), sizeof(char), 100) != 100 )
327  {
328  SG_UI_Msg_Add_Error(_TL("corrupted file header"));
329 
330  return( false );
331  }
332 
333  if( File_Header.asInt( 0, true) != 9994 ) // Byte 00 -> File Code 9994 (Integer Big)...
334  {
335  SG_UI_Msg_Add_Error(_TL("invalid file code"));
336 
337  return( false );
338  }
339 
340  if( File_Header.asInt(28, false) != 1000 ) // Byte 28 -> Version 1000 (Integer Little)...
341  {
342  SG_UI_Msg_Add_Error(_TL("unsupported file version"));
343 
344  return( false );
345  }
346 
347  int Type = File_Header.asInt(32);
348 
349  switch( Type ) // Byte 32 -> Shape Type (Integer Little)...
350  {
351  case 1: m_Type = SHAPE_TYPE_Point ; m_Vertex_Type = SG_VERTEX_TYPE_XY ; break; // Point
352  case 8: m_Type = SHAPE_TYPE_Points ; m_Vertex_Type = SG_VERTEX_TYPE_XY ; break; // MultiPoint
353  case 3: m_Type = SHAPE_TYPE_Line ; m_Vertex_Type = SG_VERTEX_TYPE_XY ; break; // PolyLine
354  case 5: m_Type = SHAPE_TYPE_Polygon; m_Vertex_Type = SG_VERTEX_TYPE_XY ; break; // Polygon
355 
356  case 11: m_Type = SHAPE_TYPE_Point ; m_Vertex_Type = SG_VERTEX_TYPE_XYZM; break; // PointZ
357  case 18: m_Type = SHAPE_TYPE_Points ; m_Vertex_Type = SG_VERTEX_TYPE_XYZM; break; // MultiPointZ
358  case 13: m_Type = SHAPE_TYPE_Line ; m_Vertex_Type = SG_VERTEX_TYPE_XYZM; break; // PolyLineZ
359  case 15: m_Type = SHAPE_TYPE_Polygon; m_Vertex_Type = SG_VERTEX_TYPE_XYZM; break; // PolygonZ
360 
361  case 21: m_Type = SHAPE_TYPE_Point ; m_Vertex_Type = SG_VERTEX_TYPE_XYZ ; break; // PointM
362  case 28: m_Type = SHAPE_TYPE_Points ; m_Vertex_Type = SG_VERTEX_TYPE_XYZ ; break; // MultiPointM
363  case 23: m_Type = SHAPE_TYPE_Line ; m_Vertex_Type = SG_VERTEX_TYPE_XYZ ; break; // PolyLineM
364  case 25: m_Type = SHAPE_TYPE_Polygon; m_Vertex_Type = SG_VERTEX_TYPE_XYZ ; break; // PolygonM
365 
366  case 31: // unsupported: MultiPatch...
367  default: // unsupported...
368  SG_UI_Msg_Add_Error(_TL("unsupported shape type."));
369  return( false );
370  }
371 
372  //-----------------------------------------------------
373  // Load Shapes...
374 
375  CSG_Buffer Record_Header(8), Content; sLong Length = Stream.Length();
376 
377  for(int iShape=0; Stream.Tell() < Length && SG_UI_Process_Set_Progress(Stream.Tell(), Length); iShape++)
378  {
379  if( Stream.Read(Record_Header.Get_Data(0), sizeof(int), 2) != 2 ) // read record header
380  {
381  SG_UI_Msg_Add_Error(_TL("corrupted record header"));
382 
383  return( false );
384  }
385 
386  if( Record_Header.asInt(0, true) != iShape + 1 ) // record number
387  {
388  SG_UI_Msg_Add_Error(CSG_String::Format("%s (%d != %d)", _TL("corrupted shapefile."), Record_Header.asInt(0, true), iShape + 1));
389 
390  return( false );
391  }
392 
393  size_t nBytes = 2 * (size_t)Record_Header.asInt(4, true); // content length as 16-bit words !!!
394 
395  if( !Content.Set_Size(nBytes, false) )
396  {
397  SG_UI_Msg_Add_Error(_TL("memory allocation error."));
398 
399  return( false );
400  }
401 
402  if( Stream.Read(Content.Get_Data(), sizeof(char), nBytes) != nBytes )
403  {
404  SG_UI_Msg_Add_Error(_TL("corrupted shapefile."));
405 
406  return( false );
407  }
408 
409  if( DBase.is_Open() && DBase.isDeleted() )
410  {
411  continue; // nop
412  }
413 
414  if( Content.asInt(0) != Type )
415  {
416  if( Content.asInt(0) == 0 )
417  {
418  // null shape is allowed !!!
419  }
420  else
421  {
422  SG_UI_Msg_Add_Error(_TL("corrupted shapefile."));
423 
424  return( false );
425  }
426  }
427 
428  //-------------------------------------------------
429  else
430  {
431  CSG_Shape *pShape = Add_Shape(); TSG_Point *pPoint; int nPoints, nParts, *Parts; double *pZ = NULL, *pM = NULL;
432 
433  switch( m_Type )
434  {
435  //---------------------------------------------
436  case SHAPE_TYPE_Point:
437 
438  pPoint = (TSG_Point *)Content.Get_Data(4);
439 
440  pShape->Add_Point(pPoint->x, pPoint->y);
441 
442  switch( m_Vertex_Type ) // read Z + M
443  {
444  default: break;
445  case SG_VERTEX_TYPE_XYZM: pShape->Set_M(Content.asDouble(28), 0);
446  case SG_VERTEX_TYPE_XYZ : pShape->Set_Z(Content.asDouble(20), 0);
447  }
448 
449  break;
450 
451  //---------------------------------------------
452  case SHAPE_TYPE_Points:
453 
454  nPoints = Content.asInt(36);
455  pPoint = (TSG_Point *)Content.Get_Data(40);
456 
457  switch( m_Vertex_Type ) // read Z + M
458  {
459  default: break;
460 
461  case SG_VERTEX_TYPE_XYZ:
462  pZ = 56 + nPoints * 24 <= (int)Length ? (double *)Content.Get_Data(56 + nPoints * 16) : NULL; // [40 + nPoints * 16 + 2 * 8] + [nPoints * 8]
463  break;
464 
465  case SG_VERTEX_TYPE_XYZM:
466  pZ = 56 + nPoints * 24 <= (int)Length ? (double *)Content.Get_Data(56 + nPoints * 16) : NULL; // [40 + nPoints * 16 + 2 * 8] + [nPoints * 8]
467  pM = 72 + nPoints * 32 <= (int)Length ? (double *)Content.Get_Data(72 + nPoints * 24) : NULL; // [40 + nPoints * 16 + 2 * 8] + [nPoints * 8 + 2 * 8] + [nPoints * 8]
468  break;
469  }
470 
471  //-----------------------------------------
472  for(int iPoint=0; iPoint<nPoints; iPoint++, pPoint++)
473  {
474  pShape->Add_Point(pPoint->x, pPoint->y);
475 
476  if( pZ ) { pShape->Set_Z(*(pZ++), iPoint); }
477  if( pM ) { pShape->Set_M(*(pM++), iPoint); }
478  }
479 
480  break;
481 
482  //---------------------------------------------
483  case SHAPE_TYPE_Line :
484  case SHAPE_TYPE_Polygon:
485 
486  nParts = Content.asInt(36);
487  nPoints = Content.asInt(40);
488  Parts = (int *)Content.Get_Data(44);
489  pPoint = (TSG_Point *)Content.Get_Data(44 + 4 * nParts);
490 
491  switch( m_Vertex_Type ) // read Z + M
492  {
493  default: break;
494 
495  case SG_VERTEX_TYPE_XYZ:
496  pZ = 60 + nParts * 4 + nPoints * 24 <= (int)Length ? (double *)Content.Get_Data(60 + nParts * 4 + nPoints * 16) : NULL; // [44 + nParts * 4 + nPoints * 16 + 2 * 8] + [nPoints * 8]
497  break;
498 
499  case SG_VERTEX_TYPE_XYZM:
500  pZ = 60 + nParts * 4 + nPoints * 24 <= (int)Length ? (double *)Content.Get_Data(60 + nParts * 4 + nPoints * 16) : NULL; // [44 + nParts * 4 + nPoints * 16 + 2 * 8] + [nPoints * 8]
501  pM = 76 + nParts * 4 + nPoints * 32 <= (int)Length ? (double *)Content.Get_Data(76 + nParts * 4 + nPoints * 24) : NULL; // [44 + nParts * 4 + nPoints * 16 + 2 * 8] + [nPoints * 8 + 2 * 8] + [nPoints * 8]
502  break;
503  }
504 
505  //-----------------------------------------
506  for(int iPoint=0, iPart=0, Offset=0; iPoint<nPoints; iPoint++, pPoint++, Offset++)
507  {
508  if( iPart < nParts - 1 && iPoint >= Parts[iPart + 1] )
509  {
510  iPart++; Offset = 0;
511  }
512 
513  pShape->Add_Point(pPoint->x, pPoint->y, iPart);
514 
515  if( pZ ) { pShape->Set_Z(*(pZ++), Offset, iPart); }
516  if( pM ) { pShape->Set_M(*(pM++), Offset, iPart); }
517  }
518 
519  break;
520 
521  //---------------------------------------------
522  default: break;
523  }
524 
525  //---------------------------------------------
526  if( DBase.is_Open() )
527  {
528  for(int iField=0; iField<Get_Field_Count(); iField++)
529  {
530  switch( DBase.Get_Field_Type(iField) )
531  {
532  default:
533  pShape->Set_Value(iField, DBase.asString(iField));
534  break;
535 
536  case DBF_FT_FLOAT: case DBF_FT_NUMERIC:
537  {
538  double Value;
539 
540  if( DBase.asDouble(iField, Value) )
541  {
542  pShape->Set_Value(iField, Value);
543  }
544  else
545  {
546  pShape->Set_NoData(iField);
547  }
548  }
549  break;
550  }
551  }
552 
553  DBase.Move_Next();
554  }
555  else
556  {
557  pShape->Set_Value(0, iShape);
558  }
559  }
560  }
561 
562  //-----------------------------------------------------
563  Get_Projection().Load(SG_File_Make_Path("", File_Name, "prj"));
564 
565  Load_MetaData(File_Name);
566 
567  CSG_MetaData *pFields = Get_MetaData_DB().Get_Child("FIELDS");
568 
569  if( pFields && pFields->Get_Children_Count() == Get_Field_Count() )
570  {
571  for(int iField=0; iField<Get_Field_Count(); iField++)
572  {
573  Set_Field_Name(iField, pFields->Get_Content(iField));
574  }
575  }
576 
577  Set_File_Name(File_Name, true);
578 
579  //-----------------------------------------------------
580  return( true );
581 }
582 
583 
585 // //
586 // //
587 // //
589 
590 //---------------------------------------------------------
591 #define Set_Content_Length(n) Record_Header.Set_Value(4, (int)(n), true);\
592  fSHP.Write(Record_Header.Get_Data(), sizeof(int), 2);\
593  fSHX.Write_Int(fSHP_Size, true);\
594  fSHX.Write_Int((n) , true);\
595  fSHP_Size += 4 + (n);\
596  fSHX_Size += 4;
597 
598 //---------------------------------------------------------
599 bool CSG_Shapes::_Save_ESRI(const CSG_String &File_Name)
600 {
601  //-----------------------------------------------------
602  // Determine Shape Type...
603 
604  int Type;
605 
606  switch( m_Type )
607  {
608  case SHAPE_TYPE_Point : Type = 1; break;
609  case SHAPE_TYPE_Points : Type = 8; break;
610  case SHAPE_TYPE_Line : Type = 3; break;
611  case SHAPE_TYPE_Polygon : Type = 5; break;
612  default: return( false );
613  }
614 
615  TSG_Vertex_Type Vertex_Type = m_Vertex_Type == 0 ? SG_VERTEX_TYPE_XY : SG_VERTEX_TYPE_XYZM;
616 
617  switch( Vertex_Type )
618  {
619  case SG_VERTEX_TYPE_XY : break;
620  case SG_VERTEX_TYPE_XYZ : Type += 20; break; // M
621  case SG_VERTEX_TYPE_XYZM: Type += 10; break; // Z (+M)
622  default: return( false );
623  }
624 
625  //-----------------------------------------------------
626  // DBase File Access...
627 
628  SG_File_Delete(SG_File_Make_Path("", File_Name, "cpg"));
629 
630  if( m_Encoding == SG_FILE_ENCODING_UTF8 )
631  {
632  CSG_File Stream;
633 
634  if( Stream.Open(SG_File_Make_Path("", File_Name, "cpg"), SG_FILE_W, false) )
635  {
636  Stream.Printf("UTF-8\n");
637 
638  Stream.Close();
639  }
640  }
641 
642  CSG_Table_DBase DBase(m_Encoding);
643 
644  if( !DBase.Open_Write(SG_File_Make_Path("", File_Name, "dbf"), this, false) )
645  {
646  return( false );
647  }
648 
649  //-----------------------------------------------------
650  // Shape File Access...
651 
652  CSG_File fSHP, fSHX;
653 
654  if( !fSHX.Open(SG_File_Make_Path("", File_Name, "shx"), SG_FILE_W, true) )
655  {
656  SG_UI_Msg_Add_Error(_TL("could not create index file"));
657 
658  return( false );
659  }
660 
661  if( !fSHP.Open(SG_File_Make_Path("", File_Name, "shp"), SG_FILE_W, true) )
662  {
663  SG_UI_Msg_Add_Error(_TL("could not create shape file"));
664 
665  return( false );
666  }
667 
668  //-----------------------------------------------------
669  // Save Header...
670 
671  Make_Clean(); // polygons: first == last point, inner rings > anti-clockwise...
672 
673  Update();
674 
675  CSG_Buffer File_Header(100);
676 
677  File_Header.Set_Value( 0, 9994 , true ); // Byte 0 Integer Big File Code = 9994
678  File_Header.Set_Value( 4, 0 , true ); // Byte 4 Integer Big unused
679  File_Header.Set_Value( 8, 0 , true ); // Byte 8 Integer Big unused
680  File_Header.Set_Value(12, 0 , true ); // Byte 12 Integer Big unused
681  File_Header.Set_Value(16, 0 , true ); // Byte 16 Integer Big unused
682  File_Header.Set_Value(20, 0 , true ); // Byte 20 Integer Big unused
683  File_Header.Set_Value(24, 0 , true ); // Byte 24 Integer Big File Length
684  File_Header.Set_Value(28, 1000 , false); // Byte 28 Integer Little Version = 1000
685  File_Header.Set_Value(32, Type , false); // Byte 32 Integer Little Shape Type
686  File_Header.Set_Value(36, m_Extent.Get_XMin(), false); // Byte 36 Double Little Bounding Box Xmin
687  File_Header.Set_Value(44, m_Extent.Get_YMin(), false); // Byte 44 Double Little Bounding Box Ymin
688  File_Header.Set_Value(52, m_Extent.Get_XMax(), false); // Byte 52 Double Little Bounding Box Xmax
689  File_Header.Set_Value(60, m_Extent.Get_YMax(), false); // Byte 60 Double Little Bounding Box Ymax
690  File_Header.Set_Value(68, Get_ZMin(), false); // Byte 68 Double Little Bounding Box Zmin
691  File_Header.Set_Value(76, Get_ZMax(), false); // Byte 76 Double Little Bounding Box Zmax
692  File_Header.Set_Value(84, Get_MMin(), false); // Byte 84 Double Little Bounding Box Mmin
693  File_Header.Set_Value(92, Get_MMax(), false); // Byte 92 Double Little Bounding Box Mmax
694 
695  fSHP.Write(File_Header.Get_Data(), sizeof(char), 100);
696  fSHX.Write(File_Header.Get_Data(), sizeof(char), 100);
697 
698  int fSHP_Size = 50; // file size measured in 16-bit words...
699  int fSHX_Size = 50; // file size measured in 16-bit words...
700 
701  //-----------------------------------------------------
702  // Save Shapes...
703 
704  for(sLong iShape=0; iShape<Get_Count() && SG_UI_Process_Set_Progress(iShape, Get_Count()); iShape++)
705  {
706  CSG_Shape *pShape = Get_Shape(iShape);
707 
708  //-------------------------------------------------
709  // geometries...
710 
711  CSG_Buffer Record_Header(8), Content;
712 
713  Record_Header.Set_Value(0, (int)iShape + 1, true); // record number
714 
715  //-------------------------------------------------
716  switch( m_Type ) // write content header
717  {
718  default: break;
719 
720  //-------------------------------------------------
721  case SHAPE_TYPE_Point:
722 
723  switch( Vertex_Type )
724  {
725  case SG_VERTEX_TYPE_XY : Set_Content_Length(10); break;
726  case SG_VERTEX_TYPE_XYZ : Set_Content_Length(14); break;
727  case SG_VERTEX_TYPE_XYZM: Set_Content_Length(18); break;
728  }
729 
730  fSHP.Write_Int (Type);
731 
732  break;
733 
734  //-------------------------------------------------
735  case SHAPE_TYPE_Points:
736 
737  switch( Vertex_Type )
738  {
739  case SG_VERTEX_TYPE_XY : Set_Content_Length(20 + 8 * pShape->Get_Point_Count()); break;
740  case SG_VERTEX_TYPE_XYZ : Set_Content_Length(28 + 12 * pShape->Get_Point_Count()); break;
741  case SG_VERTEX_TYPE_XYZM: Set_Content_Length(36 + 16 * pShape->Get_Point_Count()); break;
742  }
743 
744  fSHP.Write_Int (Type);
745  fSHP.Write_Double(pShape->Get_Extent().Get_XMin());
746  fSHP.Write_Double(pShape->Get_Extent().Get_YMin());
747  fSHP.Write_Double(pShape->Get_Extent().Get_XMax());
748  fSHP.Write_Double(pShape->Get_Extent().Get_YMax());
749  fSHP.Write_Int (pShape->Get_Point_Count());
750 
751  break;
752 
753  //-------------------------------------------------
754  case SHAPE_TYPE_Line:
755  case SHAPE_TYPE_Polygon:
756 
757  switch( Vertex_Type )
758  {
759  case SG_VERTEX_TYPE_XY : Set_Content_Length(22 + 2 * pShape->Get_Part_Count() + 8 * pShape->Get_Point_Count()); break;
760  case SG_VERTEX_TYPE_XYZ : Set_Content_Length(30 + 2 * pShape->Get_Part_Count() + 12 * pShape->Get_Point_Count()); break;
761  case SG_VERTEX_TYPE_XYZM: Set_Content_Length(38 + 2 * pShape->Get_Part_Count() + 16 * pShape->Get_Point_Count()); break;
762  }
763 
764  fSHP.Write_Int (Type);
765  fSHP.Write_Double(pShape->Get_Extent().Get_XMin());
766  fSHP.Write_Double(pShape->Get_Extent().Get_YMin());
767  fSHP.Write_Double(pShape->Get_Extent().Get_XMax());
768  fSHP.Write_Double(pShape->Get_Extent().Get_YMax());
769  fSHP.Write_Int (pShape->Get_Part_Count());
770  fSHP.Write_Int (pShape->Get_Point_Count());
771 
772  for(int iPart=0, iPoint=0; iPart<pShape->Get_Part_Count(); iPoint+=pShape->Get_Point_Count(iPart++))
773  {
774  fSHP.Write_Int(iPoint);
775  }
776 
777  break;
778  }
779 
780  //-------------------------------------------------
781  TSG_Point Point;
782 
783  switch( m_Type ) // write point data
784  {
785  default: break;
786 
787  //-------------------------------------------------
788  case SHAPE_TYPE_Point :
789 
790  fSHP.Write(&(Point = pShape->Get_Point()), sizeof(TSG_Point));
791 
792  //---------------------------------------------
793  if( Vertex_Type != SG_VERTEX_TYPE_XY )
794  {
795  fSHP.Write_Double(pShape->Get_Z(0));
796 
797  if( Vertex_Type == SG_VERTEX_TYPE_XYZM )
798  {
799  fSHP.Write_Double(pShape->Get_M(0));
800  }
801  }
802 
803  break;
804 
805  //-------------------------------------------------
806  case SHAPE_TYPE_Points :
807  case SHAPE_TYPE_Line :
808  case SHAPE_TYPE_Polygon:
809 
810  for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
811  {
812  for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
813  {
814  fSHP.Write(&(Point = pShape->Get_Point(iPoint, iPart)), sizeof(TSG_Point));
815  }
816  }
817 
818  //---------------------------------------------
819  if( Vertex_Type != SG_VERTEX_TYPE_XY )
820  {
821  fSHP.Write_Double(pShape->Get_ZMin());
822  fSHP.Write_Double(pShape->Get_ZMax());
823 
824  for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
825  {
826  for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
827  {
828  fSHP.Write_Double(pShape->Get_Z(iPoint, iPart));
829  }
830  }
831 
832  if( Vertex_Type == SG_VERTEX_TYPE_XYZM )
833  {
834  fSHP.Write_Double(pShape->Get_MMin());
835  fSHP.Write_Double(pShape->Get_MMax());
836 
837  for(int iPart=0; iPart<pShape->Get_Part_Count(); iPart++)
838  {
839  for(int iPoint=0; iPoint<pShape->Get_Point_Count(iPart); iPoint++)
840  {
841  fSHP.Write_Double(pShape->Get_M(iPoint, iPart));
842  }
843  }
844  }
845  }
846  }
847 
848  //-------------------------------------------------
849  // attributes...
850 
851  DBase.Add_Record();
852 
853  for(int iField=0; iField<Get_Field_Count(); iField++)
854  {
855  if( pShape->is_NoData(iField) )
856  {
857  DBase.Set_NoData(iField);
858  }
859  else switch( DBase.Get_Field_Type(iField) )
860  {
861  default:
862  DBase.Set_Value(iField, pShape->asString(iField));
863  break;
864 
865  case DBF_FT_FLOAT: case DBF_FT_NUMERIC:
866  DBase.Set_Value(iField, pShape->asDouble(iField));
867  break;
868  }
869  }
870 
871  DBase.Flush_Record();
872  }
873 
874  //-----------------------------------------------------
875  // File Sizes...
876 
877  fSHP.Seek(24);
878  fSHP.Write_Int(fSHP_Size, true);
879 
880  fSHX.Seek(24);
881  fSHX.Write_Int(fSHX_Size, true);
882 
883  //-----------------------------------------------------
884  Get_Projection().Save(SG_File_Make_Path("", File_Name, "prj"));
885 
886  //-----------------------------------------------------
887  CSG_MetaData *pFields = Get_MetaData_DB().Get_Child("FIELDS");
888 
889  if( !pFields )
890  {
891  pFields = Get_MetaData_DB().Add_Child("FIELDS");
892  }
893 
894  pFields->Del_Children();
895 
896  for(int iField=0; iField<Get_Field_Count(); iField++)
897  {
898  pFields->Add_Child("FIELD", Get_Field_Name(iField))->Add_Property("TYPE", gSG_Data_Type_Identifier[Get_Field_Type(iField)]);
899  }
900 
901  Get_MetaData().Del_Child("GDAL_DRIVER");
902 
903  Save_MetaData(File_Name);
904 
905  //-----------------------------------------------------
906  return( true );
907 }
908 
909 
911 // //
912 // //
913 // //
915 
916 //---------------------------------------------------------
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
DBF_FT_FLOAT
#define DBF_FT_FLOAT
Definition: table_dbase.h:77
PARAMETER_TYPE_FilePath
@ PARAMETER_TYPE_FilePath
Definition: parameters.h:136
CSG_Shapes::On_Delete
virtual bool On_Delete(void)
Definition: shapes_io.cpp:72
CSG_Projection::Save
bool Save(const CSG_String &File, ESG_CRS_Format Format=ESG_CRS_Format::WKT) const
Definition: projections.cpp:261
CSG_MetaData::Del_Child
bool Del_Child(int Index)
Definition: metadata.cpp:321
CSG_Table::Get_Field_Type
TSG_Data_Type Get_Field_Type(int Field) const
Definition: table.h:363
_TL
#define _TL(s)
Definition: api_core.h:1556
CSG_Data_Object::Set_File_Name
void Set_File_Name(const CSG_String &FileName)
Definition: dataobject.cpp:366
CSG_Shapes::Get_Shape
virtual CSG_Shape * Get_Shape(const CSG_Point &Point, double Epsilon=0.)
Definition: shapes.cpp:483
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_Data_Collection::Count
size_t Count(void) const
Definition: data_manager.h:94
SG_Shapes_Get_File_Extension_Default
CSG_String SG_Shapes_Get_File_Extension_Default(void)
Definition: shapes_io.cpp:124
CSG_MetaData::Get_Content
const CSG_String & Get_Content(void) const
Definition: metadata.h:133
CSG_Shapes::On_Reload
virtual bool On_Reload(void)
Definition: shapes_io.cpp:66
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_Shape::Get_Z
virtual double Get_Z(int iPoint=0, int iPart=0, bool bAscending=true) const
Definition: shapes.h:193
data_manager.h
CSG_Rect::Get_XMax
double Get_XMax(void) const
Definition: geo_tools.h:506
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_File::Seek
bool Seek(sLong Offset, int Origin=SG_FILE_START) const
Definition: api_file.cpp:242
CSG_Shapes::Get_MMax
double Get_MMax(void)
Definition: shapes.h:816
SHAPE_TYPE_Polygon
@ SHAPE_TYPE_Polygon
Definition: shapes.h:105
CSG_Data_Object::Save_MetaData
bool Save_MetaData(const CSG_String &FileName)
Definition: dataobject.cpp:681
CSG_Shapes::Get_MMin
double Get_MMin(void)
Definition: shapes.h:815
CSG_Buffer::asDouble
double asDouble(int Offset, bool bBigEndian=false) const
Definition: api_core.h:271
CSG_Tool
Definition: tool.h:135
CSG_Tool::Execute
bool Execute(bool bAddHistory=false)
Definition: tool.cpp:258
SG_RUN_TOOL
#define SG_RUN_TOOL(bRetVal, LIBRARY, TOOL, CONDITION)
Definition: tool_library.h:260
CSG_Table::Set_Field_Name
bool Set_Field_Name(int Field, const SG_Char *Name)
Definition: table.cpp:595
CSG_Table_DBase::Open_Write
bool Open_Write(const SG_Char *FileName, class CSG_Table *pTable, bool bRecords_Save=true)
Definition: table_dbase.cpp:318
CSG_Buffer::Set_Value
void Set_Value(int Offset, char Value, bool bBigEndian=false)
Definition: api_core.h:262
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_Shapes::m_Type
TSG_Shape_Type m_Type
Definition: shapes.h:845
CSG_Data_Manager::Shapes
CSG_Data_Collection & Shapes(void) const
Definition: data_manager.h:137
CSG_Table::m_Extent
CSG_Rect m_Extent
Definition: table.h:472
CSG_MetaData::Get_Child
CSG_MetaData * Get_Child(int Index) const
Definition: metadata.h:149
SG_FILE_R
@ SG_FILE_R
Definition: api_core.h:1112
SSG_Point
Definition: geo_tools.h:128
CSG_Buffer::Set_Size
bool Set_Size(size_t Size, bool bShrink=true)
Definition: api_memory.cpp:732
CSG_File::Read
size_t Read(void *Buffer, size_t Size, size_t Count=1) const
Definition: api_file.cpp:338
CSG_Tool_Library_Manager::Delete_Tool
bool Delete_Tool(CSG_Tool *pTool) const
Definition: tool_library.cpp:865
CSG_Shapes::Get_ZMin
double Get_ZMin(void)
Definition: shapes.h:813
gSG_Shape_File_Format_Default
static TSG_Shape_File_Format gSG_Shape_File_Format_Default
Definition: shapes_io.cpp:100
CSG_Table_Record::is_NoData
bool is_NoData(int Field) const
Definition: table_record.cpp:416
CSG_File
Definition: api_core.h:1127
CSG_Table::Set_Modified
virtual void Set_Modified(bool bModified=true)
Definition: table.cpp:1137
SG_Shapes_Set_File_Format_Default
bool SG_Shapes_Set_File_Format_Default(int Format)
Definition: shapes_io.cpp:103
Set_Content_Length
#define Set_Content_Length(n)
Definition: shapes_io.cpp:591
CSG_Shape::Get_Point
virtual TSG_Point Get_Point(int iPoint=0) const =0
CSG_Shapes::Add_Shape
virtual CSG_Shape * Add_Shape(CSG_Table_Record *pCopy=NULL, TSG_ADD_Shape_Copy_Mode mCopy=SHAPE_COPY)
Definition: shapes.cpp:402
SG_VERTEX_TYPE_XY
@ SG_VERTEX_TYPE_XY
Definition: shapes.h:92
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_Shape::Get_Part_Count
virtual int Get_Part_Count(void) const =0
SG_TOOL_PARAMETER_SET
#define SG_TOOL_PARAMETER_SET(IDENTIFIER, VALUE)
Definition: tool_library.h:354
CSG_Table_DBase
Definition: table_dbase.h:91
CSG_Buffer
Definition: api_core.h:224
CSG_Table_Record::asString
const SG_Char * asString(int Field, int Decimals=-99) const
Definition: table_record.cpp:461
CSG_Buffer::asInt
int asInt(int Offset, bool bBigEndian=false) const
Definition: api_core.h:269
CSG_Rect::Get_YMin
double Get_YMin(void) const
Definition: geo_tools.h:507
SG_VERTEX_TYPE_XYZM
@ SG_VERTEX_TYPE_XYZM
Definition: shapes.h:94
CSG_Shapes::Save
virtual bool Save(const CSG_String &File, int Format=0)
Definition: shapes_io.cpp:141
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_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_Table_DBase::Get_Field_Type
char Get_Field_Type(int iField)
Definition: table_dbase.h:111
SG_Get_Tool_Library_Manager
CSG_Tool_Library_Manager & SG_Get_Tool_Library_Manager(void)
Definition: tool_library.cpp:286
CSG_Shape::Get_ZMax
virtual double Get_ZMax(void)
Definition: shapes.h:195
SHAPE_FILE_FORMAT_GeoPackage
@ SHAPE_FILE_FORMAT_GeoPackage
Definition: shapes.h:117
CSG_Shape::Get_ZMin
virtual double Get_ZMin(void)
Definition: shapes.h:194
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_Table::Get_Count
sLong Get_Count(void) const
Definition: table.h:397
SG_Shapes_Get_File_Format_Default
TSG_Shape_File_Format SG_Shapes_Get_File_Format_Default(void)
Definition: shapes_io.cpp:118
CSG_Data_Object::Get_File_Name
const SG_Char * Get_File_Name(bool bNative=true) const
Definition: dataobject.cpp:390
CSG_Table_DBase::Add_Record
void Add_Record(void)
Definition: table_dbase.cpp:617
CSG_Shape::Get_M
virtual double Get_M(int iPoint=0, int iPart=0, bool bAscending=true) const
Definition: shapes.h:209
CSG_File::Close
virtual bool Close(void)
Definition: api_file.cpp:164
CSG_Shape::Add_Point
virtual int Add_Point(double x, double y, int iPart=0)=0
SG_FILE_W
@ SG_FILE_W
Definition: api_core.h:1113
CSG_Projection::Load
bool Load(const CSG_String &File)
Definition: projections.cpp:253
SHAPE_FILE_FORMAT_Undefined
@ SHAPE_FILE_FORMAT_Undefined
Definition: shapes.h:115
CSG_Shape::Get_MMin
virtual double Get_MMin(void)
Definition: shapes.h:210
CSG_Buffer::Get_Data
char * Get_Data(int Offset=0) const
Definition: api_core.h:244
CSG_Shapes::m_Vertex_Type
TSG_Vertex_Type m_Vertex_Type
Definition: shapes.h:847
CSG_Table::m_Encoding
int m_Encoding
Definition: table.h:460
CSG_String::Format
static CSG_String Format(const char *Format,...)
Definition: api_string.cpp:270
CSG_Table_DBase::Flush_Record
void Flush_Record(void)
Definition: table_dbase.cpp:635
CSG_String::Find
int Find(char Character, bool fromEnd=false) const
Definition: api_string.cpp:663
CSG_File::Write_Double
bool Write_Double(double Value, bool bBigEndian=false)
Definition: api_file.cpp:484
SHAPE_TYPE_Line
@ SHAPE_TYPE_Line
Definition: shapes.h:104
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_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
TSG_Shape_File_Format
TSG_Shape_File_Format
Definition: shapes.h:114
table_dbase.h
CSG_Table::_Save_DBase
bool _Save_DBase(const CSG_String &File)
Definition: table_io.cpp:565
CSG_File::Length
sLong Length(void) const
Definition: api_file.cpp:230
CSG_Shape::Get_Point_Count
virtual int Get_Point_Count(void) const =0
SHAPE_FILE_FORMAT_GeoJSON
@ SHAPE_FILE_FORMAT_GeoJSON
Definition: shapes.h:118
TSG_Vertex_Type
TSG_Vertex_Type
Definition: shapes.h:91
shapes.h
CSG_Table_DBase::Set_Value
bool Set_Value(int iField, double Value)
Definition: table_dbase.cpp:776
CSG_String
Definition: api_core.h:563
SHAPE_TYPE_Point
@ SHAPE_TYPE_Point
Definition: shapes.h:102
CSG_Data_Manager
Definition: data_manager.h:129
CSG_MetaData
Definition: metadata.h:88
CSG_Data_Object::Get_MetaData_DB
CSG_MetaData & Get_MetaData_DB(void) const
Definition: dataobject.h:235
CSG_Tool::Settings_Push
bool Settings_Push(class CSG_Data_Manager *pManager=NULL)
Definition: tool.cpp:621
CSG_File::Printf
int Printf(const char *Format,...)
Definition: api_file.cpp:287
CSG_Shape::Get_MMax
virtual double Get_MMax(void)
Definition: shapes.h:211
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_File::Write_Int
bool Write_Int(int Value, bool bBigEndian=false)
Definition: api_file.cpp:458
CSG_Data_Object::Get_MetaData
CSG_MetaData & Get_MetaData(void) const
Definition: dataobject.h:234
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
CSG_File::Read_Line
bool Read_Line(CSG_String &Line) const
Definition: api_file.cpp:399
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_Rect::Get_XMin
double Get_XMin(void) const
Definition: geo_tools.h:505
SHAPE_FILE_FORMAT_ESRI
@ SHAPE_FILE_FORMAT_ESRI
Definition: shapes.h:116
SSG_Point::y
double y
Definition: geo_tools.h:129
CSG_Table_DBase::Set_NoData
bool Set_NoData(int iField)
Definition: table_dbase.cpp:909
CSG_Shapes::Make_Clean
bool Make_Clean(void)
Definition: shapes.cpp:525
CSG_Shape::Get_Extent
virtual const CSG_Rect & Get_Extent(void)=0
CSG_Shape::Set_Z
virtual void Set_Z(double z, int iPoint=0, int iPart=0)
Definition: shapes.h:192
CSG_Table::Create
bool Create(void)
Definition: table.cpp:153
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
tool_library.h
SHAPE_TYPE_Points
@ SHAPE_TYPE_Points
Definition: shapes.h:103
CSG_File::Write
size_t Write(void *Buffer, size_t Size, size_t Count=1) const
Definition: api_file.cpp:370
SG_UI_Process_Set_Ready
bool SG_UI_Process_Set_Ready(void)
Definition: api_callback.cpp:305
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
DBF_FT_NUMERIC
#define DBF_FT_NUMERIC
Definition: table_dbase.h:78
SG_FILE_ENCODING_ANSI
@ SG_FILE_ENCODING_ANSI
Definition: api_core.h:550
SG_FILE_ENCODING_UTF8
@ SG_FILE_ENCODING_UTF8
Definition: api_core.h:552
CSG_Shape::Set_M
virtual void Set_M(double m, int iPoint=0, int iPart=0)
Definition: shapes.h:208
CSG_Shape
Definition: shapes.h:141
CSG_Data_Object::Get_Projection
CSG_Projection & Get_Projection(void)
Definition: dataobject.cpp:637
CSG_Table_Record::Set_NoData
bool Set_NoData(int Field)
Definition: table_record.cpp:366
CSG_Table::_Save_Text
bool _Save_Text(const CSG_String &File, bool bHeadline, const SG_Char Separator)
Definition: table_io.cpp:495
SG_VERTEX_TYPE_XYZ
@ SG_VERTEX_TYPE_XYZ
Definition: shapes.h:93
CSG_Shapes::Get_ZMax
double Get_ZMax(void)
Definition: shapes.h:814
CSG_File::Tell
sLong Tell(void) const
Definition: api_file.cpp:265
SG_UI_Msg_Add
void SG_UI_Msg_Add(const char *Message, bool bNewLine, TSG_UI_MSG_STYLE Style)
Definition: api_callback.cpp:502