1 /******************************************************************************
2 * $Id$
3 *
4 * Project: libLAS - http://liblas.org - A BSD library for LAS format data.
5 * Purpose: C API for libLAS
6 * Author: Howard Butler, hobu.inc@gmail.com, but I'm not proud of it.
7 * I also swiped a lot of it from GDAL.
8 *
9 ******************************************************************************
10 * Copyright (c) 2008, Mateusz Loskot
11 * Copyright (c) 2008, Howard Butler
12 *
13 * All rights reserved.
14 *
15 * Redistribution and use in source and binary forms, with or without
16 * modification, are permitted provided that the following
17 * conditions are met:
18 *
19 * * Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer.
21 * * Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in
23 * the documentation and/or other materials provided
24 * with the distribution.
25 * * Neither the name of the Martin Isenburg or Iowa Department
26 * of Natural Resources nor the names of its contributors may be
27 * used to endorse or promote products derived from this software
28 * without specific prior written permission.
29 *
30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
31 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
32 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
33 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
34 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
35 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
36 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
37 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
38 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
39 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
40 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
41 * OF SUCH DAMAGE.
42 ****************************************************************************/
43
44 #ifdef HAVE_LIBGEOTIFF
45 // Supress inclusion of cpl_serv.h per #194, perhaps remove one day
46 // when libgeotiff 1.4.0+ is widely used
47 #define CPL_SERV_H_INCLUDED
48
49 #include <geotiff.h>
50 #include <geo_simpletags.h>
51 #include <geo_normalize.h>
52 #endif
53
54 #include <liblas/liblas.hpp>
55 #include <liblas/detail/reader/reader.hpp>
56 #include <liblas/detail/reader/zipreader.hpp>
57 #include <liblas/detail/reader/cachedreader.hpp>
58 #include <liblas/external/property_tree/xml_parser.hpp>
59
60 #include <boost/uuid/uuid.hpp>
61 #include <boost/uuid/uuid_io.hpp>
62 #include <boost/uuid/uuid_generators.hpp>
63
64 typedef struct LASWriterHS *LASWriterH;
65 typedef struct LASReaderHS *LASReaderH;
66 typedef struct LASPointHS *LASPointH;
67 typedef liblas::HeaderPtr* LASHeaderH;
68 typedef struct LASGuidHS *LASGuidH;
69 typedef struct LASVLRHS *LASVLRH;
70 typedef struct LASColorHS *LASColorH;
71 typedef struct LASSRSHS *LASSRSH;
72 typedef struct LASSchemaHS *LASSchemaH;
73 typedef struct LASFilterHS *LASFilterH;
74
75
76 #include <stdint.h>
77 // std
78 #include <cstdio>
79 #include <bitset>
80 #include <exception>
81 #include <fstream>
82 #include <iostream>
83 #include <map>
84 #include <sstream> // std::stringstream
85 #include <string>
86 #include <stack>
87 #include <typeinfo>
88 #include <vector>
89
90 using namespace liblas;
91
92 #ifdef _WIN32
93 #define compare_no_case(a,b,n) _strnicmp( (a), (b), (n) )
94 #else
95 #define compare_no_case(a,b,n) strncasecmp( (a), (b), (n) )
96 #endif
97
98 #include <boost/lambda/lambda.hpp>
99
IsReprojectionTransform(liblas::TransformPtr const & p)100 bool IsReprojectionTransform(liblas::TransformPtr const& p)
101 {
102 if (dynamic_cast<liblas::ReprojectionTransform*>(p.get()))
103 return true;
104 return false;
105 }
106
107 LAS_C_START
108
109 #ifndef _WIN32
110 #include <stdint.h>
111 #endif
112
113
114 // Error stuff
115 typedef enum
116 {
117 LE_None = 0,
118 LE_Debug = 1,
119 LE_Warning = 2,
120 LE_Failure = 3,
121 LE_Fatal = 4
122 } LASErrorEnum;
123
124 typedef enum
125 {
126 LE_Filter_Bounds = 0,
127 LE_Filter_Classification = 1,
128 LE_Filter_Thin = 2,
129 LE_Filter_Return = 3,
130 LE_Filter_Color = 4,
131 LE_Filter_Intensity = 5,
132 LE_Filter_ScanAngleRank = 6,
133 LE_Filter_Time = 7
134 } LASFilterEnum;
135
136 typedef enum
137 {
138 LE_Transform_Reprojection = 0
139 } LASTransformEnum;
140
141 static std::stack<liblas::Error > errors;
142 static std::vector<liblas::TransformPtr> transforms;
143 static std::vector<liblas::FilterPtr> filters;
144
145
146 static std::map<liblas::Reader*, std::istream*> readers;
147 static std::map<liblas::Writer*, std::ostream*> writers;
148
149 #ifdef _MSC_VER
150 # pragma warning(disable: 4127) // warning C4127: conditional expression is constant
151 # pragma warning(disable: 4702) // unreachable code
152 #endif
153
154 #define VALIDATE_LAS_POINTER0(ptr, func) \
155 do { if( NULL == ptr ) { \
156 LASErrorEnum const ret = LE_Failure; \
157 std::ostringstream msg; \
158 msg << "Pointer \'" << #ptr << "\' is NULL in \'" << (func) <<"\'."; \
159 std::string message(msg.str()); \
160 LASError_PushError( ret, message.c_str(), (func)); \
161 return; \
162 }} while(0)
163
164 #define VALIDATE_LAS_POINTER1(ptr, func, rc) \
165 do { if( NULL == ptr ) { \
166 LASErrorEnum const ret = LE_Failure; \
167 std::ostringstream msg; \
168 msg << "Pointer \'" << #ptr << "\' is NULL in \'" << (func) <<"\'."; \
169 std::string message(msg.str()); \
170 LASError_PushError( ret, message.c_str(), (func)); \
171 return (rc); \
172 }} while(0)
173
LAS_IsGDALEnabled(void)174 LAS_DLL int LAS_IsGDALEnabled(void) {
175 return IsGDALEnabled();
176 }
177
LAS_IsLibGeoTIFFEnabled(void)178 LAS_DLL int LAS_IsLibGeoTIFFEnabled(void) {
179 return IsLibGeoTIFFEnabled();
180 }
181
LASError_Reset(void)182 LAS_DLL void LASError_Reset(void) {
183 if (errors.empty()) return;
184 for (std::stack<liblas::Error >::size_type i=0;i<errors.size();i++) errors.pop();
185 }
186
LASError_Pop(void)187 LAS_DLL void LASError_Pop(void) {
188 if (errors.empty()) return;
189 errors.pop();
190 }
191
LASError_GetLastErrorNum(void)192 LAS_DLL int LASError_GetLastErrorNum(void){
193 if (errors.empty())
194 return 0;
195 else {
196 liblas::Error err = errors.top();
197 return err.GetCode();
198 }
199 }
200
LASError_GetLastErrorMsg(void)201 LAS_DLL char* LASError_GetLastErrorMsg(void){
202 if (errors.empty())
203 return NULL;
204 else {
205 liblas::Error err = errors.top();
206 return LASCopyString(err.GetMessage().c_str());
207 }
208 }
209
LASError_GetLastErrorMethod(void)210 LAS_DLL char* LASError_GetLastErrorMethod(void){
211 if (errors.empty())
212 return NULL;
213 else {
214 liblas::Error err = errors.top();
215 return LASCopyString(err.GetMethod().c_str());
216 }
217 }
218
LASError_PushError(int code,const char * message,const char * method)219 LAS_DLL void LASError_PushError(int code, const char *message, const char *method) {
220 liblas::Error err = liblas::Error(code, std::string(message), std::string(method));
221 errors.push(err);
222 }
223
LASError_GetErrorCount(void)224 LAS_DLL int LASError_GetErrorCount(void) {
225 return static_cast<int>(errors.size());
226 }
227
228
229
LASReader_Create(const char * filename)230 LAS_DLL LASReaderH LASReader_Create(const char* filename)
231
232 {
233 VALIDATE_LAS_POINTER1(filename, "LASReader_Create", NULL);
234
235 std::istream* istrm = NULL;
236 try {
237 istrm = liblas::Open(filename, std::ios::in | std::ios::binary);
238 } catch (std::exception const& e)
239 {
240 if (istrm)
241 delete istrm;
242 LASError_PushError(LE_Failure, e.what(), "LASReader_Create");
243 return NULL;
244 }
245
246 try {
247 liblas::ReaderFactory f;
248 liblas::Reader* reader = new liblas::Reader(f.CreateWithStream(*istrm));
249 readers.insert(std::pair<liblas::Reader*, std::istream*>(reader, istrm));
250 return (LASReaderH) reader;
251 } catch (std::exception const& e)
252 {
253 LASError_PushError(LE_Failure, e.what(), "LASReader_Create");
254 return NULL;
255 }
256
257
258
259 }
260
LASReader_CreateWithHeader(const char * filename,LASHeaderH hHeader)261 LAS_DLL LASReaderH LASReader_CreateWithHeader( const char* filename,
262 LASHeaderH hHeader)
263
264 {
265 VALIDATE_LAS_POINTER1(filename, "LASReader_CreateWithHeader", NULL);
266 VALIDATE_LAS_POINTER1(hHeader->get(), "LASReader_CreateWithHeader", NULL);
267
268 std::istream* istrm = NULL;
269 liblas::ReaderFactory f;
270 try {
271 istrm = liblas::Open(filename, std::ios::in | std::ios::binary);
272 } catch (std::exception const& e)
273 {
274 if (istrm) delete istrm;
275 LASError_PushError(LE_Failure, e.what(), "LASReader_Create");
276 return NULL;
277 }
278
279 try {
280
281 liblas::Reader* reader = new liblas::Reader(f.CreateWithStream(*istrm));
282
283 liblas::Header const& current_header = reader->GetHeader();
284
285 // If the original data were compressed, we need to override whatever value
286 // our incoming header has for that value
287 liblas::HeaderPtr* header = ((liblas::HeaderPtr*) hHeader);
288 if (current_header.Compressed())
289 {
290 header->get()->SetCompressed(true);
291 }
292 reader->SetHeader(*header->get());
293 readers.insert(std::pair<liblas::Reader*, std::istream*>(reader, istrm));
294 return (LASReaderH) reader;
295
296
297 } catch (std::exception const& e)
298 {
299 LASError_PushError(LE_Failure, e.what(), "LASReader_Create");
300 return NULL;
301 }
302
303
304 }
305
LASReader_SetHeader(LASReaderH hReader,const LASHeaderH hHeader)306 LAS_DLL void LASReader_SetHeader( LASReaderH hReader, const LASHeaderH hHeader)
307
308 {
309 VALIDATE_LAS_POINTER0(hReader, "LASReader_SetHeader");
310 VALIDATE_LAS_POINTER0(hHeader, "LASReader_SetHeader");
311
312 liblas::Reader* reader = (liblas::Reader*)hReader;
313 liblas::HeaderPtr* header = (liblas::HeaderPtr*)hHeader;
314 if (header->get())
315 reader->SetHeader(*header->get());
316 }
317
LASReader_Destroy(LASReaderH hReader)318 LAS_DLL void LASReader_Destroy(LASReaderH hReader)
319 {
320 VALIDATE_LAS_POINTER0(hReader, "LASReader_Destroy");
321
322 try {
323 liblas::Reader* reader = (liblas::Reader*)hReader;
324
325 std::map<liblas::Reader*, std::istream*>::iterator it = readers.find(reader);
326 if (it == readers.end())
327 {
328 LASError_PushError(LE_Failure, "Unable to find reader stream", "LASReader_Destroy");
329 return;
330 }
331 std::istream* istrm = it->second;
332
333 delete reader;
334 hReader = NULL;
335
336 if ( istrm == NULL )
337 {
338 LASError_PushError(LE_Failure, "Got 99 problems, but the stream ain't one", "LASReader_Destroy");
339 return;
340 }
341
342 liblas::Cleanup(istrm);
343
344 readers.erase(reader);
345 istrm = NULL;
346
347 } catch (std::runtime_error const& e/* e */)
348 {
349 LASError_PushError(LE_Failure, e.what(), "LASReader_Destroy");
350 return;
351 }
352
353
354 hReader = NULL;
355 }
356
357
358
LASReader_GetNextPoint(const LASReaderH hReader)359 LAS_DLL LASPointH LASReader_GetNextPoint(const LASReaderH hReader)
360 {
361 VALIDATE_LAS_POINTER1(hReader, "LASReader_GetNextPoint", NULL);
362
363 try {
364 liblas::Reader *reader = ((liblas::Reader*) hReader);
365 if (reader->ReadNextPoint())
366 // return (LASPointH) new LASPoint(reader->GetPoint());
367 return (LASPointH) &(reader->GetPoint());
368 else
369 return NULL;
370 } catch (invalid_point_data const& e /*e */) {
371 LASError_PushError(LE_Failure, e.what(), "LASReader_GetNextPoint Invalid Point");
372 } catch (std::exception const& e)
373 {
374 LASError_PushError(LE_Failure, e.what(), "LASReader_GetNextPoint");
375 }
376
377 return NULL;
378 }
379
LASReader_GetPointAt(const LASReaderH hReader,uint32_t position)380 LAS_DLL LASPointH LASReader_GetPointAt(const LASReaderH hReader, uint32_t position)
381 {
382 VALIDATE_LAS_POINTER1(hReader, "LASReader_GetPointAt", NULL);
383
384 try {
385 liblas::Reader *reader = ((liblas::Reader*) hReader);
386 if (reader->ReadPointAt((std::size_t) position))
387 // return (LASPointH) new LASPoint(reader->GetPoint());
388 return (LASPointH) &(reader->GetPoint());
389 else
390 return NULL;
391 } catch (invalid_point_data const& e /*e */) {
392 LASError_PushError(LE_Failure, e.what(), "LASReader_GetPointAt Invalid Point");
393 } catch (std::exception const& e)
394 {
395 LASError_PushError(LE_Failure, e.what(), "LASReader_GetPointAt");
396 }
397
398 return NULL;
399
400 }
401
LASReader_Seek(LASReaderH hReader,uint32_t position)402 LAS_DLL LASErrorEnum LASReader_Seek(LASReaderH hReader, uint32_t position)
403 {
404 VALIDATE_LAS_POINTER1(hReader, "LASReader_Seek", LE_None);
405
406 try {
407 liblas::Reader *reader = ((liblas::Reader*) hReader);
408 if (reader->Seek((std::size_t) position))
409 return LE_None;
410 else
411 return LE_Failure;
412 } catch (invalid_point_data const& e /*e */) {
413 LASError_PushError(LE_Failure, e.what(), "LASReader_Seek Invalid location");
414 } catch (std::exception const& e)
415 {
416 LASError_PushError(LE_Failure, e.what(), "LASReader_Seek");
417 }
418
419 return LE_None;
420
421 }
422
LASReader_GetSummaryXML(const LASReaderH hReader)423 LAS_DLL char* LASReader_GetSummaryXML(const LASReaderH hReader)
424 {
425
426 VALIDATE_LAS_POINTER1(hReader, "LASReader_GetSummaryXML", NULL);
427 liblas::Reader* r = (liblas::Reader*)hReader;
428 liblas::Summary s;
429
430 r->Reset();
431 bool read = r->ReadNextPoint();
432 if (!read)
433 {
434 LASError_PushError(LE_Failure, "Unable to read point", "LASReader_GetSummaryXML");
435 return NULL;
436 }
437
438 while (read)
439 {
440 liblas::Point const& p = r->GetPoint();
441 s.AddPoint(p);
442 read = r->ReadNextPoint();
443 }
444
445 r->Reset();
446
447 std::ostringstream oss;
448
449 liblas::property_tree::write_xml(oss, s.GetPTree());
450 return LASCopyString(oss.str().c_str());
451
452 }
453
LASReader_SetInputSRS(LASReaderH hReader,const LASSRSH hSRS)454 LAS_DLL LASErrorEnum LASReader_SetInputSRS(LASReaderH hReader, const LASSRSH hSRS) {
455
456 VALIDATE_LAS_POINTER1(hReader, "LASReader_SetInputSRS", LE_Failure);
457 VALIDATE_LAS_POINTER1(hSRS, "LASReader_SetInputSRS", LE_Failure);
458
459 try {
460 liblas::Reader* reader = ((liblas::Reader*) hReader);
461 liblas::Header h = reader->GetHeader();
462 liblas::SpatialReference* ref = ((liblas::SpatialReference*) hSRS);
463 h.SetSRS(*ref);
464 reader->SetHeader(h);
465 }
466 catch (std::exception const& e) {
467 LASError_PushError(LE_Failure, e.what(), "LASReader_SetInputSRS");
468 return LE_Failure;
469 }
470
471 return LE_None;
472 }
473
474
LASReader_GetHeader(const LASReaderH hReader)475 LAS_DLL LASHeaderH LASReader_GetHeader(const LASReaderH hReader)
476 {
477 VALIDATE_LAS_POINTER1(hReader, "LASReader_GetHeader", new liblas::HeaderPtr());
478
479 liblas::Header header = ((liblas::Reader*) hReader)->GetHeader();
480 return (LASHeaderH) new liblas::HeaderPtr(new liblas::Header(header));
481 }
482
483
484
485
486
LASReader_SetOutputSRS(LASReaderH hReader,const LASSRSH hSRS)487 LAS_DLL LASErrorEnum LASReader_SetOutputSRS(LASReaderH hReader, const LASSRSH hSRS) {
488
489 VALIDATE_LAS_POINTER1(hReader, "LASReader_SetOutputSRS", LE_Failure);
490 VALIDATE_LAS_POINTER1(hSRS, "LASReader_SetOutputSRS", LE_Failure);
491
492 try {
493 liblas::Reader* reader = ((liblas::Reader*) hReader);
494 liblas::Header const& h = reader->GetHeader();
495 liblas::SpatialReference in_ref = h.GetSRS();
496 liblas::SpatialReference* out_ref = ((liblas::SpatialReference*) hSRS);
497 std::vector<liblas::TransformPtr> transforms = reader->GetTransforms();
498
499 transforms.erase( std::remove_if( transforms.begin(),
500 transforms.end(),
501 boost::bind( &IsReprojectionTransform, _1 ) ),
502 transforms.end());
503
504 liblas::TransformPtr srs_transform = liblas::TransformPtr(new liblas::ReprojectionTransform(in_ref, *out_ref, &h));
505 if (transforms.size())
506 transforms.insert(transforms.begin(), srs_transform);
507 else
508 transforms.push_back(srs_transform);
509 reader->SetTransforms(transforms);
510
511 // ((liblas::Reader*) hReader)->SetOutputSRS(*((liblas::SpatialReference*)hSRS));
512 }
513 catch (std::exception const& e) {
514 LASError_PushError(LE_Failure, e.what(), "LASReader_SetOutputSRS");
515 return LE_Failure;
516 }
517
518 return LE_None;
519 }
520
LASReader_SetSRS(LASReaderH hReader,const LASSRSH hSRS)521 LAS_DLL LASErrorEnum LASReader_SetSRS(LASReaderH hReader, const LASSRSH hSRS) {
522
523 VALIDATE_LAS_POINTER1(hReader, "LASReader_SetSRS", LE_Failure);
524 VALIDATE_LAS_POINTER1(hSRS, "LASReader_SetSRS", LE_Failure);
525
526 return LASReader_SetOutputSRS(hReader, hSRS);
527 }
528
LASHeader_Create(void)529 LAS_DLL LASHeaderH LASHeader_Create(void) {
530 return (LASHeaderH) new liblas::HeaderPtr(new liblas::Header());
531 }
532
LASPoint_Create(void)533 LAS_DLL LASPointH LASPoint_Create(void) {
534 return (LASPointH) new liblas::Point(&liblas::DefaultHeader::get());
535 }
536
LASPoint_Copy(const LASPointH hPoint)537 LAS_DLL LASPointH LASPoint_Copy(const LASPointH hPoint) {
538 return (LASPointH) new liblas::Point(*((liblas::Point*) hPoint));
539 }
540
LASPoint_GetHeader(const LASPointH hPoint)541 LAS_DLL LASHeaderH LASPoint_GetHeader(const LASPointH hPoint)
542 {
543 VALIDATE_LAS_POINTER1(hPoint , "LASPoint_GetHeader", new liblas::HeaderPtr());
544
545 liblas::Point const& p= *((liblas::Point*) hPoint);
546 liblas::Header const* h = p.GetHeader();
547 return (LASHeaderH) new liblas::HeaderPtr(new liblas::Header(*h));
548
549 }
550
LASPoint_SetHeader(LASPointH hPoint,const LASHeaderH hHeader)551 LAS_DLL void LASPoint_SetHeader( LASPointH hPoint, const LASHeaderH hHeader)
552
553 {
554 VALIDATE_LAS_POINTER0(hPoint, "LASPoint_SetHeader");
555 VALIDATE_LAS_POINTER0(hHeader, "LASPoint_SetHeader");
556
557 liblas::Point* point = (liblas::Point*)hPoint;
558 liblas::HeaderPtr h = (liblas::HeaderPtr)*hHeader;
559 liblas::Header const& header = *h;
560 point->SetHeader(&header);
561 }
562
LASPoint_SetData(LASPointH hPoint,unsigned char * data)563 LAS_DLL LASErrorEnum LASPoint_SetData(LASPointH hPoint, unsigned char* data) {
564
565 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetData", LE_Failure);
566 VALIDATE_LAS_POINTER1(data, "LASPoint_SetData", LE_Failure);
567
568 try {
569 liblas::Point* p = ((liblas::Point*) hPoint);
570 uint16_t size = 0;
571
572 liblas::Header const* h = p->GetHeader();
573 size = h->GetDataRecordLength();
574
575 std::vector<uint8_t> & d = p->GetData();
576 if (d.size() != size)
577 {
578 d.resize(size);
579 d.assign(static_cast<uint32_t>(0), d.size());
580 }
581
582 for (uint16_t i=0; i < size; i++) {
583 d[i] = data[i];
584 }
585 }
586 catch (std::exception const& e) {
587 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetData");
588 return LE_Failure;
589 }
590
591
592 return LE_None;
593 }
594
LASPoint_GetData(const LASPointH hPoint,uint8_t * data)595 LAS_DLL LASErrorEnum LASPoint_GetData( const LASPointH hPoint, uint8_t* data) {
596
597 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetData", LE_Failure);
598 VALIDATE_LAS_POINTER1(data, "LASPoint_GetData", LE_Failure);
599
600 try {
601 liblas::Point* p = ((liblas::Point*) hPoint);
602 uint16_t size = 0;
603 std::vector<uint8_t> const& d = p->GetData();
604
605 liblas::Header const* h = p->GetHeader();
606 size = h->GetDataRecordLength();
607
608 for (uint16_t i=0; i < size; i++) {
609 data[i] = d[i];
610 }
611 }
612 catch (std::exception const& e) {
613 LASError_PushError(LE_Failure, e.what(), "LASPoint_GetData");
614 return LE_Failure;
615 }
616
617
618 return LE_None;
619 }
620
621
LASPoint_Destroy(LASPointH hPoint)622 LAS_DLL void LASPoint_Destroy(LASPointH hPoint) {
623 VALIDATE_LAS_POINTER0(hPoint, "LASPoint_Destroy");
624 delete (liblas::Point*) hPoint;
625 hPoint = NULL;
626 }
627
LASPoint_GetX(const LASPointH hPoint)628 LAS_DLL double LASPoint_GetX(const LASPointH hPoint) {
629
630 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetX", 0.0);
631
632 double value = ((liblas::Point*) hPoint)->GetX();
633 return value;
634 }
635
LASPoint_SetX(LASPointH hPoint,double value)636 LAS_DLL LASErrorEnum LASPoint_SetX(LASPointH hPoint, double value) {
637
638 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetX", LE_Failure);
639
640 try {
641 ((liblas::Point*) hPoint)->SetX(value);
642 } catch (std::exception const& e)
643 {
644 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetX");
645 return LE_Failure;
646 }
647
648 return LE_None;
649
650 }
651
LASPoint_GetRawX(const LASPointH hPoint)652 LAS_DLL int32_t LASPoint_GetRawX(const LASPointH hPoint) {
653
654 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetRawX", 0);
655
656 long value = static_cast<long>(((liblas::Point*) hPoint)->GetRawX());
657 return value;
658 }
659
LASPoint_SetRawX(LASPointH hPoint,int32_t value)660 LAS_DLL LASErrorEnum LASPoint_SetRawX(LASPointH hPoint, int32_t value) {
661
662 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetRawX", LE_Failure);
663
664 try {
665 ((liblas::Point*) hPoint)->SetRawX(value);
666 } catch (std::exception const& e)
667 {
668 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetRawX");
669 return LE_Failure;
670 }
671
672 return LE_None;
673
674 }
675
LASPoint_GetY(const LASPointH hPoint)676 LAS_DLL double LASPoint_GetY(const LASPointH hPoint) {
677
678 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetY", 0.0);
679
680 double value = ((liblas::Point*) hPoint)->GetY();
681 return value;
682 }
683
LASPoint_SetY(LASPointH hPoint,double value)684 LAS_DLL LASErrorEnum LASPoint_SetY(LASPointH hPoint, double value) {
685
686 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetY", LE_Failure);
687
688 try {
689 ((liblas::Point*) hPoint)->SetY(value);
690 } catch (std::exception const& e)
691 {
692 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetY");
693 return LE_Failure;
694 }
695
696 return LE_None;
697
698 }
699
LASPoint_GetRawY(const LASPointH hPoint)700 LAS_DLL int32_t LASPoint_GetRawY(const LASPointH hPoint) {
701
702 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetRawY", 0);
703
704 long value = static_cast<long>(((liblas::Point*) hPoint)->GetRawY());
705 return value;
706 }
707
LASPoint_SetRawY(LASPointH hPoint,int32_t value)708 LAS_DLL LASErrorEnum LASPoint_SetRawY(LASPointH hPoint, int32_t value) {
709
710 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetRawY", LE_Failure);
711
712 try {
713 ((liblas::Point*) hPoint)->SetRawY(value);
714 } catch (std::exception const& e)
715 {
716 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetRawY");
717 return LE_Failure;
718 }
719
720 return LE_None;
721
722 }
LASPoint_GetZ(const LASPointH hPoint)723 LAS_DLL double LASPoint_GetZ(const LASPointH hPoint) {
724
725 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetZ", 0.0);
726
727 double value = ((liblas::Point*) hPoint)->GetZ();
728 return value;
729 }
730
LASPoint_SetZ(LASPointH hPoint,double value)731 LAS_DLL LASErrorEnum LASPoint_SetZ(LASPointH hPoint, double value) {
732
733 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetZ", LE_Failure);
734
735 try {
736 ((liblas::Point*) hPoint)->SetZ(value);
737 } catch (std::exception const& e)
738 {
739 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetZ");
740 return LE_Failure;
741 }
742
743 return LE_None;
744
745 }
746
LASPoint_GetRawZ(const LASPointH hPoint)747 LAS_DLL int32_t LASPoint_GetRawZ(const LASPointH hPoint) {
748
749 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetRawZ", 0);
750
751 long value = static_cast<long>(((liblas::Point*) hPoint)->GetRawZ());
752 return value;
753 }
754
LASPoint_SetRawZ(LASPointH hPoint,int32_t value)755 LAS_DLL LASErrorEnum LASPoint_SetRawZ(LASPointH hPoint, int32_t value) {
756
757 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetRawZ", LE_Failure);
758
759 try {
760 ((liblas::Point*) hPoint)->SetRawZ(value);
761 } catch (std::exception const& e)
762 {
763 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetRawZ");
764 return LE_Failure;
765 }
766
767 return LE_None;
768
769 }
770
LASPoint_GetIntensity(const LASPointH hPoint)771 LAS_DLL uint16_t LASPoint_GetIntensity(const LASPointH hPoint) {
772
773 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetIntensity", 0);
774
775 uint16_t value = ((liblas::Point*) hPoint)->GetIntensity();
776 return value;
777 }
778
LASPoint_SetIntensity(LASPointH hPoint,uint16_t value)779 LAS_DLL LASErrorEnum LASPoint_SetIntensity(LASPointH hPoint, uint16_t value) {
780
781 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetIntensity", LE_Failure);
782
783 try {
784 ((liblas::Point*) hPoint)->SetIntensity(value);
785 } catch (std::exception const& e)
786 {
787 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetIntensity");
788 return LE_Failure;
789 }
790
791 return LE_None;
792
793 }
794
LASPoint_GetReturnNumber(const LASPointH hPoint)795 LAS_DLL uint16_t LASPoint_GetReturnNumber(const LASPointH hPoint) {
796
797 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetReturnNumber", 0);
798
799 uint16_t value = ((liblas::Point*) hPoint)->GetReturnNumber();
800 return value;
801 }
802
LASPoint_SetReturnNumber(LASPointH hPoint,uint16_t value)803 LAS_DLL LASErrorEnum LASPoint_SetReturnNumber(LASPointH hPoint, uint16_t value) {
804
805 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetReturnNumber", LE_Failure);
806
807 try {
808 ((liblas::Point*) hPoint)->SetReturnNumber(value);
809 } catch (std::exception const& e)
810 {
811 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetReturnNumber");
812 return LE_Failure;
813 }
814
815 return LE_None;
816
817 }
818
LASPoint_GetNumberOfReturns(const LASPointH hPoint)819 LAS_DLL uint16_t LASPoint_GetNumberOfReturns(const LASPointH hPoint) {
820
821 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetNumberOfReturns", 0);
822
823 uint16_t value = ((liblas::Point*) hPoint)->GetNumberOfReturns();
824 return value;
825 }
826
LASPoint_SetNumberOfReturns(LASPointH hPoint,uint16_t value)827 LAS_DLL LASErrorEnum LASPoint_SetNumberOfReturns(LASPointH hPoint, uint16_t value) {
828
829 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetNumberOfReturns", LE_Failure);
830
831 try {
832 ((liblas::Point*) hPoint)->SetNumberOfReturns(value);
833 } catch (std::exception const& e)
834 {
835 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetNumberOfReturns");
836 return LE_Failure;
837 }
838
839 return LE_None;
840
841 }
842
LASPoint_GetScanDirection(const LASPointH hPoint)843 LAS_DLL uint16_t LASPoint_GetScanDirection(const LASPointH hPoint) {
844
845 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetScanDirection", 0);
846
847 uint16_t value = ((liblas::Point*) hPoint)->GetScanDirection();
848 return value;
849 }
850
LASPoint_SetScanDirection(LASPointH hPoint,uint16_t value)851 LAS_DLL LASErrorEnum LASPoint_SetScanDirection(LASPointH hPoint, uint16_t value) {
852
853 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetScanDirection", LE_Failure);
854
855 try {
856 ((liblas::Point*) hPoint)->SetScanDirection(value);
857 } catch (std::exception const& e)
858 {
859 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetScanDirection");
860 return LE_Failure;
861 }
862
863 return LE_None;
864
865 }
866
LASPoint_GetFlightLineEdge(const LASPointH hPoint)867 LAS_DLL uint16_t LASPoint_GetFlightLineEdge(const LASPointH hPoint) {
868
869 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetFlightLineEdge", 0);
870
871 uint16_t value = ((liblas::Point*) hPoint)->GetFlightLineEdge();
872 return value;
873 }
874
LASPoint_SetFlightLineEdge(LASPointH hPoint,uint16_t value)875 LAS_DLL LASErrorEnum LASPoint_SetFlightLineEdge(LASPointH hPoint, uint16_t value) {
876
877 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetFlightLineEdge", LE_Failure);
878
879 try {
880 ((liblas::Point*) hPoint)->SetFlightLineEdge(value);
881 } catch (std::exception const& e)
882 {
883 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetFlightLineEdge");
884 return LE_Failure;
885 }
886
887 return LE_None;
888
889 }
890
LASPoint_GetScanFlags(const LASPointH hPoint)891 LAS_DLL uint8_t LASPoint_GetScanFlags(const LASPointH hPoint) {
892
893 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetScanFlags", 0);
894
895 uint8_t value = ((liblas::Point*) hPoint)->GetScanFlags();
896 return value;
897 }
898
LASPoint_SetScanFlags(LASPointH hPoint,uint8_t value)899 LAS_DLL LASErrorEnum LASPoint_SetScanFlags(LASPointH hPoint, uint8_t value) {
900
901 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetScanFlags", LE_Failure);
902
903 try {
904 ((liblas::Point*) hPoint)->SetScanFlags(value);
905 } catch (std::exception const& e)
906 {
907 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetScanFlags");
908 return LE_Failure;
909 }
910
911 return LE_None;
912
913 }
914
LASPoint_GetClassification(const LASPointH hPoint)915 LAS_DLL uint8_t LASPoint_GetClassification(const LASPointH hPoint) {
916
917 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetClassification", 0);
918
919 liblas::Classification::bitset_type clsflags(((liblas::Point*) hPoint)->GetClassification());
920 uint8_t value = static_cast<uint8_t>(clsflags.to_ulong());
921 return value;
922 }
923
LASPoint_SetClassification(LASPointH hPoint,uint8_t value)924 LAS_DLL LASErrorEnum LASPoint_SetClassification(LASPointH hPoint, uint8_t value) {
925
926 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetClassification", LE_Failure);
927
928 try {
929 ((liblas::Point*) hPoint)->SetClassification(value);
930 } catch (std::exception const& e)
931 {
932 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetClassification");
933 return LE_Failure;
934 }
935
936 return LE_None;
937
938 }
939
LASPoint_SetTime(LASPointH hPoint,double value)940 LAS_DLL LASErrorEnum LASPoint_SetTime(LASPointH hPoint, double value) {
941
942 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetTime", LE_Failure);
943
944 try {
945 ((liblas::Point*) hPoint)->SetTime(value);
946
947 }
948 catch (std::runtime_error const&)
949 {
950 // drop the value on the floor. If the point has a schema that
951 // doesn't have time, the user needs to change the point's header.
952 }
953 catch (std::exception const& e)
954 {
955 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetTime");
956 return LE_Failure;
957 }
958
959 return LE_None;
960
961 }
962
LASPoint_GetTime(const LASPointH hPoint)963 LAS_DLL double LASPoint_GetTime(const LASPointH hPoint) {
964
965 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetTime", 0.0);
966
967 double value = 0.0;
968 try {
969 value = ((liblas::Point*) hPoint)->GetTime();
970
971 } catch (std::runtime_error const&)
972 {
973
974 }
975 return value;
976 }
977
LASPoint_GetScanAngleRank(const LASPointH hPoint)978 LAS_DLL char LASPoint_GetScanAngleRank(const LASPointH hPoint) {
979
980 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetScanAngleRank", 0);
981
982 int8_t value = ((liblas::Point*) hPoint)->GetScanAngleRank();
983 return static_cast<char>(value);
984 }
985
LASPoint_SetScanAngleRank(LASPointH hPoint,char value)986 LAS_DLL LASErrorEnum LASPoint_SetScanAngleRank(LASPointH hPoint, char value) {
987
988 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetScanAngleRank", LE_Failure);
989
990 try {
991 ((liblas::Point*) hPoint)->SetScanAngleRank(static_cast<int8_t>(value));
992 } catch (std::exception const& e)
993 {
994 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetScanAngleRank");
995 return LE_Failure;
996 }
997
998 return LE_None;
999
1000 }
1001
LASPoint_GetPointSourceId(const LASPointH hPoint)1002 LAS_DLL uint16_t LASPoint_GetPointSourceId(const LASPointH hPoint) {
1003
1004 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetPointSourceId", 0);
1005
1006 uint16_t value = ((liblas::Point*) hPoint)->GetPointSourceID();
1007 return value;
1008 }
1009
LASPoint_SetPointSourceId(LASPointH hPoint,uint16_t value)1010 LAS_DLL LASErrorEnum LASPoint_SetPointSourceId(LASPointH hPoint, uint16_t value) {
1011
1012 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetPointSourceId", LE_Failure);
1013
1014 try {
1015 ((liblas::Point*) hPoint)->SetPointSourceID(value);
1016 } catch (std::exception const& e)
1017 {
1018 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetPointSourceId");
1019 return LE_Failure;
1020 }
1021
1022 return LE_None;
1023
1024 }
1025
1026
LASPoint_GetUserData(const LASPointH hPoint)1027 LAS_DLL uint8_t LASPoint_GetUserData(const LASPointH hPoint) {
1028
1029 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetUserData", 0);
1030
1031 uint8_t value = ((liblas::Point*) hPoint)->GetUserData();
1032 return value;
1033 }
1034
LASPoint_GetXML(const LASPointH hPoint)1035 LAS_DLL char* LASPoint_GetXML(const LASPointH hPoint)
1036 {
1037 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetXML", NULL);
1038 liblas::Point* p = (liblas::Point*)hPoint;
1039
1040 std::ostringstream oss;
1041
1042 liblas::property_tree::ptree tree= p->GetPTree();
1043 liblas::property_tree::write_xml(oss, tree);
1044 return LASCopyString(oss.str().c_str());
1045
1046 }
1047
LASPoint_SetUserData(LASPointH hPoint,uint8_t value)1048 LAS_DLL LASErrorEnum LASPoint_SetUserData(LASPointH hPoint, uint8_t value) {
1049
1050 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetUserData", LE_Failure);
1051
1052 try {
1053 ((liblas::Point*) hPoint)->SetUserData(value);
1054 } catch (std::exception const& e)
1055 {
1056 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetUserData");
1057 return LE_Failure;
1058 }
1059
1060 return LE_None;
1061
1062 }
1063
LASPoint_Equal(const LASPointH hPoint1,const LASPointH hPoint2)1064 LAS_DLL int LASPoint_Equal(const LASPointH hPoint1, const LASPointH hPoint2) {
1065 VALIDATE_LAS_POINTER1(hPoint1, "LASPoint_Equal", 0);
1066 VALIDATE_LAS_POINTER1(hPoint2, "LASPoint_Equal", 0);
1067
1068 liblas::Point* point1 = ((liblas::Point*) hPoint1);
1069 liblas::Point* point2 = ((liblas::Point*) hPoint2);
1070
1071 return (point1 == point2);
1072
1073 }
1074
LASPoint_Validate(LASPointH hPoint)1075 LAS_DLL int LASPoint_Validate(LASPointH hPoint) {
1076
1077 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_Validate", LE_Failure);
1078
1079 try {
1080 ((liblas::Point*) hPoint)->Validate();
1081 } catch (invalid_point_data const& e /*e */) {
1082 return e.who();
1083 } catch (std::exception const& e)
1084 {
1085 LASError_PushError(LE_Failure, e.what(), "LASPoint_Validate");
1086 return LE_Failure;
1087 }
1088
1089 return LE_None;
1090 }
1091
LASPoint_IsValid(LASPointH hPoint)1092 LAS_DLL int LASPoint_IsValid(LASPointH hPoint) {
1093
1094 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_IsValid", LE_Failure);
1095 return ((liblas::Point*) hPoint)->IsValid();
1096 }
1097
LASHeader_GetFileSignature(const LASHeaderH hHeader)1098 LAS_DLL char* LASHeader_GetFileSignature(const LASHeaderH hHeader) {
1099 // caller owns it
1100 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetFileSignature", NULL);
1101
1102 std::string signature = ((liblas::HeaderPtr*) hHeader)->get()->GetFileSignature();
1103 return LASCopyString(signature.c_str());
1104 }
1105
LASHeader_GetFileSourceId(const LASHeaderH hHeader)1106 LAS_DLL uint16_t LASHeader_GetFileSourceId(const LASHeaderH hHeader) {
1107 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetFileSourceId", 0);
1108
1109 unsigned short value = ((liblas::HeaderPtr*) hHeader)->get()->GetFileSourceId();
1110 return value;
1111 }
1112
LASHeader_SetFileSourceId(LASHeaderH hHeader,uint16_t value)1113 LAS_DLL LASErrorEnum LASHeader_SetFileSourceId(LASHeaderH hHeader, uint16_t value) {
1114 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetFileSourceId", LE_Failure);
1115 ((liblas::HeaderPtr*) hHeader)->get()->SetFileSourceId(value);
1116 return LE_None;
1117 }
1118
1119
LASHeader_GetReserved(const LASHeaderH hHeader)1120 LAS_DLL uint16_t LASHeader_GetReserved(const LASHeaderH hHeader) {
1121 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetReserved", 0);
1122
1123 unsigned short value = ((liblas::HeaderPtr*) hHeader)->get()->GetReserved();
1124 return value;
1125 }
1126
LASHeader_SetReserved(LASHeaderH hHeader,uint16_t value)1127 LAS_DLL LASErrorEnum LASHeader_SetReserved(LASHeaderH hHeader, uint16_t value) {
1128 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetReserved", LE_Failure);
1129 ((liblas::HeaderPtr*) hHeader)->get()->SetReserved(value);
1130 return LE_None;
1131 }
1132
LASHeader_GetProjectId(const LASHeaderH hHeader)1133 LAS_DLL char* LASHeader_GetProjectId(const LASHeaderH hHeader) {
1134 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetProjectId", 0);
1135
1136 boost::uuids::uuid id = ((liblas::HeaderPtr*) hHeader)->get()->GetProjectId();
1137 std::ostringstream oss;
1138 oss << id;
1139 return LASCopyString(oss.str().c_str());
1140 }
1141
LASHeader_SetProjectId(LASHeaderH hHeader,const char * value)1142 LAS_DLL LASErrorEnum LASHeader_SetProjectId(LASHeaderH hHeader, const char* value) {
1143 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetProjectId", LE_Failure);
1144
1145 try {
1146 boost::uuids::uuid id = boost::uuids::string_generator()(value);
1147 ((liblas::HeaderPtr*) hHeader)->get()->SetProjectId(id);
1148 } catch (std::exception const& e)
1149 {
1150 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetGUID");
1151 return LE_Failure;
1152 }
1153
1154 return LE_None;
1155 }
1156
LASHeader_GetVersionMajor(const LASHeaderH hHeader)1157 LAS_DLL uint8_t LASHeader_GetVersionMajor(const LASHeaderH hHeader) {
1158 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetVersionMajor", 0);
1159
1160 long value = ((liblas::HeaderPtr*) hHeader)->get()->GetVersionMajor();
1161 return uint8_t(value);
1162 }
1163
LASHeader_SetVersionMajor(LASHeaderH hHeader,uint8_t value)1164 LAS_DLL LASErrorEnum LASHeader_SetVersionMajor(LASHeaderH hHeader, uint8_t value) {
1165 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetVersionMajor", LE_Failure);
1166
1167 try {
1168 ((liblas::HeaderPtr*) hHeader)->get()->SetVersionMajor(value);
1169 } catch (std::exception const& e)
1170 {
1171 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetVersionMajor");
1172 return LE_Failure;
1173 }
1174
1175 return LE_None;
1176 }
1177
LASHeader_GetVersionMinor(const LASHeaderH hHeader)1178 LAS_DLL uint8_t LASHeader_GetVersionMinor(const LASHeaderH hHeader) {
1179 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetVersionMinor", 0);
1180
1181 long value = ((liblas::HeaderPtr*) hHeader)->get()->GetVersionMinor();
1182 return uint8_t(value);
1183 }
1184
LASHeader_SetVersionMinor(LASHeaderH hHeader,uint8_t value)1185 LAS_DLL LASErrorEnum LASHeader_SetVersionMinor(LASHeaderH hHeader, uint8_t value) {
1186 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetVersionMinor", LE_Failure);
1187
1188 // TODO: Maybe this should be a fatal error -- hobu
1189 try {
1190 ((liblas::HeaderPtr*) hHeader)->get()->SetVersionMinor(value);
1191 } catch (std::exception const& e)
1192 {
1193 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetVersionMinor");
1194 return LE_Failure;
1195 }
1196
1197 return LE_None;
1198 }
1199
LASHeader_GetSystemId(const LASHeaderH hHeader)1200 LAS_DLL char* LASHeader_GetSystemId(const LASHeaderH hHeader) {
1201 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetSystemId", NULL);
1202
1203 // caller owns it
1204 std::string sysid = ((liblas::HeaderPtr*) hHeader)->get()->GetSystemId();
1205 return LASCopyString(sysid.c_str());
1206 }
1207
LASHeader_SetSystemId(LASHeaderH hHeader,const char * value)1208 LAS_DLL LASErrorEnum LASHeader_SetSystemId(LASHeaderH hHeader, const char* value) {
1209 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetSystemId", LE_Failure);
1210
1211 try {
1212 ((liblas::HeaderPtr*) hHeader)->get()->SetSystemId(value);
1213 } catch (std::exception const& e)
1214 {
1215 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetSystemId");
1216 return LE_Failure;
1217 }
1218
1219 return LE_None;
1220 }
1221
LASHeader_GetSoftwareId(const LASHeaderH hHeader)1222 LAS_DLL char* LASHeader_GetSoftwareId(const LASHeaderH hHeader) {
1223 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetSoftwareId", NULL);
1224
1225 // caller owns it
1226 std::string softid = ((liblas::HeaderPtr*) hHeader)->get()->GetSoftwareId();
1227 return LASCopyString(softid.c_str());
1228 }
1229
LASHeader_SetSoftwareId(LASHeaderH hHeader,const char * value)1230 LAS_DLL LASErrorEnum LASHeader_SetSoftwareId(LASHeaderH hHeader, const char* value) {
1231 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetSoftwareId", LE_Failure);
1232
1233 try {
1234 ((liblas::HeaderPtr*) hHeader)->get()->SetSoftwareId(value);
1235 } catch (std::exception const& e)
1236 {
1237 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetSoftwareId");
1238 return LE_Failure;
1239 }
1240
1241 return LE_None;
1242 }
1243
LASHeader_GetCreationDOY(const LASHeaderH hHeader)1244 LAS_DLL uint16_t LASHeader_GetCreationDOY(const LASHeaderH hHeader) {
1245 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetCreationDOY", 0);
1246
1247 unsigned short value = ((liblas::HeaderPtr*) hHeader)->get()->GetCreationDOY();
1248 return value;
1249 }
1250
LASHeader_SetCreationDOY(LASHeaderH hHeader,uint16_t value)1251 LAS_DLL LASErrorEnum LASHeader_SetCreationDOY(LASHeaderH hHeader, uint16_t value) {
1252 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetCreationDOY", LE_Failure);
1253 ((liblas::HeaderPtr*) hHeader)->get()->SetCreationDOY(value);
1254 return LE_None;
1255 }
1256
LASHeader_GetCreationYear(const LASHeaderH hHeader)1257 LAS_DLL uint16_t LASHeader_GetCreationYear(const LASHeaderH hHeader) {
1258 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetCreationYear", 0);
1259
1260 unsigned short value = ((liblas::HeaderPtr*) hHeader)->get()->GetCreationYear();
1261 return value;
1262 }
1263
LASHeader_SetCreationYear(LASHeaderH hHeader,uint16_t value)1264 LAS_DLL LASErrorEnum LASHeader_SetCreationYear(LASHeaderH hHeader, uint16_t value) {
1265 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetCreationYear", LE_Failure);
1266 ((liblas::HeaderPtr*) hHeader)->get()->SetCreationYear(value);
1267 return LE_None;
1268 }
1269
LASHeader_GetHeaderSize(const LASHeaderH hHeader)1270 LAS_DLL uint16_t LASHeader_GetHeaderSize(const LASHeaderH hHeader) {
1271 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetHeaderSize", 0);
1272
1273 unsigned short value = ((liblas::HeaderPtr*) hHeader)->get()->GetHeaderSize();
1274 return value;
1275 }
1276
LASHeader_GetDataOffset(const LASHeaderH hHeader)1277 LAS_DLL uint32_t LASHeader_GetDataOffset(const LASHeaderH hHeader) {
1278 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetDataOffset", 0);
1279
1280 unsigned long value = ((liblas::HeaderPtr*) hHeader)->get()->GetDataOffset();
1281 return value;
1282 }
1283
LASHeader_SetDataOffset(const LASHeaderH hHeader,uint32_t value)1284 LAS_DLL LASErrorEnum LASHeader_SetDataOffset(const LASHeaderH hHeader, uint32_t value) {
1285 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetDataOffset", LE_Failure);
1286
1287 try {
1288 ((liblas::HeaderPtr*) hHeader)->get()->SetDataOffset(value);
1289 } catch (std::exception const& e)
1290 {
1291 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetDataOffset");
1292 return LE_Failure;
1293 }
1294
1295 return LE_None;
1296 }
1297
LASHeader_GetHeaderPadding(const LASHeaderH hHeader)1298 LAS_DLL uint32_t LASHeader_GetHeaderPadding(const LASHeaderH hHeader) {
1299 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetHeaderPadding", 0);
1300
1301 unsigned long value = ((liblas::HeaderPtr*) hHeader)->get()->GetHeaderPadding();
1302 return value;
1303 }
1304
LASHeader_SetHeaderPadding(const LASHeaderH hHeader,uint32_t value)1305 LAS_DLL LASErrorEnum LASHeader_SetHeaderPadding(const LASHeaderH hHeader, uint32_t value) {
1306 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetHeaderPadding", LE_Failure);
1307
1308 try {
1309 ((liblas::HeaderPtr*) hHeader)->get()->SetHeaderPadding(value);
1310 } catch (std::exception const& e)
1311 {
1312 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetHeaderPadding");
1313 return LE_Failure;
1314 }
1315
1316 return LE_None;
1317 }
1318
LASHeader_GetRecordsCount(const LASHeaderH hHeader)1319 LAS_DLL uint32_t LASHeader_GetRecordsCount(const LASHeaderH hHeader) {
1320 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetRecordsCount", 0);
1321
1322 unsigned long value = ((liblas::HeaderPtr*) hHeader)->get()->GetRecordsCount();
1323 return value;
1324 }
1325
LASHeader_GetDataFormatId(const LASHeaderH hHeader)1326 LAS_DLL uint8_t LASHeader_GetDataFormatId(const LASHeaderH hHeader) {
1327 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetDataFormatId", 0);
1328
1329 liblas::PointFormatName id = ((liblas::HeaderPtr*) hHeader)->get()->GetDataFormatId();
1330 return static_cast<uint8_t>(id);
1331 }
1332
LASHeader_SetDataFormatId(LASHeaderH hHeader,uint8_t value)1333 LAS_DLL LASErrorEnum LASHeader_SetDataFormatId(LASHeaderH hHeader, uint8_t value) {
1334 VALIDATE_LAS_POINTER1(hHeader, "LASHeader_SetDataFormatId", LE_Failure);
1335
1336 try {
1337 ((liblas::HeaderPtr*) hHeader)->get()->SetDataFormatId((liblas::PointFormatName)value);
1338 } catch (std::exception const& e)
1339 {
1340 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetDataFormatId");
1341 return LE_Failure;
1342 }
1343
1344 return LE_None;
1345 }
1346
LASHeader_GetDataRecordLength(const LASHeaderH hHeader)1347 LAS_DLL uint16_t LASHeader_GetDataRecordLength(const LASHeaderH hHeader) {
1348 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetDataRecordLength", 0);
1349
1350 unsigned short value = ((liblas::HeaderPtr*) hHeader)->get()->GetDataRecordLength();
1351 return value;
1352 }
1353
1354
1355
LASHeader_GetPointRecordsByReturnCount(const LASHeaderH hHeader,int index)1356 LAS_DLL uint32_t LASHeader_GetPointRecordsByReturnCount(const LASHeaderH hHeader, int index) {
1357 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetPointRecordsByReturnCount", 0);
1358
1359 std::vector<uint32_t> counts = ((liblas::HeaderPtr*) hHeader)->get()->GetPointRecordsByReturnCount();
1360 if ( (index < 5) && (index >= 0)) {
1361 return counts[index];
1362 }
1363
1364 return 0;
1365
1366 }
1367
LASHeader_SetPointRecordsByReturnCount(const LASHeaderH hHeader,int index,uint32_t value)1368 LAS_DLL LASErrorEnum LASHeader_SetPointRecordsByReturnCount(const LASHeaderH hHeader, int index, uint32_t value) {
1369 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetPointRecordsByReturnCount", LE_Failure);
1370
1371 try {
1372 ((liblas::HeaderPtr*) hHeader)->get()->SetPointRecordsByReturnCount(index, value);
1373 } catch (std::exception const& e)
1374 {
1375 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetPointRecordsByReturnCount");
1376 return LE_Failure;
1377 }
1378
1379 return LE_None;
1380 }
1381
1382
LASHeader_GetPointRecordsCount(const LASHeaderH hHeader)1383 LAS_DLL uint32_t LASHeader_GetPointRecordsCount(const LASHeaderH hHeader) {
1384 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetPointRecordsCount", 0);
1385
1386 unsigned long value = ((liblas::HeaderPtr*) hHeader)->get()->GetPointRecordsCount();
1387 return value;
1388 }
1389
LASHeader_SetPointRecordsCount(const LASHeaderH hHeader,uint32_t value)1390 LAS_DLL LASErrorEnum LASHeader_SetPointRecordsCount(const LASHeaderH hHeader, uint32_t value) {
1391 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetPointRecordsCount", LE_Failure);
1392
1393 try {
1394 ((liblas::HeaderPtr*) hHeader)->get()->SetPointRecordsCount(value);
1395 } catch (std::exception const& e)
1396 {
1397 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetPointRecordsCount");
1398 return LE_Failure;
1399 }
1400
1401 return LE_None;
1402 }
1403
LASHeader_GetScaleX(const LASHeaderH hHeader)1404 LAS_DLL double LASHeader_GetScaleX(const LASHeaderH hHeader) {
1405 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetScaleX", 0.0);
1406
1407 double value = ((liblas::HeaderPtr*) hHeader)->get()->GetScaleX();
1408 return value;
1409 }
1410
LASHeader_GetScaleY(const LASHeaderH hHeader)1411 LAS_DLL double LASHeader_GetScaleY(const LASHeaderH hHeader) {
1412 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetScaleY", 0.0);
1413
1414 double value = ((liblas::HeaderPtr*) hHeader)->get()->GetScaleY();
1415 return value;
1416 }
1417
LASHeader_GetScaleZ(const LASHeaderH hHeader)1418 LAS_DLL double LASHeader_GetScaleZ(const LASHeaderH hHeader) {
1419 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetScaleZ", 0.0);
1420
1421 double value = ((liblas::HeaderPtr*) hHeader)->get()->GetScaleZ();
1422 return value;
1423 }
1424
LASHeader_SetScale(LASHeaderH hHeader,double x,double y,double z)1425 LAS_DLL LASErrorEnum LASHeader_SetScale(LASHeaderH hHeader, double x, double y, double z) {
1426 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetScale", LE_Failure);
1427
1428 try {
1429 ((liblas::HeaderPtr*) hHeader)->get()->SetScale(x,y,z);
1430 } catch (std::exception const& e)
1431 {
1432 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetScale");
1433 return LE_Failure;
1434 }
1435
1436 return LE_None;
1437 }
1438
LASHeader_GetOffsetX(const LASHeaderH hHeader)1439 LAS_DLL double LASHeader_GetOffsetX(const LASHeaderH hHeader) {
1440 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetOffsetX", 0.0);
1441
1442 double value = ((liblas::HeaderPtr*) hHeader)->get()->GetOffsetX();
1443 return value;
1444 }
1445
LASHeader_GetOffsetY(const LASHeaderH hHeader)1446 LAS_DLL double LASHeader_GetOffsetY(const LASHeaderH hHeader) {
1447 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetOffsetY", 0.0);
1448
1449 double value = ((liblas::HeaderPtr*) hHeader)->get()->GetOffsetY();
1450 return value;
1451 }
1452
LASHeader_GetOffsetZ(const LASHeaderH hHeader)1453 LAS_DLL double LASHeader_GetOffsetZ(const LASHeaderH hHeader) {
1454 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetOffsetZ", 0.0);
1455
1456 double value = ((liblas::HeaderPtr*) hHeader)->get()->GetOffsetZ();
1457 return value;
1458 }
1459
LASHeader_SetOffset(LASHeaderH hHeader,double x,double y,double z)1460 LAS_DLL LASErrorEnum LASHeader_SetOffset(LASHeaderH hHeader, double x, double y, double z) {
1461 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetOffset", LE_Failure);
1462
1463 try {
1464 ((liblas::HeaderPtr*) hHeader)->get()->SetOffset(x,y,z);
1465 } catch (std::exception const& e)
1466 {
1467 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetOffset");
1468 return LE_Failure;
1469 }
1470
1471 return LE_None;
1472 }
1473
LASHeader_GetMinX(const LASHeaderH hHeader)1474 LAS_DLL double LASHeader_GetMinX(const LASHeaderH hHeader) {
1475 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetMinX", 0.0);
1476
1477 double value = ((liblas::HeaderPtr*) hHeader)->get()->GetMinX();
1478 return value;
1479 }
1480
LASHeader_GetMinY(const LASHeaderH hHeader)1481 LAS_DLL double LASHeader_GetMinY(const LASHeaderH hHeader) {
1482 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetMinY", 0.0);
1483
1484 double value = ((liblas::HeaderPtr*) hHeader)->get()->GetMinY();
1485 return value;
1486 }
1487
LASHeader_GetMinZ(const LASHeaderH hHeader)1488 LAS_DLL double LASHeader_GetMinZ(const LASHeaderH hHeader) {
1489 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetMinZ", 0.0);
1490
1491 double value = ((liblas::HeaderPtr*) hHeader)->get()->GetMinZ();
1492 return value;
1493 }
1494
LASHeader_SetMin(LASHeaderH hHeader,double x,double y,double z)1495 LAS_DLL LASErrorEnum LASHeader_SetMin(LASHeaderH hHeader, double x, double y, double z) {
1496 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetMin", LE_Failure);
1497
1498 try {
1499 ((liblas::HeaderPtr*) hHeader)->get()->SetMin(x,y,z);
1500 } catch (std::exception const& e)
1501 {
1502 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetMin");
1503 return LE_Failure;
1504 }
1505
1506 return LE_None;
1507 }
1508
LASHeader_GetMaxX(const LASHeaderH hHeader)1509 LAS_DLL double LASHeader_GetMaxX(const LASHeaderH hHeader) {
1510 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetMaxX", 0.0);
1511
1512 double value = ((liblas::HeaderPtr*) hHeader)->get()->GetMaxX();
1513 return value;
1514 }
1515
LASHeader_GetMaxY(const LASHeaderH hHeader)1516 LAS_DLL double LASHeader_GetMaxY(const LASHeaderH hHeader) {
1517 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetMaxY", 0.0);
1518
1519 double value = ((liblas::HeaderPtr*) hHeader)->get()->GetMaxY();
1520 return value;
1521 }
1522
LASHeader_GetMaxZ(const LASHeaderH hHeader)1523 LAS_DLL double LASHeader_GetMaxZ(const LASHeaderH hHeader) {
1524 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetMaxZ", 0.0);
1525
1526 double value = ((liblas::HeaderPtr*) hHeader)->get()->GetMaxZ();
1527 return value;
1528 }
1529
LASHeader_SetMax(LASHeaderH hHeader,double x,double y,double z)1530 LAS_DLL LASErrorEnum LASHeader_SetMax(LASHeaderH hHeader, double x, double y, double z) {
1531 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetMax", LE_Failure);
1532
1533 try {
1534 ((liblas::HeaderPtr*) hHeader)->get()->SetMax(x,y,z);
1535 } catch (std::exception const& e)
1536 {
1537 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetMax");
1538 return LE_Failure;
1539 }
1540
1541 return LE_None;
1542 }
1543
LASHeader_GetXML(const LASHeaderH hHeader)1544 LAS_DLL char* LASHeader_GetXML(const LASHeaderH hHeader)
1545 {
1546 VALIDATE_LAS_POINTER1(hHeader, "LASHeader_GetXML", NULL);
1547 liblas::Header* h = (liblas::Header*)hHeader->get();
1548
1549 std::ostringstream oss;
1550
1551 liblas::property_tree::ptree tree= h->GetPTree();
1552 liblas::property_tree::write_xml(oss, tree);
1553 return LASCopyString(oss.str().c_str());
1554
1555 }
1556
1557
LASHeader_Destroy(LASHeaderH hHeader)1558 LAS_DLL void LASHeader_Destroy(LASHeaderH hHeader)
1559 {
1560 VALIDATE_LAS_POINTER0(hHeader, "LASHeader_Destroy");
1561 // delete ((liblas::Header*) hHeader);
1562 // hHeader=NULL;
1563 }
1564
LASHeader_Copy(const LASHeaderH hHeader)1565 LAS_DLL LASHeaderH LASHeader_Copy(const LASHeaderH hHeader) {
1566 liblas::HeaderPtr* header = ((liblas::HeaderPtr*) hHeader);
1567 return (LASHeaderH) new liblas::HeaderPtr(new liblas::Header(*header->get()));
1568 }
1569
LASHeader_Equal(const LASHeaderH hHeader1,const LASHeaderH hHeader2)1570 LAS_DLL int LASHeader_Equal(const LASHeaderH hHeader1, const LASHeaderH hHeader2) {
1571 VALIDATE_LAS_POINTER1(hHeader1->get(), "LASHeader_Equal", 0);
1572 VALIDATE_LAS_POINTER1(hHeader2->get(), "LASHeader_Equal", 0);
1573
1574 liblas::HeaderPtr* header1 = ((liblas::HeaderPtr*) hHeader1);
1575 liblas::HeaderPtr* header2 = ((liblas::HeaderPtr*) hHeader2);
1576
1577 return (*header1->get() == *header2->get());
1578 }
1579
LASHeader_GetGUID(const LASHeaderH hHeader)1580 LAS_DLL LASGuidH LASHeader_GetGUID(const LASHeaderH hHeader) {
1581 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetGUID", 0);
1582
1583 boost::uuids::uuid id = ((liblas::HeaderPtr*) hHeader)->get()->GetProjectId();
1584 return (LASGuidH) new boost::uuids::uuid(id);
1585 }
1586
1587
LASHeader_SetGUID(LASHeaderH hHeader,LASGuidH hId)1588 LAS_DLL LASErrorEnum LASHeader_SetGUID(LASHeaderH hHeader, LASGuidH hId) {
1589 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetGUID", LE_Failure);
1590
1591 try {
1592 boost::uuids::uuid* id = (boost::uuids::uuid*) hId;
1593
1594 ((liblas::HeaderPtr*) hHeader)->get()->SetProjectId(*id);
1595 } catch (std::exception const& e)
1596 {
1597 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetGUID");
1598 return LE_Failure;
1599 }
1600
1601 return LE_None;
1602 }
1603
LASHeader_GetVLR(const LASHeaderH hHeader,uint32_t i)1604 LAS_DLL LASVLRH LASHeader_GetVLR(const LASHeaderH hHeader, uint32_t i) {
1605 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetVLR", 0);
1606
1607 liblas::VariableRecord vlr = ((liblas::HeaderPtr*) hHeader)->get()->GetVLR(i);
1608 return (LASVLRH) new liblas::VariableRecord(vlr);
1609 }
1610
LASHeader_DeleteVLR(LASHeaderH hHeader,uint32_t index)1611 LAS_DLL LASErrorEnum LASHeader_DeleteVLR(LASHeaderH hHeader, uint32_t index) {
1612
1613 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_DeleteVLR", LE_Failure);
1614
1615 try {
1616 ((liblas::HeaderPtr*) hHeader)->get()->DeleteVLR(index);
1617 }
1618 catch (std::exception const& e) {
1619 LASError_PushError(LE_Failure, e.what(), "LASHeader_DeleteVLR");
1620 return LE_Failure;
1621 }
1622
1623
1624 return LE_None;
1625 }
1626
LASHeader_AddVLR(LASHeaderH hHeader,const LASVLRH hVLR)1627 LAS_DLL LASErrorEnum LASHeader_AddVLR(LASHeaderH hHeader, const LASVLRH hVLR) {
1628
1629 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_AddVLR", LE_Failure);
1630 VALIDATE_LAS_POINTER1(hVLR, "LASHeader_AddVLR", LE_Failure);
1631
1632 try {
1633 ((liblas::HeaderPtr*) hHeader)->get()->AddVLR(*((liblas::VariableRecord*)hVLR));
1634 }
1635 catch (std::exception const& e) {
1636 LASError_PushError(LE_Failure, e.what(), "LASHeader_AddVLR");
1637 return LE_Failure;
1638 }
1639
1640
1641 return LE_None;
1642 }
1643
1644
1645
1646
LASWriter_Create(const char * filename,const LASHeaderH hHeader,int mode)1647 LAS_DLL LASWriterH LASWriter_Create(const char* filename, const LASHeaderH hHeader, int mode) {
1648 VALIDATE_LAS_POINTER1(hHeader->get(), "LASWriter_Create", NULL);
1649
1650 if (filename == NULL) {
1651 LASError_PushError(LE_Failure, "Input filename was null", "LASWriter_Create");
1652 return NULL;
1653 }
1654 std::ostream* ostrm = NULL;
1655 try
1656 {
1657 std::ios::openmode m;
1658 if ( (mode > 2) || (mode < 1)) {
1659 throw std::runtime_error("File mode must be eWrite or eAppend");
1660 }
1661
1662
1663
1664 // append mode
1665 if (mode == 2) {
1666 m = std::ios::out | std::ios::in | std::ios::binary | std::ios::ate;
1667 }
1668 // write mode
1669 else {
1670 m = std::ios::out | std::ios::binary | std::ios::ate;
1671 }
1672
1673 ostrm = liblas::Create(filename, m);
1674
1675
1676
1677 } catch (std::exception const& e)
1678 {
1679 if (ostrm)
1680 delete ostrm;
1681 LASError_PushError(LE_Failure, e.what(), "LASWriter_Create");
1682 return NULL;
1683 }
1684
1685
1686 try {
1687
1688 liblas::HeaderPtr* header = ((liblas::HeaderPtr*) hHeader);
1689 liblas::Writer* writer = new liblas::Writer(*ostrm, *header->get());
1690
1691 writers.insert(std::pair<liblas::Writer*, std::ostream*>(writer, ostrm));
1692 return (LASWriterH) writer;
1693
1694
1695 } catch (std::exception const& e)
1696 {
1697 LASError_PushError(LE_Failure, e.what(), "LASWriter_Create");
1698 return NULL;
1699 }
1700
1701
1702 }
1703
LASWriter_WritePoint(const LASWriterH hWriter,const LASPointH hPoint)1704 LAS_DLL LASErrorEnum LASWriter_WritePoint(const LASWriterH hWriter, const LASPointH hPoint) {
1705
1706 VALIDATE_LAS_POINTER1(hPoint, "LASWriter_WritePoint", LE_Failure);
1707 int ret;
1708
1709 try {
1710 ret = ((liblas::Writer*) hWriter)->WritePoint(*((liblas::Point*) hPoint));
1711 if (!ret) {
1712 LASError_PushError( LE_Warning,
1713 "Failed to write point because it was invalid",
1714 "LASWriter_WritePoint");
1715 return LE_Warning;
1716 }
1717 } catch (std::exception const& e)
1718 {
1719 LASError_PushError(LE_Failure, e.what(), "LASWriter_WritePoint");
1720 return LE_Failure;
1721 }
1722
1723 return LE_None;
1724 }
1725
LASWriter_WriteHeader(const LASWriterH hWriter,const LASHeaderH hHeader)1726 LAS_DLL LASErrorEnum LASWriter_WriteHeader(const LASWriterH hWriter, const LASHeaderH hHeader) {
1727
1728 VALIDATE_LAS_POINTER1(hHeader->get(), "LASWriter_WriteHeader", LE_Failure);
1729 VALIDATE_LAS_POINTER1(hWriter, "LASWriter_WriteHeader", LE_Failure);
1730
1731 try {
1732 ((liblas::Writer*) hWriter)->SetHeader(*((liblas::HeaderPtr*) hHeader)->get());
1733 ((liblas::Writer*) hWriter)->WriteHeader();
1734 } catch (std::exception const& e)
1735 {
1736 LASError_PushError(LE_Failure, e.what(), "LASWriter_WriteHeader");
1737 return LE_Failure;
1738 }
1739
1740 return LE_None;
1741 }
1742
LASWriter_WriteOwnedHeader(const LASWriterH hWriter)1743 LAS_DLL LASErrorEnum LASWriter_WriteOwnedHeader(const LASWriterH hWriter)
1744 {
1745 VALIDATE_LAS_POINTER1(hWriter, "LASWriter_WriteOwnedHeader", LE_Failure);
1746
1747 try {
1748 ((liblas::Writer*) hWriter)->WriteHeader();
1749 } catch (std::exception const& e)
1750 {
1751 LASError_PushError(LE_Failure, e.what(), "LASWriter_WriteOwnedHeader");
1752 return LE_Failure;
1753 }
1754
1755 return LE_None;
1756 }
1757
1758
LASWriter_SetHeader(LASWriterH hWriter,const LASHeaderH hHeader)1759 LAS_DLL void LASWriter_SetHeader( LASWriterH hWriter, const LASHeaderH hHeader)
1760
1761 {
1762 VALIDATE_LAS_POINTER0(hWriter, "LASWriter_SetHeader");
1763 VALIDATE_LAS_POINTER0(hHeader, "LASWriter_SetHeader");
1764
1765 liblas::Writer* writer = (liblas::Writer*)hWriter;
1766 liblas::HeaderPtr* header = (liblas::HeaderPtr*)hHeader;
1767 if (header->get())
1768 writer->SetHeader(*header->get());
1769 }
1770
LASWriter_Destroy(LASWriterH hWriter)1771 LAS_DLL void LASWriter_Destroy(LASWriterH hWriter)
1772 {
1773 VALIDATE_LAS_POINTER0(hWriter, "LASWriter_Destroy");
1774
1775 try {
1776 liblas::Writer* writer = (liblas::Writer*)hWriter;
1777
1778 std::map<liblas::Writer*, std::ostream*>::iterator it = writers.find(writer);
1779 if (it == writers.end())
1780 {
1781 LASError_PushError(LE_Failure, "Unable to find writer stream", "LASWriter_Destroy");
1782 return;
1783 }
1784 std::ostream* ostrm = it->second;
1785
1786 delete writer;
1787 hWriter = NULL;
1788
1789 if ( ostrm == NULL )
1790 {
1791 LASError_PushError(LE_Failure, "Got 99 problems, but the stream ain't one", "LASWriter_Destroy");
1792 return;
1793 }
1794
1795 liblas::Cleanup(ostrm);
1796
1797 writers.erase(writer);
1798
1799 ostrm = NULL;
1800
1801 } catch (std::runtime_error const& e/* e */)
1802 {
1803 LASError_PushError(LE_Failure, e.what(), "LASWriter_Destroy");
1804 return;
1805 }
1806
1807 }
1808
LASWriter_SetInputSRS(LASWriterH hWriter,const LASSRSH hSRS)1809 LAS_DLL LASErrorEnum LASWriter_SetInputSRS(LASWriterH hWriter, const LASSRSH hSRS) {
1810
1811 VALIDATE_LAS_POINTER1(hWriter, "LASWriter_SetInputSRS", LE_Failure);
1812 VALIDATE_LAS_POINTER1(hSRS, "LASWriter_SetInputSRS", LE_Failure);
1813
1814 try {
1815 liblas::Writer* writer = ((liblas::Writer*) hWriter);
1816 liblas::Header h = writer->GetHeader();
1817 liblas::SpatialReference* srs = ((liblas::SpatialReference*) hSRS);
1818 h.SetSRS(*srs);
1819 writer->SetHeader(h);
1820 }
1821 catch (std::exception const& e) {
1822 LASError_PushError(LE_Failure, e.what(), "LASWriter_SetInputSRS");
1823 return LE_Failure;
1824 }
1825
1826 return LE_None;
1827 }
1828
LASWriter_SetOutputSRS(LASWriterH hWriter,const LASSRSH hSRS)1829 LAS_DLL LASErrorEnum LASWriter_SetOutputSRS(LASWriterH hWriter, const LASSRSH hSRS) {
1830
1831 VALIDATE_LAS_POINTER1(hWriter, "LASWriter_SetOutputSRS", LE_Failure);
1832 VALIDATE_LAS_POINTER1(hSRS, "LASWriter_SetOutputSRS", LE_Failure);
1833
1834 try {
1835 liblas::Writer* writer = ((liblas::Writer*) hWriter);
1836 liblas::Header const& h = writer->GetHeader();
1837 liblas::SpatialReference in_ref = h.GetSRS();
1838 liblas::SpatialReference* out_ref = ((liblas::SpatialReference*) hSRS);
1839 std::vector<liblas::TransformPtr> transforms = writer->GetTransforms();
1840
1841 transforms.erase( std::remove_if( transforms.begin(),
1842 transforms.end(),
1843 boost::bind( &IsReprojectionTransform, _1 ) ),
1844 transforms.end());
1845
1846 liblas::TransformPtr srs_transform = liblas::TransformPtr(new liblas::ReprojectionTransform(in_ref, *out_ref, &h));
1847 if (transforms.size())
1848 transforms.insert(transforms.begin(), srs_transform);
1849 else
1850 transforms.push_back(srs_transform);
1851 writer->SetTransforms(transforms);
1852 }
1853 catch (std::exception const& e) {
1854 LASError_PushError(LE_Failure, e.what(), "LASWriter_SetOutputSRS");
1855 return LE_Failure;
1856 }
1857
1858 return LE_None;
1859 }
1860
LASWriter_SetSRS(LASWriterH hWriter,const LASSRSH hSRS)1861 LAS_DLL LASErrorEnum LASWriter_SetSRS(LASWriterH hWriter, const LASSRSH hSRS) {
1862
1863 VALIDATE_LAS_POINTER1(hWriter, "LASWriter_SetSRS", LE_Failure);
1864 VALIDATE_LAS_POINTER1(hSRS, "LASWriter_SetSRS", LE_Failure);
1865
1866 return LASWriter_SetOutputSRS(hWriter, hSRS);
1867 }
1868
LASWriter_GetHeader(const LASWriterH hWriter)1869 LAS_DLL LASHeaderH LASWriter_GetHeader(const LASWriterH hWriter)
1870 {
1871 VALIDATE_LAS_POINTER1(hWriter, "LASWriter_GetHeader", new liblas::HeaderPtr());
1872
1873 liblas::Header header = ((liblas::Writer*) hWriter)->GetHeader();
1874 return (LASHeaderH) new liblas::HeaderPtr( new liblas::Header(header) );
1875 }
1876
LASError_Print(const char * message)1877 LAS_DLL void LASError_Print(const char* message) {
1878
1879 char* errmsg= NULL;
1880 char* errmethod = NULL;
1881 errmsg = LASError_GetLastErrorMsg();
1882 errmethod = LASError_GetLastErrorMethod();
1883 if (LASError_GetErrorCount()) {
1884 fprintf(stderr,
1885 "%s: %s (%d) from method %s\n",
1886 message,
1887 errmsg,
1888 LASError_GetLastErrorNum(),
1889 errmethod
1890 );
1891 if (errmsg) free(errmsg);
1892 if (errmethod) free(errmethod);
1893 } else {
1894 fprintf(stderr,
1895 "You have encountered an error. '%s'\n",
1896 message
1897 );
1898 }
1899
1900 }
1901
LAS_GetVersion()1902 LAS_DLL char* LAS_GetVersion() {
1903 return LASCopyString(liblas::GetVersion().c_str());
1904 }
1905
LAS_GetFullVersion(void)1906 LAS_DLL char* LAS_GetFullVersion(void) {
1907 return LASCopyString(liblas::GetFullVersion().c_str());
1908 }
1909
1910
LASVLR_Create(void)1911 LAS_DLL LASVLRH LASVLR_Create(void) {
1912 return (LASVLRH) new liblas::VariableRecord();
1913 }
1914
LASVLR_Destroy(LASVLRH hVLR)1915 LAS_DLL void LASVLR_Destroy(LASVLRH hVLR){
1916 VALIDATE_LAS_POINTER0(hVLR, "LASVLR_Destroy");
1917 delete (liblas::VariableRecord*)hVLR;
1918 hVLR = NULL;
1919
1920 }
1921
LASVLR_GetUserId(const LASVLRH hVLR)1922 LAS_DLL char* LASVLR_GetUserId(const LASVLRH hVLR) {
1923 VALIDATE_LAS_POINTER1(hVLR, "LASVLR_GetUserId", 0);
1924 liblas::VariableRecord* vlr = (liblas::VariableRecord*)hVLR;
1925 return LASCopyString(vlr->GetUserId(true).c_str());
1926 }
1927
LASVLR_SetUserId(LASVLRH hVLR,const char * value)1928 LAS_DLL LASErrorEnum LASVLR_SetUserId(LASVLRH hVLR, const char* value) {
1929 VALIDATE_LAS_POINTER1(hVLR, "LASVLR_SetUserId", LE_Failure);
1930
1931 try {
1932 ((liblas::VariableRecord*) hVLR)->SetUserId(value);
1933 } catch (std::exception const& e)
1934 {
1935 LASError_PushError(LE_Failure, e.what(), "LASVLR_SetUserId");
1936 return LE_Failure;
1937 }
1938
1939 return LE_None;
1940 }
1941
LASVLR_GetDescription(const LASVLRH hVLR)1942 LAS_DLL char* LASVLR_GetDescription(const LASVLRH hVLR) {
1943 VALIDATE_LAS_POINTER1(hVLR, "LASVLR_GetDescription", 0);
1944 liblas::VariableRecord* vlr = (liblas::VariableRecord*)hVLR;
1945 return LASCopyString(vlr->GetDescription(true).c_str());
1946 }
1947
LASVLR_SetDescription(LASVLRH hVLR,const char * value)1948 LAS_DLL LASErrorEnum LASVLR_SetDescription(LASVLRH hVLR, const char* value) {
1949 VALIDATE_LAS_POINTER1(hVLR, "LASVLR_SetDescription", LE_Failure);
1950
1951 try {
1952 ((liblas::VariableRecord*) hVLR)->SetDescription(value);
1953 } catch (std::exception const& e)
1954 {
1955 LASError_PushError(LE_Failure, e.what(), "LASVLR_SetDescription");
1956 return LE_Failure;
1957 }
1958
1959 return LE_None;
1960 }
1961
LASVLR_GetRecordLength(const LASVLRH hVLR)1962 LAS_DLL uint16_t LASVLR_GetRecordLength(const LASVLRH hVLR) {
1963
1964 VALIDATE_LAS_POINTER1(hVLR, "LASVLR_GetRecordLength", 0);
1965
1966 uint16_t value = ((liblas::VariableRecord*) hVLR)->GetRecordLength();
1967 return value;
1968 }
LASVLR_SetRecordLength(LASVLRH hVLR,uint16_t value)1969 LAS_DLL LASErrorEnum LASVLR_SetRecordLength(LASVLRH hVLR, uint16_t value) {
1970 VALIDATE_LAS_POINTER1(hVLR, "LASVLR_SetRecordLength", LE_Failure);
1971 ((liblas::VariableRecord*) hVLR)->SetRecordLength(value);
1972 return LE_None;
1973 }
1974
LASVLR_GetRecordId(const LASVLRH hVLR)1975 LAS_DLL uint16_t LASVLR_GetRecordId(const LASVLRH hVLR) {
1976
1977 VALIDATE_LAS_POINTER1(hVLR, "LASVLR_GetRecordId", 0);
1978
1979 uint16_t value = ((liblas::VariableRecord*) hVLR)->GetRecordId();
1980 return value;
1981 }
LASVLR_SetRecordId(LASVLRH hVLR,uint16_t value)1982 LAS_DLL LASErrorEnum LASVLR_SetRecordId(LASVLRH hVLR, uint16_t value) {
1983 VALIDATE_LAS_POINTER1(hVLR, "LASVLR_SetRecordId", LE_Failure);
1984 ((liblas::VariableRecord*) hVLR)->SetRecordId(value);
1985 return LE_None;
1986 }
1987
1988
LASVLR_SetReserved(LASVLRH hVLR,uint16_t value)1989 LAS_DLL LASErrorEnum LASVLR_SetReserved(LASVLRH hVLR, uint16_t value) {
1990 VALIDATE_LAS_POINTER1(hVLR, "LASVLR_SetReserved", LE_Failure);
1991 ((liblas::VariableRecord*) hVLR)->SetReserved(value);
1992 return LE_None;
1993 }
1994
LASVLR_GetReserved(const LASVLRH hVLR)1995 LAS_DLL uint16_t LASVLR_GetReserved(const LASVLRH hVLR) {
1996
1997 VALIDATE_LAS_POINTER1(hVLR, "LASVLR_GetReserved", 0);
1998
1999 uint16_t value = ((liblas::VariableRecord*) hVLR)->GetReserved();
2000 return value;
2001 }
2002
LASVLR_GetData(const LASVLRH hVLR,uint8_t * data)2003 LAS_DLL LASErrorEnum LASVLR_GetData(const LASVLRH hVLR, uint8_t* data) {
2004
2005 VALIDATE_LAS_POINTER1(hVLR, "LASVLR_GetData", LE_Failure);
2006
2007 try {
2008 liblas::VariableRecord* vlr = ((liblas::VariableRecord*) hVLR);
2009 std::vector<uint8_t> const& d = vlr->GetData();
2010 uint16_t length = vlr->GetRecordLength();
2011 for (uint16_t i=0; i < length; i++) {
2012 data[i] = d[i];
2013 }
2014 }
2015 catch (std::exception const& e) {
2016 LASError_PushError(LE_Failure, e.what(), "LASVLR_GetData");
2017 return LE_Failure;
2018 }
2019
2020
2021 return LE_None;
2022 }
2023
LASVLR_SetData(const LASVLRH hVLR,uint8_t * data,uint16_t length)2024 LAS_DLL LASErrorEnum LASVLR_SetData(const LASVLRH hVLR, uint8_t* data, uint16_t length) {
2025
2026 VALIDATE_LAS_POINTER1(hVLR, "LASVLR_SetData", LE_Failure);
2027
2028 try {
2029 liblas::VariableRecord* vlr = ((liblas::VariableRecord*) hVLR);
2030 std::vector<uint8_t> d;
2031 d.resize(length);
2032 for (uint16_t i=0; i < length; i++) {
2033 d[i] = data[i];
2034 }
2035 vlr->SetData(d);
2036 }
2037 catch (std::exception const& e) {
2038 LASError_PushError(LE_Failure, e.what(), "LASVLR_GetData");
2039 return LE_Failure;
2040 }
2041
2042
2043 return LE_None;
2044 }
2045
LASGuid_Create()2046 LAS_DLL LASGuidH LASGuid_Create() {
2047 try {
2048 boost::uuids::uuid id;
2049 return (LASGuidH) new boost::uuids::uuid(id);
2050 }
2051 catch (std::exception const& e) {
2052 LASError_PushError(LE_Failure, e.what(), "LASGuid_Create");
2053 return NULL;
2054 }
2055 }
2056
LASGuid_CreateFromString(const char * string)2057 LAS_DLL LASGuidH LASGuid_CreateFromString(const char* string) {
2058 VALIDATE_LAS_POINTER1(string, "LASGuid_CreateFromString", NULL);
2059 try {
2060 boost::uuids::uuid id = boost::uuids::string_generator()(string);
2061
2062 return (LASGuidH) new boost::uuids::uuid(id);
2063 }
2064 catch (std::exception const& e) {
2065 LASError_PushError(LE_Failure, e.what(), "LASGuid_CreateFromString");
2066 return NULL;
2067 }
2068 }
2069
LASGuid_Destroy(LASGuidH hId)2070 LAS_DLL void LASGuid_Destroy(LASGuidH hId) {
2071 VALIDATE_LAS_POINTER0(hId, "LASGuid_Destroy");
2072 delete (boost::uuids::uuid*) hId;
2073 hId = NULL;
2074 }
2075
LASGuid_Equals(LASGuidH hId1,LASGuidH hId2)2076 LAS_DLL int LASGuid_Equals(LASGuidH hId1, LASGuidH hId2) {
2077 VALIDATE_LAS_POINTER1(hId1, "LASGuid_Equals", LE_Failure);
2078 VALIDATE_LAS_POINTER1(hId2, "LASGuid_Equals", LE_Failure);
2079
2080 boost::uuids::uuid* id1 = (boost::uuids::uuid*)hId1;
2081 boost::uuids::uuid* id2 = (boost::uuids::uuid*)hId2;
2082 try {
2083
2084 return( *id1 == *id2);
2085 }
2086 catch (std::exception const& e) {
2087 LASError_PushError(LE_Failure, e.what(), "LASGuid_Equals");
2088 return LE_Failure;
2089 }
2090 }
2091
LASGuid_AsString(LASGuidH hId)2092 LAS_DLL char* LASGuid_AsString(LASGuidH hId) {
2093 VALIDATE_LAS_POINTER1(hId, "LASGuid_AsString", 0);
2094 boost::uuids::uuid* id= (boost::uuids::uuid*)hId;
2095 std::ostringstream oss;
2096 oss << *id;
2097 return LASCopyString(oss.str().c_str());
2098 }
2099
2100
2101
LASColor_Create(void)2102 LAS_DLL LASColorH LASColor_Create(void) {
2103 return (LASColorH) new liblas::Color();
2104 }
2105
LASColor_Destroy(LASColorH hColor)2106 LAS_DLL void LASColor_Destroy(LASColorH hColor){
2107 VALIDATE_LAS_POINTER0(hColor, "LASColor_Destroy");
2108 delete (liblas::Color*)hColor;
2109 hColor = NULL;
2110 }
2111
LASColor_SetRed(LASColorH hColor,uint16_t value)2112 LAS_DLL LASErrorEnum LASColor_SetRed(LASColorH hColor, uint16_t value) {
2113
2114 VALIDATE_LAS_POINTER1(hColor, "LASColor_SetRed", LE_Failure);
2115
2116 try {
2117 liblas::Color* color = ((liblas::Color*) hColor);
2118 color->SetRed(value);
2119 }
2120 catch (std::exception const& e) {
2121 LASError_PushError(LE_Failure, e.what(), "LASColor_SetRed");
2122 return LE_Failure;
2123 }
2124
2125 return LE_None;
2126 }
2127
LASColor_GetRed(LASColorH hColor)2128 LAS_DLL uint16_t LASColor_GetRed(LASColorH hColor) {
2129
2130 VALIDATE_LAS_POINTER1(hColor, "LASColor_GetRed", 0);
2131
2132 uint16_t value = ((liblas::Color*) hColor)->GetRed();
2133 return value;
2134 }
2135
LASColor_SetBlue(LASColorH hColor,uint16_t value)2136 LAS_DLL LASErrorEnum LASColor_SetBlue(LASColorH hColor, uint16_t value) {
2137
2138 VALIDATE_LAS_POINTER1(hColor, "LASColor_SetBlue", LE_Failure);
2139
2140 try {
2141 liblas::Color* color = ((liblas::Color*) hColor);
2142 color->SetBlue(value);
2143 }
2144 catch (std::exception const& e) {
2145 LASError_PushError(LE_Failure, e.what(), "LASColor_SetBlue");
2146 return LE_Failure;
2147 }
2148
2149 return LE_None;
2150 }
2151
LASColor_GetBlue(LASColorH hColor)2152 LAS_DLL uint16_t LASColor_GetBlue(LASColorH hColor) {
2153
2154 VALIDATE_LAS_POINTER1(hColor, "LASColor_GetBlue", 0);
2155
2156 uint16_t value = ((liblas::Color*) hColor)->GetBlue();
2157 return value;
2158 }
2159
LASColor_SetGreen(LASColorH hColor,uint16_t value)2160 LAS_DLL LASErrorEnum LASColor_SetGreen(LASColorH hColor, uint16_t value) {
2161
2162 VALIDATE_LAS_POINTER1(hColor, "LASColor_SetGreen", LE_Failure);
2163
2164 try {
2165 liblas::Color* color = ((liblas::Color*) hColor);
2166 color->SetGreen(value);
2167 }
2168 catch (std::exception const& e) {
2169 LASError_PushError(LE_Failure, e.what(), "LASColor_SetGreen");
2170 return LE_Failure;
2171 }
2172
2173 return LE_None;
2174 }
2175
LASColor_GetGreen(LASColorH hColor)2176 LAS_DLL uint16_t LASColor_GetGreen(LASColorH hColor) {
2177
2178 VALIDATE_LAS_POINTER1(hColor, "LASColor_GetGreen", 0);
2179
2180 uint16_t value = ((liblas::Color*) hColor)->GetGreen();
2181 return value;
2182 }
2183
LASPoint_GetColor(const LASPointH hPoint)2184 LAS_DLL LASColorH LASPoint_GetColor(const LASPointH hPoint) {
2185 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_GetColor", 0);
2186
2187 liblas::Color color;
2188 try {
2189 color = ((liblas::Point*) hPoint)->GetColor();
2190
2191 } catch (std::runtime_error const&)
2192 {
2193
2194 }
2195 return (LASColorH) new liblas::Color(color);
2196 }
2197
LASPoint_SetColor(LASPointH hPoint,const LASColorH hColor)2198 LAS_DLL LASErrorEnum LASPoint_SetColor(LASPointH hPoint, const LASColorH hColor) {
2199
2200 VALIDATE_LAS_POINTER1(hPoint, "LASPoint_SetColor", LE_Failure);
2201 VALIDATE_LAS_POINTER1(hColor, "LASPoint_SetColor", LE_Failure);
2202
2203 try {
2204 ((liblas::Point*) hPoint)->SetColor(*((liblas::Color*)hColor));
2205 }
2206 catch (std::runtime_error const&)
2207 {
2208 // drop the value on the floor. If the point has a schema that
2209 // doesn't have color, the user needs to change the point's header.
2210
2211 }
2212 catch (std::exception const& e) {
2213 LASError_PushError(LE_Failure, e.what(), "LASPoint_SetColor");
2214 return LE_Failure;
2215 }
2216
2217 return LE_None;
2218 }
2219
LASSRS_Create(void)2220 LAS_DLL LASSRSH LASSRS_Create(void) {
2221 return (LASSRSH) new liblas::SpatialReference();
2222 }
2223
LASSRS_Destroy(LASSRSH hSRS)2224 LAS_DLL void LASSRS_Destroy(LASSRSH hSRS){
2225 VALIDATE_LAS_POINTER0(hSRS, "LASSRS_Destroy");
2226 delete (liblas::SpatialReference*)hSRS;
2227 hSRS = NULL;
2228 }
2229
LASSRS_GetGTIF(LASSRSH hSRS)2230 LAS_DLL const void* LASSRS_GetGTIF(LASSRSH hSRS) {
2231 VALIDATE_LAS_POINTER1(hSRS, "LASSRS_GetGTIF", 0);
2232
2233 try {
2234 return (const void *) ((liblas::SpatialReference*) hSRS)->GetGTIF();
2235 }
2236 catch (std::exception const& e) {
2237 LASError_PushError(LE_Failure, e.what(), "LASSRS_GetGTIF");
2238 return 0;
2239 }
2240 }
2241
LASSRS_SetGTIF(LASSRSH hSRS,const void * pgtiff,const void * ptiff)2242 LAS_DLL LASErrorEnum LASSRS_SetGTIF(LASSRSH hSRS, const void* pgtiff, const void* ptiff)
2243 {
2244 VALIDATE_LAS_POINTER1(hSRS, "LASSRS_SetGTIF", LE_Failure);
2245 VALIDATE_LAS_POINTER1(pgtiff, "LASSRS_SetGTIF", LE_Failure);
2246 VALIDATE_LAS_POINTER1(ptiff, "LASSRS_SetGTIF", LE_Failure);
2247 try {
2248 const GTIF* cgtiff = static_cast<const GTIF*>(pgtiff);
2249 const ST_TIFF* ctiff = static_cast<const ST_TIFF*>(ptiff);
2250 GTIF* gtiff = const_cast<GTIF*>(cgtiff);
2251 ST_TIFF* tiff = const_cast<ST_TIFF*>(ctiff);
2252
2253 ((liblas::SpatialReference*) hSRS)->SetGTIF(gtiff, tiff);
2254 }
2255 catch (std::exception const& e) {
2256 LASError_PushError(LE_Failure, e.what(), "LASSRS_SetGTIF");
2257 return LE_Failure;
2258 }
2259
2260 return LE_None;
2261 }
LASSRS_GetProj4(LASSRSH hSRS)2262 LAS_DLL char* LASSRS_GetProj4(LASSRSH hSRS)
2263 {
2264 VALIDATE_LAS_POINTER1(hSRS, "LASSRS_GetProj4", NULL);
2265 liblas::SpatialReference* srs = (liblas::SpatialReference*)hSRS;
2266
2267 return LASCopyString((srs)->GetProj4().c_str());
2268
2269 }
2270
LASSRS_SetProj4(LASSRSH hSRS,const char * value)2271 LAS_DLL LASErrorEnum LASSRS_SetProj4(LASSRSH hSRS, const char* value)
2272 {
2273 VALIDATE_LAS_POINTER1(hSRS, "LASSRS_SetProj4", LE_Failure);
2274 VALIDATE_LAS_POINTER1(value, "LASSRS_SetProj4", LE_Failure);
2275
2276 try {
2277 ((liblas::SpatialReference*) hSRS)->SetProj4(value);
2278 }
2279 catch (std::exception const& e) {
2280 LASError_PushError(LE_Failure, e.what(), "LASSRS_SetProj4");
2281 return LE_Failure;
2282 }
2283
2284 return LE_None;
2285 }
2286
LASSRS_GetWKT(LASSRSH hSRS)2287 LAS_DLL char* LASSRS_GetWKT(LASSRSH hSRS)
2288 {
2289 VALIDATE_LAS_POINTER1(hSRS, "LASSRS_GetWKT", NULL);
2290 liblas::SpatialReference* srs = (liblas::SpatialReference*)hSRS;
2291
2292 return LASCopyString((srs)->GetWKT(liblas::SpatialReference::eHorizontalOnly).c_str());
2293
2294 }
2295
LASSRS_GetWKT_CompoundOK(LASSRSH hSRS)2296 LAS_DLL char* LASSRS_GetWKT_CompoundOK(LASSRSH hSRS)
2297 {
2298 VALIDATE_LAS_POINTER1(hSRS, "LASSRS_GetWKT_CompoundOK", NULL);
2299 liblas::SpatialReference* srs = (liblas::SpatialReference*)hSRS;
2300
2301 return LASCopyString((srs)->GetWKT(liblas::SpatialReference::eCompoundOK).c_str());
2302
2303 }
2304
LASSRS_SetWKT(LASSRSH hSRS,const char * value)2305 LAS_DLL LASErrorEnum LASSRS_SetWKT(LASSRSH hSRS, const char* value)
2306 {
2307 VALIDATE_LAS_POINTER1(hSRS, "LASSRS_SetWKT", LE_Failure);
2308 VALIDATE_LAS_POINTER1(value, "LASSRS_SetWKT", LE_Failure);
2309
2310 try {
2311 ((liblas::SpatialReference*) hSRS)->SetWKT(value);
2312 }
2313 catch (std::exception const& e) {
2314 LASError_PushError(LE_Failure, e.what(), "LASSRS_SetWKT");
2315 return LE_Failure;
2316 }
2317
2318 return LE_None;
2319 }
2320
LASSRS_SetVerticalCS(LASSRSH hSRS,int verticalCSType,const char * citation,int verticalDatum,int verticalUnits)2321 LAS_DLL LASErrorEnum LASSRS_SetVerticalCS(LASSRSH hSRS,
2322 int verticalCSType,
2323 const char *citation,
2324 int verticalDatum,
2325 int verticalUnits ) {
2326
2327 VALIDATE_LAS_POINTER1(hSRS, "LASSRS_SetVerticalCS", LE_Failure);
2328
2329 try {
2330 ((liblas::SpatialReference*) hSRS)->SetVerticalCS( verticalCSType, citation,
2331 verticalDatum,
2332 verticalUnits);
2333 }
2334 catch (std::exception const& e) {
2335 LASError_PushError(LE_Failure, e.what(), "LASSRS_SetVerticalCS");
2336 return LE_Failure;
2337 }
2338
2339 return LE_None;
2340 }
2341
LASSRS_SetFromUserInput(LASSRSH hSRS,const char * value)2342 LAS_DLL LASErrorEnum LASSRS_SetFromUserInput(LASSRSH hSRS, const char* value)
2343 {
2344 VALIDATE_LAS_POINTER1(hSRS, "LASSRS_SetFromUserInput", LE_Failure);
2345 VALIDATE_LAS_POINTER1(value, "LASSRS_SetFromUserInput", LE_Failure);
2346
2347 try {
2348 ((liblas::SpatialReference*) hSRS)->SetFromUserInput(value);
2349 }
2350 catch (std::exception const& e) {
2351 LASError_PushError(LE_Failure, e.what(), "LASSRS_SetFromUserInput");
2352 return LE_Failure;
2353 }
2354
2355 return LE_None;
2356 }
2357
LASSRS_AddVLR(LASSRSH hSRS,const LASVLRH hVLR)2358 LAS_DLL LASErrorEnum LASSRS_AddVLR(LASSRSH hSRS, const LASVLRH hVLR) {
2359
2360 VALIDATE_LAS_POINTER1(hSRS, "LASSRS_AddVLR", LE_Failure);
2361 VALIDATE_LAS_POINTER1(hVLR, "LASSRS_AddVLR", LE_Failure);
2362
2363 try {
2364 ((liblas::SpatialReference*) hSRS)->AddVLR(*((liblas::VariableRecord*)hVLR));
2365 }
2366 catch (std::exception const& e) {
2367 LASError_PushError(LE_Failure, e.what(), "LASSRS_AddVLR");
2368 return LE_Failure;
2369 }
2370
2371 return LE_None;
2372 }
2373
LASSRS_GetVLR(const LASSRSH hSRS,uint32_t i)2374 LAS_DLL LASVLRH LASSRS_GetVLR(const LASSRSH hSRS, uint32_t i) {
2375 VALIDATE_LAS_POINTER1(hSRS, "LASSRS_GetVLR", 0);
2376
2377 liblas::VariableRecord vlr = ((liblas::SpatialReference*) hSRS)->GetVLRs()[i];
2378 return (LASVLRH) new liblas::VariableRecord(vlr);
2379 }
2380
LASSRS_GetVLRCount(const LASSRSH hSRS)2381 LAS_DLL uint32_t LASSRS_GetVLRCount(const LASSRSH hSRS) {
2382 VALIDATE_LAS_POINTER1(hSRS, "LASSRS_GetVLR", 0);
2383
2384 uint32_t size = static_cast<uint32_t>(((liblas::SpatialReference*) hSRS)->GetVLRs().size());
2385 return size;
2386 }
2387
LASHeader_SetSRS(LASHeaderH hHeader,const LASSRSH hSRS)2388 LAS_DLL LASErrorEnum LASHeader_SetSRS(LASHeaderH hHeader, const LASSRSH hSRS) {
2389
2390 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetSRS", LE_Failure);
2391 VALIDATE_LAS_POINTER1(hSRS, "LASHeader_SetSRS", LE_Failure);
2392
2393 try {
2394 ((liblas::HeaderPtr*) hHeader)->get()->SetSRS(*((liblas::SpatialReference*)hSRS));
2395 }
2396 catch (std::exception const& e) {
2397 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetSRS");
2398 return LE_Failure;
2399 }
2400
2401
2402 return LE_None;
2403 }
2404
LASHeader_GetSRS(const LASHeaderH hHeader)2405 LAS_DLL LASSRSH LASHeader_GetSRS(const LASHeaderH hHeader) {
2406 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetSRS", 0);
2407
2408 liblas::SpatialReference srs = ((liblas::HeaderPtr*) hHeader)->get()->GetSRS();
2409 return (LASSRSH) new liblas::SpatialReference(srs);
2410 }
2411
2412
LASString_Free(char * string)2413 LAS_DLL void LASString_Free(char* string) {
2414 if (string)
2415 free(string);
2416 }
2417
2418
LASSchema_Create(liblas::PointFormatName point_format)2419 LAS_DLL LASSchemaH LASSchema_Create( liblas::PointFormatName point_format) {
2420 liblas::Schema* schema = new liblas::Schema(point_format);
2421 return (LASSchemaH) schema;
2422 }
2423
2424
LASSchema_GetByteSize(LASSchemaH hFormat)2425 LAS_DLL unsigned int LASSchema_GetByteSize( LASSchemaH hFormat)
2426 {
2427 VALIDATE_LAS_POINTER1(hFormat, "LASSchema_GetByteSize", 0);
2428
2429 liblas::Schema* format = ((liblas::Schema*) hFormat);
2430 return static_cast<unsigned int>(format->GetByteSize());
2431 }
2432
2433
LASSchema_GetBaseByteSize(LASSchemaH hFormat)2434 LAS_DLL unsigned int LASSchema_GetBaseByteSize( LASSchemaH hFormat)
2435 {
2436 VALIDATE_LAS_POINTER1(hFormat, "LASSchema_GetBaseByteSize", 0);
2437
2438 liblas::Schema* format = ((liblas::Schema*) hFormat);
2439 return static_cast<unsigned int>(format->GetBaseByteSize());
2440 }
2441
2442
LASSchema_Destroy(LASSchemaH hFormat)2443 LAS_DLL void LASSchema_Destroy(LASSchemaH hFormat) {
2444 VALIDATE_LAS_POINTER0(hFormat, "LASSchema_Destroy");
2445 delete (liblas::Schema*) hFormat;
2446 hFormat = NULL;
2447 }
2448
LASHeader_GetSchema(LASHeaderH hHeader)2449 LAS_DLL LASSchemaH LASHeader_GetSchema( LASHeaderH hHeader )
2450 {
2451 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_GetSchema", 0);
2452
2453 liblas::Schema format = ((liblas::HeaderPtr*) hHeader)->get()->GetSchema();
2454 return (LASSchemaH) new liblas::Schema(format);
2455
2456 }
2457
LASHeader_SetSchema(LASHeaderH hHeader,const LASSchemaH hFormat)2458 LAS_DLL LASErrorEnum LASHeader_SetSchema( LASHeaderH hHeader, const LASSchemaH hFormat)
2459 {
2460 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetSchema", LE_Failure);
2461 VALIDATE_LAS_POINTER1(hFormat, "LASHeader_SetSchema", LE_Failure);
2462
2463 try {
2464 ((liblas::HeaderPtr*) hHeader)->get()->SetSchema(*((liblas::Schema*)hFormat));
2465 }
2466 catch (std::exception const& e) {
2467 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetSchema");
2468 return LE_Failure;
2469 }
2470
2471 return LE_None;
2472 }
2473
LASHeader_Compressed(const LASHeaderH hHeader)2474 LAS_DLL int LASHeader_Compressed(const LASHeaderH hHeader )
2475 {
2476 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_Compressed", 0);
2477 return ((liblas::HeaderPtr*) hHeader)->get()->Compressed();
2478 }
2479
LASHeader_SetCompressed(LASHeaderH hHeader,int value)2480 LAS_DLL LASErrorEnum LASHeader_SetCompressed( LASHeaderH hHeader, int value)
2481 {
2482 VALIDATE_LAS_POINTER1(hHeader->get(), "LASHeader_SetCompressed", LE_Failure);
2483
2484 try {
2485 bool v(false);
2486 if (value == 0) v = false;
2487 else v = true;
2488 ((liblas::HeaderPtr*) hHeader)->get()->SetCompressed(v);
2489 }
2490 catch (std::exception const& e) {
2491 LASError_PushError(LE_Failure, e.what(), "LASHeader_SetCompressed");
2492 return LE_Failure;
2493 }
2494
2495 return LE_None;
2496 }
2497
2498
2499 LAS_C_END
2500
2501 #ifdef _MSC_VER
2502 # pragma warning(default: 4127) // enable warning C4127: conditional expression is constant
2503 # pragma warning(default: 4702) // unreachable code
2504 #endif
2505