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; }