← Back to branch summary

~ubuntu-branches/ubuntu/trusty/liblas/trusty-proposed

« back to all changes in this revision

Viewing changes to apps/las2las.c

  • Committer: Package Import Robot
  • Author(s): Francesco Paolo Lovergine
  • Date: 2014-01-05 17:00:29 UTC
  • mfrom: (7.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20140105170029-ddtp0j63x5jvck2u
Tags: 1.7.0+dfsg-2
http://bugs.debian.org/733282
Fixed missing linking of system boost component.
(closes: #733282)

Show diffs side-by-side

added added

removed removed

Lines of Context:
apps/las2las.c
1
 
/***************************************************************************
2
 
 * $Id$
3
 
 * $Date$
4
 
 *
5
 
 * Project: libLAS -- C/C++ read/write library for LAS LIDAR data
6
 
 * Purpose: LAS translation with optional configuration
7
 
 * Author:  Martin Isenburg isenburg@cs.unc.edu 
8
 
 ***************************************************************************
9
 
 * Copyright (c) 2007, Martin Isenburg isenburg@cs.unc.edu 
10
 
 *
11
 
 * See LICENSE.txt in this source distribution for more information.
12
 
 **************************************************************************/
13
 
 
14
 
#include <assert.h>
15
 
#include <time.h>
16
 
#include <stdio.h>
17
 
#include <stdlib.h>
18
 
#include <string.h>
19
 
 
20
 
#include "liblas.h"
21
 
 
22
 
LASPointSummary* SummarizePoints(LASReaderH reader);
23
 
void print_point_summary(FILE *file, LASPointSummary* summary, LASHeaderH header);
24
 
void print_point(FILE *file, LASPointH point);
25
 
void print_header(FILE *file, LASHeaderH header, const char* file_name, int bSkipVLR);
26
 
void repair_header(FILE *file, LASHeaderH header, LASPointSummary* summary) ;
27
 
 
28
 
#define LAS_FORMAT_10 0
29
 
#define LAS_FORMAT_11 1
30
 
#define LAS_FORMAT_12 2
31
 
 
32
 
void usage()
33
 
{
34
 
    fprintf(stderr,"----------------------------------------------------------\n");
35
 
    fprintf(stderr,"    las2las (version %s) usage:\n", LAS_GetVersion());
36
 
    fprintf(stderr,"----------------------------------------------------------\n");
37
 
    fprintf(stderr,"\n");
38
 
 
39
 
    fprintf(stderr,"Clip las file to a bounding box, throwing out points that have invalid data:\n");
40
 
    fprintf(stderr,"  las2las -i in.las -clip 63000000 483450000 63050000 483500000 -o out.las --skip_invalid\n");
41
 
    fprintf(stderr,"\n");
42
 
 
43
 
    fprintf(stderr,"Read from stdin, eliminate intensities below 2000, and write to stdout:\n");
44
 
    fprintf(stderr,"  las2las --eliminate_intensity_below 2000 --stdin --stdout < in.las > out.las \n");
45
 
    fprintf(stderr,"\n");
46
 
    
47
 
    fprintf(stderr,"Eliminate return number two:\n");
48
 
    fprintf(stderr,"  las2las -i in.las -eliminate_return 2 -o out.las\n");
49
 
    fprintf(stderr,"\n");
50
 
    
51
 
    fprintf(stderr,"Eliminate scan angles above 15:\n");
52
 
    fprintf(stderr,"  las2las -i in.las -eliminate_scan_angle_above 15 -o out.las\n");
53
 
    fprintf(stderr,"\n");
54
 
 
55
 
    fprintf(stderr,"Eliminate intensities below 1000:\n");
56
 
    fprintf(stderr,"  las2las -i in.las -eliminate_intensity_below 1000 --stdout > out.las\n");
57
 
    fprintf(stderr,"\n");
58
 
 
59
 
    fprintf(stderr,"Eliminate intensities below 1000 and classifications that equal 2 (ground):\n");
60
 
    fprintf(stderr,"  las2las -i in.las --eliminate_class 2 --out out.las\n");
61
 
    fprintf(stderr,"\n");
62
 
        
63
 
    fprintf(stderr,"Capture only first returns and clip to bounding box:\n");
64
 
    fprintf(stderr,"  las2las -i in.las -first_only -clip 63000000 483450000 63050000 483500000 -o out.las\n");
65
 
    fprintf(stderr,"\n");
66
 
 
67
 
    fprintf(stderr,"Capture only last returns, eliminate intensities below 2000, and write to stdout:\n");
68
 
    fprintf(stderr,"  las2las --input in.las --last_only --eliminate_intensity_below 2000 --stdout > out.las\n");
69
 
    fprintf(stderr,"\n");
70
 
 
71
 
 
72
 
    fprintf(stderr, "\nFor more information, see the full documentation for las2las at:\n"
73
 
                    " http://liblas.org/browser/trunk/doc/las2las.txt\n");
74
 
    fprintf(stderr,"----------------------------------------------------------\n");
75
 
 
76
 
}
77
 
 
78
 
void ptime(const char *const msg)
79
 
{
80
 
  float t= ((float)clock())/CLOCKS_PER_SEC;
81
 
  fprintf(stderr, "cumulative CPU time thru %s = %f\n", msg, t);
82
 
}
83
 
 
84
 
int main(int argc, char *argv[])
85
 
{
86
 
    int i;
87
 
    int verbose = FALSE;
88
 
    int use_stdin = FALSE;
89
 
    int use_stdout = FALSE;
90
 
    char* file_name_in = 0;
91
 
    char* file_name_out = 0;
92
 
    double *clip_xy_min = NULL;
93
 
    double *clip_xy_max = NULL;
94
 
    int clip = FALSE;
95
 
    int remove_extra_header = FALSE;
96
 
    int elim_return = 0;
97
 
    int elim_scan_angle_above = 0;
98
 
    int elim_intensity_below = 0;
99
 
    int elim_class = 0;
100
 
    int clsidx = 0;
101
 
    int first_only = FALSE;
102
 
    int last_only = FALSE;
103
 
    int skip_invalid = FALSE;
104
 
    int format = LAS_FORMAT_12;
105
 
    
106
 
    LASReaderH reader = NULL;
107
 
    LASHeaderH header = NULL;
108
 
    LASHeaderH surviving_header = NULL;
109
 
    LASPointH p = NULL;
110
 
    LASWriterH writer = NULL;
111
 
 
112
 
    int first_surviving_point = TRUE;
113
 
    unsigned int surviving_number_of_point_records = 0;
114
 
    unsigned int surviving_number_of_points_by_return[] = {0,0,0,0,0,0,0,0};
115
 
    LASPointH surviving_point_min = NULL;
116
 
    LASPointH surviving_point_max = NULL;
117
 
    double surviving_gps_time_min;
118
 
    double surviving_gps_time_max;
119
 
 
120
 
    int clipped = 0;
121
 
    int eliminated_return = 0;
122
 
    int eliminated_scan_angle = 0;
123
 
    int eliminated_intensity = 0;
124
 
    int eliminated_class = 0;
125
 
    int eliminated_first_only = 0;
126
 
    int eliminated_last_only = 0;
127
 
 
128
 
    double minx, maxx, miny, maxy, minz, maxz;
129
 
    
130
 
    LASPointSummary* summary = NULL;
131
 
    
132
 
    for (i = 1; i < argc; i++) {
133
 
        if (    strcmp(argv[i],"-h") == 0 ||
134
 
                strcmp(argv[i],"--help") == 0
135
 
            )
136
 
        {
137
 
            usage();
138
 
            exit(0);
139
 
        }
140
 
        else if (   strcmp(argv[i],"-v") == 0 ||
141
 
                    strcmp(argv[i],"--verbose") == 0
142
 
            )
143
 
        {
144
 
            verbose = TRUE;
145
 
        }
146
 
        else if (   strcmp(argv[i],"-s") == 0 ||
147
 
                    strcmp(argv[i],"--skip_invalid") == 0
148
 
            )
149
 
        {
150
 
            skip_invalid = TRUE;
151
 
        }
152
 
        else if (   strcmp(argv[i],"--input") == 0  ||
153
 
                    strcmp(argv[i],"-input") == 0   ||
154
 
                    strcmp(argv[i],"-i") == 0       ||
155
 
                    strcmp(argv[i],"-in") == 0
156
 
                )
157
 
        {
158
 
            i++;
159
 
            file_name_in = argv[i];
160
 
        }
161
 
        else if (   strcmp(argv[i],"--output") == 0  ||
162
 
                    strcmp(argv[i],"--out") == 0     ||
163
 
                    strcmp(argv[i],"-out") == 0     ||
164
 
                    strcmp(argv[i],"-o") == 0       
165
 
                )
166
 
        {
167
 
            i++;
168
 
            file_name_out = argv[i];
169
 
        }
170
 
 
171
 
        else if (   strcmp(argv[i],"--stdout") == 0  ||
172
 
                    strcmp(argv[i],"-olas") == 0    
173
 
                )
174
 
        {
175
 
            use_stdout = TRUE;
176
 
            file_name_out = "stdout";
177
 
        }
178
 
        else if (   strcmp(argv[i],"--clip") == 0   ||
179
 
                    strcmp(argv[i],"-clip") == 0    ||
180
 
                    strcmp(argv[i],"-clip_xy") == 0 
181
 
                )
182
 
        {
183
 
            clip_xy_min = (double*) malloc (2 * sizeof(double));
184
 
            clip_xy_max = (double*) malloc( 2 * sizeof(double));
185
 
            i++;
186
 
            clip_xy_min[0] = atof(argv[i]);
187
 
            i++;
188
 
            clip_xy_min[1] = atof(argv[i]);
189
 
            i++;
190
 
            clip_xy_max[0] = atof(argv[i]);
191
 
            i++;
192
 
            clip_xy_max[1] = atof(argv[i]);
193
 
            clip = TRUE;
194
 
        }
195
 
        else if (   strcmp(argv[i],"--format") == 0   ||
196
 
                    strcmp(argv[i],"-f") == 0    ||
197
 
                    strcmp(argv[i],"-format") == 0 
198
 
                )
199
 
        {
200
 
            i++;
201
 
            if (strcmp(argv[i], "1.0") == 0) {
202
 
                format = LAS_FORMAT_10;
203
 
            }
204
 
            else if (strcmp(argv[i], "1.1") == 0) {
205
 
                format = LAS_FORMAT_11;
206
 
            } 
207
 
            else if (strcmp(argv[i], "1.2") == 0) {
208
 
                format = LAS_FORMAT_12;
209
 
            }
210
 
            else {
211
 
                LASError_Print("Format must be specified as 1.0, 1.1, or 1.2");
212
 
            }
213
 
 
214
 
        }
215
 
 
216
 
        else if (   strcmp(argv[i],"--eliminate_return") == 0  ||
217
 
                    strcmp(argv[i],"-eliminate_return") == 0   ||
218
 
                    strcmp(argv[i],"-elim_return") == 0       ||
219
 
                    strcmp(argv[i],"-elim_ret") == 0
220
 
                )        
221
 
        {
222
 
            i++;
223
 
            elim_return |= (1 << atoi(argv[i]));
224
 
        }
225
 
        else if (   strcmp(argv[i],"--eliminate_scan_angle_above") == 0  ||
226
 
                    strcmp(argv[i],"-eliminate_scan_angle_above") == 0   ||
227
 
                    strcmp(argv[i],"-elim_scan_angle_above") == 0       ||
228
 
                    strcmp(argv[i],"--clip_scan_above") == 0
229
 
                )        
230
 
        {
231
 
            i++;
232
 
            elim_scan_angle_above = atoi(argv[i]);
233
 
        }
234
 
        else if (   strcmp(argv[i],"--eliminate_class") == 0  ||
235
 
                    strcmp(argv[i],"-eliminate_class") == 0   ||
236
 
                    strcmp(argv[i],"-elim_class") == 0       ||
237
 
                    strcmp(argv[i],"--class") == 0
238
 
                )        
239
 
        {
240
 
            i++;
241
 
            elim_class = atoi(argv[i]);
242
 
        }
243
 
        else if (   strcmp(argv[i],"--eliminate_intensity_below") == 0  ||
244
 
                    strcmp(argv[i],"-eliminate_intensity_below") == 0   ||
245
 
                    strcmp(argv[i],"-elim_intensity_below") == 0       ||
246
 
                    strcmp(argv[i],"--clip_intensity_below") == 0
247
 
                )        
248
 
        {
249
 
            i++;
250
 
            elim_intensity_below = atoi(argv[i]);
251
 
        }
252
 
        else if (   strcmp(argv[i], "--stdin") == 0 ||
253
 
                    strcmp(argv[i], "-ilas") == 0
254
 
                ) 
255
 
        {
256
 
            use_stdin = TRUE;
257
 
        }
258
 
        else if (   strcmp(argv[i], "--first_only") == 0 ||
259
 
                    strcmp(argv[i], "-first_only") == 0
260
 
                ) 
261
 
        {
262
 
            first_only = TRUE;
263
 
        }
264
 
        else if (   strcmp(argv[i], "--last_only") == 0 ||
265
 
                    strcmp(argv[i], "-last_only") == 0
266
 
                ) 
267
 
        {
268
 
            last_only = TRUE;
269
 
        }
270
 
        else if (   strcmp(argv[i], "--remove_extra_header") == 0 ||
271
 
                    strcmp(argv[i], "-remove_extra_header") == 0
272
 
                ) 
273
 
        {
274
 
            remove_extra_header = TRUE;
275
 
        }
276
 
        else if (file_name_in == NULL && file_name_out == NULL)
277
 
        {
278
 
            file_name_in = argv[i];
279
 
        }
280
 
        else if (file_name_in != NULL && file_name_out == NULL)
281
 
        {
282
 
            file_name_out = argv[i];
283
 
        }
284
 
        else 
285
 
        {
286
 
            fprintf(stderr, "ERROR: unknown argument '%s'\n",argv[i]);
287
 
            usage();
288
 
            exit(1);
289
 
        }
290
 
    }
291
 
 
292
 
    if (use_stdin) file_name_in="stdin";
293
 
    if (file_name_in)
294
 
    {
295
 
        reader = LASReader_Create(file_name_in);
296
 
        if (!reader) { 
297
 
            LASError_Print("Could not open file to read");
298
 
            exit(1);
299
 
        } 
300
 
    }
301
 
    else
302
 
    {
303
 
        LASError_Print("no input specified");
304
 
        usage();
305
 
        exit(1);
306
 
    }
307
 
 
308
 
 
309
 
    header = LASReader_GetHeader(reader);
310
 
    if (!header) { 
311
 
        LASError_Print("Could not fetch header");
312
 
        exit(1);
313
 
    } 
314
 
 
315
 
    if (verbose) {
316
 
        ptime("start.");
317
 
        fprintf(stderr, "first pass reading %d points ...\n", LASHeader_GetPointRecordsCount(header));
318
 
    }
319
 
 
320
 
    p  = LASReader_GetNextPoint(reader);
321
 
 
322
 
    if (!p) {
323
 
        if (LASError_GetLastErrorNum()) 
324
 
            LASError_Print("Not able to fetch a point.  LASReader is invalid");
325
 
        else
326
 
            LASError_Print("File does not contain any points to read.");
327
 
        exit(1);
328
 
    }
329
 
    
330
 
    while (p)
331
 
    {
332
 
 
333
 
        if (last_only && LASPoint_GetReturnNumber(p) != LASPoint_GetNumberOfReturns(p))
334
 
        {
335
 
            eliminated_last_only++;
336
 
            p = LASReader_GetNextPoint(reader);
337
 
            continue;
338
 
        }
339
 
        if (first_only && LASPoint_GetReturnNumber(p) != 1)
340
 
        {
341
 
            eliminated_first_only++;
342
 
            p = LASReader_GetNextPoint(reader);
343
 
            continue;
344
 
        }
345
 
    
346
 
        if (clip && (LASPoint_GetX(p) < clip_xy_min[0] || LASPoint_GetY(p) < clip_xy_min[1]))
347
 
        {
348
 
            clipped++;
349
 
            p = LASReader_GetNextPoint(reader);
350
 
            continue;
351
 
        }
352
 
        if (clip && (LASPoint_GetX(p) > clip_xy_max[0] || LASPoint_GetY(p) > clip_xy_max[1]))
353
 
        {
354
 
            clipped++;
355
 
            p = LASReader_GetNextPoint(reader);
356
 
            continue;
357
 
        } 
358
 
        if (elim_return && (elim_return & (1 << LASPoint_GetReturnNumber(p))))
359
 
        {
360
 
            eliminated_return++;
361
 
            p = LASReader_GetNextPoint(reader);
362
 
            continue;
363
 
        }
364
 
        if (elim_scan_angle_above && (LASPoint_GetScanAngleRank(p) > elim_scan_angle_above || LASPoint_GetScanAngleRank(p) < -elim_scan_angle_above))
365
 
        {
366
 
            eliminated_scan_angle++;
367
 
            p = LASReader_GetNextPoint(reader);
368
 
            continue;
369
 
        }
370
 
 
371
 
        clsidx = LASPoint_GetClassification(p);
372
 
        clsidx = (clsidx & 31); // 31 is max index in classification lookup table
373
 
        assert(clsidx <= 31);
374
 
        if (elim_class && (elim_class == clsidx))
375
 
        {
376
 
            eliminated_class++;
377
 
            p = LASReader_GetNextPoint(reader);
378
 
            continue;
379
 
        }
380
 
 
381
 
        if (elim_intensity_below && LASPoint_GetIntensity(p) < elim_intensity_below)
382
 
        {
383
 
            eliminated_intensity++;
384
 
            p = LASReader_GetNextPoint(reader);
385
 
            continue;
386
 
        }
387
 
        surviving_number_of_point_records++;
388
 
 
389
 
        if (LASPoint_GetReturnNumber(p))
390
 
            surviving_number_of_points_by_return[LASPoint_GetReturnNumber(p)-1]++;
391
 
        else
392
 
            surviving_number_of_points_by_return[LASPoint_GetReturnNumber(p)]++;        
393
 
 
394
 
        if (first_surviving_point)
395
 
        {
396
 
            surviving_point_min = LASPoint_Copy(p);
397
 
            surviving_point_max = LASPoint_Copy(p);
398
 
            surviving_gps_time_min = LASPoint_GetTime(p);
399
 
            surviving_gps_time_max = LASPoint_GetTime(p);
400
 
            first_surviving_point = FALSE;
401
 
        }
402
 
        else
403
 
        {
404
 
            if (LASPoint_GetX(p) < LASPoint_GetX(surviving_point_min))
405
 
                LASPoint_SetX(surviving_point_min,LASPoint_GetX(p));
406
 
            else if (LASPoint_GetX(p) > LASPoint_GetX(surviving_point_max)) 
407
 
                LASPoint_SetX(surviving_point_max,LASPoint_GetX(p));
408
 
 
409
 
            if (LASPoint_GetY(p) < LASPoint_GetY(surviving_point_min)) 
410
 
                LASPoint_SetY(surviving_point_min,LASPoint_GetY(p));
411
 
            else if (LASPoint_GetY(p) > LASPoint_GetY(surviving_point_max)) 
412
 
                LASPoint_SetY(surviving_point_max,LASPoint_GetY(p));
413
 
 
414
 
            if (LASPoint_GetZ(p) < LASPoint_GetZ(surviving_point_min))
415
 
                LASPoint_SetZ(surviving_point_min,LASPoint_GetZ(p));
416
 
            else if (LASPoint_GetZ(p) > LASPoint_GetZ(surviving_point_max))   
417
 
                LASPoint_SetZ(surviving_point_max,LASPoint_GetZ(p));
418
 
 
419
 
            if (LASPoint_GetIntensity(p) < LASPoint_GetIntensity(surviving_point_min)) 
420
 
                LASPoint_SetIntensity(surviving_point_min,LASPoint_GetIntensity(p));
421
 
            else if (LASPoint_GetIntensity(p) > LASPoint_GetIntensity(surviving_point_max)) 
422
 
                LASPoint_SetIntensity(surviving_point_max,LASPoint_GetIntensity(p));
423
 
 
424
 
            if (LASPoint_GetFlightLineEdge(p) < LASPoint_GetFlightLineEdge(surviving_point_min)) 
425
 
                LASPoint_SetFlightLineEdge(surviving_point_min,LASPoint_GetFlightLineEdge(p));
426
 
            else if (LASPoint_GetFlightLineEdge(p) > LASPoint_GetFlightLineEdge(surviving_point_max)) 
427
 
                LASPoint_SetFlightLineEdge(surviving_point_max,LASPoint_GetFlightLineEdge(p));
428
 
 
429
 
            if (LASPoint_GetScanDirection(p) < LASPoint_GetScanDirection(surviving_point_min)) 
430
 
                LASPoint_SetScanDirection(surviving_point_min,LASPoint_GetScanDirection(p));
431
 
            else if (LASPoint_GetScanDirection(p) > LASPoint_GetScanDirection(surviving_point_max)) 
432
 
                LASPoint_SetScanDirection(surviving_point_max,LASPoint_GetScanDirection(p));
433
 
 
434
 
            if (LASPoint_GetNumberOfReturns(p) < LASPoint_GetNumberOfReturns(surviving_point_min)) 
435
 
                LASPoint_SetNumberOfReturns(surviving_point_min,LASPoint_GetNumberOfReturns(p));
436
 
            else if (LASPoint_GetNumberOfReturns(p) > LASPoint_GetNumberOfReturns(surviving_point_max)) 
437
 
                LASPoint_SetNumberOfReturns(surviving_point_max,LASPoint_GetNumberOfReturns(p));
438
 
 
439
 
            if (LASPoint_GetReturnNumber(p) < LASPoint_GetReturnNumber(surviving_point_min)) 
440
 
                LASPoint_SetReturnNumber(surviving_point_min,LASPoint_GetReturnNumber(p));
441
 
            else if (LASPoint_GetReturnNumber(p) > LASPoint_GetReturnNumber(surviving_point_max)) 
442
 
                LASPoint_SetReturnNumber(surviving_point_max,LASPoint_GetReturnNumber(p));
443
 
 
444
 
            if (LASPoint_GetClassification(p) < LASPoint_GetClassification(surviving_point_min)) 
445
 
                LASPoint_SetClassification(surviving_point_min,LASPoint_GetClassification(p));
446
 
            else if (LASPoint_GetReturnNumber(p) > LASPoint_GetClassification(surviving_point_max)) 
447
 
                LASPoint_SetClassification(surviving_point_max,LASPoint_GetClassification(p));
448
 
 
449
 
            if (LASPoint_GetScanAngleRank(p) < LASPoint_GetScanAngleRank(surviving_point_min)) 
450
 
                LASPoint_SetScanAngleRank(surviving_point_min,LASPoint_GetScanAngleRank(p));
451
 
            else if (LASPoint_GetScanAngleRank(p) > LASPoint_GetScanAngleRank(surviving_point_max)) 
452
 
                LASPoint_SetScanAngleRank(surviving_point_max,LASPoint_GetScanAngleRank(p));
453
 
 
454
 
            if (LASPoint_GetUserData(p) < LASPoint_GetUserData(surviving_point_min)) 
455
 
                LASPoint_SetUserData(surviving_point_min,LASPoint_GetUserData(p));
456
 
            else if (LASPoint_GetUserData(p) > LASPoint_GetUserData(surviving_point_max)) 
457
 
                LASPoint_SetUserData(surviving_point_max,LASPoint_GetUserData(p));
458
 
 
459
 
            if (LASPoint_GetTime(p) < LASPoint_GetTime(surviving_point_min)) 
460
 
                LASPoint_SetTime(surviving_point_min,LASPoint_GetTime(p));
461
 
            else if (LASPoint_GetTime(p) > LASPoint_GetTime(surviving_point_max)) 
462
 
                LASPoint_SetTime(surviving_point_max,LASPoint_GetTime(p));
463
 
 
464
 
/*
465
 
      if (lasreader->point.point_source_ID < surviving_point_min.point_source_ID) surviving_point_min.point_source_ID = lasreader->point.point_source_ID;
466
 
      else if (lasreader->point.point_source_ID > surviving_point_max.point_source_ID) surviving_point_max.point_source_ID = lasreader->point.point_source_ID;
467
 
*/
468
 
        }
469
 
  
470
 
        p  = LASReader_GetNextPoint(reader);
471
 
    }
472
 
 
473
 
    if (eliminated_first_only) 
474
 
        fprintf(stderr, 
475
 
                "eliminated based on first returns only: %d\n",
476
 
                eliminated_first_only);
477
 
    if (eliminated_last_only) 
478
 
        fprintf(stderr, 
479
 
                "eliminated based on last returns only: %d\n", 
480
 
                eliminated_last_only);
481
 
    if (eliminated_class) 
482
 
        fprintf(stderr, 
483
 
                "eliminated classification: %d\n", 
484
 
                eliminated_class);
485
 
    if (clipped) 
486
 
        fprintf(stderr, 
487
 
                "clipped: %d\n", 
488
 
                clipped);
489
 
    if (eliminated_return) 
490
 
        fprintf(stderr, 
491
 
                "eliminated based on return number: %d\n", 
492
 
                eliminated_return);
493
 
    if (eliminated_scan_angle) 
494
 
        fprintf(stderr, 
495
 
                "eliminated based on scan angle: %d\n", 
496
 
                eliminated_scan_angle);
497
 
    if (eliminated_intensity) 
498
 
        fprintf(stderr, 
499
 
        "eliminated based on intensity: %d\n", 
500
 
        eliminated_intensity);
501
 
 
502
 
    LASReader_Destroy(reader);
503
 
    LASHeader_Destroy(header);
504
 
  
505
 
    if (verbose)
506
 
    {
507
 
        fprintf(stderr, 
508
 
                "x %.3f %.3f %.3f\n",
509
 
                LASPoint_GetX(surviving_point_min), 
510
 
                LASPoint_GetX(surviving_point_max), 
511
 
                LASPoint_GetX(surviving_point_max) - LASPoint_GetX(surviving_point_min)
512
 
                );
513
 
        fprintf(stderr, 
514
 
                "y %.3f %.3f %.3f\n",
515
 
                LASPoint_GetY(surviving_point_min), 
516
 
                LASPoint_GetY(surviving_point_max), 
517
 
                LASPoint_GetY(surviving_point_max) - LASPoint_GetY(surviving_point_min)
518
 
                );
519
 
        fprintf(stderr, 
520
 
                "z %.3f %.3f %.3f\n",
521
 
                LASPoint_GetZ(surviving_point_min), 
522
 
                LASPoint_GetZ(surviving_point_max), 
523
 
                LASPoint_GetZ(surviving_point_max) - LASPoint_GetZ(surviving_point_min)
524
 
                );
525
 
        fprintf(stderr, 
526
 
                "intensity %d %d %d\n",
527
 
                LASPoint_GetIntensity(surviving_point_min), 
528
 
                LASPoint_GetIntensity(surviving_point_max), 
529
 
                LASPoint_GetIntensity(surviving_point_max) - LASPoint_GetIntensity(surviving_point_min)
530
 
                );
531
 
        fprintf(stderr, 
532
 
                "edge_of_flight_line %d %d %d\n",
533
 
                LASPoint_GetFlightLineEdge(surviving_point_min), 
534
 
                LASPoint_GetFlightLineEdge(surviving_point_max), 
535
 
                LASPoint_GetFlightLineEdge(surviving_point_max) - LASPoint_GetFlightLineEdge(surviving_point_min)
536
 
                );
537
 
        fprintf(stderr, 
538
 
                "scan_direction_flag %d %d %d\n",
539
 
                LASPoint_GetScanDirection(surviving_point_min), 
540
 
                LASPoint_GetScanDirection(surviving_point_max), 
541
 
                LASPoint_GetScanDirection(surviving_point_max) - LASPoint_GetScanDirection(surviving_point_min)
542
 
                );
543
 
        fprintf(stderr, 
544
 
                "number_of_returns_of_given_pulse %d %d %d\n",
545
 
                LASPoint_GetNumberOfReturns(surviving_point_min), 
546
 
                LASPoint_GetNumberOfReturns(surviving_point_max), 
547
 
                LASPoint_GetNumberOfReturns(surviving_point_max) - LASPoint_GetNumberOfReturns(surviving_point_min)
548
 
                );
549
 
        fprintf(stderr, 
550
 
                "return_number %d %d %d\n",
551
 
                LASPoint_GetReturnNumber(surviving_point_min), 
552
 
                LASPoint_GetReturnNumber(surviving_point_max), 
553
 
                LASPoint_GetReturnNumber(surviving_point_max) - LASPoint_GetReturnNumber(surviving_point_min)
554
 
                );
555
 
        fprintf(stderr, 
556
 
                "classification %d %d %d\n",
557
 
                LASPoint_GetClassification(surviving_point_min), 
558
 
                LASPoint_GetClassification(surviving_point_max), 
559
 
                LASPoint_GetClassification(surviving_point_max) - LASPoint_GetClassification(surviving_point_min)
560
 
                );
561
 
        fprintf(stderr, 
562
 
                "scan_angle_rank %d %d %d\n",
563
 
                LASPoint_GetScanAngleRank(surviving_point_min), 
564
 
                LASPoint_GetScanAngleRank(surviving_point_max), 
565
 
                LASPoint_GetScanAngleRank(surviving_point_max) - LASPoint_GetScanAngleRank(surviving_point_min)
566
 
                );
567
 
        fprintf(stderr, 
568
 
                "user_data %d %d %d\n",
569
 
                LASPoint_GetUserData(surviving_point_min), 
570
 
                LASPoint_GetUserData(surviving_point_max), 
571
 
                LASPoint_GetUserData(surviving_point_max) - LASPoint_GetUserData(surviving_point_min)
572
 
                );
573
 
        fprintf(stderr, 
574
 
                "gps_time %.8f %.8f %.8f\n",
575
 
                LASPoint_GetTime(surviving_point_min), 
576
 
                LASPoint_GetTime(surviving_point_max), 
577
 
                LASPoint_GetTime(surviving_point_max) - LASPoint_GetTime(surviving_point_min)
578
 
                );
579
 
/*
580
 
    fprintf(stderr, "point_source_ID %d %d %d\n",surviving_point_min.point_source_ID, surviving_point_max.point_source_ID, surviving_point_max.point_source_ID - surviving_point_min.point_source_ID);
581
 
*/
582
 
    }
583
 
 
584
 
 
585
 
    if (file_name_out == NULL && !use_stdout)
586
 
    {
587
 
        LASError_Print("no output specified. exiting...");
588
 
        exit(1);
589
 
    }
590
 
 
591
 
    
592
 
    if (file_name_in)
593
 
    {
594
 
        reader = LASReader_Create(file_name_in);
595
 
      if (!reader) { 
596
 
          LASError_Print("Could not open file to read");
597
 
          exit(1);
598
 
      } 
599
 
    }
600
 
    else
601
 
    {
602
 
        LASError_Print("no input specified");
603
 
        usage();
604
 
        exit(1);
605
 
    }
606
 
 
607
 
 
608
 
    header = LASReader_GetHeader(reader);
609
 
    if (!header) { 
610
 
        LASError_Print("Could not read header");
611
 
        exit(1);
612
 
    } 
613
 
 
614
 
 
615
 
    surviving_header = LASHeader_Copy(header);
616
 
 
617
 
    LASHeader_SetPointRecordsCount(surviving_header, surviving_number_of_point_records);
618
 
    LASHeader_SetSystemId(surviving_header, "MODIFICATION");
619
 
 
620
 
    for (i = 0; i < 5; i++) LASHeader_SetPointRecordsByReturnCount(surviving_header, i, surviving_number_of_points_by_return[i]);
621
 
 
622
 
    minx = LASPoint_GetX(surviving_point_min) * LASHeader_GetScaleX(surviving_header) + LASHeader_GetOffsetX(surviving_header);
623
 
    maxx = LASPoint_GetX(surviving_point_max) * LASHeader_GetScaleX(surviving_header) + LASHeader_GetOffsetX(surviving_header);
624
 
 
625
 
    miny = LASPoint_GetY(surviving_point_min) * LASHeader_GetScaleY(surviving_header) + LASHeader_GetOffsetY(surviving_header);
626
 
    maxy = LASPoint_GetY(surviving_point_max) * LASHeader_GetScaleY(surviving_header) + LASHeader_GetOffsetY(surviving_header);
627
 
 
628
 
    minz = LASPoint_GetZ(surviving_point_min) * LASHeader_GetScaleZ(surviving_header) + LASHeader_GetOffsetZ(surviving_header);
629
 
    maxz = LASPoint_GetZ(surviving_point_max) * LASHeader_GetScaleZ(surviving_header) + LASHeader_GetOffsetZ(surviving_header);
630
 
    
631
 
    if (format == LAS_FORMAT_10) {
632
 
        LASHeader_SetVersionMinor(surviving_header, 0);
633
 
    } else if (format == LAS_FORMAT_11){
634
 
        LASHeader_SetVersionMinor(surviving_header, 1);
635
 
    } else if (format == LAS_FORMAT_12) {
636
 
        LASHeader_SetVersionMinor(surviving_header, 2);
637
 
    }
638
 
    
639
 
 
640
 
/*  if (remove_extra_header) surviving_header.offset_to_point_data = surviving_header.header_size;
641
 
*/
642
 
 
643
 
    if (verbose) {
644
 
        fprintf(stderr, 
645
 
                "second pass reading %d and writing %d points ...\n", 
646
 
                LASHeader_GetPointRecordsCount(surviving_header), 
647
 
                surviving_number_of_point_records);
648
 
    }
649
 
    
650
 
    if (use_stdout) file_name_out = "stdout";
651
 
    
652
 
    writer = LASWriter_Create(file_name_out, surviving_header, LAS_MODE_WRITE);
653
 
    if (!writer) { 
654
 
        LASError_Print("Could not open file to write");
655
 
        exit(1);
656
 
    }  
657
 
 
658
 
/*
659
 
 
660
 
  if (!remove_extra_header)
661
 
  {
662
 
    for (unsigned int u = lasreader->header.header_size; u < lasreader->header.offset_to_point_data; u++)
663
 
    {
664
 
      fputc(fgetc(file_in),file_out);
665
 
    }
666
 
  }
667
 
*/
668
 
 
669
 
    
670
 
    LASReader_Destroy(reader);
671
 
    reader = NULL;
672
 
    if (file_name_in)
673
 
    {
674
 
        reader = LASReader_Create(file_name_in);
675
 
        if (!reader) { 
676
 
            LASError_Print("Could not open file to read");
677
 
            exit(1);
678
 
        } 
679
 
    }
680
 
    else
681
 
    {
682
 
        LASError_Print("no input specified");
683
 
        usage();
684
 
        exit(1);
685
 
    }
686
 
 
687
 
    p = LASReader_GetNextPoint(reader);
688
 
    if (!p) {
689
 
        if (LASError_GetLastErrorNum()) 
690
 
            LASError_Print("Not able to fetch a point.  LASReader is invalid");
691
 
        else
692
 
            LASError_Print("File does not contain any points to read.");
693
 
        exit(1);
694
 
    }
695
 
    
696
 
    while (p) {
697
 
 
698
 
        if (skip_invalid && !LASPoint_IsValid(p)) {
699
 
            p = LASReader_GetNextPoint(reader);
700
 
            continue;
701
 
        }
702
 
        if (last_only && LASPoint_GetReturnNumber(p) != LASPoint_GetNumberOfReturns(p))
703
 
        {
704
 
            p = LASReader_GetNextPoint(reader);
705
 
            continue;
706
 
        }
707
 
        if (first_only && LASPoint_GetReturnNumber(p) != 1)
708
 
        {
709
 
            p = LASReader_GetNextPoint(reader);
710
 
            continue;
711
 
 
712
 
        }
713
 
        if (clip_xy_min && (LASPoint_GetX(p) < clip_xy_min[0] || LASPoint_GetY(p) < clip_xy_min[1]))
714
 
        {
715
 
            p = LASReader_GetNextPoint(reader);
716
 
            continue;
717
 
        }
718
 
        if (clip_xy_max && (LASPoint_GetX(p) > clip_xy_max[0] || LASPoint_GetY(p) > clip_xy_max[1]))
719
 
        {
720
 
            p = LASReader_GetNextPoint(reader);
721
 
            continue;
722
 
        }
723
 
        if (elim_return && (elim_return & (1 << LASPoint_GetReturnNumber(p))))
724
 
        {
725
 
            p = LASReader_GetNextPoint(reader);
726
 
            continue;
727
 
        }
728
 
        if (elim_scan_angle_above && (LASPoint_GetScanAngleRank(p) > elim_scan_angle_above || LASPoint_GetScanAngleRank(p) < -elim_scan_angle_above))
729
 
        {
730
 
            p = LASReader_GetNextPoint(reader);
731
 
            continue;
732
 
        }
733
 
        if (elim_intensity_below && LASPoint_GetIntensity(p) < elim_intensity_below)
734
 
        {
735
 
            p = LASReader_GetNextPoint(reader);
736
 
            continue;
737
 
        }
738
 
 
739
 
        clsidx = LASPoint_GetClassification(p);
740
 
        clsidx = (clsidx & 31); // 31 is max index in classification lookup table
741
 
        assert(clsidx <= 31);
742
 
        if (elim_class && (elim_class == clsidx))
743
 
        {
744
 
            p = LASReader_GetNextPoint(reader);
745
 
            continue;
746
 
        }
747
 
        LASWriter_WritePoint(writer,p);
748
 
 
749
 
        p  = LASReader_GetNextPoint(reader);
750
 
    }
751
 
 
752
 
    LASWriter_Destroy(writer);
753
 
    LASReader_Destroy(reader);
754
 
    LASHeader_Destroy(header);
755
 
    LASHeader_Destroy(surviving_header);
756
 
    LASPoint_Destroy(surviving_point_max);
757
 
    LASPoint_Destroy(surviving_point_min);
758
 
 
759
 
    reader = LASReader_Create(file_name_out);
760
 
    if (!reader) { 
761
 
        LASError_Print("Could not open file to read");
762
 
        exit(1);
763
 
    }
764
 
 
765
 
    header = LASReader_GetHeader(reader);
766
 
    if (!header) { 
767
 
        LASError_Print("Could not read header");
768
 
        exit(1);
769
 
    } 
770
 
    summary = SummarizePoints(reader);
771
 
    if (verbose) {
772
 
        print_point_summary(stderr, summary, header);
773
 
    }
774
 
    repair_header(stderr, header, summary) ;
775
 
 
776
 
    if (summary) {
777
 
        LASPoint_Destroy(summary->pmin);
778
 
        LASPoint_Destroy(summary->pmax);
779
 
        free(summary);
780
 
    }
781
 
 
782
 
    if (reader) {
783
 
        LASReader_Destroy(reader);
784
 
        reader = NULL;
785
 
    }
786
 
    
787
 
    writer = LASWriter_Create(file_name_out, header, LAS_MODE_APPEND);
788
 
    if (!writer) {
789
 
        LASError_Print("Problem creating LASWriterH object for append");
790
 
        LASHeader_Destroy(header);
791
 
        header = NULL;
792
 
        exit(1);
793
 
    }
794
 
    LASWriter_Destroy(writer);
795
 
    writer = NULL;
796
 
    LASHeader_Destroy(header);
797
 
    header = NULL;   
798
 
 
799
 
    if (verbose) ptime("done.");
800
 
 
801
 
    return 0;
802
 
}