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;
U32 tile_size = 100;
U32 threshold = 1000;
U32 minimum_points = 100000;
I32 maximum_intervals = -20;
double start_time = 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");
#endif
}
else if (strcmp(argv[i],"-tile") == 0 || strcmp(argv[i],"-size") == 0 || 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 = atoi(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 ((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 lasindex_gui(argc, argv, &lasreadopener);
}
#endif
#ifdef COMPILE_WITH_MULTI_CORE
if ((cores > 1) && (lasreadopener.get_file_name_number() > 1) && (!lasreadopener.get_merged()))
{
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
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;
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, (U32)(lasreader->p_count-1));
// adaptive coarsening
lasindex.complete(minimum_points, maximum_intervals);
// write to file
lasindex.write(lasreadopener.get_file_name());
lasreader->close();
delete lasreader;
}
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 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[])
{
int i;
bool dry = false;
#ifdef COMPILE_WITH_GUI
bool gui = false;
#endif
#ifdef COMPILE_WITH_MULTI_CORE
I32 cores = 1;
#endif
bool verbose = false;
bool waveform = false;
bool waveform_with_map = false;
bool report_file_size = false;
I32 end_of_points = -1;
bool projection_was_set = false;
bool lax = false;
U32 tile_size = 100;
U32 threshold = 1000;
U32 minimum_points = 100000;
I32 maximum_intervals = -20;
double start_time = 0.0;
LASreadOpener lasreadopener;
GeoProjectionConverter geoprojectionconverter;
LASwriteOpener laswriteopener;
if (argc == 1)
{
#ifdef COMPILE_WITH_GUI
return laszip_gui(argc, argv, 0);
#else
fprintf(stderr,"laszip.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 (!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],"-dry") == 0)
{
dry = true;
}
else if (strcmp(argv[i],"-lax") == 0)
{
lax = true;
}
else if (strcmp(argv[i],"-eop") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: char\n", argv[i]);
usage(true);
}
i++;
end_of_points = atoi(argv[i]);
if ((end_of_points < 0) || (end_of_points > 255))
{
fprintf(stderr,"ERROR: end of points value needs to be between 0 and 255\n");
usage(true);
}
}
else if (strcmp(argv[i],"-tile_size") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: size\n", argv[i]);
usage(true);
}
i++;
tile_size = atoi(argv[i]);
}
else if (strcmp(argv[i],"-maximum") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]);
usage(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]);
usage(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]);
usage(true);
}
i++;
threshold = atoi(argv[i]);
}
else if (strcmp(argv[i],"-size") == 0)
{
report_file_size = true;
}
else if (strcmp(argv[i],"-waveform") == 0 || strcmp(argv[i],"-waveforms") == 0)
{
waveform = true;
}
else if (strcmp(argv[i],"-waveform_with_map") == 0 || strcmp(argv[i],"-waveforms_with_map") == 0)
{
waveform = true;
waveform_with_map = 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 laszip_gui(argc, argv, &lasreadopener);
}
#endif
#ifdef COMPILE_WITH_MULTI_CORE
if ((cores > 1) && (lasreadopener.get_file_name_number() > 1) && (!lasreadopener.get_merged()))
{
return laszip_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);
}
// 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);
}
// 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);
}
// switch
if (report_file_size)
{
// maybe only report uncompressed file size
I64 uncompressed_file_size = (I64)lasreader->header.number_of_point_records * (I64)lasreader->header.point_data_record_length + lasreader->header.offset_to_point_data;
if (uncompressed_file_size == (I64)((U32)uncompressed_file_size))
fprintf(stderr,"uncompressed file size is %u bytes or %.2f MB for '%s'\n", (U32)uncompressed_file_size, (F64)uncompressed_file_size/1024.0/1024.0, lasreadopener.get_file_name());
else
fprintf(stderr,"uncompressed file size is %.2f MB or %.2f GB for '%s'\n", (F64)uncompressed_file_size/1024.0/1024.0, (F64)uncompressed_file_size/1024.0/1024.0/1024.0, lasreadopener.get_file_name());
}
else if (dry)
{
// maybe only a dry read pass
start_time = taketime();
while (lasreader->read_point());
fprintf(stderr,"needed %g secs to read '%s'\n", taketime()-start_time, lasreadopener.get_file_name());
}
else
{
I64 start_of_waveform_data_packet_record = 0;
// create output file name if no output was specified
if (!laswriteopener.active())
{
if (lasreadopener.get_file_name() == 0)
{
fprintf(stderr,"ERROR: no output specified\n");
usage(true, argc==1);
}
laswriteopener.set_force(TRUE);
laswriteopener.make_file_name(lasreadopener.get_file_name(), -2);
if (!laswriteopener.format_was_specified())
{
char* file_name_out = strdup(laswriteopener.get_file_name());
int len = strlen(file_name_out);
if (lasreader->get_format() == LAS_TOOLS_FORMAT_LAZ)
{
file_name_out[len-3] = 'l';
file_name_out[len-2] = 'a';
file_name_out[len-1] = 's';
}
else
{
file_name_out[len-3] = 'l';
file_name_out[len-2] = 'a';
file_name_out[len-1] = 'z';
}
laswriteopener.set_file_name(file_name_out);
free(file_name_out);
}
}
// 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();
}
// almost never open laswaveform13reader and laswaveform13writer (-:
LASwaveform13reader* laswaveform13reader = 0;
LASwaveform13writer* laswaveform13writer = 0;
if (waveform)
{
laswaveform13reader = lasreadopener.open_waveform13(&lasreader->header);
if (laswaveform13reader)
{
// switch compression on/off
U8 compression_type = (laswriteopener.get_format() == LAS_TOOLS_FORMAT_LAZ ? 1 : 0);
for (i = 0; i < 255; i++) if (lasreader->header.vlr_wave_packet_descr[i]) lasreader->header.vlr_wave_packet_descr[i]->setCompressionType(compression_type);
// create laswaveform13writer
laswaveform13writer = laswriteopener.open_waveform13(&lasreader->header);
if (laswaveform13writer == 0)
{
delete [] laswaveform13reader;
laswaveform13reader = 0;
waveform = 0;
// switch compression on/off back
U8 compression_type = (laswriteopener.get_format() == LAS_TOOLS_FORMAT_LAZ ? 0 : 1);
for (i = 0; i < 255; i++) if (lasreader->header.vlr_wave_packet_descr[i]) lasreader->header.vlr_wave_packet_descr[i]->setCompressionType(compression_type);
}
}
else
{
waveform = false;
}
}
// special check for LAS 1.3+ files that contain waveform data
if ((lasreader->header.version_major == 1) && (lasreader->header.version_minor >= 3))
{
if (lasreader->header.global_encoding & 2) // if bit # 1 is set we have internal waveform data
{
lasreader->header.global_encoding &= ~((U16)2); // remove internal bit
if (lasreader->header.start_of_waveform_data_packet_record) // offset to
{
start_of_waveform_data_packet_record = lasreader->header.start_of_waveform_data_packet_record;
lasreader->header.start_of_waveform_data_packet_record = 0;
lasreader->header.global_encoding |= ((U16)4); // set external bit
}
}
}
// open laswriter
LASwriter* laswriter = laswriteopener.open(&lasreader->header);
if (laswriter == 0)
{
fprintf(stderr, "ERROR: could not open laswriter\n");
usage(true, argc==1);
}
// should we also deal with waveform data
if (waveform)
{
U8 compression_type = (laswaveform13reader->is_compressed() ? 1 : 0);
for (i = 0; i < 255; i++) if (lasreader->header.vlr_wave_packet_descr[i]) lasreader->header.vlr_wave_packet_descr[i]->setCompressionType(compression_type);
U64 last_offset = 0;
U32 last_size = 60;
U64 new_offset = 0;
U32 new_size = 0;
U32 waves_written = 0;
U32 waves_referenced = 0;
my_offset_size_map offset_size_map;
LASindex lasindex;
if (lax) // should we also create a spatial indexing file
{
// setup the quadtree
LASquadtree* lasquadtree = new LASquadtree;
lasquadtree->setup(lasreader->header.min_x, lasreader->header.max_x, lasreader->header.min_y, lasreader->header.max_y, tile_size);
// create lax index
lasindex.prepare(lasquadtree, threshold);
}
// loop over points
while (lasreader->read_point())
{
if (lasreader->point.wavepacket.getIndex()) // if point is attached to a waveform
{
waves_referenced++;
if (lasreader->point.wavepacket.getOffset() == last_offset)
{
lasreader->point.wavepacket.setOffset(new_offset);
lasreader->point.wavepacket.setSize(new_size);
}
else if (lasreader->point.wavepacket.getOffset() > last_offset)
{
if (lasreader->point.wavepacket.getOffset() > (last_offset + last_size))
{
if (!waveform_with_map)
{
fprintf(stderr,"WARNING: gap in waveform offsets.\n");
#ifdef _WIN32
fprintf(stderr,"WARNING: last offset plus size was %I64d but new offset is %I64d (for point %I64d)\n", (last_offset + last_size), lasreader->point.wavepacket.getOffset(), lasreader->p_count);
#else
fprintf(stderr,"WARNING: last offset plus size was %lld but new offset is %lld (for point %lld)\n", (last_offset + last_size), lasreader->point.wavepacket.getOffset(), lasreader->p_count);
#endif
}
}
waves_written++;
last_offset = lasreader->point.wavepacket.getOffset();
last_size = lasreader->point.wavepacket.getSize();
laswaveform13reader->read_waveform(&lasreader->point);
laswaveform13writer->write_waveform(&lasreader->point, laswaveform13reader->samples);
new_offset = lasreader->point.wavepacket.getOffset();
new_size = lasreader->point.wavepacket.getSize();
if (waveform_with_map)
{
offset_size_map.insert(my_offset_size_map::value_type(last_offset, OffsetSize(new_offset,new_size)));
}
}
else
{
if (waveform_with_map)
{
my_offset_size_map::iterator map_element;
map_element = offset_size_map.find(lasreader->point.wavepacket.getOffset());
if (map_element == offset_size_map.end())
{
waves_written++;
last_offset = lasreader->point.wavepacket.getOffset();
last_size = lasreader->point.wavepacket.getSize();
laswaveform13reader->read_waveform(&lasreader->point);
laswaveform13writer->write_waveform(&lasreader->point, laswaveform13reader->samples);
new_offset = lasreader->point.wavepacket.getOffset();
new_size = lasreader->point.wavepacket.getSize();
offset_size_map.insert(my_offset_size_map::value_type(last_offset, OffsetSize(new_offset,new_size)));
}
else
{
lasreader->point.wavepacket.setOffset((*map_element).second.offset);
lasreader->point.wavepacket.setSize((*map_element).second.size);
}
}
else
{
fprintf(stderr,"ERROR: waveform offsets not in monotonically increasing order.\n");
#ifdef _WIN32
fprintf(stderr,"ERROR: last offset was %I64d but new offset is %I64d (for point %I64d)\n", last_offset, lasreader->point.wavepacket.getOffset(), lasreader->p_count);
#else
fprintf(stderr,"ERROR: last offset was %lld but new offset is %lld (for point %lld)\n", last_offset, lasreader->point.wavepacket.getOffset(), lasreader->p_count);
#endif
fprintf(stderr,"ERROR: use option '-waveforms_with_map' to compress.\n");
byebye(true, argc==1);
}
}
}
laswriter->write_point(&lasreader->point);
if (lax)
{
lasindex.add(&lasreader->point, (U32)(laswriter->p_count));
}
if (!lasreadopener.has_populated_header())
{
laswriter->update_inventory(&lasreader->point);
}
}
if (verbose && ((laswriter->p_count % 1000000) == 0)) fprintf(stderr,"written %d referenced %d of %d points\n", waves_written, waves_referenced, (I32)laswriter->p_count);
if (!lasreadopener.has_populated_header())
{
laswriter->update_header(&lasreader->header, TRUE);
}
if (lax)
{
// adaptive coarsening
lasindex.complete(minimum_points, maximum_intervals);
// write lax to file
lasindex.write(laswriteopener.get_file_name());
}
}
else
{
// loop over points
if (lasreadopener.has_populated_header())
{
if (lax) // should we also create a spatial indexing file
{
// setup the quadtree
LASquadtree* lasquadtree = new LASquadtree;
lasquadtree->setup(lasreader->header.min_x, lasreader->header.max_x, lasreader->header.min_y, lasreader->header.max_y, tile_size);
// create lax index
LASindex lasindex;
lasindex.prepare(lasquadtree, threshold);
// compress points and add to index
while (lasreader->read_point())
{
lasindex.add(&lasreader->point, (U32)(laswriter->p_count));
laswriter->write_point(&lasreader->point);
}
// adaptive coarsening
lasindex.complete(minimum_points, maximum_intervals);
// write lax to file
lasindex.write(laswriteopener.get_file_name());
}
else
{
if (end_of_points > -1)
{
U8 point10[20];
memset(point10, end_of_points, 20);
if (verbose) fprintf(stderr, "writing with end_of_points value %d\n", end_of_points);
while (lasreader->read_point())
{
if (memcmp(point10, &lasreader->point, 20) == 0)
{
break;
}
laswriter->write_point(&lasreader->point);
laswriter->update_inventory(&lasreader->point);
}
laswriter->update_header(&lasreader->header, TRUE);
}
else
{
while (lasreader->read_point())
{
laswriter->write_point(&lasreader->point);
}
}
}
}
else
{
if (lax && (lasreader->header.min_x < lasreader->header.max_x) && (lasreader->header.min_y < lasreader->header.max_y))
{
// setup the quadtree
LASquadtree* lasquadtree = new LASquadtree;
lasquadtree->setup(lasreader->header.min_x, lasreader->header.max_x, lasreader->header.min_y, lasreader->header.max_y, tile_size);
// create lax index
LASindex lasindex;
lasindex.prepare(lasquadtree, threshold);
// compress points and add to index
while (lasreader->read_point())
{
lasindex.add(&lasreader->point, (U32)(laswriter->p_count));
laswriter->write_point(&lasreader->point);
laswriter->update_inventory(&lasreader->point);
}
// adaptive coarsening
lasindex.complete(minimum_points, maximum_intervals);
// write lax to file
lasindex.write(laswriteopener.get_file_name());
}
else
{
if (end_of_points > -1)
{
U8 point10[20];
memset(point10, end_of_points, 20);
if (verbose) fprintf(stderr, "writing with end_of_points value %d\n", end_of_points);
while (lasreader->read_point())
{
if (memcmp(point10, &lasreader->point, 20) == 0)
{
break;
}
laswriter->write_point(&lasreader->point);
laswriter->update_inventory(&lasreader->point);
}
}
else
{
while (lasreader->read_point())
{
laswriter->write_point(&lasreader->point);
laswriter->update_inventory(&lasreader->point);
}
}
}
laswriter->update_header(&lasreader->header, TRUE);
}
}
I64 total_bytes = laswriter->close();
delete laswriter;
#ifdef _WIN32
if (verbose) fprintf(stderr,"%g secs to write %I64d bytes for '%s' with %I64d points of type %d\n", taketime()-start_time, total_bytes, laswriteopener.get_file_name(), lasreader->p_count, lasreader->header.point_data_format);
#else
if (verbose) fprintf(stderr,"%g secs to write %lld bytes for '%s' with %lld points of type %d\n", taketime()-start_time, total_bytes, laswriteopener.get_file_name(), lasreader->p_count, lasreader->header.point_data_format);
#endif
if (start_of_waveform_data_packet_record && !waveform)
{
lasreader->close(FALSE);
ByteStreamIn* stream = lasreader->get_stream();
stream->seek(start_of_waveform_data_packet_record);
char* wave_form_file_name;
if (laswriteopener.get_file_name())
{
wave_form_file_name = strdup(laswriteopener.get_file_name());
int len = strlen(wave_form_file_name);
if (wave_form_file_name[len-3] == 'L')
{
wave_form_file_name[len-3] = 'W';
wave_form_file_name[len-2] = 'D';
wave_form_file_name[len-1] = 'P';
}
else
{
wave_form_file_name[len-3] = 'w';
wave_form_file_name[len-2] = 'd';
wave_form_file_name[len-1] = 'p';
}
}
else
{
wave_form_file_name = strdup("wave_form.wdp");
}
FILE* file = fopen(wave_form_file_name, "wb");
if (file)
{
if (verbose) fprintf(stderr,"writing waveforms to '%s'\n", wave_form_file_name);
try
{
int byte;
while (true)
{
byte = stream->getByte();
fputc(byte, file);
}
}
catch (...)
{
fclose(file);
}
}
}
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
#ifdef COMPILE_WITH_MULTI_CORE
I32 cores = 1;
#endif
bool diff = false;
bool verbose = false;
CHAR separator_sign = ' ';
bool opts = false;
CHAR header_comment_sign = '\0';
CHAR* parse_string = strdup("xyz");
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';
}
}
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],"-parse") == 0)
{
if ((i+1) >= argc)
{
fprintf(stderr,"ERROR: '%s' needs 1 argument: string\n", argv[i]);
usage(true);
}
i++;
free(parse_string);
parse_string = strdup(argv[i]);
}
else if (strcmp(argv[i],"-parse_all") == 0)
{
free(parse_string);
parse_string = strdup("xyzirndecaupt");
}
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++;
if (strcmp(argv[i],"comma") == 0 || strcmp(argv[i],"komma") == 0)
{
separator_sign = ',';
}
else if (strcmp(argv[i],"tab") == 0)
{
separator_sign = '\t';
}
else if (strcmp(argv[i],"dot") == 0 || strcmp(argv[i],"period") == 0)
{
separator_sign = '.';
}
else if (strcmp(argv[i],"colon") == 0)
{
separator_sign = ':';
}
else if (strcmp(argv[i],"semicolon") == 0)
{
separator_sign = ';';
}
else if (strcmp(argv[i],"hyphen") == 0 || strcmp(argv[i],"minus") == 0)
{
separator_sign = '-';
}
else if (strcmp(argv[i],"space") == 0)
{
separator_sign = ' ';
}
else
{
fprintf(stderr, "ERROR: unknown seperator '%s'\n",argv[i]);
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.get_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);
// 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_extra_attributes)
{
fprintf(stderr, "WARNING: extra attribute '%d' does not exist.\n", (parse_string[i] - '0'));
parse_string[i] = 's';
}
else
{
extra_attribute_array_offsets[(parse_string[i] - '0')] = lasreader->header.get_extra_attribute_array_offset((parse_string[i] - '0'));
}
break;
default:
fprintf (stderr, "WARNING: requested unknown parse item '%c'\n", parse_string[i]);
}
i++;
}
// 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 format
if (opts)
{
if (strcmp(parse_string, "xyz") && strcmp(parse_string, "xyzi") && strcmp(parse_string, "xyziRGB"))
{
fprintf(stderr, "WARNING: the parse string for PTS should be 'xyz', 'xyzi', or 'xyziRGB'\n");
}
if (separator_sign != ' ')
{
fprintf(stderr, "WARNING: the separator for PTS should be ' ' not '%c'\n", separator_sign);
}
if (lasreader->header.version_minor >= 4)
{
#ifdef _WIN32
fprintf(file_out, "%I64d\012", lasreader->header.extended_number_of_point_records);
#else
fprintf(file_out, "%lld\012", lasreader->header.extended_number_of_point_records);
#endif
}
else
{
fprintf(file_out, "%u\012", lasreader->header.number_of_point_records);
}
}
// output header info
if (header_comment_sign)
{
LASheader* header = &(lasreader->header);
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);
}
// in case diff is requested
int last_XYZ[3] = {0,0,0};
unsigned short last_RGB[3] = {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.x);
break;
case 'Y': // the unscaled raw integer Y coordinate
fprintf(file_out, "%d", lasreader->point.y);
break;
case 'Z': // the unscaled raw integer Z coordinate
fprintf(file_out, "%d", lasreader->point.z);
break;
case 't': // the gps-time
fprintf(file_out, "%.6f", lasreader->point.gps_time);
break;
case 'i': // the intensity
fprintf(file_out, "%d", lasreader->point.intensity);
break;
case 'a': // the scan angle
fprintf(file_out, "%d", lasreader->point.scan_angle_rank);
break;
case 'r': // the number of the return
fprintf(file_out, "%d", lasreader->point.return_number);
break;
case 'c': // the classification
fprintf(file_out, "%d", lasreader->point.classification);
break;
case 'u': // the user data
fprintf(file_out, "%d", lasreader->point.user_data);
break;
case 'n': // the number of returns of given pulse
fprintf(file_out, "%d", lasreader->point.number_of_returns_of_given_pulse);
break;
case 'p': // the point source ID
fprintf(file_out, "%d", lasreader->point.point_source_ID);
break;
case 'e': // the edge of flight line flag
fprintf(file_out, "%d", lasreader->point.edge_of_flight_line);
break;
case 'd': // the direction of scan flag
fprintf(file_out, "%d", lasreader->point.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.x-last_XYZ[0]);
break;
case '!': // the raw integer Y difference to the last point
fprintf(file_out, "%d", lasreader->point.y-last_XYZ[1]);
break;
case '@': // the raw integer Z difference to the last point
fprintf(file_out, "%d", lasreader->point.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_extra_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.x;
last_XYZ[1] = lasreader->point.y;
last_XYZ[2] = lasreader->point.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;
}
