int main(int argc, char *argv[])
{
int i;
bool verbose = false;
double start_time = 0.0;
LASreadOpener lasreadopener;
LASwriteOpener laswriteopener;
if (argc == 1)
{
fprintf(stderr,"%s is better run in the command line\n", argv[0]);
char file_name[256];
fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.set_file_name(file_name);
fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
laswriteopener.set_file_name(file_name);
}
else
{
lasreadopener.parse(argc, argv);
laswriteopener.parse(argc, argv);
}
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '\0')
{
continue;
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0)
{
usage();
}
else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0)
{
verbose = true;
}
else if (i == argc - 2 && !lasreadopener.active() && !laswriteopener.active())
{
lasreadopener.set_file_name(argv[i]);
}
else if (i == argc - 1 && !lasreadopener.active() && !laswriteopener.active())
{
lasreadopener.set_file_name(argv[i]);
}
else if (i == argc - 1 && lasreadopener.active() && !laswriteopener.active())
{
laswriteopener.set_file_name(argv[i]);
}
else
{
fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]);
usage();
}
}
if (verbose) start_time = taketime();
// check input & output
if (!lasreadopener.active())
{
fprintf(stderr,"ERROR: no input specified\n");
usage(argc == 1);
}
if (!laswriteopener.active())
{
fprintf(stderr,"ERROR: no output specified\n");
usage(argc == 1);
}
// open lasreader
LASreader* lasreader = lasreadopener.open();
if (lasreader == 0)
{
fprintf(stderr, "ERROR: could not open lasreader\n");
byebye(argc==1);
}
// open laswriter
LASwriter* laswriter = laswriteopener.open(&lasreader->header);
if (laswriter == 0)
{
fprintf(stderr, "ERROR: could not open laswriter\n");
byebye(argc==1);
}
#ifdef _WIN32
if (verbose) fprintf(stderr, "reading %I64d points from '%s' and writing them modified to '%s'.\n", lasreader->npoints, lasreadopener.get_file_name(), laswriteopener.get_file_name());
#else
if (verbose) fprintf(stderr, "reading %lld points from '%s' and writing them modified to '%s'.\n", lasreader->npoints, lasreadopener.get_file_name(), laswriteopener.get_file_name());
#endif
// loop over points and modify them
// where there is a point to read
while (lasreader->read_point())
{
// modify the point
lasreader->point.set_point_source_ID(1020);
lasreader->point.set_user_data(42);
if (lasreader->point.get_classification() == 12) lasreader->point.set_classification(1);
lasreader->point.set_Z(lasreader->point.get_Z() + 10);
// write the modified point
laswriter->write_point(&lasreader->point);
// add it to the inventory
laswriter->update_inventory(&lasreader->point);
}
laswriter->update_header(&lasreader->header, TRUE);
I64 total_bytes = laswriter->close();
delete laswriter;
#ifdef _WIN32
if (verbose) fprintf(stderr,"total time: %g sec %I64d bytes for %I64d points\n", taketime()-start_time, total_bytes, lasreader->p_count);
#else
if (verbose) fprintf(stderr,"total time: %g sec %lld bytes for %lld points\n", taketime()-start_time, total_bytes, lasreader->p_count);
#endif
lasreader->close();
delete lasreader;
return 0;
}
int main(int argc, char *argv[])
{
int i;
#ifdef COMPILE_WITH_GUI
bool gui = false;
#endif
#ifdef COMPILE_WITH_MULTI_CORE
I32 cores = 1;
#endif
bool verbose = false;
F32 tile_size = 0.0f;
U32 threshold = 1000;
U32 minimum_points = 100000;
I32 maximum_intervals = -20;
BOOL append = FALSE;
F64 start_time = 0.0;
F64 total_start_time = 0.0;
LASreadOpener lasreadopener;
if (argc == 1)
{
#ifdef COMPILE_WITH_GUI
return lasindex_gui(argc, argv, 0);
#else
fprintf(stderr,"lasindex.exe is better run in the command line or via the lastool.exe GUI\n");
char file_name[256];
fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.set_file_name(file_name);
#endif
}
else
{
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '–') argv[i][0] = '-';
}
if (!lasreadopener.parse(argc, argv)) byebye(true);
}
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '\0')
{
continue;
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
usage();
}
else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0)
{
verbose = true;
}
else if (strcmp(argv[i],"-version") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
byebye();
}
else if (strcmp(argv[i],"-gui") == 0)
{
#ifdef COMPILE_WITH_GUI
gui = true;
#else
fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n");
#endif
}
else if (strcmp(argv[i],"-cores") == 0)
{
#ifdef COMPILE_WITH_MULTI_CORE
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]);
usage(true);
}
argv[i][0] = '\0';
i++;
cores = atoi(argv[i]);
argv[i][0] = '\0';
#else
fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n");
i++;
#endif
}
else if (strcmp(argv[i],"-tile_size") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: size\n", argv[i]);
byebye(true);
}
i++;
tile_size = (F32)atof(argv[i]);
}
else if (strcmp(argv[i],"-maximum") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]);
byebye(true);
}
i++;
maximum_intervals = atoi(argv[i]);
}
else if (strcmp(argv[i],"-minimum") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]);
byebye(true);
}
i++;
minimum_points = atoi(argv[i]);
}
else if (strcmp(argv[i],"-threshold") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: value\n", argv[i]);
byebye(true);
}
i++;
threshold = atoi(argv[i]);
}
else if (strcmp(argv[i],"-append") == 0)
{
append = TRUE;
}
else
{
fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]);
byebye(true);
}
}
#ifdef COMPILE_WITH_GUI
if (gui)
{
return lasindex_gui(argc, argv, &lasreadopener);
}
#endif
#ifdef COMPILE_WITH_MULTI_CORE
if (cores > 1)
{
if (lasreadopener.get_file_name_number() < 2)
{
fprintf(stderr,"WARNING: only %u input files. ignoring '-cores %d' ...\n", lasreadopener.get_file_name_number(), cores);
}
else if (lasreadopener.is_merged())
{
fprintf(stderr,"WARNING: input files merged on-the-fly. ignoring '-cores %d' ...\n", cores);
}
else
{
return lasindex_multi_core(argc, argv, &lasreadopener, cores);
}
}
#endif
// check input
if (!lasreadopener.active())
{
fprintf(stderr,"ERROR: no input specified\n");
byebye(true, argc==1);
}
/*
// lasquadtree test
LASquadtree quadtree;
quadtree.setup(0, 99, 0, 99, 10);
quadtree.intersect_rectangle(10, 10, 20, 20);
quadtree.get_intersected_cells();
while (quadtree.has_intersected_cells())
{
F32 min[2],max[2];
quadtree.get_cell_bounding_box(quadtree.intersected_cell, min, max);
fprintf(stderr," checking tile %d with %g/%g %g/%g\n", quadtree.intersected_cell, min[0], min[1], max[0], max[1]);
}
quadtree.intersect_tile(10, 10, 10);
quadtree.get_intersected_cells();
while (quadtree.has_intersected_cells())
{
F32 min[2],max[2];
quadtree.get_cell_bounding_box(quadtree.intersected_cell, min, max);
fprintf(stderr," checking tile %d with %g/%g %g/%g\n", quadtree.intersected_cell, min[0], min[1], max[0], max[1]);
}
fprintf(stderr,"intersect circle\n");
quadtree.intersect_circle(10, 10, 10);
quadtree.get_intersected_cells();
while (quadtree.has_intersected_cells())
{
F32 min[2],max[2];
quadtree.get_cell_bounding_box(quadtree.intersected_cell, min, max);
fprintf(stderr," checking tile %d with %g/%g %g/%g\n", quadtree.intersected_cell, min[0], min[1], max[0], max[1]);
}
*/
// possibly loop over multiple input files
if (verbose && lasreadopener.get_file_name_number() > 1)
{
total_start_time = taketime();
}
while (lasreadopener.active())
{
if (verbose) start_time = taketime();
// open lasreader
LASreader* lasreader = lasreadopener.open();
if (lasreader == 0)
{
fprintf(stderr, "ERROR: could not open lasreader\n");
byebye(true, argc==1);
}
// setup the quadtree
LASquadtree* lasquadtree = new LASquadtree;
if (tile_size == 0.0f)
{
F32 t;
if (((lasreader->header.max_x - lasreader->header.min_x) < 1000) && ((lasreader->header.max_y - lasreader->header.min_y) < 1000))
{
t = 10.0f;
}
else if (((lasreader->header.max_x - lasreader->header.min_x) < 10000) && ((lasreader->header.max_y - lasreader->header.min_y) < 10000))
{
t = 100.0f;
}
else if (((lasreader->header.max_x - lasreader->header.min_x) < 100000) && ((lasreader->header.max_y - lasreader->header.min_y) < 100000))
{
t = 1000.0f;
}
else if (((lasreader->header.max_x - lasreader->header.min_x) < 1000000) && ((lasreader->header.max_y - lasreader->header.min_y) < 1000000))
{
t = 10000.0f;
}
else
{
t = 100000.0f;
}
if (verbose) fprintf(stderr,"no tile size specified. setting it to %g ...\n", t);
lasquadtree->setup(lasreader->header.min_x, lasreader->header.max_x, lasreader->header.min_y, lasreader->header.max_y, t);
}
else
{
lasquadtree->setup(lasreader->header.min_x, lasreader->header.max_x, lasreader->header.min_y, lasreader->header.max_y, tile_size);
}
// create index and add points
LASindex lasindex;
lasindex.prepare(lasquadtree, threshold);
while (lasreader->read_point()) lasindex.add(lasreader->point.get_x(), lasreader->point.get_y(), (U32)(lasreader->p_count-1));
// delete the reader
lasreader->close();
delete lasreader;
// adaptive coarsening
lasindex.complete(minimum_points, maximum_intervals);
// write to file
if (append)
{
lasindex.append(lasreadopener.get_file_name());
}
else
{
lasindex.write(lasreadopener.get_file_name());
}
if (verbose) fprintf(stderr,"done with '%s'. took %g sec.\n", lasreadopener.get_file_name(), taketime()-start_time);
}
if (verbose && lasreadopener.get_file_name_number() > 1)
{
fprintf(stderr,"done with %u files. total time %g sec.\n", lasreadopener.get_file_name_number(), taketime()-total_start_time);
}
byebye(false, argc==1);
return 0;
}
int main(int argc, char *argv[])
{
int i;
#ifdef COMPILE_WITH_GUI
bool gui = false;
#endif
#ifdef COMPILE_WITH_MULTI_CORE
I32 cores = 1;
#endif
bool verbose = false;
bool report_diff = true;
bool report_diff_diff = false;
bool report_x = true;
bool report_y = true;
bool report_z = true;
bool report_gps = false;
bool report_rgb = false;
bool output = false;
U32 report_lines = 20;
U32 array_max = 5000000;
bool projection_was_set = false;
double start_time = 0;
double full_start_time = 0;
LASreadOpener lasreadopener;
GeoProjectionConverter geoprojectionconverter;
LASwriteOpener laswriteopener;
if (argc == 1)
{
#ifdef COMPILE_WITH_GUI
return lasprecision_gui(argc, argv, 0);
#else
fprintf(stderr,"lasprecision.exe is better run in the command line\n");
char file_name[256];
fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.set_file_name(file_name);
fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
laswriteopener.set_file_name(file_name);
#endif
}
else
{
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '–') argv[i][0] = '-';
if (strcmp(argv[i],"-o") == 0 || strcmp(argv[i],"-olas") == 0 || strcmp(argv[i],"-olaz") == 0 || strcmp(argv[i],"-obin") == 0 || strcmp(argv[i],"-otxt") == 0 || strcmp(argv[i],"-reoffset") == 0 || strcmp(argv[i],"-rescale") == 0)
{
output = true;
break;
}
}
if (!geoprojectionconverter.parse(argc, argv)) byebye(true);
if (!lasreadopener.parse(argc, argv)) byebye(true);
if (!laswriteopener.parse(argc, argv)) byebye(true);
}
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '\0')
{
continue;
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
usage();
}
else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0)
{
verbose = true;
}
else if (strcmp(argv[i],"-version") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
byebye();
}
else if (strcmp(argv[i],"-gui") == 0)
{
#ifdef COMPILE_WITH_GUI
gui = true;
#else
fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n");
#endif
}
else if (strcmp(argv[i],"-cores") == 0)
{
#ifdef COMPILE_WITH_MULTI_CORE
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]);
usage(true);
}
argv[i][0] = '\0';
i++;
cores = atoi(argv[i]);
argv[i][0] = '\0';
#else
fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n");
i++;
#endif
}
else if ((strcmp(argv[i],"-diff_diff") == 0) || (strcmp(argv[i],"-diff_diff_only") == 0))
{
report_diff_diff = true;
report_diff = false;
}
else if (strcmp(argv[i],"-no_x") == 0)
{
report_x = false;
}
else if (strcmp(argv[i],"-no_y") == 0)
{
report_y = false;
}
else if (strcmp(argv[i],"-no_z") == 0)
{
report_z = false;
}
else if (strcmp(argv[i],"-gps") == 0)
{
report_gps = true;
}
else if (strcmp(argv[i],"-rgb") == 0)
{
report_rgb = true;
}
else if (strcmp(argv[i],"-number") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: max\n", argv[i]);
byebye(true);
}
i++;
array_max = atoi(argv[i]);
}
else if (strcmp(argv[i],"-lines") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]);
byebye(true);
}
i++;
report_lines = atoi(argv[i]);
}
else if (strcmp(argv[i],"-all") == 0)
{
array_max = U32_MAX;
}
else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0))
{
lasreadopener.add_file_name(argv[i]);
argv[i][0] = '\0';
}
else
{
fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]);
byebye(true);
}
}
#ifdef COMPILE_WITH_GUI
if (gui)
{
return lasprecision_gui(argc, argv, &lasreadopener);
}
#endif
#ifdef COMPILE_WITH_MULTI_CORE
if ((cores > 1) && (lasreadopener.get_file_name_number() > 1) && (!lasreadopener.is_merged()))
{
return lasprecision_multi_core(argc, argv, &geoprojectionconverter, &lasreadopener, &laswriteopener, cores);
}
#endif
// check input
if (!lasreadopener.active())
{
fprintf(stderr, "ERROR: no input specified\n");
byebye(true, argc==1);
}
// make sure we do not corrupt the input file
if (lasreadopener.get_file_name() && laswriteopener.get_file_name() && (strcmp(lasreadopener.get_file_name(), laswriteopener.get_file_name()) == 0))
{
fprintf(stderr, "ERROR: input and output file name are identical\n");
usage(true);
}
// check if projection info was set in the command line
int number_of_keys;
GeoProjectionGeoKeys* geo_keys = 0;
int num_geo_double_params;
double* geo_double_params = 0;
if (geoprojectionconverter.has_projection())
{
projection_was_set = geoprojectionconverter.get_geo_keys_from_projection(number_of_keys, &geo_keys, num_geo_double_params, &geo_double_params);
}
// possibly loop over multiple input files
while (lasreadopener.active())
{
if (verbose) full_start_time = start_time = taketime();
// open lasreader
LASreader* lasreader = lasreadopener.open();
if (lasreader == 0)
{
fprintf(stderr, "ERROR: could not open lasreader\n");
byebye(true, argc==1);
}
// run presicion statistics across the first array_max points
if (!output)
{
fprintf(stdout, "original scale factors: %g %g %g\n", lasreader->header.x_scale_factor, lasreader->header.y_scale_factor, lasreader->header.z_scale_factor);
// create the arrays
int* array_x = 0;
int* array_y = 0;
int* array_z = 0;
if (report_x)
{
array_x = new int[array_max];
}
if (report_y)
{
array_y = new int[array_max];
}
if (report_z)
{
array_z = new int[array_max];
}
double* array_gps = 0;
if (report_gps && lasreader->point.have_gps_time)
{
array_gps = new double[array_max];
}
short* array_r = 0;
short* array_g = 0;
short* array_b = 0;
if (report_rgb && lasreader->point.have_rgb)
{
array_r = new short[array_max];
array_g = new short[array_max];
array_b = new short[array_max];
}
// do the first pass
fprintf(stderr, "loading first %u of %u points\n", array_max, (U32)lasreader->npoints);
// loop over points
unsigned int array_count = 0;
while ((lasreader->read_point()) && (array_count < array_max))
{
if (report_x)
{
array_x[array_count] = lasreader->point.get_X();
}
if (report_y)
{
array_y[array_count] = lasreader->point.get_Y();
}
if (report_z)
{
array_z[array_count] = lasreader->point.get_Z();
}
if (report_gps && lasreader->point.have_gps_time)
{
array_gps[array_count] = lasreader->point.gps_time;
}
if (report_rgb && lasreader->point.have_rgb)
{
array_r[array_count] = lasreader->point.rgb[0];
array_g[array_count] = lasreader->point.rgb[1];
array_b[array_count] = lasreader->point.rgb[2];
}
array_count++;
}
array_max = array_count;
// sort values
if (report_x)
{
quicksort_for_ints(array_x, 0, array_max-1);
}
if (report_y)
{
quicksort_for_ints(array_y, 0, array_max-1);
}
if (report_z)
{
quicksort_for_ints(array_z, 0, array_max-1);
}
if (report_gps && lasreader->point.have_gps_time)
{
quicksort_for_doubles(array_gps, 0, array_max-1);
}
if (report_rgb && lasreader->point.have_rgb)
{
quicksort_for_shorts(array_r, 0, array_max-1);
quicksort_for_shorts(array_g, 0, array_max-1);
quicksort_for_shorts(array_b, 0, array_max-1);
}
// create differences
if (report_x)
{
for (array_count = 1; array_count < array_max; array_count++)
{
array_x[array_count-1] = array_x[array_count] - array_x[array_count-1];
}
}
if (report_y)
{
for (array_count = 1; array_count < array_max; array_count++)
{
array_y[array_count-1] = array_y[array_count] - array_y[array_count-1];
}
}
if (report_z)
{
for (array_count = 1; array_count < array_max; array_count++)
{
array_z[array_count-1] = array_z[array_count] - array_z[array_count-1];
}
}
if (report_gps && lasreader->point.have_gps_time)
{
for (array_count = 1; array_count < array_max; array_count++)
{
array_gps[array_count-1] = array_gps[array_count] - array_gps[array_count-1];
}
}
if (report_rgb && lasreader->point.have_rgb)
{
for (array_count = 1; array_count < array_max; array_count++)
{
array_r[array_count-1] = array_r[array_count] - array_r[array_count-1];
array_g[array_count-1] = array_g[array_count] - array_g[array_count-1];
array_b[array_count-1] = array_b[array_count] - array_b[array_count-1];
}
}
// sort differences
if (report_x)
{
quicksort_for_ints(array_x, 0, array_max-2);
}
if (report_y)
{
quicksort_for_ints(array_y, 0, array_max-2);
}
if (report_z)
{
quicksort_for_ints(array_z, 0, array_max-2);
}
if (report_gps && lasreader->point.have_gps_time)
{
quicksort_for_doubles(array_gps, 0, array_max-2);
}
if (report_rgb && lasreader->point.have_rgb)
{
quicksort_for_shorts(array_r, 0, array_max-2);
quicksort_for_shorts(array_g, 0, array_max-2);
quicksort_for_shorts(array_b, 0, array_max-2);
}
// compute difference of differences, sort them, output histogram
// first for X & Y & Z
unsigned int count_lines, array_last, array_first;
if (report_x)
{
if (report_diff) fprintf(stdout, "X differences \n");
for (count_lines = 0, array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++)
{
if (array_x[array_last] != array_x[array_count])
{
if (report_diff && (count_lines < report_lines)) { count_lines++; fprintf(stdout, " %10d : %10d %g\n", array_x[array_last], array_count - array_last, lasreader->header.x_scale_factor*array_x[array_last]); }
array_x[array_first] = array_x[array_count] - array_x[array_last];
array_last = array_count;
array_first++;
}
}
if (report_diff_diff)
{
fprintf(stdout, "X differences of differences\n");
quicksort_for_ints(array_x, 0, array_first-1);
for (array_last = 0, array_count = 1; array_count < array_first; array_count++)
{
if (array_x[array_last] != array_x[array_count])
{
fprintf(stdout, " %10d : %10d\n", array_x[array_last], array_count - array_last);
array_last = array_count;
}
}
}
}
if (report_y)
{
if (report_diff) fprintf(stdout, "Y differences \n");
for (count_lines = 0, array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++)
{
if (array_y[array_last] != array_y[array_count])
{
if (report_diff && (count_lines < report_lines)) { count_lines++; fprintf(stdout, " %10d : %10d %g\n", array_y[array_last], array_count - array_last, lasreader->header.y_scale_factor*array_y[array_last]); }
array_y[array_first] = array_y[array_count] - array_y[array_last];
array_last = array_count;
array_first++;
}
}
if (report_diff_diff)
{
fprintf(stdout, "Y differences of differences\n");
quicksort_for_ints(array_y, 0, array_first-1);
for (array_last = 0, array_count = 1; array_count < array_first; array_count++)
{
if (array_y[array_last] != array_y[array_count])
{
fprintf(stdout, " %10d : %10d\n", array_y[array_last], array_count - array_last);
array_last = array_count;
}
}
}
}
if (report_z)
{
if (report_diff) fprintf(stdout, "Z differences \n");
for (count_lines = 0, array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++)
{
if (array_z[array_last] != array_z[array_count])
{
if (report_diff && (count_lines < report_lines)) { count_lines++; fprintf(stdout, " %10d : %10d %g\n", array_z[array_last], array_count - array_last, lasreader->header.z_scale_factor*array_z[array_last]); }
array_z[array_first] = array_z[array_count] - array_z[array_last];
array_last = array_count;
array_first++;
}
}
if (report_diff_diff)
{
fprintf(stdout, "Z differences of differences\n");
quicksort_for_ints(array_z, 0, array_first-1);
for (array_last = 0, array_count = 1; array_count < array_first; array_count++)
{
if (array_z[array_last] != array_z[array_count])
{
fprintf(stdout, " %10d : %10d\n", array_z[array_last], array_count - array_last);
array_last = array_count;
}
}
}
}
// then for GPS
if (report_gps && lasreader->point.have_gps_time)
{
if (report_diff) fprintf(stdout, "GPS time differences \n");
for (array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++)
{
if (array_gps[array_last] != array_gps[array_count])
{
if (report_diff) fprintf(stdout, " %.10g : %10d\n", array_gps[array_last], array_count - array_last);
array_gps[array_first] = array_gps[array_count] - array_gps[array_last];
array_last = array_count;
array_first++;
}
}
if (report_diff_diff)
{
fprintf(stdout, "GPS time differences of differences\n");
quicksort_for_doubles(array_gps, 0, array_first-1);
for (array_last = 0, array_count = 1; array_count < array_first; array_count++)
{
if (array_gps[array_last] != array_gps[array_count])
{
fprintf(stdout, " %.10g : %10d\n", array_gps[array_last], array_count - array_last);
array_last = array_count;
}
}
}
}
// then for R & G & B
if (report_rgb && lasreader->point.have_rgb)
{
if (report_diff) fprintf(stdout, "R differences \n");
for (array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++)
{
if (array_r[array_last] != array_r[array_count])
{
if (report_diff) fprintf(stdout, " %10d : %10d\n", array_r[array_last], array_count - array_last);
array_r[array_first] = array_r[array_count] - array_r[array_last];
array_last = array_count;
array_first++;
}
}
if (report_diff_diff)
{
fprintf(stdout, "R differences of differences\n");
quicksort_for_shorts(array_r, 0, array_first-1);
for (array_last = 0, array_count = 1; array_count < array_first; array_count++)
{
if (array_r[array_last] != array_r[array_count])
{
fprintf(stdout, " %10d : %10d\n", array_r[array_last], array_count - array_last);
array_last = array_count;
}
}
}
if (report_diff) fprintf(stdout, "G differences \n");
for (array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++)
{
if (array_g[array_last] != array_g[array_count])
{
if (report_diff) fprintf(stdout, " %10d : %10d\n", array_g[array_last], array_count - array_last);
array_g[array_first] = array_g[array_count] - array_g[array_last];
array_last = array_count;
array_first++;
}
}
if (report_diff_diff)
{
fprintf(stdout, "G differences of differences\n");
quicksort_for_shorts(array_g, 0, array_first-1);
for (array_last = 0, array_count = 1; array_count < array_first; array_count++)
{
if (array_g[array_last] != array_g[array_count])
{
fprintf(stdout, " %10d : %10d\n", array_g[array_last], array_count - array_last);
array_last = array_count;
}
}
}
if (report_diff) fprintf(stdout, "B differences \n");
for (array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++)
{
if (array_b[array_last] != array_b[array_count])
{
if (report_diff) fprintf(stdout, " %10d : %10d\n", array_b[array_last], array_count - array_last);
array_b[array_first] = array_b[array_count] - array_b[array_last];
array_last = array_count;
array_first++;
}
}
if (report_diff_diff)
{
fprintf(stdout, "B differences of differences\n");
quicksort_for_shorts(array_b, 0, array_first-1);
for (array_last = 0, array_count = 1; array_count < array_first; array_count++)
{
if (array_b[array_last] != array_b[array_count])
{
fprintf(stdout, " %10d : %10d\n", array_b[array_last], array_count - array_last);
array_last = array_count;
}
}
}
}
if (array_x) delete [] array_x;
if (array_y) delete [] array_y;
if (array_z) delete [] array_z;
if (array_gps) delete [] array_gps;
if (array_r) delete [] array_r;
if (array_g) delete [] array_g;
if (array_b) delete [] array_b;
}
else
{
// check output
fprintf(stdout, "new scale factors: %g %g %g\n", lasreader->header.x_scale_factor, lasreader->header.y_scale_factor, lasreader->header.z_scale_factor);
// check output
if (!laswriteopener.active())
{
// create name from input name
laswriteopener.make_file_name(lasreadopener.get_file_name());
}
// prepare the header for the surviving points
strncpy(lasreader->header.system_identifier, "LAStools (c) by rapidlasso GmbH", 32);
lasreader->header.system_identifier[31] = '\0';
char temp[64];
sprintf(temp, "lasprecision (%d)", LAS_TOOLS_VERSION);
strncpy(lasreader->header.generating_software, temp, 32);
lasreader->header.generating_software[31] = '\0';
if (projection_was_set)
{
lasreader->header.set_geo_keys(number_of_keys, (LASvlr_key_entry*)geo_keys);
if (geo_double_params)
{
lasreader->header.set_geo_double_params(num_geo_double_params, geo_double_params);
}
else
{
lasreader->header.del_geo_double_params();
}
lasreader->header.del_geo_ascii_params();
}
// open laswriter
LASwriter* laswriter = laswriteopener.open(&lasreader->header);
if (laswriter == 0)
{
fprintf(stderr, "ERROR: could not open laswriter\n");
usage(argc==1);
}
// loop over points
while (lasreader->read_point())
{
laswriter->write_point(&lasreader->point);
laswriter->update_inventory(&lasreader->point);
}
laswriter->update_header(&lasreader->header, TRUE);
laswriter->close();
delete laswriter;
laswriteopener.set_file_name(0);
}
lasreader->close();
delete lasreader;
}
if (projection_was_set)
{
free(geo_keys);
if (geo_double_params)
{
free(geo_double_params);
}
}
byebye(false, argc==1);
return 0;
}
int main(int argc, char *argv[])
{
int i;
#ifdef COMPILE_WITH_GUI
bool gui = false;
#endif
bool verbose = false;
bool keep_lastiling = false;
U32 chopchop = 0;
bool projection_was_set = false;
double start_time = 0;
LASreadOpener lasreadopener;
GeoProjectionConverter geoprojectionconverter;
LASwriteOpener laswriteopener;
if (argc == 1)
{
#ifdef COMPILE_WITH_GUI
return lasmerge_gui(argc, argv, 0);
#else
fprintf(stderr,"%s is better run in the command line\n", argv[0]);
char file_name[256];
fprintf(stderr,"enter input file 1: ");
fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.add_file_name(file_name);
fprintf(stderr,"enter input file 2: ");
fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.add_file_name(file_name);
fprintf(stderr,"enter output file: ");
fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
laswriteopener.set_file_name(file_name);
#endif
}
else
{
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '–') argv[i][0] = '-';
}
if (!geoprojectionconverter.parse(argc, argv)) byebye(true);
if (!lasreadopener.parse(argc, argv)) byebye(true);
if (!laswriteopener.parse(argc, argv)) byebye(true);
}
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '\0')
{
continue;
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
usage();
}
else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0)
{
verbose = true;
}
else if (strcmp(argv[i],"-version") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
byebye();
}
else if (strcmp(argv[i],"-gui") == 0)
{
#ifdef COMPILE_WITH_GUI
gui = true;
#else
fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n");
#endif
}
else if (strcmp(argv[i],"-split") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: size\n", argv[i]);
byebye(true);
}
i++;
chopchop = atoi(argv[i]);
}
else if (strcmp(argv[i],"-keep_lastiling") == 0)
{
keep_lastiling = true;
}
else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0))
{
lasreadopener.add_file_name(argv[i]);
argv[i][0] = '\0';
}
else
{
fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]);
byebye(true);
}
}
#ifdef COMPILE_WITH_GUI
if (gui)
{
return lasmerge_gui(argc, argv, &lasreadopener);
}
#endif
// read all the input files merged
lasreadopener.set_merged(TRUE);
// maybe we want to keep the lastiling
if (keep_lastiling)
{
lasreadopener.set_keep_lastiling(TRUE);
}
// we need to precompute the bounding box
lasreadopener.set_populate_header(TRUE);
// check input and output
if (!lasreadopener.active())
{
fprintf(stderr, "ERROR: no input specified\n");
byebye(true, argc==1);
}
if (!laswriteopener.active())
{
fprintf(stderr, "ERROR: no output specified\n");
byebye(true, argc==1);
}
// make sure we do not corrupt the input file
if (lasreadopener.get_file_name() && laswriteopener.get_file_name() && (strcmp(lasreadopener.get_file_name(), laswriteopener.get_file_name()) == 0))
{
fprintf(stderr, "ERROR: input and output file name are identical\n");
usage(true);
}
// check if projection info was set in the command line
int number_of_keys;
GeoProjectionGeoKeys* geo_keys = 0;
int num_geo_double_params;
double* geo_double_params = 0;
if (geoprojectionconverter.has_projection())
{
projection_was_set = geoprojectionconverter.get_geo_keys_from_projection(number_of_keys, &geo_keys, num_geo_double_params, &geo_double_params);
}
if (verbose) start_time = taketime();
LASreader* lasreader = lasreadopener.open();
if (lasreader == 0)
{
fprintf(stderr, "ERROR: could not open lasreader\n");
byebye(true, argc==1);
}
#ifdef _WIN32
if (verbose) {
fprintf(stderr,"merging headers took %g sec. there are %I64d points in total.\n", taketime()-start_time, lasreader->npoints);
start_time = taketime();
}
#else
if (verbose) {
fprintf(stderr,"merging headers took %g sec. there are %lld points in total.\n", taketime()-start_time, lasreader->npoints);
start_time = taketime();
}
#endif
// prepare the header for the surviving points
strncpy(lasreader->header.system_identifier, "LAStools (c) by rapidlasso GmbH", 32);
lasreader->header.system_identifier[31] = '\0';
char temp[64];
sprintf(temp, "lasmerge (version %d)", LAS_TOOLS_VERSION);
strncpy(lasreader->header.generating_software, temp, 32);
lasreader->header.generating_software[31] = '\0';
if (projection_was_set)
{
lasreader->header.set_geo_keys(number_of_keys, (LASvlr_key_entry*)geo_keys);
free(geo_keys);
if (geo_double_params)
{
lasreader->header.set_geo_double_params(num_geo_double_params, geo_double_params);
free(geo_double_params);
}
else
{
lasreader->header.del_geo_double_params();
}
lasreader->header.del_geo_ascii_params();
}
if (chopchop)
{
I32 file_number = 0;
LASwriter* laswriter = 0;
// loop over the points
while (lasreader->read_point())
{
if (laswriter == 0)
{
// open the next writer
laswriteopener.make_file_name(0, file_number);
file_number++;
laswriter = laswriteopener.open(&lasreader->header);
}
laswriter->write_point(&lasreader->point);
laswriter->update_inventory(&lasreader->point);
if (laswriter->p_count == chopchop)
{
// close the current writer
laswriter->update_header(&lasreader->header, TRUE);
laswriter->close();
if (verbose) {
fprintf(stderr,"splitting file '%s' took %g sec.\n", laswriteopener.get_file_name(), taketime()-start_time);
start_time = taketime();
}
delete laswriter;
laswriter = 0;
}
}
if (laswriter && laswriter->p_count)
{
// close the current writer
laswriter->update_header(&lasreader->header, TRUE);
laswriter->close();
if (verbose) {
fprintf(stderr,"splitting file '%s' took %g sec.\n", laswriteopener.get_file_name(), taketime()-start_time);
start_time = taketime();
}
delete laswriter;
laswriter = 0;
}
}
else
{
// open the writer
LASwriter* laswriter = laswriteopener.open(&lasreader->header);
if (laswriter == 0)
{
fprintf(stderr, "ERROR: could not open laswriter\n");
byebye(true, argc==1);
}
// loop over the points
while (lasreader->read_point())
{
laswriter->write_point(&lasreader->point);
laswriter->update_inventory(&lasreader->point);
}
// close the writer
laswriter->update_header(&lasreader->header, TRUE);
laswriter->close();
if (verbose) fprintf(stderr,"merging files took %g sec.\n", taketime()-start_time);
delete laswriter;
}
lasreader->close();
delete lasreader;
byebye(false, argc==1);
return 0;
}
int main(int argc, char *argv[])
{
int i,j;
#ifdef COMPILE_WITH_GUI
bool gui = false;
#endif
bool verbose = false;
int shutup = 5;
int random_seeks = 0;
double start_time = 0.0;
LASreadOpener lasreadopener;
LASwriteOpener laswriteopener;
if (argc == 1)
{
#ifdef COMPILE_WITH_GUI
return lasdiff_gui(argc, argv, 0);
#else
char file_name[256];
fprintf(stderr,"lasdiff.exe is better run in the command line\n");
fprintf(stderr,"enter input file1: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.set_file_name(file_name);
fprintf(stderr,"enter input file2: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.set_file_name(file_name);
#endif
}
else
{
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '–') argv[i][0] = '-';
}
if (!lasreadopener.parse(argc, argv)) byebye(true);
if (!laswriteopener.parse(argc, argv)) byebye(true);
}
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '\0')
{
continue;
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
usage();
}
else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0)
{
verbose = true;
}
else if (strcmp(argv[i],"-version") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
byebye();
}
else if (strcmp(argv[i],"-gui") == 0)
{
#ifdef COMPILE_WITH_GUI
gui = true;
#else
fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n");
#endif
}
else if (strcmp(argv[i],"-random_seeks") == 0)
{
random_seeks = 10;
}
else if (strcmp(argv[i],"-shutup") == 0)
{
i++;
shutup = atoi(argv[i]);;
}
else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0))
{
lasreadopener.add_file_name(argv[i]);
argv[i][0] = '\0';
}
else
{
fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]);
byebye(true);
}
}
#ifdef COMPILE_WITH_GUI
if (gui)
{
return lasdiff_gui(argc, argv, &lasreadopener);
}
#endif
if (!lasreadopener.active())
{
fprintf (stderr, "ERROR: no input specified\n");
byebye(true, argc==1);
}
int seeking;
char* file_name1;
char* file_name2;
LASreader* lasreader1;
LASreader* lasreader2;
LASwriter* laswriter = 0;
// possibly loop over multiple input files
while (lasreadopener.active())
{
start_time = taketime();
seeking = random_seeks;
if (lasreadopener.get_file_name_number() == 2)
{
lasreader1 = lasreadopener.open();
file_name1 = strdup(lasreadopener.get_file_name());
if (lasreader1 == 0)
{
fprintf (stderr, "ERROR: cannot open '%s'\n", file_name1);
byebye(true, argc==1);
}
lasreader2 = lasreadopener.open();
file_name2 = strdup(lasreadopener.get_file_name());
if (lasreader2 == 0)
{
fprintf (stderr, "ERROR: cannot open '%s'\n", file_name2);
byebye(true, argc==1);
}
}
else
{
lasreader1 = lasreadopener.open();
file_name1 = strdup(lasreadopener.get_file_name());
if (lasreader1 == 0)
{
fprintf (stderr, "ERROR: cannot open '%s'\n", file_name1);
byebye(true, argc==1);
}
file_name2 = strdup(lasreadopener.get_file_name());
int len = strlen(file_name1);
if (strncmp(&file_name1[len-4], ".las", 4) == 0)
{
file_name2[len-1] = 'z';
}
else if (strncmp(&file_name1[len-4], ".laz", 4) == 0)
{
file_name2[len-1] = 's';
}
else if (strncmp(&file_name1[len-4], ".LAS", 4) == 0)
{
file_name2[len-1] = 'Z';
}
else if (strncmp(&file_name1[len-4], ".LAZ", 4) == 0)
{
file_name2[len-1] = 'S';
}
else
{
fprintf (stderr, "ERROR: file '%s' not ending in *.las or *.laz\n", file_name1);
byebye(true, argc==1);
}
LASreadOpener lasreadopener_other;
lasreadopener_other.set_file_name(file_name2);
lasreader2 = lasreadopener_other.open();
if (lasreader2 == 0)
{
fprintf (stderr, "ERROR: cannot open '%s'\n", file_name2);
byebye(true, argc==1);
}
}
fprintf(stderr, "checking '%s' against '%s'\n", file_name1, file_name2);
// check header
int different_header = 0;
bool scaled_offset_difference = false;
int memcmp_until = (int)(((const char*)&(lasreader1->header.user_data_in_header_size))-((const char*)&(lasreader1->header)));
if (memcmp((const void*)&(lasreader1->header), (const void*)&(lasreader2->header), memcmp_until))
{
char printstring[128];
fprintf(stderr, "headers are different\n");
LASheader* lasheader1 = &(lasreader1->header);
LASheader* lasheader2 = &(lasreader2->header);
bool fatal_difference = false;
if (strncmp(lasheader1->file_signature, lasheader2->file_signature, 4))
{
fprintf(stderr, " different file_signature: '%4s' '%4s'\n", lasheader1->file_signature, lasheader2->file_signature);
different_header++;
}
if (lasheader1->file_source_id != lasheader2->file_source_id)
{
fprintf(stderr, " different file_source_id: %d %d\n", lasheader1->file_source_id, lasheader2->file_source_id);
different_header++;
}
if (lasheader1->global_encoding != lasheader2->global_encoding)
{
fprintf(stderr, " different reserved (global_encoding): %d %d\n", lasheader1->global_encoding, lasheader2->global_encoding);
different_header++;
}
if (lasheader1->project_ID_GUID_data_1 != lasheader2->project_ID_GUID_data_1)
{
fprintf(stderr, " different project_ID_GUID_data_1: %d %d\n", lasheader1->project_ID_GUID_data_1, lasheader2->project_ID_GUID_data_1);
different_header++;
}
if (lasheader1->project_ID_GUID_data_2 != lasheader2->project_ID_GUID_data_2)
{
fprintf(stderr, " different project_ID_GUID_data_2: %d %d\n", lasheader1->project_ID_GUID_data_2, lasheader2->project_ID_GUID_data_2);
different_header++;
}
if (lasheader1->project_ID_GUID_data_3 != lasheader2->project_ID_GUID_data_3)
{
fprintf(stderr, " different project_ID_GUID_data_3: %d %d\n", lasheader1->project_ID_GUID_data_3, lasheader2->project_ID_GUID_data_3);
different_header++;
}
if (strncmp((const char*)lasheader1->project_ID_GUID_data_4, (const char*)lasheader2->project_ID_GUID_data_4, 8))
{
fprintf(stderr, " different project_ID_GUID_data_4: '%.8s' '%.8s'\n", lasheader1->project_ID_GUID_data_4, lasheader2->project_ID_GUID_data_4);
different_header++;
}
if (lasheader1->version_major != lasheader2->version_major || lasheader1->version_minor != lasheader2->version_minor)
{
fprintf(stderr, " different version: %d.%d %d.%d\n", lasheader1->version_major, lasheader1->version_minor, lasheader2->version_major, lasheader2->version_minor);
different_header++;
}
if (strncmp(lasheader1->system_identifier, lasheader2->system_identifier, 32))
{
fprintf(stderr, " different system_identifier: '%.32s' '%.32s'\n", lasheader1->system_identifier, lasheader2->system_identifier);
different_header++;
}
if (strncmp(lasheader1->generating_software, lasheader2->generating_software, 32))
{
fprintf(stderr, " different generating_software: '%.32s' '%.32s'\n", lasheader1->generating_software, lasheader2->generating_software);
different_header++;
}
if (lasheader1->file_creation_day != lasheader2->file_creation_day || lasheader1->file_creation_year != lasheader2->file_creation_year)
{
fprintf(stderr, " different file_creation day.year: %d.%d %d.%d\n", lasheader1->file_creation_day, lasheader1->file_creation_year, lasheader2->file_creation_day, lasheader2->file_creation_year);
different_header++;
}
if (lasheader1->header_size != lasheader2->header_size)
{
fprintf(stderr, " different header_size: %d %d\n", lasheader1->header_size, lasheader2->header_size);
fatal_difference = true;
}
if (lasheader1->offset_to_point_data != lasheader2->offset_to_point_data)
{
fprintf(stderr, " different offset_to_point_data: %d %d\n", lasheader1->offset_to_point_data, lasheader2->offset_to_point_data);
different_header++;
}
if (lasheader1->number_of_variable_length_records != lasheader2->number_of_variable_length_records)
{
fprintf(stderr, " different number_of_variable_length_records: %d %d\n", lasheader1->number_of_variable_length_records, lasheader2->number_of_variable_length_records);
different_header++;
}
if (lasheader1->point_data_format != lasheader2->point_data_format)
{
fprintf(stderr, " different point_data_format: %d %d\n", lasheader1->point_data_format, lasheader2->point_data_format);
}
if (lasheader1->point_data_record_length != lasheader2->point_data_record_length)
{
fprintf(stderr, " different point_data_record_length: %d %d\n", lasheader1->point_data_record_length, lasheader2->point_data_record_length);
different_header++;
}
if (lasheader1->number_of_point_records != lasheader2->number_of_point_records)
{
fprintf(stderr, " different number_of_point_records: %d %d\n", lasheader1->number_of_point_records, lasheader2->number_of_point_records);
different_header++;
}
if (lasheader1->number_of_points_by_return[0] != lasheader2->number_of_points_by_return[0] || lasheader1->number_of_points_by_return[1] != lasheader2->number_of_points_by_return[1] || lasheader1->number_of_points_by_return[2] != lasheader2->number_of_points_by_return[2] || lasheader1->number_of_points_by_return[3] != lasheader2->number_of_points_by_return[3] || lasheader1->number_of_points_by_return[4] != lasheader2->number_of_points_by_return[4])
{
fprintf(stderr, " different number_of_points_by_return: (%d,%d,%d,%d,%d) (%d,%d,%d,%d,%d)\n", lasheader1->number_of_points_by_return[0], lasheader1->number_of_points_by_return[1], lasheader1->number_of_points_by_return[2], lasheader1->number_of_points_by_return[3], lasheader1->number_of_points_by_return[4], lasheader2->number_of_points_by_return[0], lasheader2->number_of_points_by_return[1], lasheader2->number_of_points_by_return[2], lasheader2->number_of_points_by_return[3], lasheader2->number_of_points_by_return[4]);
different_header++;
}
if (lasheader1->x_scale_factor != lasheader2->x_scale_factor)
{
lidardouble2string(printstring, lasheader1->x_scale_factor, lasheader2->x_scale_factor); fprintf(stderr, " WARNING: different x_scale_factor: %s\n", printstring);
scaled_offset_difference = true;
different_header++;
}
if (lasheader1->y_scale_factor != lasheader2->y_scale_factor)
{
lidardouble2string(printstring, lasheader1->y_scale_factor, lasheader2->y_scale_factor); fprintf(stderr, " WARNING: different y_scale_factor: %s\n", printstring);
scaled_offset_difference = true;
different_header++;
}
if (lasheader1->z_scale_factor != lasheader2->z_scale_factor)
{
lidardouble2string(printstring, lasheader1->z_scale_factor, lasheader2->z_scale_factor); fprintf(stderr, " WARNING: different z_scale_factor: %s\n", printstring);
scaled_offset_difference = true;
different_header++;
}
if (lasheader1->x_offset != lasheader2->x_offset)
{
lidardouble2string(printstring, lasheader1->x_offset, lasheader2->x_offset); fprintf(stderr, " WARNING: different x_offset: %s\n", printstring);
scaled_offset_difference = true;
}
if (lasheader1->y_offset != lasheader2->y_offset)
{
lidardouble2string(printstring, lasheader1->y_offset, lasheader2->y_offset); fprintf(stderr, " WARNING: different y_offset: %s\n", printstring);
scaled_offset_difference = true;
}
if (lasheader1->z_offset != lasheader2->z_offset)
{
lidardouble2string(printstring, lasheader1->z_offset, lasheader2->z_offset); fprintf(stderr, " WARNING: different z_offset: %s\n", printstring);
scaled_offset_difference = true;
}
if (lasheader1->max_x != lasheader2->max_x)
{
lidardouble2string(printstring, lasheader1->max_x, lasheader2->max_x); fprintf(stderr, " different max_x: %s\n", printstring);
different_header++;
}
if (lasheader1->min_x != lasheader2->min_x)
{
lidardouble2string(printstring, lasheader1->min_x, lasheader2->min_x); fprintf(stderr, " different min_x: %s\n", printstring);
different_header++;
}
if (lasheader1->max_y != lasheader2->max_y)
{
lidardouble2string(printstring, lasheader1->max_y, lasheader2->max_y); fprintf(stderr, " different max_y: %s\n", printstring);
different_header++;
}
if (lasheader1->min_y != lasheader2->min_y)
{
lidardouble2string(printstring, lasheader1->min_y, lasheader2->min_y); fprintf(stderr, " different min_y: %s\n", printstring);
different_header++;
}
if (lasheader1->max_z != lasheader2->max_z)
{
lidardouble2string(printstring, lasheader1->max_z, lasheader2->max_z); fprintf(stderr, " different max_z: %s\n", printstring);
different_header++;
}
if (lasheader1->min_z != lasheader2->min_z)
{
lidardouble2string(printstring, lasheader1->min_z, lasheader2->min_z); fprintf(stderr, " different min_z: %s\n", printstring);
different_header++;
}
if (lasheader1->start_of_waveform_data_packet_record != lasheader2->start_of_waveform_data_packet_record)
{
fprintf(stderr, " different start_of_waveform_data_packet_record: %d %d\n", (I32)lasheader1->start_of_waveform_data_packet_record, (I32)lasheader2->start_of_waveform_data_packet_record);
different_header++;
}
if (fatal_difference)
{
fprintf(stderr, "difference was fatal ... no need to check points\n");
byebye(false, argc==1);
}
}
// check user-defined data in header
if (lasreader1->header.user_data_in_header_size == lasreader2->header.user_data_in_header_size)
{
for (i = 0; i < (I32)lasreader1->header.user_data_in_header_size; i++)
{
if (lasreader1->header.user_data_in_header[i] != lasreader2->header.user_data_in_header[i])
{
different_header++;
fprintf(stderr, "user-defined data in header is different at byte %d of %d\n", i, lasreader1->header.user_data_in_header_size);
break;
}
}
}
else
{
different_header++;
fprintf(stderr, "skipping check of user-defined data in header due to length difference (%d != %d)\n", lasreader1->header.user_data_in_header_size, lasreader2->header.user_data_in_header_size);
}
// check variable length headers
if (lasreader1->header.number_of_variable_length_records == lasreader2->header.number_of_variable_length_records)
{
for (i = 0; i < (int)lasreader1->header.number_of_variable_length_records; i++)
{
if (lasreader1->header.vlrs[i].reserved != lasreader2->header.vlrs[i].reserved)
{
fprintf(stderr, "variable length record %d reserved field is different: %d %d\n", i, lasreader1->header.vlrs[i].reserved, lasreader2->header.vlrs[i].reserved);
}
if (memcmp(lasreader1->header.vlrs[i].user_id, lasreader2->header.vlrs[i].user_id, 16) != 0)
{
fprintf(stderr, "variable length record %d user_id field is different: '%s' '%s'\n", i, lasreader1->header.vlrs[i].user_id, lasreader2->header.vlrs[i].user_id);
}
if (lasreader1->header.vlrs[i].record_id != lasreader2->header.vlrs[i].record_id)
{
fprintf(stderr, "variable length record %d record_id field is different: %d %d\n", i, lasreader1->header.vlrs[i].record_id, lasreader2->header.vlrs[i].record_id);
}
if (lasreader1->header.vlrs[i].record_length_after_header != lasreader2->header.vlrs[i].record_length_after_header)
{
fprintf(stderr, "variable length record %d record_length_after_header field is different: %d %d\n", i, lasreader1->header.vlrs[i].record_length_after_header, lasreader2->header.vlrs[i].record_length_after_header);
}
if (memcmp(lasreader1->header.vlrs[i].description, lasreader2->header.vlrs[i].description, 32) != 0)
{
fprintf(stderr, "variable length record %d description field is different: '%s' '%s'\n", i, lasreader1->header.vlrs[i].description, lasreader2->header.vlrs[i].description);
}
if (memcmp(lasreader1->header.vlrs[i].data, lasreader2->header.vlrs[i].data, lasreader1->header.vlrs[i].record_length_after_header))
{
for (j = 0; j < lasreader1->header.vlrs[i].record_length_after_header; j++)
{
if (lasreader1->header.vlrs[i].data[j] != lasreader2->header.vlrs[i].data[j])
{
different_header++;
fprintf(stderr, "variable length record %d data field is different at byte %d: %d %d\n", i, j, lasreader1->header.vlrs[i].data[j], lasreader2->header.vlrs[i].data[j]);
break;
}
}
}
}
}
else
{
fprintf(stderr, "skipping check of variable length records due to different number (%d != %d)\n", lasreader1->header.number_of_variable_length_records, lasreader2->header.number_of_variable_length_records);
}
// check user-defined data after header
if (lasreader1->header.user_data_after_header_size == lasreader2->header.user_data_after_header_size)
{
for (i = 0; i < (I32)lasreader1->header.user_data_after_header_size; i++)
{
if (lasreader1->header.user_data_after_header[i] != lasreader2->header.user_data_after_header[i])
{
different_header++;
fprintf(stderr, "user-defined data after header is different at byte %d of %d\n", i, lasreader1->header.user_data_in_header_size);
break;
}
}
}
else
{
different_header++;
fprintf(stderr, "skipping check of user-defined data in header due to length difference (%d != %d)\n", lasreader1->header.user_data_after_header_size, lasreader2->header.user_data_after_header_size);
}
if (different_header)
fprintf(stderr, "headers have %d differences.\n", different_header);
else
fprintf(stderr, "headers are identical.\n");
// maybe we should create a difference file
if (laswriteopener.active() || laswriteopener.get_directory() || laswriteopener.get_appendix())
{
if (!laswriteopener.active())
{
laswriteopener.make_file_name(lasreadopener.get_file_name());
}
// prepare the header
memset(lasreader1->header.system_identifier, 0, 32);
memset(lasreader1->header.generating_software, 0, 32);
sprintf(lasreader1->header.system_identifier, "LAStools (c) by Martin Isenburg");
sprintf(lasreader1->header.generating_software, "lasdiff (version %d)", LAS_TOOLS_VERSION);
laswriter = laswriteopener.open(&lasreader1->header);
if (laswriter == 0)
{
fprintf (stderr, "ERROR: cannot open '%s'\n", laswriteopener.get_file_name());
byebye(true, argc==1);
}
laswriteopener.set_file_name(0);
}
// check points
int different_points = 0;
int different_scaled_offset_coordinates = 0;
double diff;
double max_diff_x = 0.0;
double max_diff_y = 0.0;
double max_diff_z = 0.0;
while (true)
{
bool difference = false;
if (seeking)
{
if (lasreader1->p_count%100000 == 25000)
{
I64 s = (rand()*rand())%lasreader1->npoints;
fprintf(stderr, "at p_count %u seeking to %u\n", (U32)lasreader1->p_count, (U32)s);
lasreader1->seek(s);
lasreader2->seek(s);
seeking--;
}
}
if (lasreader1->read_point())
{
if (lasreader2->read_point())
{
if (memcmp((const void*)&(lasreader1->point), (const void*)&(lasreader2->point), 20))
{
if (scaled_offset_difference)
{
if (lasreader1->get_x() != lasreader2->get_x())
{
diff = lasreader1->get_x() - lasreader2->get_x();
if (diff < 0) diff = -diff;
if (diff > max_diff_x) max_diff_x = diff;
if (different_scaled_offset_coordinates < 9) fprintf(stderr, " x: %d %d scaled offset x %g %g\n", lasreader1->point.x, lasreader2->point.x, lasreader1->get_x(), lasreader2->get_x());
different_scaled_offset_coordinates++;
}
if (lasreader1->get_y() != lasreader2->get_y())
{
diff = lasreader1->get_y() - lasreader2->get_y();
if (diff < 0) diff = -diff;
if (diff > max_diff_y) max_diff_y = diff;
if (different_scaled_offset_coordinates < 9) fprintf(stderr, " y: %d %d scaled offset y %g %g\n", lasreader1->point.y, lasreader2->point.y, lasreader1->get_y(), lasreader2->get_y());
different_scaled_offset_coordinates++;
}
if (lasreader1->get_z() != lasreader2->get_z())
{
diff = lasreader1->get_z() - lasreader2->get_z();
if (diff < 0) diff = -diff;
if (diff > max_diff_z)
{
max_diff_z = diff;
if (max_diff_z > 0.001)
{
max_diff_z = diff;
}
}
if (different_scaled_offset_coordinates < 9) fprintf(stderr, " z: %d %d scaled offset z %g %g\n", lasreader1->point.z, lasreader2->point.z, lasreader1->get_z(), lasreader2->get_z());
different_scaled_offset_coordinates++;
}
}
else
{
if (lasreader1->point.x != lasreader2->point.x)
{
if (different_points < shutup) fprintf(stderr, " x: %d %d\n", lasreader1->point.x, lasreader2->point.x);
difference = true;
}
if (lasreader1->point.y != lasreader2->point.y)
{
if (different_points < shutup) fprintf(stderr, " y: %d %d\n", lasreader1->point.y, lasreader2->point.y);
difference = true;
}
if (lasreader1->point.z != lasreader2->point.z)
{
if (different_points < shutup) fprintf(stderr, " z: %d %d\n", lasreader1->point.z, lasreader2->point.z);
difference = true;
}
}
if (lasreader1->point.intensity != lasreader2->point.intensity)
{
if (different_points < shutup) fprintf(stderr, " intensity: %d %d\n", lasreader1->point.intensity, lasreader2->point.intensity);
difference = true;
}
if (lasreader1->point.return_number != lasreader2->point.return_number)
{
if (different_points < shutup) fprintf(stderr, " return_number: %d %d\n", lasreader1->point.return_number, lasreader2->point.return_number);
difference = true;
}
if (lasreader1->point.number_of_returns_of_given_pulse != lasreader2->point.number_of_returns_of_given_pulse)
{
if (different_points < shutup) fprintf(stderr, " number_of_returns_of_given_pulse: %d %d\n", lasreader1->point.number_of_returns_of_given_pulse, lasreader2->point.number_of_returns_of_given_pulse);
difference = true;
}
if (lasreader1->point.scan_direction_flag != lasreader2->point.scan_direction_flag)
{
if (different_points < shutup) fprintf(stderr, " scan_direction_flag: %d %d\n", lasreader1->point.scan_direction_flag, lasreader2->point.scan_direction_flag);
difference = true;
}
if (lasreader1->point.edge_of_flight_line != lasreader2->point.edge_of_flight_line)
{
if (different_points < shutup) fprintf(stderr, " edge_of_flight_line: %d %d\n", lasreader1->point.edge_of_flight_line, lasreader2->point.edge_of_flight_line);
difference = true;
}
if (lasreader1->point.classification != lasreader2->point.classification)
{
if (different_points < shutup) fprintf(stderr, " classification: %d %d\n", lasreader1->point.classification, lasreader2->point.classification);
difference = true;
}
if (lasreader1->point.scan_angle_rank != lasreader2->point.scan_angle_rank)
{
if (different_points < shutup) fprintf(stderr, " scan_angle_rank: %d %d\n", lasreader1->point.scan_angle_rank, lasreader2->point.scan_angle_rank);
difference = true;
}
if (lasreader1->point.user_data != lasreader2->point.user_data)
{
if (different_points < shutup) fprintf(stderr, " user_data: %d %d\n", lasreader1->point.user_data, lasreader2->point.user_data);
difference = true;
}
if (lasreader1->point.point_source_ID != lasreader2->point.point_source_ID)
{
if (different_points < shutup) fprintf(stderr, " point_source_ID: %d %d\n", lasreader1->point.point_source_ID, lasreader2->point.point_source_ID);
difference = true;
}
if (difference) if (different_points < shutup) fprintf(stderr, "point %u of %u is different\n", (U32)lasreader1->p_count, (U32)lasreader1->npoints);
}
if (lasreader1->point.have_gps_time)
{
if (lasreader1->point.gps_time != lasreader2->point.gps_time)
{
if (different_points < shutup) fprintf(stderr, "gps time of point %u of %u is different: %f != %f\n", (U32)lasreader1->p_count, (U32)lasreader1->npoints, lasreader1->point.gps_time, lasreader2->point.gps_time);
difference = true;
}
}
if (lasreader1->point.have_rgb)
{
if (memcmp((const void*)&(lasreader1->point.rgb), (const void*)&(lasreader2->point.rgb), sizeof(short[3])))
{
if (different_points < shutup) fprintf(stderr, "rgb of point %u of %u is different: (%d %d %d) != (%d %d %d)\n", (U32)lasreader1->p_count, (U32)lasreader1->npoints, lasreader1->point.rgb[0], lasreader1->point.rgb[1], lasreader1->point.rgb[2], lasreader2->point.rgb[0], lasreader2->point.rgb[1], lasreader2->point.rgb[2]);
difference = true;
}
}
if (lasreader1->point.have_wavepacket)
{
if (memcmp((const void*)&(lasreader1->point.wavepacket), (const void*)&(lasreader2->point.wavepacket), sizeof(LASwavepacket)))
{
if (different_points < shutup) fprintf(stderr, "wavepacket of point %u of %u is different: (%d %d %d %g %g %g %g) != (%d %d %d %g %g %g %g)\n", (U32)lasreader1->p_count, (U32)lasreader1->npoints, lasreader1->point.wavepacket.getIndex(), (I32)lasreader1->point.wavepacket.getOffset(), lasreader1->point.wavepacket.getSize(), lasreader1->point.wavepacket.getLocation(), lasreader1->point.wavepacket.getXt(), lasreader1->point.wavepacket.getYt(), lasreader1->point.wavepacket.getZt(), lasreader2->point.wavepacket.getIndex(), (I32)lasreader2->point.wavepacket.getOffset(), lasreader2->point.wavepacket.getSize(), lasreader2->point.wavepacket.getLocation(), lasreader2->point.wavepacket.getXt(), lasreader2->point.wavepacket.getYt(), lasreader2->point.wavepacket.getZt());
difference = true;
}
}
}
else
{
fprintf(stderr, "%s (%u) has fewer points than %s (%u)\n", file_name1, (U32)lasreader2->p_count, file_name2, (U32)lasreader1->p_count);
break;
}
}
else
{
if (lasreader2->read_point())
{
fprintf(stderr, "%s (%u) has more points than %s (%u)\n", file_name1, (U32)lasreader2->p_count, file_name2, (U32)lasreader1->p_count);
break;
}
else
{
break;
}
}
if (difference)
{
different_points++;
if (different_points == shutup) fprintf(stderr, "more than %d points are different ... shutting up.\n", shutup);
}
if (laswriter)
{
lasreader1->point.set_z(lasreader1->point.get_z()-lasreader2->point.get_z());
laswriter->write_point(&lasreader1->point);
laswriter->update_inventory(&lasreader1->point);
}
}
if (laswriter)
{
laswriter->update_header(&lasreader1->header, TRUE);
laswriter->close();
delete laswriter;
laswriter = 0;
laswriteopener.set_file_name(0);
}
if (scaled_offset_difference)
{
if (different_scaled_offset_coordinates)
{
fprintf(stderr, "scaled offset points are different (max diff: %g %g %g).\n", max_diff_x, max_diff_y, max_diff_z);
}
else
{
fprintf(stderr, "scaled offset points are identical.\n");
}
}
else
{
if (different_points)
{
fprintf(stderr, "%u points are different.\n", different_points);
}
else
{
fprintf(stderr, "raw points are identical.\n");
}
}
if (!different_header && !different_points && !different_scaled_offset_coordinates) fprintf(stderr, "files are identical. ");
#ifdef _WIN32
fprintf(stderr, "both have %I64d points. took %g secs.\n", lasreader1->p_count, taketime()-start_time);
#else
fprintf(stderr, "both have %lld points. took %g secs.\n", lasreader1->p_count, taketime()-start_time);
#endif
lasreader1->close();
delete lasreader1;
free(file_name1);
lasreader2->close();
delete lasreader2;
free(file_name2);
}
byebye(false, argc==1);
return 0;
}
int main(int argc, char *argv[])
{
int i;
#ifdef COMPILE_WITH_GUI
bool gui = false;
#endif
#ifdef COMPILE_WITH_MULTI_CORE
I32 cores = 1;
#endif
bool diff = false;
bool verbose = false;
CHAR separator_sign = ' ';
CHAR* separator = "space";
bool opts = false;
bool optx = false;
CHAR header_comment_sign = '\0';
CHAR* parse_string = 0;
CHAR* extra_string = 0;
CHAR printstring[512];
double start_time = 0.0;
LASreadOpener lasreadopener;
LASwriteOpener laswriteopener;
laswriteopener.set_format("txt");
if (argc == 1)
{
#ifdef COMPILE_WITH_GUI
return las2txt_gui(argc, argv, 0);
#else
fprintf(stderr,"las2txt.exe is better run in the command line or via the lastool.exe GUI\n");
CHAR file_name[256];
fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.set_file_name(file_name);
fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
laswriteopener.set_file_name(file_name);
#endif
}
else
{
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '–') argv[i][0] = '-';
if (strcmp(argv[i],"-opts") == 0)
{
opts = TRUE;
*argv[i]='\0';
}
else if (strcmp(argv[i],"-optx") == 0)
{
optx = TRUE;
*argv[i]='\0';
}
}
if (!lasreadopener.parse(argc, argv)) byebye(true);
if (!laswriteopener.parse(argc, argv)) byebye(true);
}
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '\0')
{
continue;
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
usage();
}
else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0)
{
verbose = true;
}
else if (strcmp(argv[i],"-version") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
byebye();
}
else if (strcmp(argv[i],"-gui") == 0)
{
#ifdef COMPILE_WITH_GUI
gui = true;
#else
fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n");
#endif
}
else if (strcmp(argv[i],"-cores") == 0)
{
#ifdef COMPILE_WITH_MULTI_CORE
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]);
usage(true);
}
argv[i][0] = '\0';
i++;
cores = atoi(argv[i]);
argv[i][0] = '\0';
#else
fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n");
i++;
#endif
}
else if (strcmp(argv[i],"-parse") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: string\n", argv[i]);
usage(true);
}
i++;
if (parse_string) free(parse_string);
parse_string = strdup(argv[i]);
}
else if (strcmp(argv[i],"-parse_all") == 0)
{
if (parse_string) free(parse_string);
parse_string = strdup("txyzirndecaup");
}
else if (strcmp(argv[i],"-extra") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: string\n", argv[i]);
usage(true);
}
i++;
extra_string = argv[i];
}
else if (strcmp(argv[i],"-sep") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: separator\n", argv[i]);
usage(true);
}
i++;
separator = argv[i];
if (strcmp(separator,"comma") == 0 || strcmp(separator,"komma") == 0)
{
separator_sign = ',';
}
else if (strcmp(separator,"tab") == 0)
{
separator_sign = '\t';
}
else if (strcmp(separator,"dot") == 0 || strcmp(separator,"period") == 0)
{
separator_sign = '.';
}
else if (strcmp(separator,"colon") == 0)
{
separator_sign = ':';
}
else if (strcmp(separator,"semicolon") == 0)
{
separator_sign = ';';
}
else if (strcmp(separator,"hyphen") == 0 || strcmp(separator,"minus") == 0)
{
separator_sign = '-';
}
else if (strcmp(separator,"space") == 0)
{
separator_sign = ' ';
}
else
{
fprintf(stderr, "ERROR: unknown seperator '%s'\n",separator);
usage(true);
}
}
else if (strcmp(argv[i],"-header") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: comment\n", argv[i]);
usage(true);
}
i++;
if (strcmp(argv[i],"comma") == 0 || strcmp(argv[i],"komma") == 0)
{
header_comment_sign = ',';
}
else if (strcmp(argv[i],"colon") == 0)
{
header_comment_sign = ':';
}
else if (strcmp(argv[i],"scolon") == 0 || strcmp(argv[i],"semicolon") == 0)
{
header_comment_sign = ';';
}
else if (strcmp(argv[i],"pound") == 0 || strcmp(argv[i],"hash") == 0)
{
header_comment_sign = '#';
}
else if (strcmp(argv[i],"percent") == 0)
{
header_comment_sign = '%';
}
else if (strcmp(argv[i],"dollar") == 0)
{
header_comment_sign = '$';
}
else if (strcmp(argv[i],"star") == 0)
{
header_comment_sign = '*';
}
else
{
fprintf(stderr, "ERROR: unknown header comment symbol '%s'\n",argv[i]);
usage(true);
}
}
else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0))
{
lasreadopener.add_file_name(argv[i]);
argv[i][0] = '\0';
}
else
{
fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]);
usage(true);
}
}
#ifdef COMPILE_WITH_GUI
if (gui)
{
return las2txt_gui(argc, argv, &lasreadopener);
}
#endif
#ifdef COMPILE_WITH_MULTI_CORE
if ((cores > 1) && (lasreadopener.get_file_name_number() > 1) && (!lasreadopener.is_merged()))
{
return las2txt_multi_core(argc, argv, &lasreadopener, &laswriteopener, cores);
}
#endif
// check input
if (!lasreadopener.active())
{
fprintf(stderr,"ERROR: no input specified\n");
byebye(true, argc == 1);
}
// possibly loop over multiple input files
while (lasreadopener.active())
{
if (verbose) start_time = taketime();
// open lasreader
LASreader* lasreader = lasreadopener.open();
if (lasreader == 0)
{
fprintf(stderr, "ERROR: could not open lasreader\n");
byebye(true, argc==1);
}
// (maybe) open laswaveform13reader
LASwaveform13reader* laswaveform13reader = lasreadopener.open_waveform13(&lasreader->header);
// get a pointer to the header
LASheader* header = &(lasreader->header);
// open output file
FILE* file_out;
if (laswriteopener.is_piped())
{
file_out = stdout;
}
else
{
// create output file name if needed
if (laswriteopener.get_file_name() == 0)
{
if (lasreadopener.get_file_name() == 0)
{
fprintf(stderr, "ERROR: no output file specified\n");
byebye(true, argc==1);
}
laswriteopener.make_file_name(lasreadopener.get_file_name(), -2);
}
const CHAR* file_name_out = laswriteopener.get_file_name();
// open output file
file_out = fopen(file_name_out, "w");
// fail if output file does not open
if (file_out == 0)
{
fprintf(stderr, "ERROR: could not open '%s' for write\n", file_name_out);
byebye(true, argc==1);
}
laswriteopener.set_file_name(0);
}
// maybe PTS or PTX format
if (opts)
{
// look for VRL with PTS or PTX info
const LASvlr* ptsVLR = 0;
const LASvlr* ptxVLR = 0;
if ((ptsVLR = header->get_vlr("LAStools", 2000)) || (ptxVLR = header->get_vlr("LAStools", 2001)))
{
if ((parse_string == 0) || (strcmp(parse_string, "original") == 0))
{
if (parse_string) free(parse_string);
if (ptsVLR && (ptsVLR->record_length_after_header >= 32))
{
parse_string = strdup((CHAR*)(ptsVLR->data + 16));
}
else if (ptxVLR && (ptxVLR->record_length_after_header >= 32))
{
parse_string = strdup((CHAR*)(ptxVLR->data + 16));
}
else if (ptsVLR)
{
fprintf(stderr, "WARNING: found VLR for PTS with wrong payload size of %d.\n", ptsVLR->record_length_after_header);
}
else if (ptxVLR)
{
fprintf(stderr, "WARNING: found VLR for PTX with wrong payload size of %d.\n", ptxVLR->record_length_after_header);
}
}
}
else
{
fprintf(stderr, "WARNING: found no VLR with PTS or PTX info.\n");
}
if (header->version_minor >= 4)
{
#ifdef _WIN32
fprintf(file_out, "%I64d \012", header->extended_number_of_point_records);
#else
fprintf(file_out, "%lld \012", header->extended_number_of_point_records);
#endif
}
else
{
fprintf(file_out, "%u \012", header->number_of_point_records);
}
if (parse_string && strcmp(parse_string, "xyz") && strcmp(parse_string, "xyzi") && strcmp(parse_string, "xyziRGB") && strcmp(parse_string, "xyzRGB"))
{
fprintf(stderr, "WARNING: the parse string for PTS should be 'xyz', 'xyzi', 'xyziRGB', or 'xyzRGB'\n");
}
if (separator_sign != ' ')
{
fprintf(stderr, "WARNING: the separator for PTS should be 'space' not '%s'\n", separator);
}
}
else if (optx)
{
// look for VRL with PTX info
const LASvlr* ptxVLR = header->get_vlr("LAStools", 2001);
if (ptxVLR && (ptxVLR->record_length_after_header == 272))
{
U8* payload = ptxVLR->data;
if ((parse_string == 0) || (strcmp(parse_string, "original") == 0))
{
if (parse_string) free(parse_string);
parse_string = strdup((CHAR*)(payload + 16));
}
fprintf(file_out, "%u \012", (U32)((I64*)payload)[4]); // ncols
fprintf(file_out, "%u \012", (U32)((I64*)payload)[5]); // nrows
fprintf(file_out, "%g %g %g\012", ((F64*)payload)[6], ((F64*)payload)[7], ((F64*)payload)[8]); // translation
fprintf(file_out, "%g %g %g\012", ((F64*)payload)[9], ((F64*)payload)[10], ((F64*)payload)[11]); // rotation_row_0
fprintf(file_out, "%g %g %g\012", ((F64*)payload)[12], ((F64*)payload)[13], ((F64*)payload)[14]); // rotation_row_1
fprintf(file_out, "%g %g %g\012", ((F64*)payload)[15], ((F64*)payload)[16], ((F64*)payload)[17]); // rotation_row_2
fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[18], ((F64*)payload)[19], ((F64*)payload)[20], ((F64*)payload)[21]); // transformation_row_0
fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[22], ((F64*)payload)[23], ((F64*)payload)[24], ((F64*)payload)[25]); // transformation_row_0
fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[26], ((F64*)payload)[27], ((F64*)payload)[28], ((F64*)payload)[29]); // transformation_row_0
fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[30], ((F64*)payload)[31], ((F64*)payload)[32], ((F64*)payload)[33]); // transformation_row_0
}
else
{
if (ptxVLR)
{
fprintf(stderr, "WARNING: found VLR for PTX with wrong payload size of %d.\n", ptxVLR->record_length_after_header);
}
else
{
fprintf(stderr, "WARNING: found no VLR with PTX info.\n");
}
fprintf(stderr, " outputting PTS instead ...\n");
if (header->version_minor >= 4)
{
#ifdef _WIN32
fprintf(file_out, "%I64d \012", header->extended_number_of_point_records);
#else
fprintf(file_out, "%lld \012", header->extended_number_of_point_records);
#endif
}
else
{
fprintf(file_out, "%u \012", header->number_of_point_records);
}
}
if (parse_string && strcmp(parse_string, "xyz") && strcmp(parse_string, "xyzi") && strcmp(parse_string, "xyziRGB") && strcmp(parse_string, "xyzRGB"))
{
fprintf(stderr, "WARNING: the parse string for PTX should be 'xyz', 'xyzi', 'xyziRGB', or 'xyzRGB'\n");
}
if (separator_sign != ' ')
{
fprintf(stderr, "WARNING: the separator for PTX should be 'space' not '%s'\n", separator);
}
}
else if (header_comment_sign)
{
// output header info
fprintf(file_out, "%c file signature: '%.4s'\012", header_comment_sign, header->file_signature);
fprintf(file_out, "%c file source ID: %d\012", header_comment_sign, header->file_source_ID);
fprintf(file_out, "%c reserved (global encoding):%d\012", header_comment_sign, header->global_encoding);
fprintf(file_out, "%c project ID GUID data 1-4: %d %d %d '%.8s'\012", header_comment_sign, header->project_ID_GUID_data_1, header->project_ID_GUID_data_2, header->project_ID_GUID_data_3, header->project_ID_GUID_data_4);
fprintf(file_out, "%c version major.minor: %d.%d\012", header_comment_sign, header->version_major, header->version_minor);
fprintf(file_out, "%c system_identifier: '%.32s'\012", header_comment_sign, header->system_identifier);
fprintf(file_out, "%c generating_software: '%.32s'\012", header_comment_sign, header->generating_software);
fprintf(file_out, "%c file creation day/year: %d/%d\012", header_comment_sign, header->file_creation_day, header->file_creation_year);
fprintf(file_out, "%c header size %d\012", header_comment_sign, header->header_size);
fprintf(file_out, "%c offset to point data %u\012", header_comment_sign, header->offset_to_point_data);
fprintf(file_out, "%c number var. length records %u\012", header_comment_sign, header->number_of_variable_length_records);
fprintf(file_out, "%c point data format %d\012", header_comment_sign, header->point_data_format);
fprintf(file_out, "%c point data record length %d\012", header_comment_sign, header->point_data_record_length);
fprintf(file_out, "%c number of point records %u\012", header_comment_sign, header->number_of_point_records);
fprintf(file_out, "%c number of points by return %u %u %u %u %u\012", header_comment_sign, header->number_of_points_by_return[0], header->number_of_points_by_return[1], header->number_of_points_by_return[2], header->number_of_points_by_return[3], header->number_of_points_by_return[4]);
fprintf(file_out, "%c scale factor x y z %g %g %g\012", header_comment_sign, header->x_scale_factor, header->y_scale_factor, header->z_scale_factor);
fprintf(file_out, "%c offset x y z ", header_comment_sign); lidardouble2string(printstring, header->x_offset); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->y_offset); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->z_offset); fprintf(file_out, "%s\012", printstring);
fprintf(file_out, "%c min x y z ", header_comment_sign); lidardouble2string(printstring, header->min_x, header->x_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->min_y, header->y_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->min_z, header->z_scale_factor); fprintf(file_out, "%s\012", printstring);
fprintf(file_out, "%c max x y z ", header_comment_sign); lidardouble2string(printstring, header->max_x, header->x_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->max_y, header->y_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->max_z, header->z_scale_factor); fprintf(file_out, "%s\012", printstring);
}
// maybe create default parse string
if (parse_string == 0) parse_string = strdup("xyz");
// check requested fields and print warnings of necessary
i = 0;
while (parse_string[i])
{
switch (parse_string[i])
{
case 'x': // the x coordinate
case 'y': // the y coordinate
case 'z': // the z coordinate
case 'X': // the unscaled raw integer X coordinate
case 'Y': // the unscaled raw integer Y coordinate
case 'Z': // the unscaled raw integer Z coordinate
case 'i': // the intensity
case 'a': // the scan angle
case 'r': // the number of the return
case 'c': // the classification
case 'u': // the user data
case 'n': // the number of returns of given pulse
case 'p': // the point source ID
case 'e': // the edge of flight line flag
case 'd': // the direction of scan flag
case 'm': // the index of the point (count starts at 0)
case 'M': // the index of the point (count starts at 0)
break;
case 't': // the gps-time
if (lasreader->point.have_gps_time == false)
fprintf (stderr, "WARNING: requested 't' but points do not have gps time\n");
break;
case 'R': // the red channel of the RGB field
if (lasreader->point.have_rgb == false)
fprintf (stderr, "WARNING: requested 'R' but points do not have rgb\n");
break;
case 'G': // the green channel of the RGB field
if (lasreader->point.have_rgb == false)
fprintf (stderr, "WARNING: requested 'G' but points do not have rgb\n");
break;
case 'B': // the blue channel of the RGB field
if (lasreader->point.have_rgb == false)
fprintf (stderr, "WARNING: requested 'B' but points do not have rgb\n");
break;
case 'w': // the wavepacket index
if (lasreader->point.have_wavepacket == false)
fprintf (stderr, "WARNING: requested 'w' but points do not have wavepacket\n");
break;
case 'W': // all wavepacket attributes
if (lasreader->point.have_wavepacket == false)
fprintf (stderr, "WARNING: requested 'W' but points do not have wavepacket\n");
break;
case 'V': // the waveform data
if (laswaveform13reader == 0)
{
fprintf (stderr, "WARNING: requested 'V' but no waveform data available\n");
fprintf (stderr, " omitting ...\n");
}
break;
case ')':
case '!':
case '@':
case '#':
case '$':
case '%':
case '^':
case '&':
case '*':
case '(':
diff = true;
break;
case 'E':
if (extra_string == 0)
{
fprintf (stderr, "WARNING: requested 'E' but no '-extra' specified\n");
parse_string[i] = 's';
}
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if ((parse_string[i] - '0') >= lasreader->header.number_attributes)
{
fprintf(stderr, "WARNING: attribute '%d' does not exist.\n", (parse_string[i] - '0'));
parse_string[i] = 's';
}
else
{
attribute_starts[(parse_string[i] - '0')] = lasreader->header.get_attribute_start((parse_string[i] - '0'));
}
break;
default:
fprintf (stderr, "WARNING: requested unknown parse item '%c'\n", parse_string[i]);
}
i++;
}
// in case diff is requested
int last_XYZ[3] = {0,0,0};
unsigned short last_RGB[4] = {0,0,0};
double last_GPSTIME = 0;
// read and convert the points to ASCII
#ifdef _WIN32
if (verbose) fprintf(stderr,"processing %I64d points with '%s'.\n", lasreader->npoints, parse_string);
#else
if (verbose) fprintf(stderr,"processing %lld points with '%s'.\n", lasreader->npoints, parse_string);
#endif
while (lasreader->read_point())
{
i = 0;
while (true)
{
switch (parse_string[i])
{
case 'x': // the x coordinate
lidardouble2string(printstring, lasreader->point.get_x(), lasreader->header.x_scale_factor); fprintf(file_out, "%s", printstring);
break;
case 'y': // the y coordinate
lidardouble2string(printstring, lasreader->point.get_y(), lasreader->header.y_scale_factor); fprintf(file_out, "%s", printstring);
break;
case 'z': // the z coordinate
lidardouble2string(printstring, lasreader->point.get_z(), lasreader->header.z_scale_factor); fprintf(file_out, "%s", printstring);
break;
case 'X': // the unscaled raw integer X coordinate
fprintf(file_out, "%d", lasreader->point.get_X());
break;
case 'Y': // the unscaled raw integer Y coordinate
fprintf(file_out, "%d", lasreader->point.get_Y());
break;
case 'Z': // the unscaled raw integer Z coordinate
fprintf(file_out, "%d", lasreader->point.get_Z());
break;
case 't': // the gps-time
fprintf(file_out, "%.6f", lasreader->point.get_gps_time());
break;
case 'i': // the intensity
if (opts)
fprintf(file_out, "%d", -2048 + lasreader->point.get_intensity());
else if (optx)
{
int len;
len = sprintf(printstring, "%.3f", 1.0f/4095.0f * lasreader->point.get_intensity()) - 1;
while (printstring[len] == '0') len--;
if (printstring[len] != '.') len++;
printstring[len] = '\0';
fprintf(file_out, "%s", printstring);
}
else
fprintf(file_out, "%d", lasreader->point.get_intensity());
break;
case 'a': // the scan angle
fprintf(file_out, "%d", lasreader->point.get_scan_angle_rank());
break;
case 'r': // the number of the return
fprintf(file_out, "%d", lasreader->point.get_return_number());
break;
case 'c': // the classification
fprintf(file_out, "%d", lasreader->point.get_classification());
break;
case 'u': // the user data
fprintf(file_out, "%d", lasreader->point.get_user_data());
break;
case 'n': // the number of returns of given pulse
fprintf(file_out, "%d", lasreader->point.get_number_of_returns());
break;
case 'p': // the point source ID
fprintf(file_out, "%d", lasreader->point.get_point_source_ID());
break;
case 'e': // the edge of flight line flag
fprintf(file_out, "%d", lasreader->point.get_edge_of_flight_line());
break;
case 'd': // the direction of scan flag
fprintf(file_out, "%d", lasreader->point.get_scan_direction_flag());
break;
case 'R': // the red channel of the RGB field
fprintf(file_out, "%d", lasreader->point.rgb[0]);
break;
case 'G': // the green channel of the RGB field
fprintf(file_out, "%d", lasreader->point.rgb[1]);
break;
case 'B': // the blue channel of the RGB field
fprintf(file_out, "%d", lasreader->point.rgb[2]);
break;
case 'm': // the index of the point (count starts at 0)
#ifdef _WIN32
fprintf(file_out, "%I64d", lasreader->p_count-1);
#else
fprintf(file_out, "%lld", lasreader->p_count-1);
#endif
break;
case 'M': // the index of the point (count starts at 1)
#ifdef _WIN32
fprintf(file_out, "%I64d", lasreader->p_count);
#else
fprintf(file_out, "%lld", lasreader->p_count);
#endif
break;
case ')': // the raw integer X difference to the last point
fprintf(file_out, "%d", lasreader->point.get_X()-last_XYZ[0]);
break;
case '!': // the raw integer Y difference to the last point
fprintf(file_out, "%d", lasreader->point.get_Y()-last_XYZ[1]);
break;
case '@': // the raw integer Z difference to the last point
fprintf(file_out, "%d", lasreader->point.get_Z()-last_XYZ[2]);
break;
case '#': // the gps-time difference to the last point
lidardouble2string(printstring,lasreader->point.gps_time-last_GPSTIME); fprintf(file_out, "%s", printstring);
break;
case '$': // the R difference to the last point
fprintf(file_out, "%d", lasreader->point.rgb[0]-last_RGB[0]);
break;
case '%': // the G difference to the last point
fprintf(file_out, "%d", lasreader->point.rgb[1]-last_RGB[1]);
break;
case '^': // the B difference to the last point
fprintf(file_out, "%d", lasreader->point.rgb[2]-last_RGB[2]);
break;
case '&': // the byte-wise R difference to the last point
fprintf(file_out, "%d%c%d", (lasreader->point.rgb[0]>>8)-(last_RGB[0]>>8), separator_sign, (lasreader->point.rgb[0]&255)-(last_RGB[0]&255));
break;
case '*': // the byte-wise G difference to the last point
fprintf(file_out, "%d%c%d", (lasreader->point.rgb[1]>>8)-(last_RGB[1]>>8), separator_sign, (lasreader->point.rgb[1]&255)-(last_RGB[1]&255));
break;
case '(': // the byte-wise B difference to the last point
fprintf(file_out, "%d%c%d", (lasreader->point.rgb[2]>>8)-(last_RGB[2]>>8), separator_sign, (lasreader->point.rgb[2]&255)-(last_RGB[2]&255));
break;
case 'w': // the wavepacket index
fprintf(file_out, "%d", lasreader->point.wavepacket.getIndex());
break;
case 'W': // all wavepacket attributes
fprintf(file_out, "%d%c%d%c%d%c%g%c%g%c%g%c%g", lasreader->point.wavepacket.getIndex(), separator_sign, (U32)lasreader->point.wavepacket.getOffset(), separator_sign, lasreader->point.wavepacket.getSize(), separator_sign, lasreader->point.wavepacket.getLocation(), separator_sign, lasreader->point.wavepacket.getXt(), separator_sign, lasreader->point.wavepacket.getYt(), separator_sign, lasreader->point.wavepacket.getZt());
break;
case 'V': // the waVeform
if (laswaveform13reader && laswaveform13reader->read_waveform(&lasreader->point))
{
output_waveform(file_out, separator_sign, laswaveform13reader);
}
else
{
fprintf(file_out, "no_waveform");
}
break;
case 'E': // the extra string
fprintf(file_out, "%s", extra_string);
break;
default:
print_attribute(file_out, &lasreader->header, &lasreader->point, (I32)(parse_string[i]-'0'), printstring);
}
i++;
if (parse_string[i])
{
fprintf(file_out, "%c", separator_sign);
}
else
{
fprintf(file_out, "\012");
break;
}
}
if (diff)
{
last_XYZ[0] = lasreader->point.get_X();
last_XYZ[1] = lasreader->point.get_Y();
last_XYZ[2] = lasreader->point.get_Z();
last_GPSTIME = lasreader->point.gps_time;
last_RGB[0] = lasreader->point.rgb[0];
last_RGB[1] = lasreader->point.rgb[1];
last_RGB[2] = lasreader->point.rgb[2];
}
}
#ifdef _WIN32
if (verbose) fprintf(stderr,"converting %I64d points of '%s' took %g sec.\n", lasreader->p_count, lasreadopener.get_file_name(), taketime()-start_time);
#else
if (verbose) fprintf(stderr,"converting %lld points of '%s' took %g sec.\n", lasreader->p_count, lasreadopener.get_file_name(), taketime()-start_time);
#endif
// close the reader
lasreader->close();
delete lasreader;
// (maybe) close the waveform reader
if (laswaveform13reader)
{
laswaveform13reader->close();
delete laswaveform13reader;
}
// close the files
if (file_out != stdout) fclose(file_out);
}
free(parse_string);
byebye(false, argc==1);
return 0;
}
int main(int argc, char *argv[])
{
int i;
#ifdef COMPILE_WITH_GUI
bool gui = false;
#endif
#ifdef COMPILE_WITH_MULTI_CORE
I32 cores = 1;
#endif
bool verbose = false;
bool projection_was_set = false;
bool quiet = false;
int file_creation_day = -1;
int file_creation_year = -1;
int set_version_major = -1;
int set_version_minor = -1;
int set_classification = -1;
char* set_system_identifier = 0;
char* set_generating_software = 0;
bool set_ogc_wkt = false;
double start_time = 0.0;
LASreadOpener lasreadopener;
GeoProjectionConverter geoprojectionconverter;
LASwriteOpener laswriteopener;
if (argc == 1)
{
#ifdef COMPILE_WITH_GUI
return txt2las_gui(argc, argv, 0);
#else
char file_name[256];
fprintf(stderr,"%s is better run in the command line\n", argv[0]);
fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.set_file_name(file_name);
fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
laswriteopener.set_file_name(file_name);
#endif
}
else
{
// need to get those before lastransform->parse() routine gets them
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '–') argv[i][0] = '-';
if (strcmp(argv[i],"-scale_intensity") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: factor\n", argv[i]);
usage(true);
}
lasreadopener.set_scale_intensity((F32)atof(argv[i+1]));
*argv[i]='\0'; *argv[i+1]='\0'; i+=1;
}
else if (strcmp(argv[i],"-translate_intensity") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: offset\n", argv[i]);
usage(true);
}
lasreadopener.set_translate_intensity((F32)atof(argv[i+1]));
*argv[i]='\0'; *argv[i+1]='\0'; i+=1;
}
else if (strcmp(argv[i],"-translate_then_scale_intensity") == 0)
{
if ((i+2) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 2 arguments: offset factor\n", argv[i]);
usage(true);
}
lasreadopener.set_translate_intensity((F32)atof(argv[i+1]));
lasreadopener.set_scale_intensity((F32)atof(argv[i+2]));
*argv[i]='\0'; *argv[i+1]='\0'; *argv[i+2]='\0'; i+=2;
}
else if (strcmp(argv[i],"-scale_scan_angle") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: factor\n", argv[i]);
usage(true);
}
lasreadopener.set_scale_scan_angle((F32)atof(argv[i+1]));
*argv[i]='\0'; *argv[i+1]='\0'; i+=1;
}
}
if (!lasreadopener.parse(argc, argv)) byebye(true);
if (!geoprojectionconverter.parse(argc, argv)) byebye(true);
if (!laswriteopener.parse(argc, argv)) byebye(true);
}
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '\0')
{
continue;
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
usage();
}
else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0)
{
verbose = true;
}
else if (strcmp(argv[i],"-version") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
byebye();
}
else if (strcmp(argv[i],"-gui") == 0)
{
#ifdef COMPILE_WITH_GUI
gui = true;
#else
fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n");
#endif
}
else if (strcmp(argv[i],"-cores") == 0)
{
#ifdef COMPILE_WITH_MULTI_CORE
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]);
usage(true);
}
argv[i][0] = '\0';
i++;
cores = atoi(argv[i]);
argv[i][0] = '\0';
#else
fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n");
i++;
#endif
}
else if (strcmp(argv[i],"-quiet") == 0)
{
quiet = true;
}
else if (strcmp(argv[i],"-parse") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: parse_string\n", argv[i]);
usage(true);
}
i++;
lasreadopener.set_parse_string(argv[i]);
}
else if (strcmp(argv[i],"-skip") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: number_of_lines\n", argv[i]);
usage(true);
}
i++;
lasreadopener.set_skip_lines(atoi(argv[i]));
}
else if (strcmp(argv[i],"-set_scale") == 0)
{
if ((i+3) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 3 arguments: x y z\n", argv[i]);
usage(true);
}
F64 scale_factor[3];
i++;
sscanf(argv[i], "%lf", &(scale_factor[0]));
i++;
sscanf(argv[i], "%lf", &(scale_factor[1]));
i++;
sscanf(argv[i], "%lf", &(scale_factor[2]));
lasreadopener.set_scale_factor(scale_factor);
}
else if (strcmp(argv[i],"-set_offset") == 0)
{
if ((i+3) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 3 arguments: x y z\n", argv[i]);
usage(true);
}
F64 offset[3];
i++;
sscanf(argv[i], "%lf", &(offset[0]));
i++;
sscanf(argv[i], "%lf", &(offset[1]));
i++;
sscanf(argv[i], "%lf", &(offset[2]));
lasreadopener.set_offset(offset);
}
else if (strcmp(argv[i],"-add_extra") == 0 || strcmp(argv[i],"-add_attribute") == 0)
{
if ((i+3) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs at least 3 arguments: data_type name description\n", argv[i]);
usage(true);
}
if (((i+4) < argc) && (atof(argv[i+4]) != 0.0))
{
if (((i+5) < argc) && ((atof(argv[i+5]) != 0.0) || (strcmp(argv[i+5], "0") == 0) || (strcmp(argv[i+5], "0.0") == 0)))
{
if (((i+6) < argc) && (atof(argv[i+6]) != 0.0))
{
if (((i+7) < argc) && ((atof(argv[i+7]) != 0.0) || (strcmp(argv[i+7], "0") == 0) || (strcmp(argv[i+7], "0.0") == 0)))
{
lasreadopener.add_attribute(atoi(argv[i+1]), argv[i+2], argv[i+3], atof(argv[i+4]), atof(argv[i+5]), atof(argv[i+6]), atof(argv[i+7]));
i+=7;
}
else
{
lasreadopener.add_attribute(atoi(argv[i+1]), argv[i+2], argv[i+3], atof(argv[i+4]), atof(argv[i+5]), atof(argv[i+6]));
i+=6;
}
}
else
{
lasreadopener.add_attribute(atoi(argv[i+1]), argv[i+2], argv[i+3], atof(argv[i+4]), atof(argv[i+5]));
i+=5;
}
}
else
{
lasreadopener.add_attribute(atoi(argv[i+1]), argv[i+2], argv[i+3], atof(argv[i+4]));
i+=4;
}
}
else
{
lasreadopener.add_attribute(atoi(argv[i+1]), argv[i+2], argv[i+3]);
i+=3;
}
}
else if (strcmp(argv[i],"-set_creation_date") == 0 || strcmp(argv[i],"-set_file_creation") == 0)
{
if ((i+2) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 2 arguments: day year\n", argv[i]);
usage(true);
}
i++;
sscanf(argv[i], "%d", &file_creation_day);
i++;
sscanf(argv[i], "%d", &file_creation_year);
}
else if (strcmp(argv[i],"-set_class") == 0 || strcmp(argv[i],"-set_classification") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: value\n", argv[i]);
usage(true);
}
i++;
set_classification = atoi(argv[i]);
}
else if (strcmp(argv[i],"-set_system_identifier") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: name\n", argv[i]);
usage(true);
}
i++;
set_system_identifier = argv[i];
}
else if (strcmp(argv[i],"-set_generating_software") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: name\n", argv[i]);
usage(true);
}
i++;
set_generating_software = argv[i];
}
else if (strcmp(argv[i],"-set_ogc_wkt") == 0)
{
set_ogc_wkt = true;
}
else if (strcmp(argv[i],"-set_version") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: major.minor\n", argv[i]);
usage(true);
}
i++;
if (sscanf(argv[i],"%d.%d",&set_version_major,&set_version_minor) != 2)
{
fprintf(stderr, "ERROR: cannot understand argument '%s' of '%s'\n", argv[i], argv[i-1]);
usage(true);
}
}
else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0))
{
lasreadopener.add_file_name(argv[i]);
argv[i][0] = '\0';
}
else
{
fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]);
usage(true);
}
}
#ifdef COMPILE_WITH_GUI
if (gui)
{
return txt2las_gui(argc, argv, &lasreadopener);
}
#endif
#ifdef COMPILE_WITH_MULTI_CORE
if (cores > 1)
{
if (lasreadopener.get_file_name_number() < 2)
{
fprintf(stderr,"WARNING: only %u input files. ignoring '-cores %d' ...\n", lasreadopener.get_file_name_number(), cores);
}
else if (lasreadopener.is_merged())
{
fprintf(stderr,"WARNING: input files merged on-the-fly. ignoring '-cores %d' ...\n", cores);
}
else
{
return txt2las_multi_core(argc, argv, &geoprojectionconverter, &lasreadopener, &laswriteopener, cores);
}
}
#endif
// make sure we have input
if (!lasreadopener.active())
{
fprintf(stderr, "ERROR: no input specified\n");
byebye(true, argc==1);
}
// make sure that input and output are not *both* piped
if (lasreadopener.is_piped() && laswriteopener.is_piped())
{
fprintf(stderr, "ERROR: input and output cannot both be piped\n");
byebye(true, argc==1);
}
// check if projection info was set in the command line
int number_of_keys;
GeoProjectionGeoKeys* geo_keys = 0;
int num_geo_double_params;
double* geo_double_params = 0;
if (geoprojectionconverter.has_projection())
{
projection_was_set = geoprojectionconverter.get_geo_keys_from_projection(number_of_keys, &geo_keys, num_geo_double_params, &geo_double_params);
}
// loop over multiple input files
while (lasreadopener.active())
{
if (verbose) start_time = taketime();
// open lasreader
LASreader* lasreader = lasreadopener.open();
if (lasreader == 0)
{
fprintf(stderr, "ERROR: could not open lasreader\n");
byebye(true, argc==1);
}
// check output
if (!laswriteopener.active())
{
// create name from input name
laswriteopener.make_file_name(lasreadopener.get_file_name(), -2);
}
// if the output was piped we need to precompute the bounding box, etc ...
if (laswriteopener.is_piped())
{
// because the output goes to a pipe we have to precompute the header
// information with an additional pass.
if (verbose) { fprintf(stderr, "piped output. extra read pass over file '%s' ...\n", lasreadopener.get_file_name()); }
while (lasreader->read_point());
lasreader->close();
// output some stats
if (verbose)
{
#ifdef _WIN32
fprintf(stderr, "npoints %I64d min %g %g %g max %g %g %g\n", lasreader->npoints, lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z);
#else
fprintf(stderr, "npoints %lld min %g %g %g max %g %g %g\n", lasreader->npoints, lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z);
#endif
fprintf(stderr, "return histogram %d %d %d %d %d\n", lasreader->header.number_of_points_by_return[0], lasreader->header.number_of_points_by_return[1], lasreader->header.number_of_points_by_return[2], lasreader->header.number_of_points_by_return[3], lasreader->header.number_of_points_by_return[4]);
fprintf(stderr,"took %g sec.\n", taketime()-start_time); start_time = taketime();
}
// reopen lasreader for the second pass
if (!lasreadopener.reopen(lasreader))
{
fprintf(stderr, "ERROR: could not reopen '%s' for main pass\n", lasreadopener.get_file_name());
byebye(true, argc==1);
}
}
// populate header
for (i = 0; i < 32; i++)
{
lasreader->header.system_identifier[i] = '\0';
lasreader->header.generating_software[i] = '\0';
}
if (set_system_identifier)
{
strncpy(lasreader->header.system_identifier, set_system_identifier, 32);
lasreader->header.system_identifier[31] = '\0';
}
else
{
strncpy(lasreader->header.system_identifier, "LAStools (c) by rapidlasso GmbH", 32);
lasreader->header.system_identifier[31] = '\0';
}
if (set_generating_software)
{
strncpy(lasreader->header.generating_software, set_generating_software, 32);
lasreader->header.generating_software[31] = '\0';
}
else
{
char temp[64];
sprintf(temp, "txt2las (version %d)", LAS_TOOLS_VERSION);
strncpy(lasreader->header.generating_software, temp, 32);
lasreader->header.generating_software[31] = '\0';
}
// maybe set creation date
#ifdef _WIN32
if (lasreadopener.get_file_name() && file_creation_day == -1 && file_creation_year == -1)
{
WIN32_FILE_ATTRIBUTE_DATA attr;
SYSTEMTIME creation;
GetFileAttributesEx(lasreadopener.get_file_name(), GetFileExInfoStandard, &attr);
FileTimeToSystemTime(&attr.ftCreationTime, &creation);
int startday[13] = {-1, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
file_creation_day = startday[creation.wMonth] + creation.wDay;
file_creation_year = creation.wYear;
// leap year handling
if ((((creation.wYear)%4) == 0) && (creation.wMonth > 2)) file_creation_day++;
}
#endif
if (file_creation_day == -1 && file_creation_year == -1)
{
lasreader->header.file_creation_day = (U16)333;
lasreader->header.file_creation_year = (U16)2011;
}
else
{
lasreader->header.file_creation_day = (U16)file_creation_day;
lasreader->header.file_creation_year = (U16)file_creation_year;
}
// maybe set version
if (set_version_major != -1) lasreader->header.version_major = (U8)set_version_major;
if (set_version_minor != -1) lasreader->header.version_minor = (U8)set_version_minor;
if (set_version_minor == 3)
{
lasreader->header.header_size = 235;
lasreader->header.offset_to_point_data = 235;
}
else if (set_version_minor == 4)
{
lasreader->header.header_size = 375;
lasreader->header.offset_to_point_data = 375;
}
// maybe set projection
if (projection_was_set)
{
lasreader->header.set_geo_keys(number_of_keys, (LASvlr_key_entry*)geo_keys);
if (geo_double_params)
{
lasreader->header.set_geo_double_params(num_geo_double_params, geo_double_params);
}
else
{
lasreader->header.del_geo_double_params();
}
lasreader->header.del_geo_ascii_params();
if (set_ogc_wkt) // maybe also set the OCG WKT
{
I32 len = 0;
CHAR* ogc_wkt = 0;
if (geoprojectionconverter.get_ogc_wkt_from_projection(len, &ogc_wkt, !geoprojectionconverter.has_projection(false)))
{
lasreader->header.set_geo_wkt_ogc_cs(len, ogc_wkt);
free(ogc_wkt);
if ((lasreader->header.version_minor >= 4) && (lasreader->header.point_data_format >= 6))
{
lasreader->header.set_global_encoding_bit(LAS_TOOLS_GLOBAL_ENCODING_BIT_OGC_WKT_CRS);
}
}
else
{
fprintf(stderr, "WARNING: cannot produce OCG WKT. ignoring '-set_ogc_wkt' for '%s'\n", lasreadopener.get_file_name());
}
}
}
// open the output
LASwriter* laswriter = laswriteopener.open(&lasreader->header);
if (laswriter == 0)
{
fprintf(stderr, "ERROR: could not open laswriter\n");
byebye(true, argc==1);
}
if (verbose) fprintf(stderr, "reading file '%s' and writing to '%s'\n", lasreadopener.get_file_name(), laswriteopener.get_file_name());
// loop over points
while (lasreader->read_point())
{
// maybe set classification
if (set_classification != -1)
{
lasreader->point.set_classification(set_classification);
}
// write the point
laswriter->write_point(&lasreader->point);
}
lasreader->close();
if (!laswriteopener.is_piped())
{
laswriter->update_header(&lasreader->header, FALSE, TRUE);
if (verbose)
{
#ifdef _WIN32
fprintf(stderr, "npoints %I64d min %g %g %g max %g %g %g\n", lasreader->npoints, lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z);
#else
fprintf(stderr, "npoints %lld min %g %g %g max %g %g %g\n", lasreader->npoints, lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z);
#endif
fprintf(stderr, "return histogram %d %d %d %d %d\n", lasreader->header.number_of_points_by_return[0], lasreader->header.number_of_points_by_return[1], lasreader->header.number_of_points_by_return[2], lasreader->header.number_of_points_by_return[3], lasreader->header.number_of_points_by_return[4]);
}
}
laswriter->close();
delete laswriter;
delete lasreader;
laswriteopener.set_file_name(0);
if (verbose) fprintf(stderr,"took %g sec.\n", taketime()-start_time);
}
byebye(false, argc==1);
return 0;
}
int main(int argc, char *argv[])
{
MPI_Init(&argc, &argv);
int i;
#ifdef COMPILE_WITH_GUI
bool gui = false;
#endif
bool verbose = false;
bool keep_lastiling = false;
U32 chopchop = 0;
bool projection_was_set = false;
double start_time = 0;
LASreadOpener lasreadopener;
GeoProjectionConverter geoprojectionconverter;
LASwriteOpener laswriteopener;
if (argc == 1)
{
#ifdef COMPILE_WITH_GUI
return lasmerge_gui(argc, argv, 0);
#else
fprintf(stderr,"%s is better run in the command line\n", argv[0]);
char file_name[256];
fprintf(stderr,"enter input file 1: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.add_file_name(file_name);
fprintf(stderr,"enter input file 2: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.add_file_name(file_name);
fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
laswriteopener.set_file_name(file_name);
#endif
}
else
{
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '�') argv[i][0] = '-';
}
if (!geoprojectionconverter.parse(argc, argv)) byebye(true);
if (!lasreadopener.parse(argc, argv)) byebye(true);
if (lasreadopener.get_file_name_number()<2)
{
fprintf(stderr,"Must specify more than one input file.\n");
byebye(true); // only support merging more than one file
}
if (!laswriteopener.parse(argc, argv)) byebye(true);
}
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '\0')
{
continue;
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
usage();
}
else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0)
{
verbose = true;
}
else if (strcmp(argv[i],"-version") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
byebye();
}
else if (strcmp(argv[i],"-gui") == 0)
{
#ifdef COMPILE_WITH_GUI
gui = true;
#else
fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n");
#endif
}
else if (strcmp(argv[i],"-split") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: size\n", argv[i]);
byebye(true);
}
i++;
chopchop = atoi(argv[i]);
}
else if (strcmp(argv[i],"-keep_lastiling") == 0)
{
keep_lastiling = true;
}
else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0))
{
lasreadopener.add_file_name(argv[i]);
argv[i][0] = '\0';
}
else
{
fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]);
byebye(true);
}
}
#ifdef COMPILE_WITH_GUI
if (gui)
{
return lasmerge_gui(argc, argv, &lasreadopener);
}
#endif
// read all the input files merged
lasreadopener.set_merged(TRUE);
// maybe we want to keep the lastiling
if (keep_lastiling)
{
lasreadopener.set_keep_lastiling(TRUE);
}
// we need to precompute the bounding box
lasreadopener.set_populate_header(TRUE);
// check input and output
if (!lasreadopener.active())
{
fprintf(stderr, "ERROR: no input specified\n");
byebye(true, argc==1);
}
if (!laswriteopener.active())
{
fprintf(stderr, "ERROR: no output specified\n");
byebye(true, argc==1);
}
// make sure we do not corrupt the input file
if (lasreadopener.get_file_name() && laswriteopener.get_file_name() && (strcmp(lasreadopener.get_file_name(), laswriteopener.get_file_name()) == 0))
{
fprintf(stderr, "ERROR: input and output file name are identical\n");
usage(true);
}
// check if projection info was set in the command line
int number_of_keys;
GeoProjectionGeoKeys* geo_keys = 0;
int num_geo_double_params;
double* geo_double_params = 0;
if (geoprojectionconverter.has_projection())
{
projection_was_set = geoprojectionconverter.get_geo_keys_from_projection(number_of_keys, &geo_keys, num_geo_double_params, &geo_double_params);
}
if (verbose) start_time = taketime();
LASreader* lasreader = lasreadopener.open();
lasreader->populate_rank_points();
LASreaderMerged *lasreadermerged = (LASreaderMerged *)lasreader;
I32 process_count = lasreadermerged->get_process_count();
dbg(3, "rank %i, lasreadermerged->npoints %lli", lasreadermerged->get_rank(), lasreadermerged->npoints);
for (i=0; i<process_count; i++)
{
dbg(3, "rank %i, rank_begin_point %lli", lasreadermerged->get_rank(), lasreadermerged->get_rank_begin_index()[i]);
for(int j=lasreadermerged->get_file_name_start(); j< lasreadermerged->get_file_name_number(); j++)
{
dbg(3, "rank %i, number %i name %s count %lli, begin", lasreadermerged->get_rank(), j, lasreadermerged->get_file_names()[j], lasreadermerged->get_file_point_counts()[j]);
}
}
dbg(3,"type of reader returned: class %s and declared name %s", typeid(*lasreader).name(), quote(*lasreader));
if (lasreader == 0)
{
fprintf(stderr, "ERROR: could not open lasreader\n");
byebye(true, argc==1);
}
#ifdef _WIN32
if (verbose) { fprintf(stderr,"merging headers took %g sec. there are %I64d points in total.\n", taketime()-start_time, lasreader->npoints); start_time = taketime(); }
#else
if (verbose) { fprintf(stderr,"merging headers took %g sec. there are %lld points in total.\n", taketime()-start_time, lasreader->npoints); start_time = taketime(); }
#endif
// prepare the header for the surviving points
strncpy(lasreader->header.system_identifier, "LAStools (c) by rapidlasso GmbH", 32);
lasreader->header.system_identifier[31] = '\0';
char temp[64];
sprintf(temp, "lasmerge (version %d)", LAS_TOOLS_VERSION);
strncpy(lasreader->header.generating_software, temp, 32);
lasreader->header.generating_software[31] = '\0';
if (projection_was_set)
{
lasreader->header.set_geo_keys(number_of_keys, (LASvlr_key_entry*)geo_keys);
free(geo_keys);
if (geo_double_params)
{
lasreader->header.set_geo_double_params(num_geo_double_params, geo_double_params);
free(geo_double_params);
}
else
{
lasreader->header.del_geo_double_params();
}
lasreader->header.del_geo_ascii_params();
}
if (chopchop)
{
I32 file_number = 0;
LASwriter* laswriter = 0;
// loop over the points
while (lasreader->read_point())
{
if (laswriter == 0)
{
// open the next writer
laswriteopener.make_file_name(0, file_number);
file_number++;
laswriter = laswriteopener.open(&lasreader->header);
}
laswriter->write_point(&lasreader->point);
laswriter->update_inventory(&lasreader->point);
if (laswriter->p_count == chopchop)
{
// close the current writer
laswriter->update_header(&lasreader->header, TRUE);
laswriter->close();
if (verbose) { fprintf(stderr,"splitting file '%s' took %g sec.\n", laswriteopener.get_file_name(), taketime()-start_time); start_time = taketime(); }
delete laswriter;
laswriter = 0;
}
}
if (laswriter && laswriter->p_count)
{
// close the current writer
laswriter->update_header(&lasreader->header, TRUE);
laswriter->close();
if (verbose) { fprintf(stderr,"splitting file '%s' took %g sec.\n", laswriteopener.get_file_name(), taketime()-start_time); start_time = taketime(); }
delete laswriter;
laswriter = 0;
}
}
else
{
// wait for all processes to open their input files
MPI_Barrier(MPI_COMM_WORLD);
// all processes open a writer
LASwriter* laswriter = laswriteopener.open (&lasreader->header);
// set the write file pointer... no filter support, assumes all input file's points are written to output file
//ByteStreamOutFileLE *bs = (ByteStreamOutFileLE*) laswriter->get_stream (); <-- this is the ByteStreamOut type for las files
ByteStreamOut *bs = laswriter->get_stream ();
I64 begin_index = (lasreadermerged->get_rank_begin_index())[lasreadermerged->get_rank ()];
bs->seek (lasreader->header.point_data_record_length * begin_index + lasreader->header.offset_to_point_data);
if (laswriter == 0)
{
fprintf (stderr, "ERROR: could not open laswriter\n");
byebye (true, argc == 1);
}
// wait for all processes to open the output file and set their write file pointers.
MPI_Barrier(MPI_COMM_WORLD);
// loop over the points
while (lasreader->read_point())
{
laswriter->write_point(&lasreader->point);
laswriter->update_inventory(&lasreader->point);
}
int rank = lasreadermerged->get_rank();
if(rank!=0)
{
laswriter->close(FALSE);
}
MPI_Barrier(MPI_COMM_WORLD); // not needed since reduce causes barrier, used for testing
// this whole MPI_Reduce section is not technically needed since we don't yet support point filtering,
// It was implemented now to ensure that it will work when point filtering of input files is supported
MPI_Reduce(&(laswriter->inventory.extended_number_of_point_records), &extended_number_of_point_records, 1,
MPI_LONG_LONG_INT, MPI_SUM, 0, MPI_COMM_WORLD);
int i;
for(i=0; i<16; i++)
{
MPI_Reduce(&(laswriter->inventory.extended_number_of_points_by_return[i]), &extended_number_of_points_by_return[i], 1,
MPI_LONG_LONG_INT, MPI_SUM, 0, MPI_COMM_WORLD);
}
MPI_Reduce(&(laswriter->inventory.max_X), &max_X, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD);
MPI_Reduce(&(laswriter->inventory.min_X), &min_X, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD);
MPI_Reduce(&(laswriter->inventory.max_Y), &max_Y, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD);
MPI_Reduce(&(laswriter->inventory.min_Y), &min_Y, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD);
MPI_Reduce(&(laswriter->inventory.max_Z), &max_Z, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD);
MPI_Reduce(&(laswriter->inventory.min_Z), &min_Z, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD);
if(rank==0)
{
dbg(3, "extended_number_of_point_records %lli", extended_number_of_point_records);
laswriter->inventory.extended_number_of_point_records = extended_number_of_point_records;
for(i=0; i<16; i++)
{
laswriter->inventory.extended_number_of_points_by_return[i] = extended_number_of_points_by_return[i];
}
laswriter->inventory.max_X = max_X;
laswriter->inventory.min_X = min_X;
laswriter->inventory.max_Y = max_Y;
laswriter->inventory.min_Y = min_Y;
laswriter->inventory.max_Z = max_Z;
laswriter->inventory.min_Z = min_Z;
}
dbg(3, "rank %i, point data record length %i", lasreadermerged->get_rank(), lasreader->header.point_data_record_length);
// close the writer
if(rank==0)
{
// update header should only be called with TRUE when using the MPI_Reduce calls above,
// lasreadopener.open(), called above, generates a correct header for the output file, provided no points are filtered during the read
laswriter->update_header(&lasreader->header, TRUE);
laswriter->close(FALSE);
}
if (verbose) fprintf(stderr,"merging files took %g sec.\n", taketime()-start_time);
delete laswriter;
}
MPI_Finalize();
lasreader->close();
delete lasreader;
byebye(false, argc==1);
return 0;
}
int main(int argc, char *argv[])
{
int i;
int is_mpi = 1;
int debug = 0;
bool verbose = false;
bool force = false;
// fixed header changes
int set_version_major = -1;
int set_version_minor = -1;
int set_point_data_format = -1;
int set_point_data_record_length = -1;
int set_gps_time_endcoding = -1;
// variable header changes
bool remove_extra_header = false;
bool remove_all_variable_length_records = false;
int remove_variable_length_record = -1;
int remove_variable_length_record_from = -1;
int remove_variable_length_record_to = -1;
bool remove_tiling_vlr = false;
bool remove_original_vlr = false;
// extract a subsequence
//unsigned int subsequence_start = 0;
//unsigned int subsequence_stop = U32_MAX;
I64 subsequence_start = 0;
I64 subsequence_stop = I64_MAX;
// fix files with corrupt points
bool clip_to_bounding_box = false;
double start_time = 0;
time_t wall_start_time;
time_t wall_end_time;
LASreadOpener lasreadopener;
//if(is_mpi)lasreadopener.setIsMpi(TRUE);
GeoProjectionConverter geoprojectionconverter;
LASwriteOpener laswriteopener;
if(is_mpi)laswriteopener.setIsMpi(TRUE);
int process_count = 1;
int rank = 0;
start_time = taketime();
time(&wall_start_time);
if (is_mpi){
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&process_count);
MPI_Comm_rank(MPI_COMM_WORLD,&rank);
if(debug) printf ("MPI task %d has started...\n", rank);
}
if (argc == 1)
{
fprintf(stderr,"las2las.exe is better run in the command line or via the lastool.exe GUI\n");
char file_name[256];
fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.set_file_name(file_name);
fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
laswriteopener.set_file_name(file_name);
}
else
{
for (i = 1; i < argc; i++)
{
//if (argv[i][0] == '�') argv[i][0] = '-';
if (strcmp(argv[i],"-week_to_adjusted") == 0)
{
set_gps_time_endcoding = 1;
}
else if (strcmp(argv[i],"-adjusted_to_week") == 0)
{
set_gps_time_endcoding = 0;
}
}
if (!geoprojectionconverter.parse(argc, argv)) byebye(true);
if (!lasreadopener.parse(argc, argv)) byebye(true);
if (!laswriteopener.parse(argc, argv)) byebye(true);
}
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '\0')
{
continue;
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
usage();
}
else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0)
{
verbose = true;
}
else if (strcmp(argv[i],"-version") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
byebye();
}
else if (strcmp(argv[i],"-gui") == 0)
{
fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n");
}
else if (strcmp(argv[i],"-cores") == 0)
{
fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n");
i++;
}
else if (strcmp(argv[i],"-force") == 0)
{
force = true;
}
else if (strcmp(argv[i],"-subseq") == 0)
{
if ((i+2) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 2 arguments: start stop\n", argv[i]);
byebye(true);
}
subsequence_start = (unsigned int)atoi(argv[i+1]); subsequence_stop = (unsigned int)atoi(argv[i+2]);
i+=2;
}
else if (strcmp(argv[i],"-start_at_point") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: start\n", argv[i]);
byebye(true);
}
subsequence_start = (unsigned int)atoi(argv[i+1]);
i+=1;
}
else if (strcmp(argv[i],"-stop_at_point") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: stop\n", argv[i]);
byebye(true);
}
subsequence_stop = (unsigned int)atoi(argv[i+1]);
i+=1;
}
else if (strcmp(argv[i],"-set_version") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: major.minor\n", argv[i]);
byebye(true);
}
if (sscanf(argv[i+1],"%d.%d",&set_version_major,&set_version_minor) != 2)
{
fprintf(stderr, "ERROR: cannot understand argument '%s' for '%s'\n", argv[i+1], argv[i]);
usage(true);
}
i+=1;
}
else if (strcmp(argv[i],"-set_version_major") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: major\n", argv[i]);
byebye(true);
}
set_version_major = atoi(argv[i+1]);
i+=1;
}
else if (strcmp(argv[i],"-set_version_minor") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: minor\n", argv[i]);
byebye(true);
}
set_version_minor = atoi(argv[i+1]);
i+=1;
}
else if (strcmp(argv[i],"-remove_extra") == 0)
{
remove_extra_header = true;
}
else if (strcmp(argv[i],"-remove_all_vlrs") == 0)
{
remove_all_variable_length_records = true;
}
else if (strcmp(argv[i],"-remove_vlr") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]);
byebye(true);
}
remove_variable_length_record = atoi(argv[i+1]);
remove_variable_length_record_from = -1;
remove_variable_length_record_to = -1;
i++;
}
else if (strcmp(argv[i],"-remove_vlrs_from_to") == 0)
{
if ((i+2) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 2 arguments: start end\n", argv[i]);
byebye(true);
}
remove_variable_length_record = -1;
remove_variable_length_record_from = atoi(argv[i+1]);
remove_variable_length_record_to = atoi(argv[i+2]);
i+=2;
}
else if (strcmp(argv[i],"-remove_tiling_vlr") == 0)
{
remove_tiling_vlr = true;
i++;
}
else if (strcmp(argv[i],"-remove_original_vlr") == 0)
{
remove_original_vlr = true;
i++;
}
else if (strcmp(argv[i],"-set_point_type") == 0 || strcmp(argv[i],"-set_point_data_format") == 0 || strcmp(argv[i],"-point_type") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: type\n", argv[i]);
byebye(true);
}
set_point_data_format = atoi(argv[i+1]);
i++;
}
else if (strcmp(argv[i],"-set_point_data_record_length") == 0 || strcmp(argv[i],"-set_point_size") == 0 || strcmp(argv[i],"-point_size") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: size\n", argv[i]);
byebye(true);
}
set_point_data_record_length = atoi(argv[i+1]);
i++;
}
else if (strcmp(argv[i],"-clip_to_bounding_box") == 0 || strcmp(argv[i],"-clip_to_bb") == 0)
{
clip_to_bounding_box = true;
}
else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0))
{
lasreadopener.add_file_name(argv[i]);
argv[i][0] = '\0';
}
else
{
fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]);
usage(true);
}
}
// check input
if (!lasreadopener.active())
{
fprintf(stderr,"ERROR: no input specified\n");
usage(true, argc==1);
}
BOOL extra_pass = laswriteopener.is_piped();
// for piped output we need an extra pass
if (extra_pass)
{
if (lasreadopener.is_piped())
{
fprintf(stderr, "ERROR: input and output cannot both be piped\n");
usage(true);
}
}
// make sure we do not corrupt the input file
if (lasreadopener.get_file_name() && laswriteopener.get_file_name() && (strcmp(lasreadopener.get_file_name(), laswriteopener.get_file_name()) == 0))
{
fprintf(stderr, "ERROR: input and output file name are identical\n");
usage(true);
}
// possibly loop over multiple input files
while (lasreadopener.active())
{
// if (verbose) start_time = taketime();
// open lasreader
LASreader* lasreader = lasreadopener.open();
if (lasreader == 0)
{
fprintf(stderr, "ERROR: could not open lasreader\n");
usage(true, argc==1);
}
// store the inventory for the header
LASinventory lasinventory;
// the point we write sometimes needs to be copied
LASpoint* point = 0;
// prepare the header for output
if (set_gps_time_endcoding != -1)
{
if (set_gps_time_endcoding == 0)
{
if ((lasreader->header.global_encoding & 1) == 0)
{
fprintf(stderr, "WARNING: global encoding indicates file already in GPS week time\n");
if (force)
{
fprintf(stderr, " forced conversion.\n");
}
else
{
fprintf(stderr, " use '-force' to force conversion.\n");
byebye(true);
}
}
else
{
lasreader->header.global_encoding &= ~1;
}
}
else if (set_gps_time_endcoding == 1)
{
if ((lasreader->header.global_encoding & 1) == 1)
{
fprintf(stderr, "WARNING: global encoding indicates file already in Adjusted Standard GPS time\n");
if (force)
{
fprintf(stderr, " forced conversion.\n");
}
else
{
fprintf(stderr, " use '-force' to force conversion.\n");
byebye(true);
}
}
else
{
lasreader->header.global_encoding |= 1;
}
}
}
if (set_version_major != -1)
{
if (set_version_major != 1)
{
fprintf(stderr, "ERROR: unknown version_major %d\n", set_version_major);
byebye(true);
}
lasreader->header.version_major = (U8)set_version_major;
}
if (set_version_minor >= 0)
{
if (set_version_minor > 4)
{
fprintf(stderr, "ERROR: unknown version_minor %d\n", set_version_minor);
byebye(true);
}
if (set_version_minor < 3)
{
if (lasreader->header.version_minor == 3)
{
lasreader->header.header_size -= 8;
lasreader->header.offset_to_point_data -= 8;
}
else if (lasreader->header.version_minor >= 4)
{
lasreader->header.header_size -= (8 + 140);
lasreader->header.offset_to_point_data -= (8 + 140);
}
}
else if (set_version_minor == 3)
{
if (lasreader->header.version_minor < 3)
{
lasreader->header.header_size += 8;
lasreader->header.offset_to_point_data += 8;
lasreader->header.start_of_waveform_data_packet_record = 0;
}
else if (lasreader->header.version_minor >= 4)
{
lasreader->header.header_size -= 140;
lasreader->header.offset_to_point_data -= 140;
}
}
else if (set_version_minor == 4)
{
if (lasreader->header.version_minor < 3)
{
lasreader->header.header_size += (8 + 140);
lasreader->header.offset_to_point_data += (8 + 140);
lasreader->header.start_of_waveform_data_packet_record = 0;
}
else if (lasreader->header.version_minor == 3)
{
lasreader->header.header_size += 140;
lasreader->header.offset_to_point_data += 140;
}
}
if ((set_version_minor <= 3) && (lasreader->header.version_minor >= 4))
{
if (lasreader->header.point_data_format > 5)
{
switch (lasreader->header.point_data_format)
{
case 6:
fprintf(stderr, "WARNING: downgrading point_data_format from %d to 1\n", lasreader->header.point_data_format);
lasreader->header.point_data_format = 1;
fprintf(stderr, " and point_data_record_length from %d to %d\n", lasreader->header.point_data_record_length, lasreader->header.point_data_record_length - 2);
lasreader->header.point_data_record_length -= 2;
break;
case 7:
fprintf(stderr, "WARNING: downgrading point_data_format from %d to 3\n", lasreader->header.point_data_format);
lasreader->header.point_data_format = 3;
fprintf(stderr, " and point_data_record_length from %d to %d\n", lasreader->header.point_data_record_length, lasreader->header.point_data_record_length - 2);
lasreader->header.point_data_record_length -= 2;
break;
case 8:
fprintf(stderr, "WARNING: downgrading point_data_format from %d to 3\n", lasreader->header.point_data_format);
lasreader->header.point_data_format = 3;
fprintf(stderr, " and point_data_record_length from %d to %d\n", lasreader->header.point_data_record_length, lasreader->header.point_data_record_length - 4);
lasreader->header.point_data_record_length -= 4;
break;
case 9:
fprintf(stderr, "WARNING: downgrading point_data_format from %d to 4\n", lasreader->header.point_data_format);
lasreader->header.point_data_format = 4;
fprintf(stderr, " and point_data_record_length from %d to %d\n", lasreader->header.point_data_record_length, lasreader->header.point_data_record_length - 2);
lasreader->header.point_data_record_length -= 2;
break;
case 10:
fprintf(stderr, "WARNING: downgrading point_data_format from %d to 5\n", lasreader->header.point_data_format);
lasreader->header.point_data_format = 5;
fprintf(stderr, " and point_data_record_length from %d to %d\n", lasreader->header.point_data_record_length, lasreader->header.point_data_record_length - 4);
lasreader->header.point_data_record_length -= 4;
break;
default:
fprintf(stderr, "ERROR: unknown point_data_format %d\n", lasreader->header.point_data_format);
byebye(true);
}
}
point = new LASpoint;
point->init(&lasreader->header, lasreader->header.point_data_format, lasreader->header.point_data_record_length);
}
lasreader->header.version_minor = (U8)set_version_minor;
}
// are we supposed to change the point data format
if (set_point_data_format != -1)
{
if (set_point_data_format < 0 || set_point_data_format > 10)
{
fprintf(stderr, "ERROR: unknown point_data_format %d\n", set_point_data_format);
byebye(true);
}
// depending on the conversion we may need to copy the point
if (convert_point_type_from_to[lasreader->header.point_data_format][set_point_data_format])
{
if (point == 0) point = new LASpoint;
}
lasreader->header.point_data_format = (U8)set_point_data_format;
lasreader->header.clean_laszip();
switch (lasreader->header.point_data_format)
{
case 0:
lasreader->header.point_data_record_length = 20;
break;
case 1:
lasreader->header.point_data_record_length = 28;
break;
case 2:
lasreader->header.point_data_record_length = 26;
break;
case 3:
lasreader->header.point_data_record_length = 34;
break;
case 4:
lasreader->header.point_data_record_length = 57;
break;
case 5:
lasreader->header.point_data_record_length = 63;
break;
case 6:
lasreader->header.point_data_record_length = 30;
break;
case 7:
lasreader->header.point_data_record_length = 36;
break;
case 8:
lasreader->header.point_data_record_length = 38;
break;
case 9:
lasreader->header.point_data_record_length = 59;
break;
case 10:
lasreader->header.point_data_record_length = 67;
break;
}
}
// are we supposed to change the point data record length
if (set_point_data_record_length != -1)
{
I32 num_extra_bytes = 0;
switch (lasreader->header.point_data_format)
{
case 0:
num_extra_bytes = set_point_data_record_length - 20;
break;
case 1:
num_extra_bytes = set_point_data_record_length - 28;
break;
case 2:
num_extra_bytes = set_point_data_record_length - 26;
break;
case 3:
num_extra_bytes = set_point_data_record_length - 34;
break;
case 4:
num_extra_bytes = set_point_data_record_length - 57;
break;
case 5:
num_extra_bytes = set_point_data_record_length - 63;
break;
case 6:
num_extra_bytes = set_point_data_record_length - 30;
break;
case 7:
num_extra_bytes = set_point_data_record_length - 36;
break;
case 8:
num_extra_bytes = set_point_data_record_length - 38;
break;
case 9:
num_extra_bytes = set_point_data_record_length - 59;
break;
case 10:
num_extra_bytes = set_point_data_record_length - 67;
break;
}
if (num_extra_bytes < 0)
{
fprintf(stderr, "ERROR: point_data_format %d needs record length of at least %d\n", lasreader->header.point_data_format, set_point_data_record_length - num_extra_bytes);
byebye(true);
}
if (lasreader->header.point_data_record_length < set_point_data_record_length)
{
if (!point) point = new LASpoint;
}
lasreader->header.point_data_record_length = (U16)set_point_data_record_length;
lasreader->header.clean_laszip();
}
// if the point needs to be copied set up the data fields
if (point)
{
point->init(&lasreader->header, lasreader->header.point_data_format, lasreader->header.point_data_record_length);
}
// maybe we should remove some stuff
if (remove_extra_header)
{
lasreader->header.clean_user_data_in_header();
lasreader->header.clean_user_data_after_header();
}
if (remove_all_variable_length_records)
{
lasreader->header.clean_vlrs();
}
else
{
if (remove_variable_length_record != -1)
{
lasreader->header.remove_vlr(remove_variable_length_record);
}
if (remove_variable_length_record_from != -1)
{
for (i = remove_variable_length_record_to; i >= remove_variable_length_record_from; i--)
{
lasreader->header.remove_vlr(i);
}
}
}
if (remove_tiling_vlr)
{
lasreader->header.clean_lastiling();
}
if (remove_original_vlr)
{
lasreader->header.clean_lasoriginal();
}
// maybe we should add / change the projection information
LASquantizer* reproject_quantizer = 0;
LASquantizer* saved_quantizer = 0;
if (geoprojectionconverter.has_projection(true) || geoprojectionconverter.has_projection(false))
{
if (!geoprojectionconverter.has_projection(true) && lasreader->header.vlr_geo_keys)
{
geoprojectionconverter.set_projection_from_geo_keys(lasreader->header.vlr_geo_keys[0].number_of_keys, (GeoProjectionGeoKeys*)lasreader->header.vlr_geo_key_entries, lasreader->header.vlr_geo_ascii_params, lasreader->header.vlr_geo_double_params);
}
if (geoprojectionconverter.has_projection(true) && geoprojectionconverter.has_projection(false))
{
reproject_quantizer = new LASquantizer();
double point[3];
point[0] = (lasreader->header.min_x+lasreader->header.max_x)/2;
point[1] = (lasreader->header.min_y+lasreader->header.max_y)/2;
point[2] = (lasreader->header.min_z+lasreader->header.max_z)/2;
geoprojectionconverter.to_target(point);
reproject_quantizer->x_scale_factor = geoprojectionconverter.get_target_precision();
reproject_quantizer->y_scale_factor = geoprojectionconverter.get_target_precision();
reproject_quantizer->z_scale_factor = lasreader->header.z_scale_factor;
reproject_quantizer->x_offset = ((I64)((point[0]/reproject_quantizer->x_scale_factor)/10000000))*10000000*reproject_quantizer->x_scale_factor;
reproject_quantizer->y_offset = ((I64)((point[1]/reproject_quantizer->y_scale_factor)/10000000))*10000000*reproject_quantizer->y_scale_factor;
reproject_quantizer->z_offset = ((I64)((point[2]/reproject_quantizer->z_scale_factor)/10000000))*10000000*reproject_quantizer->z_scale_factor;
}
int number_of_keys;
GeoProjectionGeoKeys* geo_keys = 0;
int num_geo_double_params;
double* geo_double_params = 0;
if (geoprojectionconverter.get_geo_keys_from_projection(number_of_keys, &geo_keys, num_geo_double_params, &geo_double_params, !geoprojectionconverter.has_projection(false)))
{
lasreader->header.set_geo_keys(number_of_keys, (LASvlr_key_entry*)geo_keys);
free(geo_keys);
if (geo_double_params)
{
lasreader->header.set_geo_double_params(num_geo_double_params, geo_double_params);
free(geo_double_params);
}
else
{
lasreader->header.del_geo_double_params();
}
lasreader->header.del_geo_ascii_params();
}
}
// do we need an extra pass
BOOL extra_pass = laswriteopener.is_piped();
// for piped output we need an extra pass
if (extra_pass)
{
if (lasreadopener.is_piped())
{
fprintf(stderr, "ERROR: input and output cannot both be piped\n");
usage(true);
}
if (verbose) fprintf(stderr, "extra pass for piped output: reading %lld points ...\n", lasreader->npoints);
// maybe seek to start position
if (subsequence_start) lasreader->seek(subsequence_start);
while (lasreader->read_point())
{
if (lasreader->p_count > subsequence_stop) break;
if (clip_to_bounding_box)
{
if (!lasreader->point.inside_box(lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z))
{
continue;
}
}
if (reproject_quantizer)
{
lasreader->point.compute_coordinates();
geoprojectionconverter.to_target(lasreader->point.coordinates);
lasreader->point.compute_XYZ(reproject_quantizer);
}
lasinventory.add(&lasreader->point);
}
lasreader->close();
lasreader->header.number_of_point_records = lasinventory.number_of_point_records;
for (i = 0; i < 5; i++) lasreader->header.number_of_points_by_return[i] = lasinventory.number_of_points_by_return[i+1];
if (reproject_quantizer) lasreader->header = *reproject_quantizer;
lasreader->header.max_x = lasreader->header.get_x(lasinventory.max_X);
lasreader->header.min_x = lasreader->header.get_x(lasinventory.min_X);
lasreader->header.max_y = lasreader->header.get_y(lasinventory.max_Y);
lasreader->header.min_y = lasreader->header.get_y(lasinventory.min_Y);
lasreader->header.max_z = lasreader->header.get_z(lasinventory.max_Z);
lasreader->header.min_z = lasreader->header.get_z(lasinventory.min_Z);
// if (verbose) { fprintf(stderr,"extra pass took %g sec.\n", taketime()-start_time); start_time = taketime(); }
if (verbose) fprintf(stderr, "piped output: reading %lld and writing %d points ...\n", lasreader->npoints, lasinventory.number_of_point_records);
}
else
{
if (reproject_quantizer)
{
saved_quantizer = new LASquantizer();
*saved_quantizer = lasreader->header;
lasreader->header = *reproject_quantizer;
}
//if (verbose) fprintf(stderr, "reading %lld and writing all surviving points ...\n", lasreader->npoints);
}
// check output
if (!laswriteopener.active())
{
// create name from input name
laswriteopener.make_file_name(lasreadopener.get_file_name());
}
// prepare the header for the surviving points
strncpy(lasreader->header.system_identifier, "LAStools (c) by rapidlasso GmbH", 32);
lasreader->header.system_identifier[31] = '\0';
char temp[64];
sprintf(temp, "las2las (version %d)", LAS_TOOLS_VERSION);
strncpy(lasreader->header.generating_software, temp, 32);
lasreader->header.generating_software[31] = '\0';
LASwriter* laswriter = 0;
// open laswriter
if(is_mpi){
// remove any existing out file, before opening with MPI_File_open
if(rank==0){
remove(laswriteopener.get_file_name());
}
MPI_Barrier(MPI_COMM_WORLD);
}
laswriter = laswriteopener.open(&lasreader->header);
if (laswriter == 0)
{
fprintf(stderr, "ERROR: could not open laswriter\n");
byebye(true, argc==1);
}
// **************************************************************************************************
if(is_mpi == 1){ // jdw, we do this because only rank 0 now writes the header in laswriter_las.cpp
MPI_File fh = laswriter->get_MPI_File();
MPI_Offset offset;
//MPI_File_get_position(fh, &offset);
//printf ("offset %lld, rank %i fh %lld\n", offset, rank, fh);
if(rank==0){
MPI_File_get_position(fh, &offset);
}
MPI_Bcast(&offset, 1, MPI_OFFSET, 0, MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
MPI_File_seek(fh, offset, MPI_SEEK_SET);
}
// ****************************************************************************************************
// for piped output we need to re-open the input file
if (extra_pass)
{
if (!lasreadopener.reopen(lasreader))
{
fprintf(stderr, "ERROR: could not re-open lasreader\n");
byebye(true);
}
}
else
{
if (reproject_quantizer)
{
lasreader->header = *saved_quantizer;
delete saved_quantizer;
}
}
// maybe seek to start position
if (subsequence_start) lasreader->seek(subsequence_start);
// loop over points
if (point)
{
while (lasreader->read_point())
{
if (lasreader->p_count > subsequence_stop) break;
if (clip_to_bounding_box)
{
if (!lasreader->point.inside_box(lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z))
{
continue;
}
}
if (reproject_quantizer)
{
lasreader->point.compute_coordinates();
geoprojectionconverter.to_target(lasreader->point.coordinates);
lasreader->point.compute_XYZ(reproject_quantizer);
}
*point = lasreader->point;
laswriter->write_point(point);
// without extra pass we need inventory of surviving points
if (!extra_pass) laswriter->update_inventory(point);
}
delete point;
point = 0;
}
else // ***************************** MPI ********************************************************
{
// ***** Determine the start and stop points for this process *****
I64 left_over_count = lasreader->npoints % process_count;
I64 process_points = lasreader->npoints / process_count;
subsequence_start = rank*process_points;
subsequence_stop = subsequence_start + process_points;
if(rank == process_count-1) subsequence_stop += left_over_count;
// ***** Set the input stream file offset for this process *****
// subsequence_start parameter gets cast to U32 in the implementation of seek and overflows for large files
// manually set the file offset instead for now
//((LASreaderLAS*)lasreader)->stream->seek(subsequence_start);
I64 header_end_read_position = lasreader->get_Stream()->tell();
//printf("header end %lld subseqence_start * 28 %lld rank %i\n", header_end_read_position, subsequence_start*28, rank);
lasreader->p_count = subsequence_start;
lasreader->get_Stream()->seek(header_end_read_position + subsequence_start*28);
//printf("seek pos first loop %lld rank %i\n", lasreader->get_Stream()->tell(), rank);
if (verbose) fprintf(stderr, "reading %lli points, rank %i\n", subsequence_stop - subsequence_start, rank);
// *****Read the file for the first time *****
// this first read and filter of the file is to gather a count of points that pass the filter so that
// write offsets can be set.
I64 filtered_count = 0;
//while (lasreader->read_point()){
lasreader->MPI_END_POINT = subsequence_stop;
while (lasreader->read_point())
{
filtered_count++;
}
// ***** Gather and set the write offset for this process *****
I64* filtered_counts = (I64*)malloc(process_count * sizeof(I64));
if(is_mpi)MPI_Barrier(MPI_COMM_WORLD);
filtered_counts[rank] = filtered_count;
if(is_mpi)MPI_Allgather(&filtered_count, 1, MPI_LONG_LONG, filtered_counts, 1, MPI_LONG_LONG, MPI_COMM_WORLD);
if(is_mpi)MPI_Barrier(MPI_COMM_WORLD);
if(debug) printf("filtered count %lli rank %i\n", filtered_counts[rank], rank);
if(is_mpi)MPI_Barrier(MPI_COMM_WORLD);
I64 write_point_offset = 0;
for (int k=0; k < rank; k++){
write_point_offset += filtered_counts[k];
}
if(is_mpi){
MPI_File fh = laswriter->get_MPI_File();
MPI_Offset cur = 0;
// jdw, todo, remove the hardcoding by adding methods to read point size from reader
MPI_File_seek(fh, write_point_offset*28, MPI_SEEK_CUR);
if(debug){
MPI_File_get_position(fh, &cur);
printf ("rank %i, write offset %lld\n", rank, write_point_offset*28);
}
}
if(is_mpi)MPI_Barrier(MPI_COMM_WORLD);
// ***** Read and filter the input file again, this time write the filtered point since output file offset in now known amd set *****
//lasreader->seek(subsequence_start); // subsequence_start parameter gets cast to U32 in the implementation and overflows for large files
// manually set the file offset instead for now
//printf("header end %lld subseqence_start * 28 %lld rank %i\n", header_end_read_position, subsequence_start*28, rank);
lasreader->p_count = subsequence_start;
lasreader->get_Stream()->seek(header_end_read_position + subsequence_start*28);
//printf("seek pos second loop %lld rank %i\n", lasreader->get_Stream()->tell(), rank);
lasreader->MPI_END_POINT = subsequence_stop;
while (lasreader->read_point())
{
//if (lasreader->p_count > subsequence_stop) break;
//if (clip_to_bounding_box)
//{
// if (!lasreader->point.inside_box(lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z))
// {
// continue;
// }
// }
if (reproject_quantizer)
{
lasreader->point.compute_coordinates();
geoprojectionconverter.to_target(lasreader->point.coordinates);
lasreader->point.compute_XYZ(reproject_quantizer);
}
laswriter->write_point(&lasreader->point);
// without extra pass we need inventory of surviving points
if (!extra_pass){
laswriter->update_inventory(&lasreader->point);
}
}
//***** this is part of an mpi write optimization *****
laswriter->get_Stream()->flushBytes();
}
// without the extra pass we need to fix the header now
// ***** do the inventory reconciliation *****
// ***** Reduce inventory information in rank 0 *****
if (is_mpi){
U32 number_of_point_records = 0;
U32 number_of_points_by_return[8];
for(int i = 0; i<8; i++)number_of_points_by_return[i] = 0;
I32 max_X = 0;
I32 min_X = 0;
I32 max_Y = 0;
I32 min_Y = 0;
I32 max_Z = 0;
I32 min_Z = 0;
MPI_Reduce(&laswriter->inventory.number_of_point_records, &number_of_point_records, 1, MPI_UNSIGNED, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(laswriter->inventory.number_of_points_by_return, number_of_points_by_return, 8, MPI_UNSIGNED, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&laswriter->inventory.max_X, &max_X, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD);
MPI_Reduce(&laswriter->inventory.min_X, &min_X, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD);
MPI_Reduce(&laswriter->inventory.max_Y, &max_Y, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD);
MPI_Reduce(&laswriter->inventory.min_Y, &min_Y, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD);
MPI_Reduce(&laswriter->inventory.max_Z, &max_Z, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD);
MPI_Reduce(&laswriter->inventory.min_Z, &min_Z, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD);
if (rank ==0){
laswriter->inventory.number_of_point_records = number_of_point_records;
for(int i=0; i<8; i++)laswriter->inventory.number_of_points_by_return[i] = number_of_points_by_return[i];
laswriter->inventory.max_X = max_X;
laswriter->inventory.min_X = min_X;
laswriter->inventory.max_Y = max_Y;
laswriter->inventory.min_Y = min_Y;
laswriter->inventory.max_Z = max_Z;
laswriter->inventory.min_Z = min_Z;
}
}
if(rank == 0){
if (!extra_pass)
{
if (reproject_quantizer) lasreader->header = *reproject_quantizer;
laswriter->update_header(&lasreader->header, TRUE);
}
}
if(is_mpi)MPI_Barrier(MPI_COMM_WORLD);
if (verbose) { fprintf(stderr,"%lli surviving points written by rank: %i\n", laswriter->p_count, rank); }
laswriter->close(FALSE);
if(is_mpi)MPI_Barrier(MPI_COMM_WORLD);
delete laswriter;
lasreader->close();
delete lasreader;
if (reproject_quantizer) delete reproject_quantizer;
}
if(is_mpi)MPI_Finalize();
time(&wall_end_time);
if (verbose) { fprintf(stderr,"total time %.f sec, cpu time: %g sec. rank: %i\n", difftime(wall_end_time, wall_start_time), taketime()-start_time, rank); }
return 0;
}
int main(int argc, char *argv[])
{
int i;
#ifdef COMPILE_WITH_GUI
bool gui = false;
#endif
#ifdef COMPILE_WITH_MULTI_CORE
I32 cores = 1;
#endif
bool verbose = false;
bool force = false;
// fixed header changes
int set_version_major = -1;
int set_version_minor = -1;
int set_point_data_format = -1;
int set_point_data_record_length = -1;
int set_gps_time_endcoding = -1;
// variable header changes
bool remove_extra_header = false;
bool remove_all_variable_length_records = false;
int remove_variable_length_record = -1;
bool remove_tiling_vlr = false;
bool remove_original_vlr = false;
// extract a subsequence
unsigned int subsequence_start = 0;
unsigned int subsequence_stop = U32_MAX;
// fix files with corrupt points
bool clip_to_bounding_box = false;
double start_time = 0;
LASreadOpener lasreadopener;
GeoProjectionConverter geoprojectionconverter;
LASwriteOpener laswriteopener;
if (argc == 1)
{
#ifdef COMPILE_WITH_GUI
return las2las_gui(argc, argv, 0);
#else
fprintf(stderr,"las2las.exe is better run in the command line or via the lastool.exe GUI\n");
char file_name[256];
fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.set_file_name(file_name);
fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
laswriteopener.set_file_name(file_name);
#endif
}
else
{
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '–') argv[i][0] = '-';
if (strcmp(argv[i],"-week_to_adjusted") == 0)
{
set_gps_time_endcoding = 1;
}
else if (strcmp(argv[i],"-adjusted_to_week") == 0)
{
set_gps_time_endcoding = 0;
}
}
if (!geoprojectionconverter.parse(argc, argv)) byebye(true);
if (!lasreadopener.parse(argc, argv)) byebye(true);
if (!laswriteopener.parse(argc, argv)) byebye(true);
}
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '\0')
{
continue;
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
usage();
}
else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0)
{
verbose = true;
}
else if (strcmp(argv[i],"-version") == 0)
{
fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION);
byebye();
}
else if (strcmp(argv[i],"-gui") == 0)
{
#ifdef COMPILE_WITH_GUI
gui = true;
#else
fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n");
#endif
}
else if (strcmp(argv[i],"-cores") == 0)
{
#ifdef COMPILE_WITH_MULTI_CORE
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]);
usage(true);
}
argv[i][0] = '\0';
i++;
cores = atoi(argv[i]);
argv[i][0] = '\0';
#else
fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n");
#endif
}
else if (strcmp(argv[i],"-force") == 0)
{
force = true;
}
else if (strcmp(argv[i],"-subseq") == 0)
{
if ((i+2) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 2 arguments: start stop\n", argv[i]);
byebye(true);
}
subsequence_start = (unsigned int)atoi(argv[i+1]); subsequence_stop = (unsigned int)atoi(argv[i+2]);
i+=2;
}
else if (strcmp(argv[i],"-start_at_point") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: start\n", argv[i]);
byebye(true);
}
subsequence_start = (unsigned int)atoi(argv[i+1]);
i+=1;
}
else if (strcmp(argv[i],"-stop_at_point") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: stop\n", argv[i]);
byebye(true);
}
subsequence_stop = (unsigned int)atoi(argv[i+1]);
i+=1;
}
else if (strcmp(argv[i],"-set_version") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: major.minor\n", argv[i]);
byebye(true);
}
if (sscanf(argv[i+1],"%d.%d",&set_version_major,&set_version_minor) != 2)
{
fprintf(stderr, "ERROR: cannot understand argument '%s' for '%s'\n", argv[i+1], argv[i]);
usage(true);
}
i+=1;
}
else if (strcmp(argv[i],"-set_version_major") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: major\n", argv[i]);
byebye(true);
}
set_version_major = atoi(argv[i+1]);
i+=1;
}
else if (strcmp(argv[i],"-set_version_minor") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: minor\n", argv[i]);
byebye(true);
}
set_version_minor = atoi(argv[i+1]);
i+=1;
}
else if (strcmp(argv[i],"-remove_extra") == 0)
{
remove_extra_header = true;
}
else if (strcmp(argv[i],"-remove_all_vlrs") == 0 || strcmp(argv[i],"-remove_all_vlr") == 0)
{
remove_all_variable_length_records = true;
}
else if (strcmp(argv[i],"-remove_vlr") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]);
byebye(true);
}
remove_variable_length_record = atoi(argv[i+1]);
i++;
}
else if (strcmp(argv[i],"-remove_tiling_vlr") == 0)
{
remove_tiling_vlr = true;
i++;
}
else if (strcmp(argv[i],"-remove_original_vlr") == 0)
{
remove_original_vlr = true;
i++;
}
else if (strcmp(argv[i],"-point_type") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: type\n", argv[i]);
byebye(true);
}
set_point_data_format = atoi(argv[i+1]);
i++;
}
else if (strcmp(argv[i],"-point_size") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: size\n", argv[i]);
byebye(true);
}
set_point_data_record_length = atoi(argv[i+1]);
i++;
}
else if (strcmp(argv[i],"-clip_to_bounding_box") == 0 || strcmp(argv[i],"-clip_to_bbox") == 0)
{
clip_to_bounding_box = true;
}
else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0))
{
lasreadopener.add_file_name(argv[i]);
argv[i][0] = '\0';
}
else
{
fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]);
usage(true);
}
}
#ifdef COMPILE_WITH_GUI
if (gui)
{
return las2las_gui(argc, argv, &lasreadopener);
}
#endif
#ifdef COMPILE_WITH_MULTI_CORE
if ((cores > 1) && (lasreadopener.get_file_name_number() > 1) && (!lasreadopener.get_merged()))
{
return las2las_multi_core(argc, argv, &geoprojectionconverter, &lasreadopener, &laswriteopener, cores);
}
#endif
// check input
if (!lasreadopener.active())
{
fprintf(stderr,"ERROR: no input specified\n");
usage(true, argc==1);
}
BOOL extra_pass = laswriteopener.is_piped();
// for piped output we need an extra pass
if (extra_pass)
{
if (lasreadopener.is_piped())
{
fprintf(stderr, "ERROR: input and output cannot both be piped\n");
usage(true);
}
}
// make sure we do not corrupt the input file
if (lasreadopener.get_file_name() && laswriteopener.get_file_name() && (strcmp(lasreadopener.get_file_name(), laswriteopener.get_file_name()) == 0))
{
fprintf(stderr, "ERROR: input and output file name are identical\n");
usage(true);
}
// possibly loop over multiple input files
while (lasreadopener.active())
{
if (verbose) start_time = taketime();
// open lasreader
LASreader* lasreader = lasreadopener.open();
if (lasreader == 0)
{
fprintf(stderr, "ERROR: could not open lasreader\n");
usage(true, argc==1);
}
// store the inventory for the header
LASinventory lasinventory;
// the point we write sometimes needs to be copied
LASpoint* point = 0;
// prepare the header for output
if (set_gps_time_endcoding != -1)
{
if (set_gps_time_endcoding == 0)
{
if ((lasreader->header.global_encoding & 1) == 0)
{
fprintf(stderr, "WARNING: global encoding indicates file already in GPS week time\n");
if (force)
{
fprintf(stderr, " forced conversion.\n");
}
else
{
fprintf(stderr, " use '-force' to force conversion.\n");
byebye(true);
}
}
else
{
lasreader->header.global_encoding &= ~1;
}
}
else if (set_gps_time_endcoding == 1)
{
if ((lasreader->header.global_encoding & 1) == 1)
{
fprintf(stderr, "WARNING: global encoding indicates file already in Adjusted Standard GPS time\n");
if (force)
{
fprintf(stderr, " forced conversion.\n");
}
else
{
fprintf(stderr, " use '-force' to force conversion.\n");
byebye(true);
}
}
else
{
lasreader->header.global_encoding |= 1;
}
}
}
if (set_version_major != -1)
{
if (set_version_major != 1)
{
fprintf(stderr, "ERROR: unknown version_major %d\n", set_version_major);
byebye(true);
}
lasreader->header.version_major = (U8)set_version_major;
}
if (set_version_minor >= 0)
{
if (set_version_minor > 4)
{
fprintf(stderr, "ERROR: unknown version_minor %d\n", set_version_minor);
byebye(true);
}
if (set_version_minor < 3)
{
if (lasreader->header.version_minor == 3)
{
lasreader->header.header_size -= 8;
lasreader->header.offset_to_point_data -= 8;
}
else if (lasreader->header.version_minor >= 4)
{
lasreader->header.header_size -= (8 + 140);
lasreader->header.offset_to_point_data -= (8 + 140);
}
}
else if (set_version_minor == 3)
{
if (lasreader->header.version_minor < 3)
{
lasreader->header.header_size += 8;
lasreader->header.offset_to_point_data += 8;
lasreader->header.start_of_waveform_data_packet_record = 0;
}
else if (lasreader->header.version_minor >= 4)
{
lasreader->header.header_size -= 140;
lasreader->header.offset_to_point_data -= 140;
}
}
else if (set_version_minor == 4)
{
if (lasreader->header.version_minor < 3)
{
lasreader->header.header_size += (8 + 140);
lasreader->header.offset_to_point_data += (8 + 140);
lasreader->header.start_of_waveform_data_packet_record = 0;
}
else if (lasreader->header.version_minor == 3)
{
lasreader->header.header_size += 140;
lasreader->header.offset_to_point_data += 140;
}
}
lasreader->header.version_minor = (U8)set_version_minor;
}
// are we supposed to change the point data format
if (set_point_data_format != -1)
{
if (set_point_data_format < 0 || set_point_data_format >= 6)
{
fprintf(stderr, "ERROR: unknown point_data_format %d\n", set_point_data_format);
byebye(true);
}
// depending on the conversion we may need to copy the point
if (convert_point_type_from_to[lasreader->header.point_data_format][set_point_data_format])
{
point = new LASpoint;
}
lasreader->header.point_data_format = (U8)set_point_data_format;
lasreader->header.clean_laszip();
switch (lasreader->header.point_data_format)
{
case 0:
lasreader->header.point_data_record_length = 20;
break;
case 1:
lasreader->header.point_data_record_length = 28;
break;
case 2:
lasreader->header.point_data_record_length = 26;
break;
case 3:
lasreader->header.point_data_record_length = 34;
break;
case 4:
lasreader->header.point_data_record_length = 57;
break;
case 5:
lasreader->header.point_data_record_length = 63;
break;
}
}
// are we supposed to change the point data record length
if (set_point_data_record_length != -1)
{
I32 num_extra_bytes = 0;
switch (lasreader->header.point_data_format)
{
case 0:
num_extra_bytes = set_point_data_record_length - 20;
break;
case 1:
num_extra_bytes = set_point_data_record_length - 28;
break;
case 2:
num_extra_bytes = set_point_data_record_length - 26;
break;
case 3:
num_extra_bytes = set_point_data_record_length - 34;
break;
case 4:
num_extra_bytes = set_point_data_record_length - 57;
break;
case 5:
num_extra_bytes = set_point_data_record_length - 63;
break;
}
if (num_extra_bytes < 0)
{
fprintf(stderr, "ERROR: point_data_format %d needs record length of at least %d\n", lasreader->header.point_data_format, set_point_data_record_length - num_extra_bytes);
byebye(true);
}
if (lasreader->header.point_data_record_length < set_point_data_record_length)
{
if (!point) point = new LASpoint;
}
lasreader->header.point_data_record_length = (U16)set_point_data_record_length;
lasreader->header.clean_laszip();
}
// if the point needs to be copied set up the data fields
if (point)
{
point->init(&lasreader->header, lasreader->header.point_data_format, lasreader->header.point_data_record_length);
}
// maybe we should remove some stuff
if (remove_extra_header)
{
lasreader->header.clean_user_data_in_header();
lasreader->header.clean_user_data_after_header();
}
if (remove_all_variable_length_records)
{
lasreader->header.clean_vlrs();
}
if (remove_variable_length_record != -1)
{
lasreader->header.remove_vlr(remove_variable_length_record);
}
if (remove_tiling_vlr)
{
lasreader->header.clean_lastiling();
}
if (remove_original_vlr)
{
lasreader->header.clean_lasoriginal();
}
// maybe we should add / change the projection information
LASquantizer* reproject_quantizer = 0;
LASquantizer* saved_quantizer = 0;
if (geoprojectionconverter.has_projection(true) || geoprojectionconverter.has_projection(false))
{
if (!geoprojectionconverter.has_projection(true) && lasreader->header.vlr_geo_keys)
{
geoprojectionconverter.set_projection_from_geo_keys(lasreader->header.vlr_geo_keys[0].number_of_keys, (GeoProjectionGeoKeys*)lasreader->header.vlr_geo_key_entries, lasreader->header.vlr_geo_ascii_params, lasreader->header.vlr_geo_double_params);
}
if (geoprojectionconverter.has_projection(true) && geoprojectionconverter.has_projection(false))
{
reproject_quantizer = new LASquantizer();
double point[3];
point[0] = (lasreader->header.min_x+lasreader->header.max_x)/2;
point[1] = (lasreader->header.min_y+lasreader->header.max_y)/2;
point[2] = (lasreader->header.min_z+lasreader->header.max_z)/2;
geoprojectionconverter.to_target(point);
reproject_quantizer->x_scale_factor = geoprojectionconverter.get_target_precision();
reproject_quantizer->y_scale_factor = geoprojectionconverter.get_target_precision();
reproject_quantizer->z_scale_factor = lasreader->header.z_scale_factor;
reproject_quantizer->x_offset = ((I64)((point[0]/reproject_quantizer->x_scale_factor)/10000000))*10000000*reproject_quantizer->x_scale_factor;
reproject_quantizer->y_offset = ((I64)((point[1]/reproject_quantizer->y_scale_factor)/10000000))*10000000*reproject_quantizer->y_scale_factor;
reproject_quantizer->z_offset = ((I64)((point[2]/reproject_quantizer->z_scale_factor)/10000000))*10000000*reproject_quantizer->z_scale_factor;
}
int number_of_keys;
GeoProjectionGeoKeys* geo_keys = 0;
int num_geo_double_params;
double* geo_double_params = 0;
if (geoprojectionconverter.get_geo_keys_from_projection(number_of_keys, &geo_keys, num_geo_double_params, &geo_double_params, !geoprojectionconverter.has_projection(false)))
{
lasreader->header.set_geo_keys(number_of_keys, (LASvlr_key_entry*)geo_keys);
free(geo_keys);
if (geo_double_params)
{
lasreader->header.set_geo_double_params(num_geo_double_params, geo_double_params);
free(geo_double_params);
}
else
{
lasreader->header.del_geo_double_params();
}
lasreader->header.del_geo_ascii_params();
}
}
// do we need an extra pass
BOOL extra_pass = laswriteopener.is_piped();
// for piped output we need an extra pass
if (extra_pass)
{
if (lasreadopener.is_piped())
{
fprintf(stderr, "ERROR: input and output cannot both be piped\n");
usage(true);
}
#ifdef _WIN32
if (verbose) fprintf(stderr, "extra pass for piped output: reading %I64d points ...\n", lasreader->npoints);
#else
if (verbose) fprintf(stderr, "extra pass for piped output: reading %lld points ...\n", lasreader->npoints);
#endif
// maybe seek to start position
if (subsequence_start) lasreader->seek(subsequence_start);
while (lasreader->read_point())
{
if (lasreader->p_count > subsequence_stop) break;
if (clip_to_bounding_box)
{
if (!lasreader->point.inside_box(lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z))
{
continue;
}
}
if (reproject_quantizer)
{
lasreader->point.compute_coordinates();
geoprojectionconverter.to_target(lasreader->point.coordinates);
lasreader->point.compute_xyz(reproject_quantizer);
}
lasinventory.add(&lasreader->point);
}
lasreader->close();
lasreader->header.number_of_point_records = lasinventory.number_of_point_records;
for (i = 0; i < 5; i++) lasreader->header.number_of_points_by_return[i] = lasinventory.number_of_points_by_return[i+1];
if (reproject_quantizer) lasreader->header = *reproject_quantizer;
lasreader->header.max_x = lasreader->header.get_x(lasinventory.raw_max_x);
lasreader->header.min_x = lasreader->header.get_x(lasinventory.raw_min_x);
lasreader->header.max_y = lasreader->header.get_y(lasinventory.raw_max_y);
lasreader->header.min_y = lasreader->header.get_y(lasinventory.raw_min_y);
lasreader->header.max_z = lasreader->header.get_z(lasinventory.raw_max_z);
lasreader->header.min_z = lasreader->header.get_z(lasinventory.raw_min_z);
if (verbose) { fprintf(stderr,"extra pass took %g sec.\n", taketime()-start_time); start_time = taketime(); }
#ifdef _WIN32
if (verbose) fprintf(stderr, "piped output: reading %I64d and writing %u points ...\n", lasreader->npoints, lasinventory.number_of_point_records);
#else
if (verbose) fprintf(stderr, "piped output: reading %lld and writing %u points ...\n", lasreader->npoints, lasinventory.number_of_point_records);
#endif
}
else
{
if (reproject_quantizer)
{
saved_quantizer = new LASquantizer();
*saved_quantizer = lasreader->header;
lasreader->header = *reproject_quantizer;
}
#ifdef _WIN32
if (verbose) fprintf(stderr, "reading %I64d and writing all surviving points ...\n", lasreader->npoints);
#else
if (verbose) fprintf(stderr, "reading %lld and writing all surviving points ...\n", lasreader->npoints);
#endif
}
// check output
if (!laswriteopener.active())
{
// create name from input name
laswriteopener.make_file_name(lasreadopener.get_file_name());
}
// prepare the header for the surviving points
strncpy(lasreader->header.system_identifier, "LAStools (c) by Martin Isenburg", 32);
lasreader->header.system_identifier[31] = '\0';
char temp[64];
sprintf(temp, "las2las (version %d)", LAS_TOOLS_VERSION);
strncpy(lasreader->header.generating_software, temp, 32);
lasreader->header.generating_software[31] = '\0';
// open laswriter
LASwriter* laswriter = laswriteopener.open(&lasreader->header);
if (laswriter == 0)
{
fprintf(stderr, "ERROR: could not open laswriter\n");
byebye(true, argc==1);
}
// for piped output we need to re-open the input file
if (extra_pass)
{
if (!lasreadopener.reopen(lasreader))
{
fprintf(stderr, "ERROR: could not re-open lasreader\n");
byebye(true);
}
}
else
{
if (reproject_quantizer)
{
lasreader->header = *saved_quantizer;
delete saved_quantizer;
}
}
// maybe seek to start position
if (subsequence_start) lasreader->seek(subsequence_start);
// loop over points
if (point)
{
while (lasreader->read_point())
{
if (lasreader->p_count > subsequence_stop) break;
if (clip_to_bounding_box)
{
if (!lasreader->point.inside_box(lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z))
{
continue;
}
}
if (reproject_quantizer)
{
lasreader->point.compute_coordinates();
geoprojectionconverter.to_target(lasreader->point.coordinates);
lasreader->point.compute_xyz(reproject_quantizer);
}
*point = lasreader->point;
laswriter->write_point(point);
// without extra pass we need inventory of surviving points
if (!extra_pass) laswriter->update_inventory(point);
}
delete point;
point = 0;
}
else
{
while (lasreader->read_point())
{
if (lasreader->p_count > subsequence_stop) break;
if (clip_to_bounding_box)
{
if (!lasreader->point.inside_box(lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z))
{
continue;
}
}
if (reproject_quantizer)
{
lasreader->point.compute_coordinates();
geoprojectionconverter.to_target(lasreader->point.coordinates);
lasreader->point.compute_xyz(reproject_quantizer);
}
laswriter->write_point(&lasreader->point);
// without extra pass we need inventory of surviving points
if (!extra_pass) laswriter->update_inventory(&lasreader->point);
}
}
// without the extra pass we need to fix the header now
if (!extra_pass)
{
if (reproject_quantizer) lasreader->header = *reproject_quantizer;
laswriter->update_header(&lasreader->header, TRUE);
if (verbose) { fprintf(stderr,"total time: %g sec. written %u surviving points.\n", taketime()-start_time, (U32)laswriter->p_count); }
}
else
{
if (verbose) { fprintf(stderr,"main pass took %g sec.\n", taketime()-start_time); }
}
laswriter->close();
delete laswriter;
lasreader->close();
delete lasreader;
if (reproject_quantizer) delete reproject_quantizer;
laswriteopener.set_file_name(0);
}
byebye(false, argc==1);
return 0;
}
int main(int argc, char *argv[])
{
double start_time = 0.0;
char* file_name_in = 0;
char* file_name_out = 0;
// load LASzip DLL
if (laszip_load_dll())
{
fprintf(stderr,"DLL ERROR: loading LASzip DLL\n");
byebye(true, argc==1);
}
// get version of LASzip DLL
laszip_U8 version_major;
laszip_U8 version_minor;
laszip_U16 version_revision;
laszip_U32 version_build;
if (laszip_get_version(&version_major, &version_minor, &version_revision, &version_build))
{
fprintf(stderr,"DLL ERROR: getting LASzip DLL version number\n");
byebye(true, argc==1);
}
fprintf(stderr,"LASzip DLL v%d.%d r%d (build %d)\n", (int)version_major, (int)version_minor, (int)version_revision, (int)version_build);
if (argc == 1)
{
char file_name[256];
fprintf(stderr,"%s is better run in the command line\n", argv[0]);
fprintf(stderr,"enter input file%s: ", ((EXAMPLE == EXAMPLE_THREE) ? " (not used)" : "")); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
file_name_in = strdup(file_name);
fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
file_name_out = strdup(file_name);
}
else if (argc == 3)
{
file_name_in = strdup(argv[1]);
file_name_out = strdup(argv[2]);
}
else
{
if ((argc != 2) || (strcmp(argv[1], "-h") != 0))
{
fprintf(stderr, "ERROR: cannot understand arguments\n");
}
usage();
}
start_time = taketime();
if (EXAMPLE == EXAMPLE_ONE)
{
fprintf(stderr,"running EXAMPLE_ONE\n");
// create the reader
laszip_POINTER laszip_reader;
if (laszip_create(&laszip_reader))
{
fprintf(stderr,"DLL ERROR: creating laszip reader\n");
byebye(true, argc==1);
}
// open the reader
laszip_BOOL is_compressed = 0;
if (laszip_open_reader(laszip_reader, file_name_in, &is_compressed))
{
fprintf(stderr,"DLL ERROR: opening laszip reader for '%s'\n", file_name_in);
byebye(true, argc==1, laszip_reader);
}
fprintf(stderr,"file '%s' is %scompressed\n", file_name_in, (is_compressed ? "" : "un"));
// get a pointer to the header of the reader that was just populated
laszip_header* header;
if (laszip_get_header_pointer(laszip_reader, &header))
{
fprintf(stderr,"DLL ERROR: getting header pointer from laszip reader\n");
byebye(true, argc==1, laszip_reader);
}
// report how many points the file has
fprintf(stderr,"file '%s' contains %u points\n", file_name_in, header->number_of_point_records);
// get a pointer to the points that will be read
laszip_point* point;
if (laszip_get_point_pointer(laszip_reader, &point))
{
fprintf(stderr,"DLL ERROR: getting point pointer from laszip reader\n");
byebye(true, argc==1, laszip_reader);
}
// create the writer
laszip_POINTER laszip_writer;
if (laszip_create(&laszip_writer))
{
fprintf(stderr,"DLL ERROR: creating laszip writer\n");
byebye(true, argc==1);
}
// initialize the header for the writer using the header of the reader
if (laszip_set_header(laszip_writer, header))
{
fprintf(stderr,"DLL ERROR: setting header for laszip writer\n");
byebye(true, argc==1, laszip_writer);
}
// open the writer
laszip_BOOL compress = (strstr(file_name_out, ".laz") != 0);
if (laszip_open_writer(laszip_writer, file_name_out, compress))
{
fprintf(stderr,"DLL ERROR: opening laszip writer for '%d'\n", file_name_out);
byebye(true, argc==1, laszip_writer);
}
fprintf(stderr,"writing file '%s' %scompressed\n", file_name_out, (compress ? "" : "un"));
// read the points
laszip_U32 count = 0;
while (count < header->number_of_point_records)
{
// read a point
if (laszip_read_point(laszip_reader))
{
fprintf(stderr,"DLL ERROR: reading point %u\n", count);
byebye(true, argc==1, laszip_reader);
}
// copy the point
if (laszip_set_point(laszip_writer, point))
{
fprintf(stderr,"DLL ERROR: setting point %u\n", count);
byebye(true, argc==1, laszip_writer);
}
// write the point
if (laszip_write_point(laszip_writer))
{
fprintf(stderr,"DLL ERROR: writing point %u\n", count);
byebye(true, argc==1, laszip_writer);
}
count++;
}
fprintf(stderr,"successfully read and written %u points\n", count);
// close the writer
if (laszip_close_writer(laszip_writer))
{
fprintf(stderr,"DLL ERROR: closing laszip writer\n");
byebye(true, argc==1, laszip_writer);
}
// destroy the writer
if (laszip_destroy(laszip_writer))
{
fprintf(stderr,"DLL ERROR: destroying laszip writer\n");
byebye(true, argc==1);
}
// close the reader
if (laszip_close_reader(laszip_reader))
{
fprintf(stderr,"DLL ERROR: closing laszip reader\n");
byebye(true, argc==1, laszip_reader);
}
// destroy the reader
if (laszip_destroy(laszip_reader))
{
fprintf(stderr,"DLL ERROR: destroying laszip reader\n");
byebye(true, argc==1);
}
fprintf(stderr,"total time: %g sec for reading %scompressed and writing %scompressed\n", taketime()-start_time, (is_compressed ? "" : "un"), (compress ? "" : "un"));
} // EXAMPLE_ONE
if (EXAMPLE == EXAMPLE_TWO)
{
fprintf(stderr,"running EXAMPLE_TWO\n");
// create the reader
laszip_POINTER laszip_reader;
if (laszip_create(&laszip_reader))
{
fprintf(stderr,"DLL ERROR: creating laszip reader\n");
byebye(true, argc==1);
}
// open the reader
laszip_BOOL is_compressed = 0;
if (laszip_open_reader(laszip_reader, file_name_in, &is_compressed))
{
fprintf(stderr,"DLL ERROR: opening laszip reader for '%s'\n", file_name_in);
byebye(true, argc==1, laszip_reader);
}
fprintf(stderr,"file '%s' is %scompressed\n", file_name_in, (is_compressed ? "" : "un"));
// get a pointer to the header of the reader that was just populated
laszip_header* header_read;
if (laszip_get_header_pointer(laszip_reader, &header_read))
{
fprintf(stderr,"DLL ERROR: getting header pointer from laszip reader\n");
byebye(true, argc==1, laszip_reader);
}
// report how many points the file has
fprintf(stderr,"file '%s' contains %u points\n", file_name_in, header_read->number_of_point_records);
// create the writer
laszip_POINTER laszip_writer;
if (laszip_create(&laszip_writer))
{
fprintf(stderr,"DLL ERROR: creating laszip writer\n");
byebye(true, argc==1);
}
// get a pointer to the header of the writer so we can populate it
laszip_header* header_write;
if (laszip_get_header_pointer(laszip_writer, &header_write))
{
fprintf(stderr,"DLL ERROR: getting header pointer from laszip writer\n");
byebye(true, argc==1, laszip_writer);
}
// copy entries from the reader header to the writer header
laszip_U32 i;
header_write->file_source_ID = header_read->file_source_ID;
header_write->global_encoding = header_read->global_encoding;
header_write->project_ID_GUID_data_1 = header_read->project_ID_GUID_data_1;
header_write->project_ID_GUID_data_2 = header_read->project_ID_GUID_data_2;
header_write->project_ID_GUID_data_3 = header_read->project_ID_GUID_data_3;
memcpy(header_write->project_ID_GUID_data_4, header_read->project_ID_GUID_data_4, 8);
header_write->version_major = header_read->version_major;
header_write->version_minor = header_read->version_minor;
memcpy(header_write->system_identifier, header_read->system_identifier, 32);
memcpy(header_write->generating_software, header_read->generating_software, 32);
header_write->file_creation_day = header_read->file_creation_day;
header_write->file_creation_year = header_read->file_creation_year;
header_write->header_size = header_read->header_size;
header_write->offset_to_point_data = header_read->header_size; /* note !!! */
header_write->number_of_variable_length_records = header_read->number_of_variable_length_records;
header_write->point_data_format = header_read->point_data_format;
header_write->point_data_record_length = header_read->point_data_record_length;
header_write->number_of_point_records = header_read->number_of_point_records;
for (i = 0; i < 5; i++)
{
header_write->number_of_points_by_return[i] = header_read->number_of_points_by_return[i];
}
header_write->x_scale_factor = header_read->x_scale_factor;
header_write->y_scale_factor = header_read->y_scale_factor;
header_write->z_scale_factor = header_read->z_scale_factor;
header_write->x_offset = header_read->x_offset;
header_write->y_offset = header_read->y_offset;
header_write->z_offset = header_read->z_offset;
header_write->max_x = header_read->max_x;
header_write->min_x = header_read->min_x;
header_write->max_y = header_read->max_y;
header_write->min_y = header_read->min_y;
header_write->max_z = header_read->max_z;
header_write->min_z = header_read->min_z;
// LAS 1.3 and higher only
header_write->start_of_waveform_data_packet_record = header_read->start_of_waveform_data_packet_record;
// LAS 1.4 and higher only
header_write->start_of_first_extended_variable_length_record = header_read->start_of_first_extended_variable_length_record;
header_write->number_of_extended_variable_length_records = header_read->number_of_extended_variable_length_records;
header_write->extended_number_of_point_records = header_read->extended_number_of_point_records;
for (i = 0; i < 15; i++)
{
header_write->extended_number_of_points_by_return[i] = header_read->extended_number_of_points_by_return[i];
}
// we may modify output because we omit any user defined data that may be ** the header
if (header_read->user_data_in_header_size)
{
header_write->header_size -= header_read->user_data_in_header_size;
header_write->offset_to_point_data -= header_read->user_data_in_header_size;
fprintf(stderr,"omitting %d bytes of user_data_in_header\n", header_read->user_data_after_header_size);
}
// add all the VLRs
if (header_read->number_of_variable_length_records)
{
fprintf(stderr,"offset_to_point_data before adding %u VLRs is %d\n", header_read->number_of_variable_length_records, (laszip_I32)header_write->offset_to_point_data);
for (i = 0; i < header_read->number_of_variable_length_records; i++)
{
if (laszip_add_vlr(laszip_writer, &(header_read->vlrs[i])))
{
fprintf(stderr,"DLL ERROR: adding VLR %u of %u to the header of the laszip writer\n", i+i, header_read->number_of_variable_length_records);
byebye(true, argc==1, laszip_writer);
}
fprintf(stderr," after adding VLR number %u is %d\n", i+1, (laszip_I32)header_write->offset_to_point_data);
}
}
// we may modify output because we omit any user defined data that may be *after* the header
if (header_read->user_data_after_header_size)
{
fprintf(stderr,"omitting %d bytes of user_data_after_header\n", header_read->user_data_after_header_size);
}
// open the writer
laszip_BOOL compress = (strstr(file_name_out, ".laz") != 0);
if (laszip_open_writer(laszip_writer, file_name_out, compress))
{
fprintf(stderr,"DLL ERROR: opening laszip writer for '%d'\n", file_name_out);
byebye(true, argc==1, laszip_writer);
}
fprintf(stderr,"writing file '%s' %scompressed\n", file_name_out, (compress ? "" : "un"));
// get a pointer to the point of the reader will be read
laszip_point* point_read;
if (laszip_get_point_pointer(laszip_reader, &point_read))
{
fprintf(stderr,"DLL ERROR: getting point pointer from laszip reader\n");
byebye(true, argc==1, laszip_reader);
}
// get a pointer to the point of the writer that we will populate and write
laszip_point* point_write;
if (laszip_get_point_pointer(laszip_writer, &point_write))
{
fprintf(stderr,"DLL ERROR: getting point pointer from laszip writer\n");
byebye(true, argc==1, laszip_writer);
}
// read the points
laszip_U32 count = 0;
while (count < header_read->number_of_point_records)
{
// read a point
if (laszip_read_point(laszip_reader))
{
fprintf(stderr,"DLL ERROR: reading point %u\n", count);
byebye(true, argc==1, laszip_reader);
}
// copy the point
point_write->X = point_read->X;
point_write->Y = point_read->Y;
point_write->Z = point_read->Z;
point_write->intensity = point_read->intensity;
point_write->return_number = point_read->return_number;
point_write->number_of_returns_of_given_pulse = point_read->number_of_returns_of_given_pulse;
point_write->scan_direction_flag = point_read->scan_direction_flag;
point_write->edge_of_flight_line = point_read->edge_of_flight_line;
point_write->classification = point_read->classification;
point_write->scan_angle_rank = point_read->scan_angle_rank;
point_write->user_data = point_read->user_data;
point_write->point_source_ID = point_read->point_source_ID;
point_write->gps_time = point_read->gps_time;
memcpy(point_write->rgb, point_read->rgb, 8);
memcpy(point_write->wave_packet, point_read->wave_packet, 29);
// LAS 1.4 only
point_write->extended_point_type = point_read->extended_point_type;
point_write->extended_scanner_channel = point_read->extended_scanner_channel;
point_write->extended_classification_flags = point_read->extended_classification_flags;
point_write->extended_classification = point_read->extended_classification;
point_write->extended_return_number = point_read->extended_return_number;
point_write->extended_number_of_returns_of_given_pulse = point_read->extended_number_of_returns_of_given_pulse;
point_write->extended_scan_angle = point_read->extended_scan_angle;
if (point_read->num_extra_bytes)
{
memcpy(point_write->extra_bytes, point_read->extra_bytes, point_read->num_extra_bytes);
}
// write the point
if (laszip_write_point(laszip_writer))
{
fprintf(stderr,"DLL ERROR: writing point %u\n", count);
byebye(true, argc==1, laszip_writer);
}
count++;
}
fprintf(stderr,"successfully read and written %u points\n", count);
// close the writer
if (laszip_close_writer(laszip_writer))
{
fprintf(stderr,"DLL ERROR: closing laszip writer\n");
byebye(true, argc==1, laszip_writer);
}
// destroy the writer
if (laszip_destroy(laszip_writer))
{
fprintf(stderr,"DLL ERROR: destroying laszip writer\n");
byebye(true, argc==1);
}
// close the reader
if (laszip_close_reader(laszip_reader))
{
fprintf(stderr,"DLL ERROR: closing laszip reader\n");
byebye(true, argc==1, laszip_reader);
}
// destroy the reader
if (laszip_destroy(laszip_reader))
{
fprintf(stderr,"DLL ERROR: destroying laszip reader\n");
byebye(true, argc==1);
}
fprintf(stderr,"total time: %g sec for reading %scompressed and writing %scompressed\n", taketime()-start_time, (is_compressed ? "" : "un"), (compress ? "" : "un"));
} // EXAMPLE_TWO
if (EXAMPLE == EXAMPLE_THREE)
{
fprintf(stderr,"running EXAMPLE_THREE\n");
// create the writer
laszip_POINTER laszip_writer;
if (laszip_create(&laszip_writer))
{
fprintf(stderr,"DLL ERROR: creating laszip writer\n");
byebye(true, argc==1);
}
// get a pointer to the header of the writer so we can populate it
laszip_header* header;
if (laszip_get_header_pointer(laszip_writer, &header))
{
fprintf(stderr,"DLL ERROR: getting header pointer from laszip writer\n");
byebye(true, argc==1, laszip_writer);
}
// populate the header
header->global_encoding = 0; // see LAS specification for details
header->version_major = 1;
header->version_minor = 2;
strncpy(header->system_identifier, "my LAS file writer", 32);
header->file_creation_day = 120;
header->file_creation_year = 2013;
header->point_data_format = 1;
header->point_data_record_length = 28;
header->number_of_point_records = 5;
header->number_of_points_by_return[0] = 3;
header->number_of_points_by_return[1] = 2;
header->max_x = 630499.95;
header->min_x = 630498.56;
header->max_y = 4834749.66;
header->min_y = 4834748.73;
header->max_z = 63.68;
header->min_z = 61.33;
// optional: use the bounding box and the scale factor to create a "good" offset
if (laszip_auto_offset(laszip_writer))
{
fprintf(stderr,"DLL ERROR: during automatic offset creation\n");
byebye(true, argc==1, laszip_writer);
}
// create some funny VLR
laszip_vlr funny_vlr;
memset(&funny_vlr, 0, sizeof(laszip_vlr));
strcpy(funny_vlr.user_id, "funny");
funny_vlr.record_id = 12345;
funny_vlr.record_length_after_header = 0;
strcpy(funny_vlr.description, "just a funny VLR");
// add the funny VLR
fprintf(stderr,"offset_to_point_data before adding funny VLR is : %d\n", (laszip_I32)header->offset_to_point_data);
if (laszip_add_vlr(laszip_writer, &funny_vlr))
{
fprintf(stderr,"DLL ERROR: adding funny VLR to the header\n");
byebye(true, argc==1, laszip_writer);
}
// create the geokeys with the projection information
laszip_geokey_struct key_entries[5];
// projected coordinates
key_entries[0].key_id = 1024; // GTModelTypeGeoKey
key_entries[0].tiff_tag_location = 0;
key_entries[0].count = 1;
key_entries[0].value_offset = 1; // ModelTypeProjected
// projection
key_entries[1].key_id = 3072; // ProjectedCSTypeGeoKey
key_entries[1].tiff_tag_location = 0;
key_entries[1].count = 1;
key_entries[1].value_offset = 32613; // PCS_WGS84_UTM_zone_13N
// horizontal units
key_entries[2].key_id = 3076; // ProjLinearUnitsGeoKey
key_entries[2].tiff_tag_location = 0;
key_entries[2].count = 1;
key_entries[2].value_offset = 9001; // meters
// vertical units
key_entries[3].key_id = 4099; // VerticalUnitsGeoKey
key_entries[3].tiff_tag_location = 0;
key_entries[3].count = 1;
key_entries[3].value_offset = 9001; // meters
// vertical datum
key_entries[4].key_id = 4096; // VerticalCSTypeGeoKey
key_entries[4].tiff_tag_location = 0;
key_entries[4].count = 1;
key_entries[4].value_offset = 5030; // WGS84
// add the geokeys (create or replace the appropriate VLR)
fprintf(stderr," before adding projection VLR : %d\n", (laszip_I32)header->offset_to_point_data);
if (laszip_set_geokeys(laszip_writer, 5, key_entries))
{
fprintf(stderr,"DLL ERROR: adding funny VLR to the header\n");
byebye(true, argc==1, laszip_writer);
}
fprintf(stderr," after adding two VLRs : %d\n", (laszip_I32)header->offset_to_point_data);
// open the writer
laszip_BOOL compress = (strstr(file_name_out, ".laz") != 0);
if (laszip_open_writer(laszip_writer, file_name_out, compress))
{
fprintf(stderr,"DLL ERROR: opening laszip writer for '%d'\n", file_name_out);
byebye(true, argc==1, laszip_writer);
}
fprintf(stderr,"writing file '%s' %scompressed\n", file_name_out, (compress ? "" : "un"));
// get a pointer to the point of the writer that we will populate and write
laszip_point* point;
if (laszip_get_point_pointer(laszip_writer, &point))
{
fprintf(stderr,"DLL ERROR: getting point pointer from laszip writer\n");
byebye(true, argc==1, laszip_writer);
}
// write five points
laszip_I64 count = 0;
laszip_F64 coordinates[3];
// populate the first point
coordinates[0] = 630499.95;
coordinates[1] = 4834749.17;
coordinates[2] = 62.15;
if (laszip_set_coordinates(laszip_writer, coordinates))
{
fprintf(stderr,"DLL ERROR: setting coordinates for point %u\n", (laszip_U32)count);
byebye(true, argc==1, laszip_writer);
}
point->intensity = 60;
point->return_number = 2;
point->number_of_returns_of_given_pulse = 2;
point->classification = 2;
point->scan_angle_rank = 21;
point->gps_time = 413162.560400;
// write the first point
if (laszip_write_point(laszip_writer))
{
fprintf(stderr,"DLL ERROR: writing point %u\n", (laszip_U32)count);
byebye(true, argc==1, laszip_writer);
}
count++;
// populate the second point
coordinates[0] = 630499.83;
coordinates[1] = 4834748.88;
coordinates[2] = 62.68;
if (laszip_set_coordinates(laszip_writer, coordinates))
{
fprintf(stderr,"DLL ERROR: setting coordinates for point %u\n", (laszip_U32)count);
byebye(true, argc==1, laszip_writer);
}
point->intensity = 90;
point->return_number = 1;
point->number_of_returns_of_given_pulse = 1;
point->classification = 1;
point->scan_angle_rank = 21;
point->gps_time = 413162.563600;
// write the second point
if (laszip_write_point(laszip_writer))
{
fprintf(stderr,"DLL ERROR: writing point %u\n", (laszip_U32)count);
byebye(true, argc==1, laszip_writer);
}
count++;
// populate the third point
coordinates[0] = 630499.54;
coordinates[1] = 4834749.66;
coordinates[2] = 62.66;
if (laszip_set_coordinates(laszip_writer, coordinates))
{
fprintf(stderr,"DLL ERROR: setting coordinates for point %u\n", (laszip_U32)count);
byebye(true, argc==1, laszip_writer);
}
point->intensity = 70;
point->return_number = 1;
point->number_of_returns_of_given_pulse = 1;
point->classification = 1;
point->scan_angle_rank = 22;
point->gps_time = 413162.566800;
// write the third point
if (laszip_write_point(laszip_writer))
{
fprintf(stderr,"DLL ERROR: writing point %u\n", (laszip_U32)count);
byebye(true, argc==1, laszip_writer);
}
count++;
// populate the fourth point
coordinates[0] = 630498.56;
coordinates[1] = 4834749.41;
coordinates[2] = 63.68;
if (laszip_set_coordinates(laszip_writer, coordinates))
{
fprintf(stderr,"DLL ERROR: setting coordinates for point %u\n", (laszip_U32)count);
byebye(true, argc==1, laszip_writer);
}
point->intensity = 20;
point->return_number = 1;
point->number_of_returns_of_given_pulse = 2;
point->classification = 3;
point->scan_angle_rank = 22;
point->gps_time = 413162.580200;
// write the fourth point
if (laszip_write_point(laszip_writer))
{
fprintf(stderr,"DLL ERROR: writing point %u\n", (laszip_U32)count);
byebye(true, argc==1, laszip_writer);
}
count++;
// populate the fifth point
coordinates[0] = 630498.80;
coordinates[1] = 4834748.73;
coordinates[2] = 62.16;
if (laszip_set_coordinates(laszip_writer, coordinates))
{
fprintf(stderr,"DLL ERROR: setting coordinates for point %u\n", (laszip_U32)count);
byebye(true, argc==1, laszip_writer);
}
point->intensity = 110;
point->return_number = 2;
point->number_of_returns_of_given_pulse = 2;
point->classification = 2;
point->scan_angle_rank = 22;
point->gps_time = 413162.580200;
// write the fifth point
if (laszip_write_point(laszip_writer))
{
fprintf(stderr,"DLL ERROR: writing point %u\n", (laszip_U32)count);
byebye(true, argc==1, laszip_writer);
}
count++;
// get the number of points written so far
if (laszip_get_point_count(laszip_writer, &count))
{
fprintf(stderr,"DLL ERROR: getting point count\n");
byebye(true, argc==1, laszip_writer);
}
fprintf(stderr,"successfully written %u points\n", (laszip_U32)count);
// close the writer
if (laszip_close_writer(laszip_writer))
{
fprintf(stderr,"DLL ERROR: closing laszip writer\n");
byebye(true, argc==1, laszip_writer);
}
// destroy the writer
if (laszip_destroy(laszip_writer))
{
fprintf(stderr,"DLL ERROR: destroying laszip writer\n");
byebye(true, argc==1);
}
fprintf(stderr,"total time: %g sec for writing %scompressed\n", taketime()-start_time, (compress ? "" : "un"));
} // EXAMPLE_THREE
if (EXAMPLE == EXAMPLE_FOUR)
{
fprintf(stderr,"running EXAMPLE_FOUR\n");
// create the reader
laszip_POINTER laszip_reader;
if (laszip_create(&laszip_reader))
{
fprintf(stderr,"DLL ERROR: creating laszip reader\n");
byebye(true, argc==1);
}
// signal that spatial queries are coming
laszip_BOOL exploit = 1;
if (laszip_exploit_spatial_index(laszip_reader, exploit))
{
fprintf(stderr,"DLL ERROR: signaling laszip reader that spatial queries are coming for '%s'\n", file_name_in);
byebye(true, argc==1, laszip_reader);
}
// open the reader
laszip_BOOL is_compressed = 0;
if (laszip_open_reader(laszip_reader, file_name_in, &is_compressed))
{
fprintf(stderr,"DLL ERROR: opening laszip reader for '%s'\n", file_name_in);
byebye(true, argc==1, laszip_reader);
}
fprintf(stderr,"file '%s' is %scompressed\n", file_name_in, (is_compressed ? "" : "un"));
// check whether spatial indexing information is available
laszip_BOOL is_indexed = 0;
laszip_BOOL is_appended = 0;
if (laszip_has_spatial_index(laszip_reader, &is_indexed, &is_appended))
{
fprintf(stderr,"DLL ERROR: checking laszip reader whether spatial indexing information is present for '%s'\n", file_name_in);
byebye(true, argc==1, laszip_reader);
}
fprintf(stderr,"file '%s' does %shave spatial indexing information\n", file_name_in, (is_indexed ? "" : "not "));
// get a pointer to the header of the reader that was just populated
laszip_header* header;
if (laszip_get_header_pointer(laszip_reader, &header))
{
fprintf(stderr,"DLL ERROR: getting header pointer from laszip reader\n");
byebye(true, argc==1, laszip_reader);
}
// report how many points the file has
fprintf(stderr,"file '%s' contains %u points\n", file_name_in, header->number_of_point_records);
// create a rectangular box enclosing a subset of points at the center of the full bounding box
const laszip_F64 sub = 0.05;
laszip_F64 mid_x = (header->min_x + header->max_x) / 2;
laszip_F64 mid_y = (header->min_y + header->max_y) / 2;
laszip_F64 range_x = header->max_x - header->min_x;
laszip_F64 range_y = header->max_y - header->min_y;
laszip_F64 sub_min_x = mid_x - sub * range_x;
laszip_F64 sub_min_y = mid_y - sub * range_y;
laszip_F64 sub_max_x = mid_x + sub * range_x;
laszip_F64 sub_max_y = mid_y + sub * range_y;
// request the reader to only read this specified rectangular subset of points
laszip_BOOL is_empty = 0;
if (laszip_inside_rectangle(laszip_reader, sub_min_x, sub_min_y, sub_max_x, sub_max_y, &is_empty))
{
fprintf(stderr,"DLL ERROR: requesting points inside of rectangle [%g,%g] (%g,%g) from laszip reader\n", sub_min_x, sub_min_y, sub_max_x, sub_max_y);
byebye(true, argc==1, laszip_reader);
}
// get a pointer to the points that will be read
laszip_point* point;
if (laszip_get_point_pointer(laszip_reader, &point))
{
fprintf(stderr,"DLL ERROR: getting point pointer from laszip reader\n");
byebye(true, argc==1, laszip_reader);
}
// create the writer
laszip_POINTER laszip_writer;
if (laszip_create(&laszip_writer))
{
fprintf(stderr,"DLL ERROR: creating laszip writer\n");
byebye(true, argc==1);
}
// initialize the header for the writer using the header of the reader
if (laszip_set_header(laszip_writer, header))
{
fprintf(stderr,"DLL ERROR: setting header for laszip writer\n");
byebye(true, argc==1, laszip_writer);
}
// open the writer
laszip_BOOL compress = (strstr(file_name_out, ".laz") != 0);
if (laszip_open_writer(laszip_writer, file_name_out, compress))
{
fprintf(stderr,"DLL ERROR: opening laszip writer for '%d'\n", file_name_out);
byebye(true, argc==1, laszip_writer);
}
fprintf(stderr,"writing file '%s' %scompressed\n", file_name_out, (compress ? "" : "un"));
// read the points
laszip_U32 count = 0;
laszip_BOOL is_done = 0;
while (count < header->number_of_point_records)
{
// read a point
if (laszip_read_inside_point(laszip_reader, &is_done))
{
fprintf(stderr,"DLL ERROR: reading point %u\n", count);
byebye(true, argc==1, laszip_reader);
}
// are we done reading
if (is_done)
{
break;
}
// copy the point
if (laszip_set_point(laszip_writer, point))
{
fprintf(stderr,"DLL ERROR: setting point %u\n", count);
byebye(true, argc==1, laszip_writer);
}
// write the point
if (laszip_write_point(laszip_writer))
{
fprintf(stderr,"DLL ERROR: writing point %u\n", count);
byebye(true, argc==1, laszip_writer);
}
// update the inventory
if (laszip_update_inventory(laszip_writer))
{
fprintf(stderr,"DLL ERROR: updating inventory for point %u\n", count);
byebye(true, argc==1, laszip_writer);
}
count++;
}
fprintf(stderr,"successfully read and written %u points\n", count);
// close the writer
if (laszip_close_writer(laszip_writer))
{
fprintf(stderr,"DLL ERROR: closing laszip writer\n");
byebye(true, argc==1, laszip_writer);
}
// destroy the writer
if (laszip_destroy(laszip_writer))
{
fprintf(stderr,"DLL ERROR: destroying laszip writer\n");
byebye(true, argc==1);
}
// close the reader
if (laszip_close_reader(laszip_reader))
{
fprintf(stderr,"DLL ERROR: closing laszip reader\n");
byebye(true, argc==1, laszip_reader);
}
// destroy the reader
if (laszip_destroy(laszip_reader))
{
fprintf(stderr,"DLL ERROR: destroying laszip reader\n");
byebye(true, argc==1);
}
fprintf(stderr,"total time: %g sec for reading %scompressed and writing %scompressed\n", taketime()-start_time, (is_compressed ? "" : "un"), (compress ? "" : "un"));
} // EXAMPLE_FOUR
if (EXAMPLE == EXAMPLE_FIVE)
{
fprintf(stderr,"running EXAMPLE_FIVE\n");
// create the reader
laszip_POINTER laszip_reader;
if (laszip_create(&laszip_reader))
{
fprintf(stderr,"DLL ERROR: creating laszip reader\n");
byebye(true, argc==1);
}
// open the reader
laszip_BOOL is_compressed = 0;
if (laszip_open_reader(laszip_reader, file_name_in, &is_compressed))
{
fprintf(stderr,"DLL ERROR: opening laszip reader for '%s'\n", file_name_in);
byebye(true, argc==1, laszip_reader);
}
fprintf(stderr,"file '%s' is %scompressed\n", file_name_in, (is_compressed ? "" : "un"));
// get a pointer to the header of the reader that was just populated
laszip_header* header;
if (laszip_get_header_pointer(laszip_reader, &header))
{
fprintf(stderr,"DLL ERROR: getting header pointer from laszip reader\n");
byebye(true, argc==1, laszip_reader);
}
// report how many points the file has
fprintf(stderr,"file '%s' contains %u points\n", file_name_in, header->number_of_point_records);
// get a pointer to the points that will be read
laszip_point* point;
if (laszip_get_point_pointer(laszip_reader, &point))
{
fprintf(stderr,"DLL ERROR: getting point pointer from laszip reader\n");
byebye(true, argc==1, laszip_reader);
}
// create the writer
laszip_POINTER laszip_writer;
if (laszip_create(&laszip_writer))
{
fprintf(stderr,"DLL ERROR: creating laszip writer\n");
byebye(true, argc==1);
}
// initialize the header for the writer using the header of the reader
if (laszip_set_header(laszip_writer, header))
{
fprintf(stderr,"DLL ERROR: setting header for laszip writer\n");
byebye(true, argc==1, laszip_writer);
}
// enable the creation of spatial indices
laszip_BOOL create = 1;
laszip_BOOL append = 0; /* not supported yet */
if (laszip_create_spatial_index(laszip_writer, create, append))
{
fprintf(stderr,"DLL ERROR: signaling laszip writer to create spatial indexing information\n");
byebye(true, argc==1, laszip_writer);
}
// open the writer
laszip_BOOL compress = (strstr(file_name_out, ".laz") != 0);
if (laszip_open_writer(laszip_writer, file_name_out, compress))
{
fprintf(stderr,"DLL ERROR: opening laszip writer for '%d'\n", file_name_out);
byebye(true, argc==1, laszip_writer);
}
fprintf(stderr,"writing file '%s' spatially indexed and %scompressed\n", file_name_out, (compress ? "" : "un"));
// read the points
laszip_U32 count = 0;
while (count < header->number_of_point_records)
{
// read a point
if (laszip_read_point(laszip_reader))
{
fprintf(stderr,"DLL ERROR: reading point %u\n", count);
byebye(true, argc==1, laszip_reader);
}
// copy the point
if (laszip_set_point(laszip_writer, point))
{
fprintf(stderr,"DLL ERROR: setting point %u\n", count);
byebye(true, argc==1, laszip_writer);
}
// write the point
if (laszip_write_indexed_point(laszip_writer))
{
fprintf(stderr,"DLL ERROR: writing indexed point %u\n", count);
byebye(true, argc==1, laszip_writer);
}
count++;
}
fprintf(stderr,"successfully read and written %u indexed points\n", count);
// close the writer
if (laszip_close_writer(laszip_writer))
{
fprintf(stderr,"DLL ERROR: closing laszip writer\n");
byebye(true, argc==1, laszip_writer);
}
// destroy the writer
if (laszip_destroy(laszip_writer))
{
fprintf(stderr,"DLL ERROR: destroying laszip writer\n");
byebye(true, argc==1);
}
// close the reader
if (laszip_close_reader(laszip_reader))
{
fprintf(stderr,"DLL ERROR: closing laszip reader\n");
byebye(true, argc==1, laszip_reader);
}
// destroy the reader
if (laszip_destroy(laszip_reader))
{
fprintf(stderr,"DLL ERROR: destroying laszip reader\n");
byebye(true, argc==1);
}
fprintf(stderr,"total time: %g sec for reading %scompressed and writing indexed & %scompressed\n", taketime()-start_time, (is_compressed ? "" : "un"), (compress ? "" : "un"));
} // EXAMPLE_FIVE
// unload LASzip DLL
if (laszip_unload_dll())
{
fprintf(stderr,"DLL ERROR: unloading LASzip DLL\n");
byebye(true, argc==1);
}
return 0;
}
int main(int argc, char *argv[])
{
int i;
BOOL verbose = TRUE;
BOOL very_verbose = TRUE;
F64 start_time = 0.0;
F64 full_start_time = 0.0;
const CHAR* xml_output_file = 0;
BOOL one_report_per_file = FALSE;
U32 num_pass = 0;
U32 num_fail = 0;
U32 num_warning = 0;
fprintf(stderr, "This is version '%s' of the LAS validator. Please contact\n", "GRiD-1");
fprintf(stderr, "me at '*****@*****.**' if you disagree with\n");
fprintf(stderr, "validation reports, want additional checks, or find bugs as\n");
fprintf(stderr, "the software is still under development. Your feedback will\n");
fprintf(stderr, "help to finish it sooner.\n");
LASreadOpener lasreadopener;
if (argc == 1)
{
fprintf(stderr,"lasvalidate.exe is best run with arguments in the command line\n");
char file_name[256];
fprintf(stderr,"enter input LAS file name: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
lasreadopener.set_file_name(file_name);
fprintf(stderr,"enter output XML file name: "); fgets(file_name, 256, stdin);
file_name[strlen(file_name)-1] = '\0';
xml_output_file = strdup(file_name);
}
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i],"-version") == 0)
{
fprintf(stderr, "\nlasvalidate %d with LASread (v %d.%d %d) and LAScheck (v %d.%d %d) by rapidlasso GmbH\n", VALIDATE_VERSION, LASREAD_VERSION_MAJOR, LASREAD_VERSION_MINOR, LASREAD_BUILD_DATE, LASCHECK_VERSION_MAJOR, LASCHECK_VERSION_MINOR, LASCHECK_BUILD_DATE);
byebye(LAS_VALIDATE_SUCCESS);
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0)
{
lasreadopener.usage();
usage(LAS_VALIDATE_SUCCESS);
}
else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0)
{
verbose = TRUE;
}
else if (strcmp(argv[i],"-vv") == 0 || strcmp(argv[i],"-very_verbose") == 0)
{
verbose = TRUE;
very_verbose = TRUE;
}
else if (strcmp(argv[i],"-i") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs at least 1 argument: file_name or wild_card\n", argv[i]);
usage(LAS_VALIDATE_WRONG_COMMAND_LINE_SYNTAX);
}
i+=1;
do
{
lasreadopener.add_file_name(argv[i]);
i+=1;
} while (i < argc && *argv[i] != '-');
i-=1;
}
else if (strcmp(argv[i],"-irec") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs at least 1 argument: directory_name\n", argv[i]);
usage(LAS_VALIDATE_WRONG_COMMAND_LINE_SYNTAX);
}
i+=1;
do
{
lasreadopener.add_directory(argv[i], TRUE);
i+=1;
} while (i < argc && *argv[i] != '-');
i-=1;
}
else if (strcmp(argv[i],"-stdin") == 0)
{
lasreadopener.set_piped(TRUE);
}
else if (strcmp(argv[i],"-lof") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: list_of_files\n", argv[i]);
usage(LAS_VALIDATE_WRONG_COMMAND_LINE_SYNTAX);
}
FILE* file = fopen(argv[i+1], "r");
if (file == 0)
{
fprintf(stderr, "ERROR: cannot open '%s'\n", argv[i+1]);
return FALSE;
}
char line[1024];
while (fgets(line, 1024, file))
{
// find end of line
int len = strlen(line) - 1;
// remove extra white spaces and line return at the end
while (len > 0 && ((line[len] == '\n') || (line[len] == ' ') || (line[len] == '\t') || (line[len] == '\012')))
{
line[len] = '\0';
len--;
}
lasreadopener.add_file_name(line);
}
fclose(file);
i+=1;
}
else if (strcmp(argv[i],"-o") == 0)
{
i++;
xml_output_file = argv[i];
}
else if (strcmp(argv[i],"-oxml") == 0)
{
one_report_per_file = TRUE;
}
else
{
fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]);
usage(LAS_VALIDATE_WRONG_COMMAND_LINE_SYNTAX);
}
}
// in verbose mode we measure the total time
if (verbose) full_start_time = taketime();
// check input
if (!lasreadopener.is_active())
{
fprintf(stderr,"ERROR: no input specified\n");
byebye(LAS_VALIDATE_NO_INPUT_SPECIFIED, argc == 1);
}
// output logging
XMLwriter xmlwriter;
if (lasreadopener.is_active())
{
if (xml_output_file)
{
one_report_per_file = FALSE;
}
else if (!one_report_per_file)
{
xml_output_file = "validate.xml";
}
}
// maybe we are doing one summary report
if (xml_output_file)
{
if (!xmlwriter.open(xml_output_file, "LASvalidator"))
{
byebye(LAS_VALIDATE_WRITE_PERMISSION_ERROR, argc == 1);
}
}
// accumulated pass
U32 total_pass = VALIDATE_PASS;
// possibly loop over multiple input files
while (lasreadopener.is_active())
{
// in very verbose mode we measure the time for each file
if (very_verbose) start_time = taketime();
// open lasreader
LASreader* lasreader = lasreadopener.open();
if (lasreader == 0)
{
fprintf(stderr, "ERROR: could not open lasreader\n");
byebye(LAS_VALIDATE_INPUT_FILE_NOT_FOUND, argc == 1);
}
// get a pointer to the header
LASheader* lasheader = &lasreader->header;
// maybe we are doing one report per file
if (one_report_per_file)
{
int len = strlen(lasreadopener.get_path());
CHAR* current_xml_output_file = (CHAR*)malloc(len + 5);
strcpy(current_xml_output_file, lasreadopener.get_path());
current_xml_output_file[len-4] = '_';
current_xml_output_file[len-3] = 'L';
current_xml_output_file[len-2] = 'V';
current_xml_output_file[len-1] = 'S';
current_xml_output_file[len ] = '.';
current_xml_output_file[len+1] = 'x';
current_xml_output_file[len+2] = 'm';
current_xml_output_file[len+3] = 'l';
current_xml_output_file[len+4] = '\0';
if (!xmlwriter.open(current_xml_output_file, "LASvalidator"))
{
byebye(LAS_VALIDATE_WRITE_PERMISSION_ERROR, argc == 1);
}
free(current_xml_output_file);
}
// start a new report
xmlwriter.begin("report");
// report description of file
xmlwriter.beginsub("file");
xmlwriter.write("name", lasreadopener.get_file_name());
xmlwriter.write("path", lasreadopener.get_path());
CHAR temp[32];
sprintf(temp, "%d.%d", lasheader->version_major, lasheader->version_minor);
xmlwriter.write("version", temp);
strncpy(temp, lasheader->system_identifier, 32);
temp[31] = '\0';
xmlwriter.write("system_identifier", temp);
strncpy(temp, lasheader->generating_software, 32);
temp[31] = '\0';
xmlwriter.write("generating_software", temp);
xmlwriter.write("point_data_format", lasheader->point_data_format);
CHAR crsdescription[512];
strcpy(crsdescription, "not valid or not specified");
if (lasheader->fails == 0)
{
// header was loaded. now parse and check.
LAScheck lascheck(lasheader);
while (lasreader->read_point())
{
lascheck.parse(&lasreader->point);
}
// check header and points and get CRS description
lascheck.check(lasheader, crsdescription);
}
xmlwriter.write("CRS", crsdescription);
xmlwriter.endsub("file");
// report the verdict
U32 pass = (lasheader->fails ? VALIDATE_FAIL : VALIDATE_PASS);
if (lasheader->warnings) pass |= VALIDATE_WARNING;
xmlwriter.beginsub("summary");
xmlwriter.write((pass == VALIDATE_PASS ? "pass" : ((pass & VALIDATE_FAIL) ? "fail" : "warning")));
xmlwriter.endsub("summary");
// report details (if necessary)
if (pass != VALIDATE_PASS)
{
xmlwriter.beginsub("details");
for (i = 0; i < lasheader->fail_num; i+=2)
{
xmlwriter.write(lasheader->fails[i], "fail", lasheader->fails[i+1]);
}
for (i = 0; i < lasheader->warning_num; i+=2)
{
xmlwriter.write(lasheader->warnings[i], "warning", lasheader->warnings[i+1]);
}
xmlwriter.endsub("details");
total_pass |= pass;
if (pass & VALIDATE_FAIL)
{
num_fail++;
}
else
{
num_warning++;
}
}
else
{
num_pass++;
}
// end the report
xmlwriter.end("report");
// maybe we are doing one report per file
if (one_report_per_file)
{
// report the total verdict
xmlwriter.begin("total");
xmlwriter.write((total_pass == VALIDATE_PASS ? "pass" : ((total_pass & VALIDATE_FAIL) ? "fail" : "warning")));
xmlwriter.beginsub("details");
xmlwriter.write("pass", num_pass);
xmlwriter.write("warning", num_warning);
xmlwriter.write("fail", num_fail);
xmlwriter.endsub("details");
xmlwriter.end("total");
num_pass = 0;
num_warning = 0;
num_fail = 0;
// write which validator was used
write_version(xmlwriter);
// write which command line was used
write_command_line(xmlwriter, argc, argv);
// close the LASvalidator XML output file
xmlwriter.close("LASvalidator");
}
lasreader->close();
delete lasreader;
// in very verbose mode we report the time for each file
if (very_verbose)
{
fprintf(stderr,"needed %.2f sec for '%s'\n", taketime()-start_time, lasreadopener.get_file_name());
start_time = taketime();
}
}
// maybe we are doing one summary report
if (!one_report_per_file)
{
// report the total verdict
xmlwriter.begin("total");
xmlwriter.write((total_pass == 0 ? "pass" : ((total_pass & 1) ? "fail" : "warning")));
xmlwriter.beginsub("details");
xmlwriter.write("pass", num_pass);
xmlwriter.write("warning", num_warning);
xmlwriter.write("fail", num_fail);
xmlwriter.endsub("details");
xmlwriter.end("total");
// write which validator was used
write_version(xmlwriter);
// write which command line was used
write_command_line(xmlwriter, argc, argv);
// close the LASvalidator XML output file
xmlwriter.close("LASvalidator");
}
// in verbose mode we report the total time
if (verbose && (lasreadopener.get_file_name_number() > 1))
{
fprintf(stderr,"done. total time %.2f sec.\n", taketime()-full_start_time);
}
byebye(argc==1);
return 0;
}