This is an automated email from the git hooks/post-receive script.

sebastic-guest pushed a commit to branch master
in repository liblas.

commit 931f4da2532874f8ea2aa6349aa727e0cce68060
Author: Bas Couwenberg <sebas...@xs4all.nl>
Date:   Tue Jun 10 23:54:17 2014 +0200

    Add patch from upstream to remove old LAStools utilities.
---
 debian/changelog                                   |    2 +
 ...ols-utilities-that-don-t-belong-in-liblas.patch | 2201 ++++++++++++++++++++
 debian/patches/series                              |    1 +
 3 files changed, 2204 insertions(+)

diff --git a/debian/changelog b/debian/changelog
index 674535a..49597f7 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -4,6 +4,8 @@ liblas (1.7.0+dfsg-6) UNRELEASED; urgency=medium
   * Use dh_install --list-install.
   * Also include lasblock, ts2las, las2las-old, las2txt-old & lasinfo-old
     programs in liblas-bin.
+  * Add patch from upstream to remove old LAStools utilities.
+    (closes: #749403)
 
  -- Bas Couwenberg <sebas...@xs4all.nl>  Fri, 06 Jun 2014 13:56:59 +0200
 
diff --git 
a/debian/patches/0001-remove-old-LAStools-utilities-that-don-t-belong-in-liblas.patch
 
b/debian/patches/0001-remove-old-LAStools-utilities-that-don-t-belong-in-liblas.patch
new file mode 100644
index 0000000..ad4c951
--- /dev/null
+++ 
b/debian/patches/0001-remove-old-LAStools-utilities-that-don-t-belong-in-liblas.patch
@@ -0,0 +1,2201 @@
+From 834f1ab517d6e93233fe10391a78ae390ceb200b Mon Sep 17 00:00:00 2001
+From: Howard Butler <hobu....@gmail.com>
+Date: Fri, 6 Jun 2014 16:42:36 -0500
+Subject: remove old LAStools utilities that don't belong in liblas #39
+Origin: 
https://github.com/libLAS/libLAS/commit/834f1ab517d6e93233fe10391a78ae390ceb200b
+
+
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -142,13 +142,13 @@ else()
+   # Recommended C++ compilation flags
+   # -Weffc++
+   set(LIBLAS_COMMON_CXX_FLAGS
+-      "-pedantic -ansi -Wall -Wpointer-arith -Wcast-align -Wcast-qual 
-Wfloat-equal -Wredundant-decls -Wno-long-long")
++      " -Wall -Wpointer-arith -Wcast-align -Wcast-qual -Wfloat-equal 
-Wredundant-decls -Wno-long-long")
+ 
+   if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
+ 
+     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LIBLAS_COMMON_CXX_FLAGS}")
+     if (CMAKE_COMPILER_IS_GNUCXX)
+-      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++98")
++      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++98 -ansi")
+     endif()
+ 
+   elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" OR 
"${CMAKE_CXX_COMPILER}" MATCHES "clang")
+--- a/apps/CMakeLists.txt
++++ b/apps/CMakeLists.txt
+@@ -14,12 +14,8 @@ include_directories(
+ 
###############################################################################
+ # Collect programs to build
+ 
+-set(LASINFO_OLD lasinfo-old)
+ set(LASINFO lasinfo)
+-set(LASMERGE lasmerge)
+ set(LAS2LAS las2las)
+-set(LAS2LAS_OLD las2las-old)
+-set(LAS2TXT_OLD las2txt-old)
+ set(LAS2TXT las2txt)
+ set(TXT2LAS txt2las)
+ set(TS2LAS ts2las)
+@@ -45,8 +41,8 @@ endif()
+ 
+ 
+ set(LIBLAS_UTILITIES
+-    ${LASINFO_OLD} ${LASINFO} ${LASMERGE} ${LAS2LAS} ${LAS2TXT_OLD} 
${TXT2LAS} 
+-    ${LAS2OGR} ${LAS2LAS} ${LAS2LAS_OLD} ${LASBLOCK} ${TS2LAS}  ${LAS2TXT} )
++    ${LASINFO} ${LAS2LAS} ${TXT2LAS} 
++    ${LAS2OGR} ${LAS2LAS} ${LASBLOCK} ${TS2LAS}  ${LAS2TXT} )
+ 
+ # TODO: Experimental and requires testing --mloskot
+ # Generate user-specific settings for Visual Studio project
+@@ -84,20 +80,6 @@ link_directories(${Boost_LIBRARY_DIRS})
+ #    add_executable(lasschematest lasschematest.cpp laskernel.cpp)
+ #    target_link_libraries(lasschematest ${APPS_CPP_DEPENDENCIES} 
${LIBXML2_LIBRARIES})
+ 
+-# Build lasinfo
+-if(LASINFO_OLD)
+-    set(LASINFO_OLD_SRC lascommon.c ${LASINFO_OLD}.c)
+-    add_executable(${LASINFO_OLD} ${LASINFO_OLD_SRC})
+-    target_link_libraries(${LASINFO_OLD} ${LIBLAS_C_LIB_NAME})
+-endif()
+-
+-# Build las2las
+-if(LAS2LAS_OLD)
+-    set(LAS2LAS_OLD_SRC lascommon.c ${LAS2LAS_OLD}.c)
+-    add_executable(${LAS2LAS_OLD} ${LAS2LAS_OLD_SRC})
+-    target_link_libraries(${LAS2LAS_OLD} ${LIBLAS_C_LIB_NAME})
+-endif()
+-
+ 
+ if(LAS2LAS)
+     add_executable(${LAS2LAS} las2las.cpp laskernel.cpp)
+@@ -109,13 +91,6 @@ if(LASINFO)
+     target_link_libraries(${LASINFO} ${APPS_CPP_DEPENDENCIES}  )
+ endif()
+ 
+-# Build las2txt
+-if(LAS2TXT_OLD)
+-    set(LAS2TXT_OLD_SRC lascommon.c ${LAS2TXT}.c)
+-    add_executable(${LAS2TXT_OLD} ${LAS2TXT_OLD_SRC})
+-    target_link_libraries(${LAS2TXT_OLD} ${LIBLAS_C_LIB_NAME})
+-endif()
+-
+ if(LAS2TXT)
+     add_executable( ${LAS2TXT}  las2txt.cpp laskernel.cpp )
+     target_link_libraries(${LAS2TXT} ${APPS_CPP_DEPENDENCIES}  )
+@@ -133,13 +108,6 @@ if(TS2LAS)
+     target_link_libraries(${TS2LAS} ${APPS_CPP_DEPENDENCIES} )
+ endif()
+ 
+-# Build lasmerge
+-if(LASMERGE)
+-    set(LASMERGE_SRC lascommon.c ${LASMERGE}.c)
+-    add_executable(${LASMERGE} ${LASMERGE_SRC})
+-    target_link_libraries(${LASMERGE} ${LIBLAS_C_LIB_NAME})
+-endif()
+-
+ # Build lasblock
+ if(LASBLOCK)
+     set(LASBLOCK_SRC lasblock.cpp laskernel.cpp)
+--- a/apps/las2las-old.c
++++ /dev/null
+@@ -1,1165 +0,0 @@
+-/***************************************************************************
+- * $Id$
+- * $Date$
+- *
+- * Project: libLAS -- C/C++ read/write library for LAS LIDAR data
+- * Purpose: LAS translation with optional configuration
+- * Author:  Martin Isenburg isenb...@cs.unc.edu 
+- ***************************************************************************
+- * Copyright (c) 2007, Martin Isenburg isenb...@cs.unc.edu 
+- *
+- * See LICENSE.txt in this source distribution for more information.
+- **************************************************************************/
+-
+-#include "liblas.h"
+-#include "lascommon.h"
+-
+-/* std */
+-#include <assert.h>
+-#include <time.h>
+-#include <stdio.h>
+-#include <stdlib.h>
+-#include <string.h>
+-
+-#ifdef _WIN32
+-#define compare_no_case(a,b,n)  _strnicmp( (a), (b), (n) )
+-#else
+-#define compare_no_case(a,b,n)  strncasecmp( (a), (b), (n) )
+-#endif
+-
+-LASPointSummary* SummarizePoints(LASReaderH reader);
+-void print_point_summary(FILE *file, LASPointSummary* summary, LASHeaderH 
header);
+-void print_point(FILE *file, LASPointH point);
+-void print_header(FILE *file, LASHeaderH header, const char* file_name, int 
bSkipVLR);
+-void repair_header(FILE *file, LASHeaderH header, LASPointSummary* summary) ;
+-
+-#define LAS_FORMAT_10 0
+-#define LAS_FORMAT_11 1
+-#define LAS_FORMAT_12 2
+-
+-void do_bulk_copy(const char* infile, size_t in_start_point, const char* 
outfile)
+-{
+-    /* bulk copy assumes that the header has already been written to outfile 
+-       as it is supposed to be, and that we're just going to copy all of the 
+-       points in infile as they are.  
+-    */
+-    FILE* file_out = 0;
+-    FILE* file_in = 0;
+-    
+-    size_t read = 0;
+-    size_t written = 0;
+-    size_t size = 1000;
+-
+-    char *buffer = 0;
+-    
+-    buffer = (char*) malloc(size * sizeof(char));
+-    
+-    if (buffer == 0) {
+-        LASError_Print("unable to allocate buffer copy");
+-        exit(1);
+-    }
+-    file_in = fopen(infile, "rb");
+-    fseek(file_in, in_start_point, SEEK_SET);
+-    
+-    if (file_in == 0) {
+-        LASError_Print("input filename not valid for bulk copy");
+-        exit(1);
+-    }
+-    file_out = fopen(outfile, "ab+");
+-    if (file_out == 0) {
+-        LASError_Print("output filename not valid for bulk copy");
+-        exit(1);
+-    }
+-    
+-    while (feof(file_in) == 0) {
+-        read = fread(buffer, 1, size, file_in);
+-        written = fwrite(buffer, 1, read, file_out);
+-        
+-        if (read != written) {
+-            LASError_Print("unable to write data in bulk copy");
+-            exit(1);
+-        }
+-    }
+-    
+-    fclose(file_in);
+-    fclose(file_out);
+-    free(buffer);
+-}
+-
+-
+-void usage()
+-{
+-    
fprintf(stderr,"----------------------------------------------------------\n");
+-    fprintf(stderr,"    las2las-old (version %s) usage:\n", 
LAS_GetFullVersion());
+-    
fprintf(stderr,"----------------------------------------------------------\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Clip las file to a bounding box, throwing out points that 
have invalid data:\n");
+-    fprintf(stderr,"  las2las-old -i in.las -clip 63000000 483450000 63050000 
483500000 -o out.las --skip_invalid\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Read from stdin, eliminate intensities below 2000, and 
write to stdout:\n");
+-    fprintf(stderr,"  las2las-old --eliminate_intensity_below 2000 --stdin 
--stdout < in.las > out.las \n");
+-    fprintf(stderr,"\n");
+-    
+-    fprintf(stderr,"Eliminate return number two:\n");
+-    fprintf(stderr,"  las2las-old -i in.las -eliminate_return 2 -o 
out.las\n");
+-    fprintf(stderr,"\n");
+-    
+-    fprintf(stderr,"Eliminate scan angles above 15:\n");
+-    fprintf(stderr,"  las2las-old -i in.las -eliminate_scan_angle_above 15 -o 
out.las\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Eliminate intensities below 1000:\n");
+-    fprintf(stderr,"  las2las-old -i in.las -eliminate_intensity_below 1000 
--stdout > out.las\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Eliminate intensities below 1000 and classifications that 
equal 2 (ground):\n");
+-    fprintf(stderr,"  las2las-old -i in.las --eliminate_class 2 --out 
out.las\n");
+-    fprintf(stderr,"\n");
+-        
+-    fprintf(stderr,"Capture only first returns and clip to bounding box:\n");
+-    fprintf(stderr,"  las2las-old -i in.las -first_only -clip 63000000 
483450000 63050000 483500000 -o out.las\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Capture only last returns, eliminate intensities below 
2000, and write to stdout:\n");
+-    fprintf(stderr,"  las2las-old --input in.las --last_only 
--eliminate_intensity_below 2000 --stdout > out.las\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Reproject the data (requires GDAL support):\n");
+-    fprintf(stderr,"  las2las-old -v in.las output.las -xyz_offset 0 0 0 "
+-                   "-t_srs EPSG:4326 --xyz_scale 0.0000001 0.0000001 
0.0000001"
+-                   "-s_srs EPSG:26915\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr, "\nFor more information, see the full documentation for 
las2las-old at:\n"
+-                    " http://liblas.org/utilities/las2las-old.html\n";);
+-    
fprintf(stderr,"----------------------------------------------------------\n");
+-
+-}
+-
+-void ptime(const char *const msg)
+-{
+-  float t= ((float)clock())/CLOCKS_PER_SEC;
+-  fprintf(stderr, "cumulative CPU time thru %s = %f\n", msg, t);
+-}
+-
+-int main(int argc, char *argv[])
+-{
+-    int i;
+-    int verbose = FALSE;
+-    int use_stdin = FALSE;
+-    int use_stdout = FALSE;
+-    char* file_name_in = 0;
+-    char* file_name_out = 0;
+-    char* proj4_text = NULL;
+-    double *clip_xy_min = NULL;
+-    double *clip_xy_max = NULL;
+-    int clip = FALSE;
+-    int remove_extra_header = FALSE;
+-    int elim_return = 0;
+-    int elim_scan_angle_above = 0;
+-    int elim_intensity_below = 0;
+-    int elim_class = 0;
+-    int clsidx = 0;
+-    int first_only = FALSE;
+-    int last_only = FALSE;
+-    int skip_invalid = FALSE;
+-    int format = LAS_FORMAT_12;
+-    int bulk_copy = FALSE;
+-    
+-    LASReaderH reader = NULL;
+-    LASHeaderH header = NULL;
+-    LASHeaderH surviving_header = NULL;
+-    LASPointH p = NULL;
+-    LASWriterH writer = NULL;
+-    
+-    LASSRSH in_srs = NULL;
+-    LASSRSH out_srs = NULL;
+-    int use_min_offset = FALSE;
+-    int do_reprojection = FALSE;
+-    int do_set_offset = FALSE;
+-    int do_set_scale = FALSE;
+-    int do_pad_header = FALSE;
+-    
+-    int header_pad = 0;
+-    
+-    int first_surviving_point = TRUE;
+-    unsigned int surviving_number_of_point_records = 0;
+-    unsigned int surviving_number_of_points_by_return[] = {0,0,0,0,0,0,0,0};
+-    LASPointH surviving_point_min = NULL;
+-    LASPointH surviving_point_max = NULL;
+-    double surviving_gps_time_min;
+-    double surviving_gps_time_max;
+-    int verticalCSType = -1, verticalDatum = -1, verticalUnits = 9001;
+-    const char *verticalCitation = "";
+-
+-    int clipped = 0;
+-    int eliminated_return = 0;
+-    int eliminated_scan_angle = 0;
+-    int eliminated_intensity = 0;
+-    int eliminated_class = 0;
+-    int eliminated_first_only = 0;
+-    int eliminated_last_only = 0; 
+-    int thinned = 0;
+-    
+-    int bThin = FALSE;
+-    int nThin = 0;
+-
+-    double xyz_scale[3] = {0.0, 0.0, 0.0};
+-    double xyz_offset[3] = {0.0, 0.0, 0.0};
+-    
+-    double minx, maxx, miny, maxy, minz, maxz;
+-    
+-    LASPointSummary* summary = NULL;
+-    
+-    int ret = 0;
+-    
+-    for (i = 1; i < argc; i++) {
+-        if (    strcmp(argv[i],"-h") == 0 ||
+-                strcmp(argv[i],"--help") == 0
+-            )
+-        {
+-            usage();
+-            exit(0);
+-        }
+-        else if (   strcmp(argv[i],"-v") == 0 ||
+-                    strcmp(argv[i],"--verbose") == 0
+-            )
+-        {
+-            verbose = TRUE;
+-        }
+-        else if (   strcmp(argv[i],"-s") == 0 ||
+-                    strcmp(argv[i],"--skip_invalid") == 0
+-            )
+-        {
+-            skip_invalid = TRUE;
+-        }
+-        else if (   strcmp(argv[i],"-b") == 0 ||
+-                    strcmp(argv[i],"--bulk") == 0
+-            )
+-        {
+-            bulk_copy = TRUE;
+-        }
+-        
+-        else if (   strcmp(argv[i],"--input") == 0  ||
+-                    strcmp(argv[i],"-input") == 0   ||
+-                    strcmp(argv[i],"-i") == 0       ||
+-                    strcmp(argv[i],"-in") == 0
+-                )
+-        {
+-            i++;
+-            file_name_in = argv[i];
+-        }
+-        else if (   strcmp(argv[i],"--output") == 0  ||
+-                    strcmp(argv[i],"--out") == 0     ||
+-                    strcmp(argv[i],"-out") == 0     ||
+-                    strcmp(argv[i],"-o") == 0       
+-                )
+-        {
+-            i++;
+-            file_name_out = argv[i];
+-        }
+-
+-        else if (   strcmp(argv[i],"--stdout") == 0  ||
+-                    strcmp(argv[i],"-olas") == 0    
+-                )
+-        {
+-            use_stdout = TRUE;
+-            file_name_out = "stdout";
+-        }
+-        else if (   strcmp(argv[i],"--clip") == 0   ||
+-                    strcmp(argv[i],"-clip") == 0    ||
+-                    strcmp(argv[i],"-clip_xy") == 0 
+-                )
+-        {
+-            clip_xy_min = (double*) malloc (2 * sizeof(double));
+-            clip_xy_max = (double*) malloc( 2 * sizeof(double));
+-            i++;
+-            clip_xy_min[0] = atof(argv[i]);
+-            i++;
+-            clip_xy_min[1] = atof(argv[i]);
+-            i++;
+-            clip_xy_max[0] = atof(argv[i]);
+-            i++;
+-            clip_xy_max[1] = atof(argv[i]);
+-            clip = TRUE;
+-        }
+-        else if (   strcmp(argv[i],"--format") == 0   ||
+-                    strcmp(argv[i],"-f") == 0    ||
+-                    strcmp(argv[i],"-format") == 0 
+-                )
+-        {
+-            i++;
+-            if (strcmp(argv[i], "1.0") == 0) {
+-                format = LAS_FORMAT_10;
+-            }
+-            else if (strcmp(argv[i], "1.1") == 0) {
+-                format = LAS_FORMAT_11;
+-            } 
+-            else if (strcmp(argv[i], "1.2") == 0) {
+-                format = LAS_FORMAT_12;
+-            }
+-            else {
+-                LASError_Print("Format must be specified as 1.0, 1.1, or 
1.2");
+-            }
+-
+-        }
+-
+-        else if (   strcmp(argv[i],"--eliminate_return") == 0  ||
+-                    strcmp(argv[i],"-eliminate_return") == 0   ||
+-                    strcmp(argv[i],"-elim_return") == 0       ||
+-                    strcmp(argv[i],"-elim_ret") == 0
+-                )        
+-        {
+-            i++;
+-            elim_return |= (1 << atoi(argv[i]));
+-        }
+-        else if (   strcmp(argv[i],"--eliminate_scan_angle_above") == 0  ||
+-                    strcmp(argv[i],"-eliminate_scan_angle_above") == 0   ||
+-                    strcmp(argv[i],"-elim_scan_angle_above") == 0       ||
+-                    strcmp(argv[i],"--clip_scan_above") == 0
+-                )        
+-        {
+-            i++;
+-            elim_scan_angle_above = atoi(argv[i]);
+-        }
+-        else if (   strcmp(argv[i],"--eliminate_class") == 0  ||
+-                    strcmp(argv[i],"-eliminate_class") == 0   ||
+-                    strcmp(argv[i],"-elim_class") == 0       ||
+-                    strcmp(argv[i],"--class") == 0
+-                )        
+-        {
+-            i++;
+-            elim_class = atoi(argv[i]);
+-        }
+-        else if (   strcmp(argv[i],"--eliminate_intensity_below") == 0  ||
+-                    strcmp(argv[i],"-eliminate_intensity_below") == 0   ||
+-                    strcmp(argv[i],"-elim_intensity_below") == 0       ||
+-                    strcmp(argv[i],"--clip_intensity_below") == 0
+-                )        
+-        {
+-            i++;
+-            elim_intensity_below = atoi(argv[i]);
+-        }
+-        else if (   strcmp(argv[i], "--stdin") == 0 ||
+-                    strcmp(argv[i], "-ilas") == 0
+-                ) 
+-        {
+-            use_stdin = TRUE;
+-        }
+-        else if (   strcmp(argv[i], "--first_only") == 0 ||
+-                    strcmp(argv[i], "-first_only") == 0
+-                ) 
+-        {
+-            first_only = TRUE;
+-        }
+-        else if (   strcmp(argv[i], "--last_only") == 0 ||
+-                    strcmp(argv[i], "-last_only") == 0
+-                ) 
+-        {
+-            last_only = TRUE;
+-        }
+-        else if (   strcmp(argv[i], "--remove_extra_header") == 0 ||
+-                    strcmp(argv[i], "-remove_extra_header") == 0
+-                ) 
+-        {
+-            remove_extra_header = TRUE;
+-        }
+-        else if (   strcmp(argv[i],"--s_srs") == 0  ||
+-                    strcmp(argv[i],"-s_srs") == 0    
+-                )
+-        {
+-            ++i;
+-            if (LAS_IsGDALEnabled()) {
+-                in_srs = LASSRS_Create();
+-                ret = LASSRS_SetFromUserInput(in_srs, argv[i]);
+-                if (ret) {
+-                    LASError_Print("Unable to import assigned SRS");
+-                    exit(1);
+-                }
+-            }
+-        }
+-        else if (   strcmp(argv[i],"--t_srs") == 0  ||
+-                    strcmp(argv[i],"-t_srs") == 0    ||
+-                    strcmp(argv[i],"-t") == 0 
+-                )
+-        {
+-            ++i;
+-            if (LAS_IsGDALEnabled()) {
+-                out_srs = LASSRS_Create();
+-                ret = LASSRS_SetFromUserInput(out_srs, argv[i]);
+-                if (ret) {
+-                    LASError_Print("Unable to import output SRS");
+-                    exit(1);
+-                }
+-                do_reprojection = TRUE;
+-            }
+-        }
+-        else if (   strcmp(argv[i],"--a_srs") == 0  ||
+-                    strcmp(argv[i],"-a_srs") == 0 
+-                )
+-        {
+-            ++i;
+-            if (LAS_IsGDALEnabled()) {
+-                out_srs = LASSRS_Create();
+-                ret = LASSRS_SetFromUserInput(out_srs, argv[i]);
+-                if (ret) {
+-                    LASError_Print("Unable to import output SRS");
+-                    exit(1);
+-                }
+-            }
+-        }
+-        else if (   strcmp(argv[i],"--a_vertcs") == 0  ||
+-                    strcmp(argv[i],"-a_vertcs") == 0 
+-                )
+-        {
+-            ++i;
+-            verticalCSType = atoi(argv[i]);
+-            ++i;
+-            if( i < argc && argv[i][0] != '-' )
+-            {
+-                verticalCitation = argv[i];
+-                ++i;
+-
+-                if( i < argc && argv[i][0] != '-' )
+-                {
+-                    verticalDatum = atoi(argv[i]);
+-                    ++i;
+-                    if( i < argc && argv[i][0] != '-' )
+-                    {
+-                        verticalUnits = atoi(argv[i]);
+-                        ++i;
+-                    }
+-                }
+-            }
+-        }
+-        else if (   strcmp(argv[i],"--scale") == 0  ||
+-                    strcmp(argv[i],"-scale") == 0    
+-                )
+-        {
+-
+-            i++;
+-            sscanf(argv[i], "%lf", &(xyz_scale[2]));
+-            xyz_scale[0] = xyz_scale[1] = xyz_scale[2];
+-            do_set_scale = TRUE;
+-        }
+-        else if (   strcmp(argv[i],"--xyz_scale") == 0  ||
+-                    strcmp(argv[i],"-xyz_scale") == 0    
+-                )
+-
+-        {
+-            i++;
+-            sscanf(argv[i], "%lf", &(xyz_scale[0]));
+-            i++;
+-            sscanf(argv[i], "%lf", &(xyz_scale[1]));
+-            i++;
+-            sscanf(argv[i], "%lf", &(xyz_scale[2]));
+-            do_set_scale = TRUE;
+-        }
+-        else if (   strcmp(argv[i],"--xyz_offset") == 0  ||
+-                    strcmp(argv[i],"-xyz_offset") == 0    
+-                )
+-        {
+-            i++;
+-            if (!compare_no_case(argv[i], "min", 3)) {
+-                use_min_offset = TRUE;
+-                do_set_offset = TRUE;
+-            } else
+-            {
+-                sscanf(argv[i], "%lf", &(xyz_offset[0]));
+-                i++;
+-                sscanf(argv[i], "%lf", &(xyz_offset[1]));
+-                i++;
+-                sscanf(argv[i], "%lf", &(xyz_offset[2]));
+-                do_set_offset = TRUE;
+-            }
+-        }
+-        else if (   strcmp(argv[i],"--pad-header") == 0  ||
+-                    strcmp(argv[i],"-pad-header") == 0   ||
+-                    strcmp(argv[i],"-ph") == 0 
+-                )        
+-        {
+-            i++;
+-            do_pad_header = TRUE;
+-            header_pad = atoi(argv[i]);
+-        }
+-        else if (   strcmp(argv[i],"--thin") == 0  ||
+-                    strcmp(argv[i],"-y") == 0    
+-                )
+-        {
+-            i++;
+-            bThin = TRUE;
+-            nThin = atoi(argv[i]);
+-        }
+-        else if (file_name_in == NULL && file_name_out == NULL)
+-        {
+-            file_name_in = argv[i];
+-        }
+-        else if (file_name_in != NULL && file_name_out == NULL)
+-        {
+-            file_name_out = argv[i];
+-        }
+-        else 
+-        {
+-            fprintf(stderr, "ERROR: unknown argument '%s'\n",argv[i]);
+-            usage();
+-            exit(1);
+-        }
+-    }
+-
+-    if (use_stdin) file_name_in="stdin";
+-    if (file_name_in)
+-    {
+-        reader = LASReader_Create(file_name_in);
+-        if (!reader) { 
+-            LASError_Print("Could not open file to read");
+-            exit(1);
+-        }
+-    }
+-    else
+-    {
+-        LASError_Print("no input specified");
+-        usage();
+-        exit(1);
+-    }
+-
+-        
+-    header = LASReader_GetHeader(reader);
+-    if (!header) { 
+-        LASError_Print("Could not fetch header");
+-        exit(1);
+-    } 
+-
+-    if (verbose) {
+-        ptime("start.");
+-        fprintf(stderr, "first pass reading %d points ...\n", 
LASHeader_GetPointRecordsCount(header));
+-    }
+-
+-    p  = LASReader_GetNextPoint(reader);
+-
+-    if (!p) {
+-        if (LASError_GetLastErrorNum()) 
+-            LASError_Print("Not able to fetch a point.  LASReader is 
invalid");
+-        else
+-            LASError_Print("File does not contain any points to read.");
+-        exit(1);
+-    }
+-    
+-    i = 0;
+-    while (p)
+-    {
+-        if (bThin && ((i % nThin) != 0)) {
+-            thinned++;
+-            i++;
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        if (last_only && LASPoint_GetReturnNumber(p) != 
LASPoint_GetNumberOfReturns(p))
+-        {
+-            eliminated_last_only++;
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        if (first_only && LASPoint_GetReturnNumber(p) != 1)
+-        {
+-            eliminated_first_only++;
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-    
+-        if (clip && (LASPoint_GetX(p) < clip_xy_min[0] || LASPoint_GetY(p) < 
clip_xy_min[1]))
+-        {
+-            clipped++;
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        if (clip && (LASPoint_GetX(p) > clip_xy_max[0] || LASPoint_GetY(p) > 
clip_xy_max[1]))
+-        {
+-            clipped++;
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        } 
+-        if (elim_return && (elim_return & (1 << LASPoint_GetReturnNumber(p))))
+-        {
+-            eliminated_return++;
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        if (elim_scan_angle_above && (LASPoint_GetScanAngleRank(p) > 
elim_scan_angle_above || LASPoint_GetScanAngleRank(p) < -elim_scan_angle_above))
+-        {
+-            eliminated_scan_angle++;
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-
+-        clsidx = LASPoint_GetClassification(p);
+-        clsidx = (clsidx & 31); /* 31 is max index in classification lookup 
table */
+-        assert(clsidx <= 31);
+-        if (elim_class && (elim_class == clsidx))
+-        {
+-            eliminated_class++;
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-
+-        if (elim_intensity_below && LASPoint_GetIntensity(p) < 
elim_intensity_below)
+-        {
+-            eliminated_intensity++;
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        surviving_number_of_point_records++;
+-
+-        if (LASPoint_GetReturnNumber(p))
+-            
surviving_number_of_points_by_return[LASPoint_GetReturnNumber(p)-1]++;
+-        else
+-            
surviving_number_of_points_by_return[LASPoint_GetReturnNumber(p)]++;        
+-
+-        if (first_surviving_point)
+-        {
+-            surviving_point_min = LASPoint_Copy(p);
+-            surviving_point_max = LASPoint_Copy(p);
+-            surviving_gps_time_min = LASPoint_GetTime(p);
+-            surviving_gps_time_max = LASPoint_GetTime(p);
+-            first_surviving_point = FALSE;
+-        }
+-        else
+-        {
+-            if (LASPoint_GetX(p) < LASPoint_GetX(surviving_point_min))
+-                LASPoint_SetX(surviving_point_min,LASPoint_GetX(p));
+-            else if (LASPoint_GetX(p) > LASPoint_GetX(surviving_point_max)) 
+-                LASPoint_SetX(surviving_point_max,LASPoint_GetX(p));
+-
+-            if (LASPoint_GetY(p) < LASPoint_GetY(surviving_point_min)) 
+-                LASPoint_SetY(surviving_point_min,LASPoint_GetY(p));
+-            else if (LASPoint_GetY(p) > LASPoint_GetY(surviving_point_max)) 
+-                LASPoint_SetY(surviving_point_max,LASPoint_GetY(p));
+-
+-            if (LASPoint_GetZ(p) < LASPoint_GetZ(surviving_point_min))
+-                LASPoint_SetZ(surviving_point_min,LASPoint_GetZ(p));
+-            else if (LASPoint_GetZ(p) > LASPoint_GetZ(surviving_point_max))   
+-                LASPoint_SetZ(surviving_point_max,LASPoint_GetZ(p));
+-
+-            if (LASPoint_GetIntensity(p) < 
LASPoint_GetIntensity(surviving_point_min)) 
+-                
LASPoint_SetIntensity(surviving_point_min,LASPoint_GetIntensity(p));
+-            else if (LASPoint_GetIntensity(p) > 
LASPoint_GetIntensity(surviving_point_max)) 
+-                
LASPoint_SetIntensity(surviving_point_max,LASPoint_GetIntensity(p));
+-
+-            if (LASPoint_GetFlightLineEdge(p) < 
LASPoint_GetFlightLineEdge(surviving_point_min)) 
+-                
LASPoint_SetFlightLineEdge(surviving_point_min,LASPoint_GetFlightLineEdge(p));
+-            else if (LASPoint_GetFlightLineEdge(p) > 
LASPoint_GetFlightLineEdge(surviving_point_max)) 
+-                
LASPoint_SetFlightLineEdge(surviving_point_max,LASPoint_GetFlightLineEdge(p));
+-
+-            if (LASPoint_GetScanDirection(p) < 
LASPoint_GetScanDirection(surviving_point_min)) 
+-                
LASPoint_SetScanDirection(surviving_point_min,LASPoint_GetScanDirection(p));
+-            else if (LASPoint_GetScanDirection(p) > 
LASPoint_GetScanDirection(surviving_point_max)) 
+-                
LASPoint_SetScanDirection(surviving_point_max,LASPoint_GetScanDirection(p));
+-
+-            if (LASPoint_GetNumberOfReturns(p) < 
LASPoint_GetNumberOfReturns(surviving_point_min)) 
+-                
LASPoint_SetNumberOfReturns(surviving_point_min,LASPoint_GetNumberOfReturns(p));
+-            else if (LASPoint_GetNumberOfReturns(p) > 
LASPoint_GetNumberOfReturns(surviving_point_max)) 
+-                
LASPoint_SetNumberOfReturns(surviving_point_max,LASPoint_GetNumberOfReturns(p));
+-
+-            if (LASPoint_GetReturnNumber(p) < 
LASPoint_GetReturnNumber(surviving_point_min)) 
+-                
LASPoint_SetReturnNumber(surviving_point_min,LASPoint_GetReturnNumber(p));
+-            else if (LASPoint_GetReturnNumber(p) > 
LASPoint_GetReturnNumber(surviving_point_max)) 
+-                
LASPoint_SetReturnNumber(surviving_point_max,LASPoint_GetReturnNumber(p));
+-
+-            if (LASPoint_GetClassification(p) < 
LASPoint_GetClassification(surviving_point_min)) 
+-                
LASPoint_SetClassification(surviving_point_min,LASPoint_GetClassification(p));
+-            else if (LASPoint_GetReturnNumber(p) > 
LASPoint_GetClassification(surviving_point_max)) 
+-                
LASPoint_SetClassification(surviving_point_max,LASPoint_GetClassification(p));
+-
+-            if (LASPoint_GetScanAngleRank(p) < 
LASPoint_GetScanAngleRank(surviving_point_min)) 
+-                
LASPoint_SetScanAngleRank(surviving_point_min,LASPoint_GetScanAngleRank(p));
+-            else if (LASPoint_GetScanAngleRank(p) > 
LASPoint_GetScanAngleRank(surviving_point_max)) 
+-                
LASPoint_SetScanAngleRank(surviving_point_max,LASPoint_GetScanAngleRank(p));
+-
+-            if (LASPoint_GetUserData(p) < 
LASPoint_GetUserData(surviving_point_min)) 
+-                
LASPoint_SetUserData(surviving_point_min,LASPoint_GetUserData(p));
+-            else if (LASPoint_GetUserData(p) > 
LASPoint_GetUserData(surviving_point_max)) 
+-                
LASPoint_SetUserData(surviving_point_max,LASPoint_GetUserData(p));
+-
+-            if (LASPoint_GetTime(p) < LASPoint_GetTime(surviving_point_min)) 
+-                LASPoint_SetTime(surviving_point_min,LASPoint_GetTime(p));
+-            else if (LASPoint_GetTime(p) > 
LASPoint_GetTime(surviving_point_max)) 
+-                LASPoint_SetTime(surviving_point_max,LASPoint_GetTime(p));
+-
+-        }
+-  
+-        p  = LASReader_GetNextPoint(reader);
+-        i++;
+-    }
+-
+-    if (eliminated_first_only) 
+-        fprintf(stderr, 
+-                "eliminated based on first returns only: %d\n",
+-                eliminated_first_only);
+-    if (eliminated_last_only) 
+-        fprintf(stderr, 
+-                "eliminated based on last returns only: %d\n", 
+-                eliminated_last_only);
+-    if (eliminated_class) 
+-        fprintf(stderr, 
+-                "eliminated classification: %d\n", 
+-                eliminated_class);
+-    if (clipped) 
+-        fprintf(stderr, 
+-                "clipped: %d\n", 
+-                clipped);
+-    if (eliminated_return) 
+-        fprintf(stderr, 
+-                "eliminated based on return number: %d\n", 
+-                eliminated_return);
+-    if (eliminated_scan_angle) 
+-        fprintf(stderr, 
+-                "eliminated based on scan angle: %d\n", 
+-                eliminated_scan_angle);
+-    if (eliminated_intensity) 
+-        fprintf(stderr, 
+-        "eliminated based on intensity: %d\n", 
+-        eliminated_intensity);
+-
+-    if (bThin) 
+-        fprintf(stderr, 
+-        "thinned: %d\n", 
+-        thinned);
+-    
+-    if (surviving_number_of_point_records == 0) {
+-        fprintf(stderr, "All points were eliminated!\n");
+-        exit(0);
+-    }
+-    
+-    LASReader_Destroy(reader);
+-    LASHeader_Destroy(header);
+-  
+-    if (verbose)
+-    {
+-        fprintf(stderr, 
+-                "x %.3f %.3f %.3f\n",
+-                LASPoint_GetX(surviving_point_min), 
+-                LASPoint_GetX(surviving_point_max), 
+-                LASPoint_GetX(surviving_point_max) - 
LASPoint_GetX(surviving_point_min)
+-                );
+-        fprintf(stderr, 
+-                "y %.3f %.3f %.3f\n",
+-                LASPoint_GetY(surviving_point_min), 
+-                LASPoint_GetY(surviving_point_max), 
+-                LASPoint_GetY(surviving_point_max) - 
LASPoint_GetY(surviving_point_min)
+-                );
+-        fprintf(stderr, 
+-                "z %.3f %.3f %.3f\n",
+-                LASPoint_GetZ(surviving_point_min), 
+-                LASPoint_GetZ(surviving_point_max), 
+-                LASPoint_GetZ(surviving_point_max) - 
LASPoint_GetZ(surviving_point_min)
+-                );
+-        fprintf(stderr, 
+-                "intensity %d %d %d\n",
+-                LASPoint_GetIntensity(surviving_point_min), 
+-                LASPoint_GetIntensity(surviving_point_max), 
+-                LASPoint_GetIntensity(surviving_point_max) - 
LASPoint_GetIntensity(surviving_point_min)
+-                );
+-        fprintf(stderr, 
+-                "edge_of_flight_line %d %d %d\n",
+-                LASPoint_GetFlightLineEdge(surviving_point_min), 
+-                LASPoint_GetFlightLineEdge(surviving_point_max), 
+-                LASPoint_GetFlightLineEdge(surviving_point_max) - 
LASPoint_GetFlightLineEdge(surviving_point_min)
+-                );
+-        fprintf(stderr, 
+-                "scan_direction_flag %d %d %d\n",
+-                LASPoint_GetScanDirection(surviving_point_min), 
+-                LASPoint_GetScanDirection(surviving_point_max), 
+-                LASPoint_GetScanDirection(surviving_point_max) - 
LASPoint_GetScanDirection(surviving_point_min)
+-                );
+-        fprintf(stderr, 
+-                "number_of_returns_of_given_pulse %d %d %d\n",
+-                LASPoint_GetNumberOfReturns(surviving_point_min), 
+-                LASPoint_GetNumberOfReturns(surviving_point_max), 
+-                LASPoint_GetNumberOfReturns(surviving_point_max) - 
LASPoint_GetNumberOfReturns(surviving_point_min)
+-                );
+-        fprintf(stderr, 
+-                "return_number %d %d %d\n",
+-                LASPoint_GetReturnNumber(surviving_point_min), 
+-                LASPoint_GetReturnNumber(surviving_point_max), 
+-                LASPoint_GetReturnNumber(surviving_point_max) - 
LASPoint_GetReturnNumber(surviving_point_min)
+-                );
+-        fprintf(stderr, 
+-                "classification %d %d %d\n",
+-                LASPoint_GetClassification(surviving_point_min), 
+-                LASPoint_GetClassification(surviving_point_max), 
+-                LASPoint_GetClassification(surviving_point_max) - 
LASPoint_GetClassification(surviving_point_min)
+-                );
+-        fprintf(stderr, 
+-                "scan_angle_rank %d %d %d\n",
+-                LASPoint_GetScanAngleRank(surviving_point_min), 
+-                LASPoint_GetScanAngleRank(surviving_point_max), 
+-                LASPoint_GetScanAngleRank(surviving_point_max) - 
LASPoint_GetScanAngleRank(surviving_point_min)
+-                );
+-        fprintf(stderr, 
+-                "user_data %d %d %d\n",
+-                LASPoint_GetUserData(surviving_point_min), 
+-                LASPoint_GetUserData(surviving_point_max), 
+-                LASPoint_GetUserData(surviving_point_max) - 
LASPoint_GetUserData(surviving_point_min)
+-                );
+-        fprintf(stderr, 
+-                "gps_time %.8f %.8f %.8f\n",
+-                LASPoint_GetTime(surviving_point_min), 
+-                LASPoint_GetTime(surviving_point_max), 
+-                LASPoint_GetTime(surviving_point_max) - 
LASPoint_GetTime(surviving_point_min)
+-                );
+-
+-    }
+-
+-    if (file_name_out == NULL && !use_stdout)
+-    {
+-        LASError_Print("no output specified. exiting...");
+-        exit(1);
+-    }
+-
+-
+-    fprintf(stderr, "Creating another reader...\n");
+-    if (file_name_in)
+-    {
+-        reader = LASReader_Create(file_name_in);
+-      if (!reader) { 
+-          LASError_Print("Could not open file to read");
+-          exit(1);
+-      } 
+-    }
+-    else
+-    {
+-        LASError_Print("no input specified");
+-        usage();
+-        exit(1);
+-    }
+-
+-    
+-    header = LASReader_GetHeader(reader);
+-    if (!header) { 
+-        LASError_Print("Could not read header");
+-        exit(1);
+-    } 
+-
+-
+-    surviving_header = LASHeader_Copy(header);
+-
+-    LASHeader_SetPointRecordsCount(surviving_header, 
surviving_number_of_point_records);
+-    LASHeader_SetSystemId(surviving_header, "MODIFICATION");
+-
+-    for (i = 0; i < 5; i++) 
LASHeader_SetPointRecordsByReturnCount(surviving_header, i, 
surviving_number_of_points_by_return[i]);
+-
+-    minx =  LASPoint_GetX(surviving_point_min) * \
+-            LASHeader_GetScaleX(surviving_header) + \
+-            LASHeader_GetOffsetX(surviving_header);
+-            
+-    maxx = LASPoint_GetX(surviving_point_max) * 
LASHeader_GetScaleX(surviving_header) + LASHeader_GetOffsetX(surviving_header);
+-
+-    miny = LASPoint_GetY(surviving_point_min) * 
LASHeader_GetScaleY(surviving_header) + LASHeader_GetOffsetY(surviving_header);
+-    maxy = LASPoint_GetY(surviving_point_max) * 
LASHeader_GetScaleY(surviving_header) + LASHeader_GetOffsetY(surviving_header);
+-
+-    minz = LASPoint_GetZ(surviving_point_min) * 
LASHeader_GetScaleZ(surviving_header) + LASHeader_GetOffsetZ(surviving_header);
+-    maxz = LASPoint_GetZ(surviving_point_max) * 
LASHeader_GetScaleZ(surviving_header) + LASHeader_GetOffsetZ(surviving_header);
+-    
+-    if (format == LAS_FORMAT_10) {
+-        LASHeader_SetVersionMinor(surviving_header, 0);
+-    } else if (format == LAS_FORMAT_11){
+-        LASHeader_SetVersionMinor(surviving_header, 1);
+-    } else if (format == LAS_FORMAT_12) {
+-        LASHeader_SetVersionMinor(surviving_header, 2);
+-    }
+-
+-    if (do_set_offset) {
+-        if (use_min_offset) {
+-            if (verbose) {
+-                fprintf(stderr, 
+-                    "Setting xyz offset to minimums...\n");
+-            }
+-            LASHeader_SetOffset(surviving_header, 
+-                                LASPoint_GetX(surviving_point_min), 
+-                                LASPoint_GetY(surviving_point_min), 
+-                                LASPoint_GetZ(surviving_point_min));
+-        } else {
+-            if (verbose) {
+-                fprintf(stderr, 
+-                    "Setting xyz offset to %.8f %.8f %.8f...\n", 
xyz_offset[0], xyz_offset[1], xyz_offset[2]);
+-            }
+-            LASHeader_SetOffset(surviving_header,
+-                                xyz_offset[0],
+-                                xyz_offset[1],
+-                                xyz_offset[2]);
+-        }
+-    }
+-
+-    if (do_set_scale) {
+-        if (verbose) {
+-            fprintf(stderr, 
+-                "Setting xyz scale to %.8f %.8f %.8f...\n", xyz_scale[0], 
xyz_scale[1], xyz_scale[2]);
+-        }
+-        LASHeader_SetScale( surviving_header, 
+-                            xyz_scale[0],
+-                            xyz_scale[1],
+-                            xyz_scale[2]);
+-    }
+-    
+-    if (do_pad_header){
+-        if (verbose) {
+-            fprintf(stderr, 
+-                "Padding header by %d bytes. New header will be %d bytes long 
instead of %d bytes ...\n", 
+-                header_pad, 
+-                LASHeader_GetDataOffset(surviving_header)+abs(header_pad), 
+-                LASHeader_GetDataOffset(surviving_header));
+-        }
+-        
+-        LASHeader_SetDataOffset(surviving_header, 
LASHeader_GetDataOffset(surviving_header)+abs(header_pad));
+-    }
+-    
+-    /* Do we have vertical cs info to set? */
+-    if( verticalCSType > 0 )
+-    {
+-        if( out_srs == NULL )
+-            out_srs = LASHeader_GetSRS(surviving_header);
+-
+-        if( out_srs == NULL )
+-            out_srs = LASSRS_Create();
+-
+-        LASSRS_SetVerticalCS( out_srs,
+-                              verticalCSType, 
+-                              verticalCitation, 
+-                              verticalDatum, 
+-                              verticalUnits );
+-    }
+-
+-    if (do_reprojection) {
+-        if (verbose) {
+-            proj4_text =  LASSRS_GetProj4(out_srs);
+-            fprintf(stderr,
+-                "Setting new coordinate system to %s", proj4_text);
+-            LASString_Free(proj4_text);
+-        }
+-        
+-        /* keep around the header's SRS if we don't have one set by the user 
*/
+-        if (in_srs == NULL) {
+-            in_srs = LASHeader_GetSRS(surviving_header);
+-        }
+-        
+-        LASHeader_SetSRS(surviving_header, out_srs);
+-    }
+-
+-    /* Are we just assigning an override SRS? (-a_srs) */
+-    else if( out_srs != NULL )
+-    {
+-        LASHeader_SetSRS(surviving_header, out_srs);
+-    }
+-
+-    if (verbose) {
+-        fprintf(stderr, 
+-                "second pass reading %d and writing %d points ...\n", 
+-                LASHeader_GetPointRecordsCount(surviving_header), 
+-                surviving_number_of_point_records);
+-    }
+-    
+-    
+-    if (use_stdout) file_name_out = "stdout";
+-    
+-    writer = LASWriter_Create(  file_name_out, 
+-                                surviving_header, 
+-                                LAS_MODE_WRITE);
+-    if (!writer) { 
+-        LASError_Print("Could not open file to write");
+-        exit(1);
+-    }  
+-
+-    if (do_reprojection) {
+-        if (in_srs != NULL) {
+-            char* in_wkt = LASSRS_GetWKT(in_srs);
+-            if (strlen(in_wkt) == 0) {
+-                LASString_Free(in_wkt);
+-                LASError_Print("Input SRS is empty, please specify with 
-s_srs");
+-                exit(1);
+-            }
+-            LASString_Free(in_wkt);
+-            LASWriter_SetInputSRS(writer, in_srs);
+-        } else {
+-            
+-        }
+-    
+-        if (out_srs != NULL) {
+-            if (verbose) {
+-                fprintf(stderr,
+-                    "Setting LASWriter_SetOutputSRS to %s", 
LASSRS_GetProj4(out_srs));
+-            }
+-            LASWriter_SetOutputSRS(writer, out_srs);
+-        }
+-    }
+-/*
+-
+-  if (!remove_extra_header)
+-  {
+-    for (unsigned int u = lasreader->header.header_size; u < 
lasreader->header.offset_to_point_data; u++)
+-    {
+-      fputc(fgetc(file_in),file_out);
+-    }
+-  }
+-*/
+-
+-    
+-    LASReader_Destroy(reader);
+-    reader = NULL;
+-    if (file_name_in)
+-    {
+-        reader = LASReader_Create(file_name_in);
+-        if (!reader) { 
+-            LASError_Print("Could not open file to read");
+-            exit(1);
+-        } 
+-    }
+-    else
+-    {
+-        LASError_Print("no input specified");
+-        usage();
+-        exit(1);
+-    }
+-
+-    
+-    p = LASReader_GetNextPoint(reader);
+-    if (!p) {
+-        if (LASError_GetLastErrorNum()) 
+-            LASError_Print("Not able to fetch a point.  LASReader is 
invalid");
+-        else
+-            LASError_Print("File does not contain any points to read.");
+-        exit(1);
+-    }
+-    
+-    i = 0;
+-    while (p) {
+-
+-        if (bThin && ((i % nThin) != 0)) {
+-            i++;
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        
+-        if (skip_invalid && !LASPoint_IsValid(p)) {
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        if (last_only && LASPoint_GetReturnNumber(p) != 
LASPoint_GetNumberOfReturns(p))
+-        {
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        if (first_only && LASPoint_GetReturnNumber(p) != 1)
+-        {
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-
+-        }
+-        if (clip_xy_min && (LASPoint_GetX(p) < clip_xy_min[0] || 
LASPoint_GetY(p) < clip_xy_min[1]))
+-        {
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        if (clip_xy_max && (LASPoint_GetX(p) > clip_xy_max[0] || 
LASPoint_GetY(p) > clip_xy_max[1]))
+-        {
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        if (elim_return && (elim_return & (1 << LASPoint_GetReturnNumber(p))))
+-        {
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        if (elim_scan_angle_above && (LASPoint_GetScanAngleRank(p) > 
elim_scan_angle_above || LASPoint_GetScanAngleRank(p) < -elim_scan_angle_above))
+-        {
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        if (elim_intensity_below && LASPoint_GetIntensity(p) < 
elim_intensity_below)
+-        {
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-
+-        clsidx = LASPoint_GetClassification(p);
+-        clsidx = (clsidx & 31); /* 31 is max index in classification lookup 
table */
+-        assert(clsidx <= 31);
+-        if (elim_class && (elim_class == clsidx))
+-        {
+-            p = LASReader_GetNextPoint(reader);
+-            continue;
+-        }
+-        ret = LASWriter_WritePoint(writer,p);
+-        
+-        if (ret == LE_Warning) {
+-            LASError_Print("Unable to write invalid point.  Use 
--skip_invalid to avoid this problem (you will lose data in the translation)");
+-            exit(1);
+-        }
+-        p  = LASReader_GetNextPoint(reader);
+-        i++;
+-    }
+-
+-    LASWriter_Destroy(writer);
+-    LASReader_Destroy(reader);
+-    LASHeader_Destroy(header);
+-    LASHeader_Destroy(surviving_header);
+-
+-    if (surviving_point_max != NULL)
+-        LASPoint_Destroy(surviving_point_max);
+-    if (surviving_point_min != NULL)
+-        LASPoint_Destroy(surviving_point_min);
+-
+-    reader = LASReader_Create(file_name_out);
+-    if (!reader) { 
+-        LASError_Print("Could not open file to read");
+-        exit(1);
+-    }
+-
+-    header = LASReader_GetHeader(reader);
+-    if (!header) { 
+-        LASError_Print("Could not read header");
+-        exit(1);
+-    }
+-
+-    
+-    summary = SummarizePoints(reader);
+-    if (verbose) {
+-        print_point_summary(stderr, summary, header);
+-    }
+-    repair_header(stderr, header, summary) ;
+-
+-    if (summary != NULL) {
+-        if (summary->pmin != NULL)
+-            LASPoint_Destroy(summary->pmin);
+-        if (summary->pmax != NULL)
+-            LASPoint_Destroy(summary->pmax);
+-        free(summary);
+-    }
+-
+-    if (reader != NULL) {
+-        LASReader_Destroy(reader);
+-        reader = NULL;
+-    }
+-    
+-    writer = LASWriter_Create(file_name_out, header, LAS_MODE_APPEND);
+-    if (!writer) {
+-        LASError_Print("Problem creating LASWriterH object for append");
+-        LASHeader_Destroy(header);
+-        header = NULL;
+-        exit(1);
+-    }
+-    LASWriter_Destroy(writer);
+-    writer = NULL;
+-    LASHeader_Destroy(header);
+-    header = NULL;
+-    
+-    if (out_srs != NULL)
+-        LASSRS_Destroy(out_srs);
+-    
+-    if (in_srs != NULL)
+-        LASSRS_Destroy(in_srs);
+-
+-    if (verbose) ptime("done.");
+-
+-    return 0;
+-}
+--- a/apps/lasinfo-old.c
++++ /dev/null
+@@ -1,420 +0,0 @@
+-/***************************************************************************
+-* $Id$
+-* $Date$
+-*
+-* Project: libLAS -- C/C++ read/write library for LAS LIDAR data
+-* Purpose: LAS information reporting and setting
+-* Author:  Martin Isenburg isenb...@cs.unc.edu 
+-***************************************************************************
+-* Copyright (c) 2007, Martin Isenburg isenb...@cs.unc.edu 
+-*
+-* See LICENSE.txt in this source distribution for more information.
+-**************************************************************************/
+-
+-/* TODO: Remove before releasing */
+-#if defined(_MSC_VER) && defined(USE_VLD)
+-#include <vld.h>
+-#endif
+-
+-/* liblas */
+-#include <liblas.h>
+-/* std */
+-#include <stdio.h>
+-#include <stdlib.h>
+-#include <string.h>
+-
+-#ifdef HAVE_GDAL
+-#include <cpl_multiproc.h>
+-#include <cpl_string.h>
+-#endif
+-
+-#include "lascommon.h"
+-
+-LASPointSummary* SummarizePoints(LASReaderH reader);
+-void print_point_summary(FILE *file, LASPointSummary* summary, LASHeaderH 
header);
+-void print_header(FILE *file, LASHeaderH header, const char* file_name, int 
bSkipVLR, int bWKT);
+-
+-void usage()
+-{
+-    char* version = LAS_GetFullVersion();
+-    
fprintf(stderr,"----------------------------------------------------------\n");
+-    fprintf(stderr,"    lasinfo-old (version %s) usage:\n", version);
+-    
fprintf(stderr,"----------------------------------------------------------\n");
+-    fprintf(stderr,"\n");
+-    LASString_Free(version);
+-    version = NULL;
+-
+-    fprintf(stderr,"Printing simple header info:\n");
+-    fprintf(stderr,"  lasinfo-old lidar.las\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Checking point information:\n");
+-    fprintf(stderr,"  lasinfo-old --input lidar.las --check\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Print header info and point summary and redirect output 
to a file:\n");
+-    fprintf(stderr,"  lasinfo-old --check --input lidar.las 2> output.txt\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Read from stdin, scan the points, and skip printing VLR 
info:\n");
+-    fprintf(stderr,"  lasinfo-old --stdin --check --skip_vlr < lidar.las\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Repairing header info to reflect point data:\n");
+-    fprintf(stderr,"  lasinfo-old -i lidar.las --repair\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Altering header info:\n");
+-    fprintf(stderr, "  lasinfo-old -i lidar.las --system_identifier \"hello 
world!\" "
+-                    "--generating_software \"this is a test (-:\"  
--file_creation 8 2007\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Print this output:\n");
+-    fprintf(stderr, "  lasinfo-old --help\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr, "\nFor more information, see the full documentation for 
lasinfo-old at:\n"
+-                    " http://liblas.org/utilities/lasinfo-old.html\n";);
+-    
fprintf(stderr,"----------------------------------------------------------\n");
+-}
+-
+-int main(int argc, char *argv[])
+-{
+-    int i = 0;
+-    char* file_name = NULL;
+-
+-    LASReaderH reader = NULL;
+-    LASHeaderH header = NULL;
+-    LASWriterH writer = NULL;
+-
+-    int check_points = FALSE;
+-    int repair_header = FALSE;
+-    int change_header = FALSE;
+-    int repair_bounding_box = FALSE;
+-    int use_stdin = FALSE;
+-    int update_return_counts = FALSE;
+-    int skip_vlr = FALSE;
+-    int wkt = FALSE;
+-
+-    char *system_identifier = NULL;
+-    char *generating_software = NULL;
+-    unsigned char file_creation_day = 0;
+-    unsigned char file_creation_year = 0;
+-
+-    int err = 0;
+-
+-    LASPointSummary* summary = NULL;
+-
+-    for (i = 1; i < argc; i++)
+-    {
+-        if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"--version") == 0)
+-        {
+-            char* ver = LAS_GetFullVersion();
+-            fprintf(stderr,"%s", ver);
+-            LASString_Free(ver);
+-            exit(0);
+-        }
+-        else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"--help") == 0)
+-        {
+-            usage();
+-            exit(0);
+-        }
+-        else if (strcmp(argv[i],"--input") == 0
+-              || strcmp(argv[i],"-input") == 0
+-              || strcmp(argv[i],"-i") == 0
+-              || strcmp(argv[i],"-in") == 0)
+-        {
+-            i++;
+-            file_name = argv[i];
+-        }
+-        else if (strcmp(argv[i], "--points") == 0
+-              || strcmp(argv[i], "--check") == 0
+-              || strcmp(argv[i], "--check_points") == 0
+-              || strcmp(argv[i], "-c") == 0
+-              || strcmp(argv[i], "-points") == 0
+-              || strcmp(argv[i], "-check") == 0
+-              || strcmp(argv[i], "-check_points") == 0)
+-        {
+-            check_points = TRUE;
+-        }
+-        else if (strcmp(argv[i], "--nocheck") == 0
+-              || strcmp(argv[i], "-nocheck") == 0)
+-        {
+-            check_points = FALSE;
+-        }
+-        else if (strcmp(argv[i], "--stdin") == 0
+-              || strcmp(argv[i], "-ilas") == 0) 
+-        {
+-            use_stdin = TRUE;
+-        }
+-        else if (strcmp(argv[i], "--repair") == 0
+-              || strcmp(argv[i], "-r") == 0
+-              || strcmp(argv[i], "-repair_header") == 0
+-              || strcmp(argv[i], "-repair") == 0) 
+-        {
+-            repair_header = TRUE;
+-            check_points = TRUE;
+-        }
+-        else if (strcmp(argv[i], "--repair_bb") == 0
+-              || strcmp(argv[i], "--repair_bounding_box") == 0
+-              || strcmp(argv[i], "--repair_boundingbox") == 0
+-              || strcmp(argv[i], "-repair_bb") == 0
+-              || strcmp(argv[i], "-repair_bounding_box") == 0
+-              || strcmp(argv[i], "-repair_boundingbox") == 0
+-              || strcmp(argv[i], "-repair") == 0
+-              || strcmp(argv[i], "-rb") == 0) 
+-        {
+-            repair_bounding_box = TRUE;
+-            check_points = TRUE;
+-        }
+-
+-        else if (strcmp(argv[i],"--system_identifier") == 0
+-              || strcmp(argv[i],"-system_identifier") == 0
+-              || strcmp(argv[i],"-s") == 0
+-              || strcmp(argv[i],"-sys_id") == 0)
+-        {
+-            i++;
+-            system_identifier = (char*) malloc(31 * sizeof(char));
+-            strcpy(system_identifier, argv[i]);
+-            change_header = TRUE;
+-        }
+-
+-        else if (strcmp(argv[i],"--generating_software") == 0
+-              || strcmp(argv[i],"-generating_software") == 0
+-              || strcmp(argv[i],"-g") == 0
+-              || strcmp(argv[i],"-gen_soft") == 0)
+-        {
+-            i++;
+-            generating_software = (char*) malloc(31*sizeof(char));
+-            strcpy(generating_software, argv[i]);
+-            change_header = TRUE;
+-        }
+-        else if (strcmp(argv[i],"--file_creation") == 0
+-              || strcmp(argv[i],"-file_creation") == 0)
+-        {
+-            /* XXX - mloskot: Consider replacing atoi with strtol,
+-            see http://www.iso-9899.info/wiki/Converting */
+-            i++;
+-            file_creation_day = (unsigned char)atoi(argv[i]);
+-            i++;
+-            file_creation_year = (unsigned char)atoi(argv[i]);
+-            change_header = TRUE;
+-        }
+-        else if (strcmp(argv[i],"--skip_vlr") == 0 || 
strcmp(argv[i],"--no_vlr") == 0)
+-        {
+-            skip_vlr = TRUE;
+-        }
+-        else if (strcmp(argv[i],"--wkt") == 0)
+-        {
+-            wkt = TRUE;
+-        }    
+-        else if (file_name == NULL)
+-        {
+-            file_name = argv[i];
+-        } 
+-        else
+-        {
+-            usage();
+-            fprintf(stderr, "ERROR: unknown argument '%s'\n",argv[i]);
+-            exit(1);
+-        }
+-    }
+-
+-    if (use_stdin) {
+-        file_name = "stdin";
+-    }
+-
+-    if (!file_name) {
+-        LASError_Print("No filename was provided to be opened");
+-        usage();
+-        exit(1);
+-    }
+-
+-    reader = LASReader_Create(file_name);
+-    if (!reader) { 
+-        LASError_Print("Could not open file ");
+-        exit(1);
+-    } 
+-
+-    header = LASReader_GetHeader(reader);
+-    if (!header) { 
+-        LASError_Print("Could not get LASHeader ");
+-        exit(1);
+-    } 
+-
+-    print_header(stdout, header, file_name, skip_vlr, wkt);
+-
+-    if (change_header) {
+-        if (system_identifier) {
+-            err = LASHeader_SetSystemId (header, system_identifier);
+-            if (err) LASError_Print("Could not set SystemId");
+-        }
+-        if (generating_software) {
+-            err = LASHeader_SetSoftwareId(header, generating_software);
+-            if (err) LASError_Print("Could not set SoftwareId");
+-        }
+-        if ( file_creation_day || file_creation_year) {
+-            err = LASHeader_SetCreationDOY(header, file_creation_day);
+-            if (err) LASError_Print("Could not set file creation day");
+-            err = LASHeader_SetCreationYear(header, file_creation_year);
+-            if (err) LASError_Print("Could not set file creation year");
+-        }
+-
+-        /* We need to wipe out the reader and make a writer. */
+-        if (reader) {
+-            LASReader_Destroy(reader);
+-            reader = NULL;
+-        }
+-
+-        writer = LASWriter_Create(file_name, header, LAS_MODE_APPEND);
+-        if (!writer) {
+-            LASError_Print("Problem creating LASWriterH object");
+-            LASHeader_Destroy(header);
+-            header = NULL;
+-            exit(1);
+-        }
+-
+-        if (writer) LASWriter_Destroy(writer);
+-        writer = NULL;
+-        if (header) LASHeader_Destroy(header);
+-        header = NULL;
+-    }
+-
+-    if (check_points)
+-    {
+-        if (!reader) {
+-            reader = LASReader_Create(file_name);
+-            if (!reader) { 
+-                LASError_Print("Could not open file ");
+-                exit(1);
+-            } 
+-        }
+-
+-        if (! header) {
+-            header = LASReader_GetHeader(reader);
+-            if (!header) { 
+-                LASError_Print("Could not get LASHeader ");
+-                exit(1);
+-            } 
+-        } 
+-
+-        if (!summary)
+-            summary = SummarizePoints(reader);
+-        print_point_summary(stdout, summary, header);
+-
+-        if (repair_header) {
+-            fprintf(stdout, 
"\n---------------------------------------------------------\n");
+-            fprintf(stdout, "  Repair Summary\n");
+-            fprintf(stdout, 
"---------------------------------------------------------\n");
+-
+-            if (use_stdin) {
+-                LASError_Print("Cannot update header information on piped 
input!");
+-                exit(1);
+-            }
+-
+-            if (! header) {
+-                header = LASReader_GetHeader(reader);
+-                if (!header) { 
+-                    LASError_Print("Could not get LASHeader ");
+-                    exit(1);
+-                }
+-            } 
+-
+-            if (! repair_bounding_box) {
+-                if ( LASHeader_GetMinX(header) != 
LASPoint_GetX(summary->pmin) )
+-                    repair_bounding_box = TRUE;
+-                if ( LASHeader_GetMinY(header) != 
LASPoint_GetY(summary->pmin) )
+-                    repair_bounding_box = TRUE;
+-                if ( LASHeader_GetMinZ(header) != 
LASPoint_GetZ(summary->pmin) )
+-                    repair_bounding_box = TRUE;
+-
+-                if ( LASHeader_GetMaxX(header) != 
LASPoint_GetX(summary->pmax) )
+-                    repair_bounding_box = TRUE;
+-                if ( LASHeader_GetMaxY(header) != 
LASPoint_GetY(summary->pmax) )
+-                    repair_bounding_box = TRUE;
+-                if ( LASHeader_GetMaxZ(header) != 
LASPoint_GetZ(summary->pmax) )
+-                    repair_bounding_box = TRUE;
+-            }
+-
+-            if (repair_bounding_box) {
+-                fprintf(stdout, "  Reparing Bounding Box...\n");
+-                err = LASHeader_SetMin( header, 
+-                    LASPoint_GetX(summary->pmin), 
+-                    LASPoint_GetY(summary->pmin), 
+-                    LASPoint_GetZ(summary->pmin)
+-                    );
+-                if (err) {
+-                    LASError_Print("Could not set minimum for header ");
+-                    exit(1);
+-                }
+-                err = LASHeader_SetMax( header, 
+-                    LASPoint_GetX(summary->pmax), 
+-                    LASPoint_GetY(summary->pmax), 
+-                    LASPoint_GetZ(summary->pmax)
+-                    );
+-                if (err) {
+-                    LASError_Print("Could not set minimum for header ");
+-                    exit(1);
+-                }
+-            }
+-
+-            for (i = 0; i < 5; i++) {
+-
+-                if (LASHeader_GetPointRecordsByReturnCount(header, i) != 
+-                    summary->number_of_points_by_return[i]) 
+-                {
+-                    update_return_counts = TRUE;
+-                    break;
+-                }
+-            }
+-
+-            if (update_return_counts) {
+-                fprintf(stdout, "  Reparing Point Count by Return...\n");
+-                for (i = 0; i < 5; i++) {
+-                    LASHeader_SetPointRecordsByReturnCount( header,  
+-                        i, 
+-                        summary->number_of_points_by_return[i]);
+-                }                
+-            }
+-
+-            if (reader) {
+-                LASReader_Destroy(reader);
+-                reader = NULL;
+-            }
+-
+-            writer = LASWriter_Create(file_name, header, LAS_MODE_APPEND);
+-            if (!writer) {
+-                LASError_Print("Problem creating LASWriterH object for 
append");
+-                LASHeader_Destroy(header);
+-                header = NULL;
+-                exit(1);
+-            }
+-            LASWriter_Destroy(writer);
+-            writer = NULL;
+-            LASHeader_Destroy(header);
+-            header = NULL;            
+-        }
+-
+-        if (summary) {
+-            LASPoint_Destroy(summary->pmin);
+-            LASPoint_Destroy(summary->pmax);
+-            free(summary);
+-
+-        }
+-    }   
+-
+-    if (reader) LASReader_Destroy(reader);
+-    if (header) LASHeader_Destroy(header);
+-
+-#ifdef HAVE_GDAL
+-    /* Various GDAL related cleanups */
+-#ifdef OSRCleanup
+-    OSRCleanup();
+-#endif
+-    CPLFinderClean();
+-    CPLFreeConfig();
+-    CPLCleanupTLS();
+-#endif
+-
+-    return 0;
+-}
+--- a/apps/lasmerge.c
++++ /dev/null
+@@ -1,507 +0,0 @@
+-/***************************************************************************
+- * $Id$
+- * $Date$
+- *
+- * Project: libLAS -- C/C++ read/write library for LAS LIDAR data
+- * Purpose: LAS file merging
+- * Author:  Martin Isenburg isenb...@cs.unc.edu 
+- ***************************************************************************
+- * Copyright (c) 2007, Martin Isenburg isenb...@cs.unc.edu 
+- *
+- * See LICENSE.txt in this source distribution for more information.
+- **************************************************************************/
+-
+-
+-#include <time.h>
+-#include <stdio.h>
+-#include <stdlib.h>
+-#include <string.h>
+-
+-#include "liblas.h"
+-#include "lascommon.h"
+-
+-LASPointSummary* SummarizePoints(LASReaderH reader);
+-void print_point_summary(FILE *file, LASPointSummary* summary, LASHeaderH 
header);
+-void print_header(FILE *file, LASHeaderH header, const char* file_name, int 
bSkipVLR);
+-
+-void usage()
+-{
+-
+-    
fprintf(stderr,"----------------------------------------------------------\n");
+-    fprintf(stderr,"    lasmerge (version %s) usage:\n", 
LAS_GetFullVersion());
+-    
fprintf(stderr,"----------------------------------------------------------\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Merge using a list of files:\n");
+-    fprintf(stderr,"  lasmerge -i lasfiles.txt -o out.las\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Manually list files to merge:\n");
+-    fprintf(stderr,"  lasmerge -i file1.las -i file2.las -i file3.las -o 
out.las\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Merge to stdout:\n");
+-    fprintf(stderr,"  lasmerge -i file1.las -i file2.las --stdout\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Merge and set scale:\n");
+-    fprintf(stderr, "  lasmerge --input lasfiles.txt --scale 0.01 --output 
out.las\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Merge and set scale individually:\n");
+-    fprintf(stderr, "  lasmerge --input lasfiles.txt --xyz_scale 0.01 0.01 
0.1 --output out.las\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Merge and set offset individually:\n");
+-    fprintf(stderr, "  lasmerge --input lasfiles.txt --xyz_offset 0.01 0.01 
0.1 --output out.las\n");
+-    fprintf(stderr,"\n");
+-
+-    fprintf(stderr,"Print this output:\n");
+-    fprintf(stderr, "  lasmerge --help\n");
+-    fprintf(stderr,"\n");
+-    
+-    fprintf(stderr, "For more information, see the full documentation for 
lasmerge at:\n"
+-                    " http://liblas.org/utilities/lasmerge.html\n";);
+-    
fprintf(stderr,"----------------------------------------------------------\n");
+-
+-}
+-
+-void ptime(const char *const msg)
+-{
+-    float t= ((float)clock())/CLOCKS_PER_SEC;
+-    fprintf(stderr, "cumulative CPU time thru %s = %f\n", msg, t);
+-}
+-
+-int main(int argc, char *argv[])
+-{
+-    int i;
+-    int verbose = FALSE;
+-    int skip_vlr = FALSE;
+-    int num_file_name_in = 0;
+-    int alloced_file_name_in = 32;
+-    char** file_names_in = (char**)malloc(sizeof(char*)*alloced_file_name_in);
+-    char* file_name_out = 0;
+-    int use_stdout = FALSE;
+-    double xyz_scale[3] = {0.0, 0.0, 0.0};
+-    double xyz_offset[3] = {0.0, 0.0, 0.0};
+-
+-    double minx, miny, maxx, maxy, minz, maxz;
+-    double x_scale_factor, y_scale_factor, z_scale_factor;
+-
+-  
+-    LASHeaderH merged_header=NULL;
+-    LASHeaderH header = NULL;
+-    LASReaderH reader = NULL;
+-    LASWriterH writer = NULL;
+-    LASPointH p = NULL;
+-  
+-    FILE* file = NULL;
+-
+-    int smallest_int = (1<<31)+10;
+-    int largest_int = smallest_int-1-20;
+-
+-    int same = TRUE;
+-    LASPointSummary* summary = NULL;
+-
+-    for (i = 1; i < argc; i++)
+-    {
+-        if (    strcmp(argv[i],"-h") == 0 ||
+-                strcmp(argv[i],"--help") == 0
+-            )
+-        {
+-            usage();
+-            exit(0);
+-        }
+-        else if (   strcmp(argv[i],"-v") == 0 ||
+-                    strcmp(argv[i],"--verbose") == 0
+-            )
+-        {
+-            verbose = TRUE;
+-        }        
+-        else if (   strcmp(argv[i],"--input") == 0  ||
+-                    strcmp(argv[i],"-input") == 0   ||
+-                    strcmp(argv[i],"-i") == 0       ||
+-                    strcmp(argv[i],"-in") == 0
+-                )
+-        {
+-            i++;
+-            if (num_file_name_in == alloced_file_name_in)
+-            {
+-                alloced_file_name_in *= 2;
+-                file_names_in = 
(char**)realloc(file_names_in,sizeof(char*)*alloced_file_name_in);
+-            }
+-            file_names_in[num_file_name_in] = argv[i];
+-            num_file_name_in++;
+-        }
+-        else if (   strcmp(argv[i],"--output") == 0  ||
+-                    strcmp(argv[i],"--out") == 0     ||
+-                    strcmp(argv[i],"-out") == 0     ||
+-                    strcmp(argv[i],"-o") == 0       
+-                )
+-        {
+-            i++;
+-            file_name_out = argv[i];
+-        }
+-        else if (   strcmp(argv[i],"--scale") == 0  ||
+-                    strcmp(argv[i],"-scale") == 0     ||
+-                    strcmp(argv[i],"-s") == 0       
+-                )
+-        {
+-
+-            i++;
+-            sscanf(argv[i], "%lf", &(xyz_scale[2]));
+-            xyz_scale[0] = xyz_scale[1] = xyz_scale[2];
+-        }
+-        else if (   strcmp(argv[i],"--xyz_scale") == 0  ||
+-                    strcmp(argv[i],"-xyz_scale") == 0    
+-                )
+-
+-        {
+-            i++;
+-            sscanf(argv[i], "%lf", &(xyz_scale[0]));
+-            i++;
+-            sscanf(argv[i], "%lf", &(xyz_scale[1]));
+-            i++;
+-            sscanf(argv[i], "%lf", &(xyz_scale[2]));
+-        }
+-        else if (   strcmp(argv[i],"--xyz_offset") == 0  ||
+-                    strcmp(argv[i],"-xyz_offset") == 0    
+-                )
+-        {
+-            i++;
+-            sscanf(argv[i], "%lf", &(xyz_offset[0]));
+-            i++;
+-            sscanf(argv[i], "%lf", &(xyz_offset[1]));
+-            i++;
+-            sscanf(argv[i], "%lf", &(xyz_offset[2]));
+-        }
+-        else if (   strcmp(argv[i],"--stdout") == 0  ||
+-                    strcmp(argv[i],"-olas") == 0    
+-                )
+-        {
+-            use_stdout = TRUE;
+-            file_name_out = "stdout";
+-        }
+-        else if (   strcmp(argv[i],"--skip_vlr") == 0   ||
+-                    strcmp(argv[i],"--no_vlr") == 0)
+-        {
+-            skip_vlr = TRUE;
+-        } 
+-        else if (i == argc - 2 && num_file_name_in == 0 && file_name_out == 0)
+-        {
+-            file_names_in[0] = argv[i];
+-            num_file_name_in = 1;
+-        }
+-        else if (i == argc - 1 && num_file_name_in == 0 && file_name_out == 0)
+-        {
+-            file_names_in[0] = argv[i];
+-            num_file_name_in = 1;
+-        }
+-        else if (i == argc - 1 && num_file_name_in != 0 && file_name_out == 0)
+-        {
+-            file_name_out = argv[i];
+-        }
+-        else 
+-        {
+-            fprintf(stderr, "ERROR: unknown argument '%s'\n",argv[i]);
+-            usage();
+-            exit(1);
+-        }
+-    }
+-
+-    if (num_file_name_in == 0)
+-    {
+-        fprintf(stderr, "ERROR: no input specified\n");
+-        usage();
+-        exit(1);
+-    }
+-
+-    if (    num_file_name_in == 1 && 
+-            strstr(file_names_in[0],".las") == 0 && 
+-            strstr(file_names_in[0],".LAS") == 0
+-       )
+-    {
+-        char line[512];
+-
+-        num_file_name_in = 0;
+-        file = fopen(file_names_in[0], "r");
+-        while (fgets(line, sizeof(char) * 512, file))
+-            {
+-                if (strstr(line,".las") || strstr(line,".LAS") )
+-                {
+-                    if (num_file_name_in == alloced_file_name_in)
+-                    {
+-                        alloced_file_name_in *= 2;
+-                        file_names_in = 
(char**)realloc(file_names_in,sizeof(char*)*alloced_file_name_in);
+-                    }
+-                    file_names_in[num_file_name_in] = LASCopyString(line);
+-                    i = (int)strlen(file_names_in[num_file_name_in]) - 1;
+-                    while ( i && 
+-                            file_names_in[num_file_name_in][i] != 's' && 
+-                            file_names_in[num_file_name_in][i] != 'S' && 
+-                            file_names_in[num_file_name_in][i] != 'z' && 
+-                            file_names_in[num_file_name_in][i] != 'Z') 
+-                    i--;
+-                    if (i)
+-                    {
+-                        file_names_in[num_file_name_in][i+1] = '\0';
+-                        num_file_name_in++;
+-                    }
+-                    else
+-                    {
+-                        fprintf(stderr, "WARNING: cannot parse line 
'%s'\n",line);
+-                    }
+-                }
+-                else
+-                {
+-                    fprintf(stderr, "WARNING: no a valid LAS file name 
'%s'\n",line);
+-                }
+-            }
+-    }
+-
+-
+-    if (verbose) ptime("starting first pass.");
+-    fprintf(stderr, "first pass ... reading headers of %d LAS files...\n", 
num_file_name_in);
+-
+-    for (i = 0; i < num_file_name_in; i++)
+-    {
+-        reader = LASReader_Create(file_names_in[i]);
+-        if (!reader) { 
+-                LASError_Print("Could not get LASReader "); 
+-                exit(1);
+-            } 
+-      
+-            header = LASReader_GetHeader(reader);
+-            if (!header) { 
+-                LASError_Print("Could not get LASHeader "); 
+-                exit(1);
+-            } 
+-
+-
+-        if (i == 0)
+-        {
+-            merged_header = LASReader_GetHeader(reader);
+-        }
+-        else
+-        {
+-            LASHeader_SetPointRecordsCount( merged_header, 
+-                                            
LASHeader_GetPointRecordsCount(merged_header) + 
+-                                            
LASHeader_GetPointRecordsCount(header));
+-            LASHeader_SetPointRecordsByReturnCount( merged_header, 
+-                                                    0, 
+-                                                    
LASHeader_GetPointRecordsByReturnCount(merged_header,0) + 
+-                                                    
LASHeader_GetPointRecordsByReturnCount(header,0));
+-            LASHeader_SetPointRecordsByReturnCount( merged_header, 
+-                                                    1, 
+-                                                    
LASHeader_GetPointRecordsByReturnCount(merged_header,1) + 
+-                                                    
LASHeader_GetPointRecordsByReturnCount(header,1));
+-            LASHeader_SetPointRecordsByReturnCount( merged_header, 
+-                                                    2, 
+-                                                    
LASHeader_GetPointRecordsByReturnCount(merged_header,2) + 
+-                                                    
LASHeader_GetPointRecordsByReturnCount(header,2));
+-            LASHeader_SetPointRecordsByReturnCount( merged_header, 
+-                                                    3, 
+-                                                    
LASHeader_GetPointRecordsByReturnCount(merged_header,3) + 
+-                                                    
LASHeader_GetPointRecordsByReturnCount(header,3));
+-            LASHeader_SetPointRecordsByReturnCount( merged_header, 
+-                                                    4, 
+-                                                    
LASHeader_GetPointRecordsByReturnCount(merged_header,4) + 
+-                                                    
LASHeader_GetPointRecordsByReturnCount(header,4));
+-
+-            LASHeader_SetSystemId(merged_header, "MERGED");
+-
+-            minx = LASHeader_GetMinX(merged_header);
+-            maxx = LASHeader_GetMaxX(merged_header);
+-            miny = LASHeader_GetMinY(merged_header);
+-            maxy = LASHeader_GetMaxY(merged_header);
+-            minz = LASHeader_GetMinZ(merged_header);
+-            maxz = LASHeader_GetMaxZ(merged_header);
+-        
+-            if (minx > LASHeader_GetMinX(header)) minx = 
LASHeader_GetMinX(header);
+-            if (maxx < LASHeader_GetMaxX(header)) maxx = 
LASHeader_GetMaxX(header);
+-            if (miny > LASHeader_GetMinY(header)) miny = 
LASHeader_GetMinY(header);
+-            if (maxy < LASHeader_GetMaxY(header)) maxy = 
LASHeader_GetMaxY(header);
+-            if (minz > LASHeader_GetMinZ(header)) minz = 
LASHeader_GetMinZ(header);
+-            if (maxz < LASHeader_GetMaxZ(header)) maxz = 
LASHeader_GetMaxZ(header);
+-        
+-            LASHeader_SetMin(merged_header, minx, miny, minz);
+-            LASHeader_SetMax(merged_header, maxx, maxy, maxz);
+-        }
+-        
+-        LASHeader_Destroy(header);
+-        LASReader_Destroy(reader);
+-    }
+-
+-    if (verbose)
+-    {
+-        fprintf(stderr, "  number_of_point_records %d\n", 
+-                LASHeader_GetPointRecordsCount(merged_header));
+-        fprintf(stderr, "  number of points by return %d %d %d %d %d\n", 
+-                        LASHeader_GetPointRecordsByReturnCount(merged_header, 
0),
+-                        LASHeader_GetPointRecordsByReturnCount(merged_header, 
1), 
+-                        LASHeader_GetPointRecordsByReturnCount(merged_header, 
2), 
+-                        LASHeader_GetPointRecordsByReturnCount(merged_header, 
3), 
+-                        LASHeader_GetPointRecordsByReturnCount(merged_header, 
4));
+-        fprintf(stderr, "  min x y z                  %.6f %.6f %.6f\n", 
+-                        LASHeader_GetMinX(merged_header), 
+-                        LASHeader_GetMinY(merged_header), 
+-                        LASHeader_GetMinZ(merged_header));
+-        fprintf(stderr, "  max x y z                  %.6f %.6f %.6f\n", 
+-                        LASHeader_GetMaxX(merged_header), 
+-                        LASHeader_GetMaxY(merged_header), 
+-                        LASHeader_GetMaxZ(merged_header));
+-    }
+-
+-    LASHeader_SetScale( merged_header, 
+-                        xyz_scale[0], 
+-                        xyz_scale[1], 
+-                        xyz_scale[2]);
+-
+-    LASHeader_SetOffset(merged_header, 
+-                        xyz_offset[0], 
+-                        xyz_offset[1], 
+-                        xyz_offset[2] );
+-
+-    x_scale_factor = LASHeader_GetScaleX(merged_header);
+-    if (((LASHeader_GetMaxX(merged_header) - 
LASHeader_GetOffsetX(merged_header)) / LASHeader_GetScaleX(merged_header)) > 
largest_int ||
+-        ((LASHeader_GetMinX(merged_header) - 
LASHeader_GetOffsetX(merged_header)) / LASHeader_GetScaleX(merged_header)) < 
smallest_int )
+-    {
+-        x_scale_factor = 0.0000001;
+-        while (((LASHeader_GetMaxX(merged_header) - 
LASHeader_GetOffsetX(merged_header)) / x_scale_factor) > largest_int ||
+-            ((LASHeader_GetMinX(merged_header) - 
LASHeader_GetOffsetX(merged_header)) / x_scale_factor) < smallest_int )
+-        {
+-            x_scale_factor *= 10;
+-        }
+-        fprintf(stderr, "x_scale_factor of merged_header changed to %g\n", 
x_scale_factor);
+-    }
+-
+-    y_scale_factor = LASHeader_GetScaleY(merged_header);
+-    if (((LASHeader_GetMaxY(merged_header) - 
LASHeader_GetOffsetY(merged_header)) / y_scale_factor) > largest_int ||
+-        ((LASHeader_GetMinY(merged_header) - 
LASHeader_GetOffsetY(merged_header)) / y_scale_factor) < smallest_int )
+-    {
+-        y_scale_factor = 0.0000001;
+-        while (((LASHeader_GetMaxY(merged_header) - 
LASHeader_GetOffsetY(merged_header)) / y_scale_factor) > largest_int ||
+-            ((LASHeader_GetMinY(merged_header) - 
LASHeader_GetOffsetY(merged_header)) / y_scale_factor) < smallest_int )
+-        {
+-            y_scale_factor *= 10;
+-        }
+-        fprintf(stderr, "y_scale_factor of merged_header changed to %g\n", 
y_scale_factor);
+-    }
+-  
+-    z_scale_factor = LASHeader_GetScaleZ(merged_header);
+-    if (((LASHeader_GetMaxZ(merged_header) - 
LASHeader_GetOffsetZ(merged_header)) / z_scale_factor) > largest_int ||
+-        ((LASHeader_GetMinZ(merged_header) - 
LASHeader_GetOffsetZ(merged_header)) / z_scale_factor) < smallest_int )
+-    {
+-        z_scale_factor = 0.0000001;
+-        while (((LASHeader_GetMaxZ(merged_header) - 
LASHeader_GetOffsetZ(merged_header)) / z_scale_factor) > largest_int ||
+-            ((LASHeader_GetMinZ(merged_header) - 
LASHeader_GetOffsetZ(merged_header)) / z_scale_factor) < smallest_int )\
+-        {
+-            z_scale_factor *= 10;
+-        }
+-        fprintf(stderr, "z_scale_factor of merged_header changed to %g\n", 
z_scale_factor);
+-    }
+-  
+-    LASHeader_SetScale( merged_header, 
+-                        x_scale_factor, 
+-                        y_scale_factor, 
+-                        z_scale_factor);
+-
+-    if (file_name_out == NULL && !use_stdout)
+-    {
+-        LASError_Print("no output was specified "); 
+-        exit(1);
+-    }
+-
+-    writer = LASWriter_Create(file_name_out, merged_header, LAS_MODE_WRITE);
+-    if (!writer) { 
+-        LASError_Print("Could not create LASWriter "); 
+-        exit(1);
+-    } 
+-
+-    if (verbose) ptime("starting second pass.");
+-    fprintf(stderr, "second pass ... merge %d LAS files into one ...\n", 
num_file_name_in);
+-
+-    for (i = 0; i < num_file_name_in; i++)
+-    {
+-        reader = LASReader_Create(file_names_in[i]);
+-        if (!reader) { 
+-            LASError_Print("Could not get LASReader ");
+-            exit(1);
+-        } 
+-        header = LASReader_GetHeader(reader);
+-        if (!header) { 
+-            LASError_Print("Could not get LASHeader ");
+-            exit(1);
+-        } 
+-
+-        same = TRUE;
+-        if (LASHeader_GetOffsetX(merged_header) != 
LASHeader_GetOffsetX(header)) same = FALSE;
+-        if (LASHeader_GetOffsetY(merged_header) != 
LASHeader_GetOffsetY(header)) same = FALSE;
+-        if (LASHeader_GetOffsetZ(merged_header) != 
LASHeader_GetOffsetZ(header)) same = FALSE;
+-
+-        if (LASHeader_GetScaleX(merged_header) != 
LASHeader_GetScaleX(header)) same = FALSE;
+-        if (LASHeader_GetScaleY(merged_header) != 
LASHeader_GetScaleY(header)) same = FALSE;
+-        if (LASHeader_GetScaleZ(merged_header) != 
LASHeader_GetScaleZ(header)) same = FALSE;
+-    
+-
+-        if (same)
+-        {
+-            p = LASReader_GetNextPoint(reader);
+-            while (p)
+-            {
+-                LASWriter_WritePoint(writer, p);
+-                p = LASReader_GetNextPoint(reader);
+-            }
+-        }
+-        else
+-        {
+-            p = LASReader_GetNextPoint(reader);
+-            while (p)
+-            {
+-                LASPoint_SetX(p,(0.5 + (LASPoint_GetX(p) - 
LASHeader_GetOffsetX(merged_header)) / LASHeader_GetScaleX(merged_header)));
+-                LASPoint_SetY(p,(0.5 + (LASPoint_GetY(p) - 
LASHeader_GetOffsetY(merged_header)) / LASHeader_GetScaleY(merged_header)));
+-                LASPoint_SetZ(p,(0.5 + (LASPoint_GetZ(p) - 
LASHeader_GetOffsetZ(merged_header)) / LASHeader_GetScaleZ(merged_header)));
+-                LASWriter_WritePoint(writer, p);
+-                p = LASReader_GetNextPoint(reader);
+-            }
+-        }
+-
+-        LASHeader_Destroy(header);
+-        LASReader_Destroy(reader);
+-        reader = NULL;
+-    }
+-    
+-    LASHeader_Destroy(merged_header);
+-    LASWriter_Destroy(writer);
+-
+-    if (verbose) ptime("done.");
+-
+-    if (verbose) {
+-        reader = LASReader_Create(file_name_out);
+-        if (!reader) { 
+-            LASError_Print("Could not open file ");
+-            exit(1);
+-        } 
+-      
+-        header = LASReader_GetHeader(reader);
+-        if (!header) { 
+-            LASError_Print("Could not get LASHeader ");
+-            exit(1);
+-        } 
+-
+-        print_header(stderr, header, file_name_out, skip_vlr);        
+-        summary = SummarizePoints(reader);
+-        print_point_summary(stderr, summary, header);
+-        
+-        LASHeader_Destroy(header);
+-        header = NULL;            
+-        LASReader_Destroy(reader);
+-        reader = NULL;
+-        
+-        LASPoint_Destroy(summary->pmin);
+-        LASPoint_Destroy(summary->pmax);
+-        free(summary);
+-    }
+-    
+-    return 0;
+-}
diff --git a/debian/patches/series b/debian/patches/series
index f58753b..adda01a 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -2,3 +2,4 @@ boost
 soversion
 fix_library_search
 separator-typo
+0001-remove-old-LAStools-utilities-that-don-t-belong-in-liblas.patch

-- 
Alioth's /usr/local/bin/git-commit-notice on 
/srv/git.debian.org/git/pkg-grass/liblas.git

_______________________________________________
Pkg-grass-devel mailing list
Pkg-grass-devel@lists.alioth.debian.org
http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-grass-devel

Reply via email to