static void lidardouble2string(char* string, double value, double precision) { if (precision == 0.1) sprintf(string, "%.1f", value); else if (precision == 0.01) sprintf(string, "%.2f", value); else if (precision == 0.001) sprintf(string, "%.3f", value); else if (precision == 0.0001) sprintf(string, "%.4f", value); else if (precision == 0.00001) sprintf(string, "%.5f", value); else if (precision == 0.000001) sprintf(string, "%.6f", value); else if (precision == 0.0000001) sprintf(string, "%.7f", value); else if (precision == 0.00000001) sprintf(string, "%.8f", value); else if (precision == 0.000000001) sprintf(string, "%.9f", value); else lidardouble2string(string, value); }
BOOL LASwriterTXT::write_point(const LASpoint* point) { p_count++; int i = 0; while (true) { switch (parse_string[i]) { case 'x': // the x coordinate lidardouble2string(printstring, header->get_x(point->x), header->x_scale_factor); fprintf(file, "%s", printstring); break; case 'y': // the y coordinate lidardouble2string(printstring, header->get_y(point->y), header->y_scale_factor); fprintf(file, "%s", printstring); break; case 'z': // the z coordinate lidardouble2string(printstring, header->get_z(point->z), header->z_scale_factor); fprintf(file, "%s", printstring); break; case 't': // the gps-time lidardouble2string(printstring,point->gps_time); fprintf(file, "%s", printstring); break; case 'i': // the intensity fprintf(file, "%d", point->intensity); break; case 'a': // the scan angle fprintf(file, "%d", point->scan_angle_rank); break; case 'r': // the number of the return fprintf(file, "%d", point->return_number); break; case 'c': // the classification fprintf(file, "%d", point->classification); break; case 'u': // the user data fprintf(file, "%d", point->user_data); break; case 'n': // the number of returns of given pulse fprintf(file, "%d", point->number_of_returns_of_given_pulse); break; case 'p': // the point source ID fprintf(file, "%d", point->point_source_ID); break; case 'e': // the edge of flight line flag fprintf(file, "%d", point->edge_of_flight_line); break; case 'd': // the direction of scan flag fprintf(file, "%d", point->scan_direction_flag); break; case 'R': // the red channel of the RGB field fprintf(file, "%d", point->rgb[0]); break; case 'G': // the green channel of the RGB field fprintf(file, "%d", point->rgb[1]); break; case 'B': // the blue channel of the RGB field fprintf(file, "%d", point->rgb[2]); break; case 'm': // the index of the point (count starts at 0) #ifdef _WIN32 fprintf(file, "%I64d", p_count-1); #else fprintf(file, "%lld", p_count-1); #endif break; case 'M': // the index of the point (count starts at 1) #ifdef _WIN32 fprintf(file, "%I64d", p_count); #else fprintf(file, "%lld", p_count); #endif break; case 'w': // the wavepacket descriptor index fprintf(file, "%d", point->wavepacket.getIndex()); break; case 'W': // all wavepacket attributes fprintf(file, "%d%c%d%c%d%c%g%c%.15g%c%.15g%c%.15g", point->wavepacket.getIndex(), separator_sign, (U32)point->wavepacket.getOffset(), separator_sign, point->wavepacket.getSize(), separator_sign, point->wavepacket.getLocation(), separator_sign, point->wavepacket.getXt(), separator_sign, point->wavepacket.getYt(), separator_sign, point->wavepacket.getZt()); break; case 'X': // the unscaled and unoffset integer X coordinate fprintf(file, "%d", point->x); break; case 'Y': // the unscaled and unoffset integer Y coordinate fprintf(file, "%d", point->y); break; case 'Z': // the unscaled and unoffset integer Z coordinate fprintf(file, "%d", point->z); break; default: unparse_extra_attribute(point, (I32)(parse_string[i]-'0')); } i++; if (parse_string[i]) { fprintf(file, "%c", separator_sign); } else { fprintf(file, "\012"); break; } } return TRUE; }
int main(int argc, char *argv[]) { int i,j; #ifdef COMPILE_WITH_GUI bool gui = false; #endif bool verbose = false; int shutup = 5; int random_seeks = 0; double start_time = 0.0; LASreadOpener lasreadopener; LASwriteOpener laswriteopener; if (argc == 1) { #ifdef COMPILE_WITH_GUI return lasdiff_gui(argc, argv, 0); #else char file_name[256]; fprintf(stderr,"lasdiff.exe is better run in the command line\n"); fprintf(stderr,"enter input file1: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.set_file_name(file_name); fprintf(stderr,"enter input file2: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.set_file_name(file_name); #endif } else { for (i = 1; i < argc; i++) { if (argv[i][0] == '–') argv[i][0] = '-'; } if (!lasreadopener.parse(argc, argv)) byebye(true); if (!laswriteopener.parse(argc, argv)) byebye(true); } for (i = 1; i < argc; i++) { if (argv[i][0] == '\0') { continue; } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); usage(); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = true; } else if (strcmp(argv[i],"-version") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); byebye(); } else if (strcmp(argv[i],"-gui") == 0) { #ifdef COMPILE_WITH_GUI gui = true; #else fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n"); #endif } else if (strcmp(argv[i],"-random_seeks") == 0) { random_seeks = 10; } else if (strcmp(argv[i],"-shutup") == 0) { i++; shutup = atoi(argv[i]);; } else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0)) { lasreadopener.add_file_name(argv[i]); argv[i][0] = '\0'; } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); byebye(true); } } #ifdef COMPILE_WITH_GUI if (gui) { return lasdiff_gui(argc, argv, &lasreadopener); } #endif if (!lasreadopener.active()) { fprintf (stderr, "ERROR: no input specified\n"); byebye(true, argc==1); } int seeking; char* file_name1; char* file_name2; LASreader* lasreader1; LASreader* lasreader2; LASwriter* laswriter = 0; // possibly loop over multiple input files while (lasreadopener.active()) { start_time = taketime(); seeking = random_seeks; if (lasreadopener.get_file_name_number() == 2) { lasreader1 = lasreadopener.open(); file_name1 = strdup(lasreadopener.get_file_name()); if (lasreader1 == 0) { fprintf (stderr, "ERROR: cannot open '%s'\n", file_name1); byebye(true, argc==1); } lasreader2 = lasreadopener.open(); file_name2 = strdup(lasreadopener.get_file_name()); if (lasreader2 == 0) { fprintf (stderr, "ERROR: cannot open '%s'\n", file_name2); byebye(true, argc==1); } } else { lasreader1 = lasreadopener.open(); file_name1 = strdup(lasreadopener.get_file_name()); if (lasreader1 == 0) { fprintf (stderr, "ERROR: cannot open '%s'\n", file_name1); byebye(true, argc==1); } file_name2 = strdup(lasreadopener.get_file_name()); int len = strlen(file_name1); if (strncmp(&file_name1[len-4], ".las", 4) == 0) { file_name2[len-1] = 'z'; } else if (strncmp(&file_name1[len-4], ".laz", 4) == 0) { file_name2[len-1] = 's'; } else if (strncmp(&file_name1[len-4], ".LAS", 4) == 0) { file_name2[len-1] = 'Z'; } else if (strncmp(&file_name1[len-4], ".LAZ", 4) == 0) { file_name2[len-1] = 'S'; } else { fprintf (stderr, "ERROR: file '%s' not ending in *.las or *.laz\n", file_name1); byebye(true, argc==1); } LASreadOpener lasreadopener_other; lasreadopener_other.set_file_name(file_name2); lasreader2 = lasreadopener_other.open(); if (lasreader2 == 0) { fprintf (stderr, "ERROR: cannot open '%s'\n", file_name2); byebye(true, argc==1); } } fprintf(stderr, "checking '%s' against '%s'\n", file_name1, file_name2); // check header int different_header = 0; bool scaled_offset_difference = false; int memcmp_until = (int)(((const char*)&(lasreader1->header.user_data_in_header_size))-((const char*)&(lasreader1->header))); if (memcmp((const void*)&(lasreader1->header), (const void*)&(lasreader2->header), memcmp_until)) { char printstring[128]; fprintf(stderr, "headers are different\n"); LASheader* lasheader1 = &(lasreader1->header); LASheader* lasheader2 = &(lasreader2->header); bool fatal_difference = false; if (strncmp(lasheader1->file_signature, lasheader2->file_signature, 4)) { fprintf(stderr, " different file_signature: '%4s' '%4s'\n", lasheader1->file_signature, lasheader2->file_signature); different_header++; } if (lasheader1->file_source_id != lasheader2->file_source_id) { fprintf(stderr, " different file_source_id: %d %d\n", lasheader1->file_source_id, lasheader2->file_source_id); different_header++; } if (lasheader1->global_encoding != lasheader2->global_encoding) { fprintf(stderr, " different reserved (global_encoding): %d %d\n", lasheader1->global_encoding, lasheader2->global_encoding); different_header++; } if (lasheader1->project_ID_GUID_data_1 != lasheader2->project_ID_GUID_data_1) { fprintf(stderr, " different project_ID_GUID_data_1: %d %d\n", lasheader1->project_ID_GUID_data_1, lasheader2->project_ID_GUID_data_1); different_header++; } if (lasheader1->project_ID_GUID_data_2 != lasheader2->project_ID_GUID_data_2) { fprintf(stderr, " different project_ID_GUID_data_2: %d %d\n", lasheader1->project_ID_GUID_data_2, lasheader2->project_ID_GUID_data_2); different_header++; } if (lasheader1->project_ID_GUID_data_3 != lasheader2->project_ID_GUID_data_3) { fprintf(stderr, " different project_ID_GUID_data_3: %d %d\n", lasheader1->project_ID_GUID_data_3, lasheader2->project_ID_GUID_data_3); different_header++; } if (strncmp((const char*)lasheader1->project_ID_GUID_data_4, (const char*)lasheader2->project_ID_GUID_data_4, 8)) { fprintf(stderr, " different project_ID_GUID_data_4: '%.8s' '%.8s'\n", lasheader1->project_ID_GUID_data_4, lasheader2->project_ID_GUID_data_4); different_header++; } if (lasheader1->version_major != lasheader2->version_major || lasheader1->version_minor != lasheader2->version_minor) { fprintf(stderr, " different version: %d.%d %d.%d\n", lasheader1->version_major, lasheader1->version_minor, lasheader2->version_major, lasheader2->version_minor); different_header++; } if (strncmp(lasheader1->system_identifier, lasheader2->system_identifier, 32)) { fprintf(stderr, " different system_identifier: '%.32s' '%.32s'\n", lasheader1->system_identifier, lasheader2->system_identifier); different_header++; } if (strncmp(lasheader1->generating_software, lasheader2->generating_software, 32)) { fprintf(stderr, " different generating_software: '%.32s' '%.32s'\n", lasheader1->generating_software, lasheader2->generating_software); different_header++; } if (lasheader1->file_creation_day != lasheader2->file_creation_day || lasheader1->file_creation_year != lasheader2->file_creation_year) { fprintf(stderr, " different file_creation day.year: %d.%d %d.%d\n", lasheader1->file_creation_day, lasheader1->file_creation_year, lasheader2->file_creation_day, lasheader2->file_creation_year); different_header++; } if (lasheader1->header_size != lasheader2->header_size) { fprintf(stderr, " different header_size: %d %d\n", lasheader1->header_size, lasheader2->header_size); fatal_difference = true; } if (lasheader1->offset_to_point_data != lasheader2->offset_to_point_data) { fprintf(stderr, " different offset_to_point_data: %d %d\n", lasheader1->offset_to_point_data, lasheader2->offset_to_point_data); different_header++; } if (lasheader1->number_of_variable_length_records != lasheader2->number_of_variable_length_records) { fprintf(stderr, " different number_of_variable_length_records: %d %d\n", lasheader1->number_of_variable_length_records, lasheader2->number_of_variable_length_records); different_header++; } if (lasheader1->point_data_format != lasheader2->point_data_format) { fprintf(stderr, " different point_data_format: %d %d\n", lasheader1->point_data_format, lasheader2->point_data_format); } if (lasheader1->point_data_record_length != lasheader2->point_data_record_length) { fprintf(stderr, " different point_data_record_length: %d %d\n", lasheader1->point_data_record_length, lasheader2->point_data_record_length); different_header++; } if (lasheader1->number_of_point_records != lasheader2->number_of_point_records) { fprintf(stderr, " different number_of_point_records: %d %d\n", lasheader1->number_of_point_records, lasheader2->number_of_point_records); different_header++; } if (lasheader1->number_of_points_by_return[0] != lasheader2->number_of_points_by_return[0] || lasheader1->number_of_points_by_return[1] != lasheader2->number_of_points_by_return[1] || lasheader1->number_of_points_by_return[2] != lasheader2->number_of_points_by_return[2] || lasheader1->number_of_points_by_return[3] != lasheader2->number_of_points_by_return[3] || lasheader1->number_of_points_by_return[4] != lasheader2->number_of_points_by_return[4]) { fprintf(stderr, " different number_of_points_by_return: (%d,%d,%d,%d,%d) (%d,%d,%d,%d,%d)\n", lasheader1->number_of_points_by_return[0], lasheader1->number_of_points_by_return[1], lasheader1->number_of_points_by_return[2], lasheader1->number_of_points_by_return[3], lasheader1->number_of_points_by_return[4], lasheader2->number_of_points_by_return[0], lasheader2->number_of_points_by_return[1], lasheader2->number_of_points_by_return[2], lasheader2->number_of_points_by_return[3], lasheader2->number_of_points_by_return[4]); different_header++; } if (lasheader1->x_scale_factor != lasheader2->x_scale_factor) { lidardouble2string(printstring, lasheader1->x_scale_factor, lasheader2->x_scale_factor); fprintf(stderr, " WARNING: different x_scale_factor: %s\n", printstring); scaled_offset_difference = true; different_header++; } if (lasheader1->y_scale_factor != lasheader2->y_scale_factor) { lidardouble2string(printstring, lasheader1->y_scale_factor, lasheader2->y_scale_factor); fprintf(stderr, " WARNING: different y_scale_factor: %s\n", printstring); scaled_offset_difference = true; different_header++; } if (lasheader1->z_scale_factor != lasheader2->z_scale_factor) { lidardouble2string(printstring, lasheader1->z_scale_factor, lasheader2->z_scale_factor); fprintf(stderr, " WARNING: different z_scale_factor: %s\n", printstring); scaled_offset_difference = true; different_header++; } if (lasheader1->x_offset != lasheader2->x_offset) { lidardouble2string(printstring, lasheader1->x_offset, lasheader2->x_offset); fprintf(stderr, " WARNING: different x_offset: %s\n", printstring); scaled_offset_difference = true; } if (lasheader1->y_offset != lasheader2->y_offset) { lidardouble2string(printstring, lasheader1->y_offset, lasheader2->y_offset); fprintf(stderr, " WARNING: different y_offset: %s\n", printstring); scaled_offset_difference = true; } if (lasheader1->z_offset != lasheader2->z_offset) { lidardouble2string(printstring, lasheader1->z_offset, lasheader2->z_offset); fprintf(stderr, " WARNING: different z_offset: %s\n", printstring); scaled_offset_difference = true; } if (lasheader1->max_x != lasheader2->max_x) { lidardouble2string(printstring, lasheader1->max_x, lasheader2->max_x); fprintf(stderr, " different max_x: %s\n", printstring); different_header++; } if (lasheader1->min_x != lasheader2->min_x) { lidardouble2string(printstring, lasheader1->min_x, lasheader2->min_x); fprintf(stderr, " different min_x: %s\n", printstring); different_header++; } if (lasheader1->max_y != lasheader2->max_y) { lidardouble2string(printstring, lasheader1->max_y, lasheader2->max_y); fprintf(stderr, " different max_y: %s\n", printstring); different_header++; } if (lasheader1->min_y != lasheader2->min_y) { lidardouble2string(printstring, lasheader1->min_y, lasheader2->min_y); fprintf(stderr, " different min_y: %s\n", printstring); different_header++; } if (lasheader1->max_z != lasheader2->max_z) { lidardouble2string(printstring, lasheader1->max_z, lasheader2->max_z); fprintf(stderr, " different max_z: %s\n", printstring); different_header++; } if (lasheader1->min_z != lasheader2->min_z) { lidardouble2string(printstring, lasheader1->min_z, lasheader2->min_z); fprintf(stderr, " different min_z: %s\n", printstring); different_header++; } if (lasheader1->start_of_waveform_data_packet_record != lasheader2->start_of_waveform_data_packet_record) { fprintf(stderr, " different start_of_waveform_data_packet_record: %d %d\n", (I32)lasheader1->start_of_waveform_data_packet_record, (I32)lasheader2->start_of_waveform_data_packet_record); different_header++; } if (fatal_difference) { fprintf(stderr, "difference was fatal ... no need to check points\n"); byebye(false, argc==1); } } // check user-defined data in header if (lasreader1->header.user_data_in_header_size == lasreader2->header.user_data_in_header_size) { for (i = 0; i < (I32)lasreader1->header.user_data_in_header_size; i++) { if (lasreader1->header.user_data_in_header[i] != lasreader2->header.user_data_in_header[i]) { different_header++; fprintf(stderr, "user-defined data in header is different at byte %d of %d\n", i, lasreader1->header.user_data_in_header_size); break; } } } else { different_header++; fprintf(stderr, "skipping check of user-defined data in header due to length difference (%d != %d)\n", lasreader1->header.user_data_in_header_size, lasreader2->header.user_data_in_header_size); } // check variable length headers if (lasreader1->header.number_of_variable_length_records == lasreader2->header.number_of_variable_length_records) { for (i = 0; i < (int)lasreader1->header.number_of_variable_length_records; i++) { if (lasreader1->header.vlrs[i].reserved != lasreader2->header.vlrs[i].reserved) { fprintf(stderr, "variable length record %d reserved field is different: %d %d\n", i, lasreader1->header.vlrs[i].reserved, lasreader2->header.vlrs[i].reserved); } if (memcmp(lasreader1->header.vlrs[i].user_id, lasreader2->header.vlrs[i].user_id, 16) != 0) { fprintf(stderr, "variable length record %d user_id field is different: '%s' '%s'\n", i, lasreader1->header.vlrs[i].user_id, lasreader2->header.vlrs[i].user_id); } if (lasreader1->header.vlrs[i].record_id != lasreader2->header.vlrs[i].record_id) { fprintf(stderr, "variable length record %d record_id field is different: %d %d\n", i, lasreader1->header.vlrs[i].record_id, lasreader2->header.vlrs[i].record_id); } if (lasreader1->header.vlrs[i].record_length_after_header != lasreader2->header.vlrs[i].record_length_after_header) { fprintf(stderr, "variable length record %d record_length_after_header field is different: %d %d\n", i, lasreader1->header.vlrs[i].record_length_after_header, lasreader2->header.vlrs[i].record_length_after_header); } if (memcmp(lasreader1->header.vlrs[i].description, lasreader2->header.vlrs[i].description, 32) != 0) { fprintf(stderr, "variable length record %d description field is different: '%s' '%s'\n", i, lasreader1->header.vlrs[i].description, lasreader2->header.vlrs[i].description); } if (memcmp(lasreader1->header.vlrs[i].data, lasreader2->header.vlrs[i].data, lasreader1->header.vlrs[i].record_length_after_header)) { for (j = 0; j < lasreader1->header.vlrs[i].record_length_after_header; j++) { if (lasreader1->header.vlrs[i].data[j] != lasreader2->header.vlrs[i].data[j]) { different_header++; fprintf(stderr, "variable length record %d data field is different at byte %d: %d %d\n", i, j, lasreader1->header.vlrs[i].data[j], lasreader2->header.vlrs[i].data[j]); break; } } } } } else { fprintf(stderr, "skipping check of variable length records due to different number (%d != %d)\n", lasreader1->header.number_of_variable_length_records, lasreader2->header.number_of_variable_length_records); } // check user-defined data after header if (lasreader1->header.user_data_after_header_size == lasreader2->header.user_data_after_header_size) { for (i = 0; i < (I32)lasreader1->header.user_data_after_header_size; i++) { if (lasreader1->header.user_data_after_header[i] != lasreader2->header.user_data_after_header[i]) { different_header++; fprintf(stderr, "user-defined data after header is different at byte %d of %d\n", i, lasreader1->header.user_data_in_header_size); break; } } } else { different_header++; fprintf(stderr, "skipping check of user-defined data in header due to length difference (%d != %d)\n", lasreader1->header.user_data_after_header_size, lasreader2->header.user_data_after_header_size); } if (different_header) fprintf(stderr, "headers have %d differences.\n", different_header); else fprintf(stderr, "headers are identical.\n"); // maybe we should create a difference file if (laswriteopener.active() || laswriteopener.get_directory() || laswriteopener.get_appendix()) { if (!laswriteopener.active()) { laswriteopener.make_file_name(lasreadopener.get_file_name()); } // prepare the header memset(lasreader1->header.system_identifier, 0, 32); memset(lasreader1->header.generating_software, 0, 32); sprintf(lasreader1->header.system_identifier, "LAStools (c) by Martin Isenburg"); sprintf(lasreader1->header.generating_software, "lasdiff (version %d)", LAS_TOOLS_VERSION); laswriter = laswriteopener.open(&lasreader1->header); if (laswriter == 0) { fprintf (stderr, "ERROR: cannot open '%s'\n", laswriteopener.get_file_name()); byebye(true, argc==1); } laswriteopener.set_file_name(0); } // check points int different_points = 0; int different_scaled_offset_coordinates = 0; double diff; double max_diff_x = 0.0; double max_diff_y = 0.0; double max_diff_z = 0.0; while (true) { bool difference = false; if (seeking) { if (lasreader1->p_count%100000 == 25000) { I64 s = (rand()*rand())%lasreader1->npoints; fprintf(stderr, "at p_count %u seeking to %u\n", (U32)lasreader1->p_count, (U32)s); lasreader1->seek(s); lasreader2->seek(s); seeking--; } } if (lasreader1->read_point()) { if (lasreader2->read_point()) { if (memcmp((const void*)&(lasreader1->point), (const void*)&(lasreader2->point), 20)) { if (scaled_offset_difference) { if (lasreader1->get_x() != lasreader2->get_x()) { diff = lasreader1->get_x() - lasreader2->get_x(); if (diff < 0) diff = -diff; if (diff > max_diff_x) max_diff_x = diff; if (different_scaled_offset_coordinates < 9) fprintf(stderr, " x: %d %d scaled offset x %g %g\n", lasreader1->point.x, lasreader2->point.x, lasreader1->get_x(), lasreader2->get_x()); different_scaled_offset_coordinates++; } if (lasreader1->get_y() != lasreader2->get_y()) { diff = lasreader1->get_y() - lasreader2->get_y(); if (diff < 0) diff = -diff; if (diff > max_diff_y) max_diff_y = diff; if (different_scaled_offset_coordinates < 9) fprintf(stderr, " y: %d %d scaled offset y %g %g\n", lasreader1->point.y, lasreader2->point.y, lasreader1->get_y(), lasreader2->get_y()); different_scaled_offset_coordinates++; } if (lasreader1->get_z() != lasreader2->get_z()) { diff = lasreader1->get_z() - lasreader2->get_z(); if (diff < 0) diff = -diff; if (diff > max_diff_z) { max_diff_z = diff; if (max_diff_z > 0.001) { max_diff_z = diff; } } if (different_scaled_offset_coordinates < 9) fprintf(stderr, " z: %d %d scaled offset z %g %g\n", lasreader1->point.z, lasreader2->point.z, lasreader1->get_z(), lasreader2->get_z()); different_scaled_offset_coordinates++; } } else { if (lasreader1->point.x != lasreader2->point.x) { if (different_points < shutup) fprintf(stderr, " x: %d %d\n", lasreader1->point.x, lasreader2->point.x); difference = true; } if (lasreader1->point.y != lasreader2->point.y) { if (different_points < shutup) fprintf(stderr, " y: %d %d\n", lasreader1->point.y, lasreader2->point.y); difference = true; } if (lasreader1->point.z != lasreader2->point.z) { if (different_points < shutup) fprintf(stderr, " z: %d %d\n", lasreader1->point.z, lasreader2->point.z); difference = true; } } if (lasreader1->point.intensity != lasreader2->point.intensity) { if (different_points < shutup) fprintf(stderr, " intensity: %d %d\n", lasreader1->point.intensity, lasreader2->point.intensity); difference = true; } if (lasreader1->point.return_number != lasreader2->point.return_number) { if (different_points < shutup) fprintf(stderr, " return_number: %d %d\n", lasreader1->point.return_number, lasreader2->point.return_number); difference = true; } if (lasreader1->point.number_of_returns_of_given_pulse != lasreader2->point.number_of_returns_of_given_pulse) { if (different_points < shutup) fprintf(stderr, " number_of_returns_of_given_pulse: %d %d\n", lasreader1->point.number_of_returns_of_given_pulse, lasreader2->point.number_of_returns_of_given_pulse); difference = true; } if (lasreader1->point.scan_direction_flag != lasreader2->point.scan_direction_flag) { if (different_points < shutup) fprintf(stderr, " scan_direction_flag: %d %d\n", lasreader1->point.scan_direction_flag, lasreader2->point.scan_direction_flag); difference = true; } if (lasreader1->point.edge_of_flight_line != lasreader2->point.edge_of_flight_line) { if (different_points < shutup) fprintf(stderr, " edge_of_flight_line: %d %d\n", lasreader1->point.edge_of_flight_line, lasreader2->point.edge_of_flight_line); difference = true; } if (lasreader1->point.classification != lasreader2->point.classification) { if (different_points < shutup) fprintf(stderr, " classification: %d %d\n", lasreader1->point.classification, lasreader2->point.classification); difference = true; } if (lasreader1->point.scan_angle_rank != lasreader2->point.scan_angle_rank) { if (different_points < shutup) fprintf(stderr, " scan_angle_rank: %d %d\n", lasreader1->point.scan_angle_rank, lasreader2->point.scan_angle_rank); difference = true; } if (lasreader1->point.user_data != lasreader2->point.user_data) { if (different_points < shutup) fprintf(stderr, " user_data: %d %d\n", lasreader1->point.user_data, lasreader2->point.user_data); difference = true; } if (lasreader1->point.point_source_ID != lasreader2->point.point_source_ID) { if (different_points < shutup) fprintf(stderr, " point_source_ID: %d %d\n", lasreader1->point.point_source_ID, lasreader2->point.point_source_ID); difference = true; } if (difference) if (different_points < shutup) fprintf(stderr, "point %u of %u is different\n", (U32)lasreader1->p_count, (U32)lasreader1->npoints); } if (lasreader1->point.have_gps_time) { if (lasreader1->point.gps_time != lasreader2->point.gps_time) { if (different_points < shutup) fprintf(stderr, "gps time of point %u of %u is different: %f != %f\n", (U32)lasreader1->p_count, (U32)lasreader1->npoints, lasreader1->point.gps_time, lasreader2->point.gps_time); difference = true; } } if (lasreader1->point.have_rgb) { if (memcmp((const void*)&(lasreader1->point.rgb), (const void*)&(lasreader2->point.rgb), sizeof(short[3]))) { if (different_points < shutup) fprintf(stderr, "rgb of point %u of %u is different: (%d %d %d) != (%d %d %d)\n", (U32)lasreader1->p_count, (U32)lasreader1->npoints, lasreader1->point.rgb[0], lasreader1->point.rgb[1], lasreader1->point.rgb[2], lasreader2->point.rgb[0], lasreader2->point.rgb[1], lasreader2->point.rgb[2]); difference = true; } } if (lasreader1->point.have_wavepacket) { if (memcmp((const void*)&(lasreader1->point.wavepacket), (const void*)&(lasreader2->point.wavepacket), sizeof(LASwavepacket))) { if (different_points < shutup) fprintf(stderr, "wavepacket of point %u of %u is different: (%d %d %d %g %g %g %g) != (%d %d %d %g %g %g %g)\n", (U32)lasreader1->p_count, (U32)lasreader1->npoints, lasreader1->point.wavepacket.getIndex(), (I32)lasreader1->point.wavepacket.getOffset(), lasreader1->point.wavepacket.getSize(), lasreader1->point.wavepacket.getLocation(), lasreader1->point.wavepacket.getXt(), lasreader1->point.wavepacket.getYt(), lasreader1->point.wavepacket.getZt(), lasreader2->point.wavepacket.getIndex(), (I32)lasreader2->point.wavepacket.getOffset(), lasreader2->point.wavepacket.getSize(), lasreader2->point.wavepacket.getLocation(), lasreader2->point.wavepacket.getXt(), lasreader2->point.wavepacket.getYt(), lasreader2->point.wavepacket.getZt()); difference = true; } } } else { fprintf(stderr, "%s (%u) has fewer points than %s (%u)\n", file_name1, (U32)lasreader2->p_count, file_name2, (U32)lasreader1->p_count); break; } } else { if (lasreader2->read_point()) { fprintf(stderr, "%s (%u) has more points than %s (%u)\n", file_name1, (U32)lasreader2->p_count, file_name2, (U32)lasreader1->p_count); break; } else { break; } } if (difference) { different_points++; if (different_points == shutup) fprintf(stderr, "more than %d points are different ... shutting up.\n", shutup); } if (laswriter) { lasreader1->point.set_z(lasreader1->point.get_z()-lasreader2->point.get_z()); laswriter->write_point(&lasreader1->point); laswriter->update_inventory(&lasreader1->point); } } if (laswriter) { laswriter->update_header(&lasreader1->header, TRUE); laswriter->close(); delete laswriter; laswriter = 0; laswriteopener.set_file_name(0); } if (scaled_offset_difference) { if (different_scaled_offset_coordinates) { fprintf(stderr, "scaled offset points are different (max diff: %g %g %g).\n", max_diff_x, max_diff_y, max_diff_z); } else { fprintf(stderr, "scaled offset points are identical.\n"); } } else { if (different_points) { fprintf(stderr, "%u points are different.\n", different_points); } else { fprintf(stderr, "raw points are identical.\n"); } } if (!different_header && !different_points && !different_scaled_offset_coordinates) fprintf(stderr, "files are identical. "); #ifdef _WIN32 fprintf(stderr, "both have %I64d points. took %g secs.\n", lasreader1->p_count, taketime()-start_time); #else fprintf(stderr, "both have %lld points. took %g secs.\n", lasreader1->p_count, taketime()-start_time); #endif lasreader1->close(); delete lasreader1; free(file_name1); lasreader2->close(); delete lasreader2; free(file_name2); } byebye(false, argc==1); return 0; }
int main(int argc, char *argv[]) { int i; #ifdef COMPILE_WITH_GUI bool gui = false; #endif #ifdef COMPILE_WITH_MULTI_CORE I32 cores = 1; #endif bool diff = false; bool verbose = false; CHAR separator_sign = ' '; CHAR* separator = "space"; bool opts = false; bool optx = false; CHAR header_comment_sign = '\0'; CHAR* parse_string = 0; CHAR* extra_string = 0; CHAR printstring[512]; double start_time = 0.0; LASreadOpener lasreadopener; LASwriteOpener laswriteopener; laswriteopener.set_format("txt"); if (argc == 1) { #ifdef COMPILE_WITH_GUI return las2txt_gui(argc, argv, 0); #else fprintf(stderr,"las2txt.exe is better run in the command line or via the lastool.exe GUI\n"); CHAR file_name[256]; fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.set_file_name(file_name); fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; laswriteopener.set_file_name(file_name); #endif } else { for (i = 1; i < argc; i++) { if (argv[i][0] == '–') argv[i][0] = '-'; if (strcmp(argv[i],"-opts") == 0) { opts = TRUE; *argv[i]='\0'; } else if (strcmp(argv[i],"-optx") == 0) { optx = TRUE; *argv[i]='\0'; } } if (!lasreadopener.parse(argc, argv)) byebye(true); if (!laswriteopener.parse(argc, argv)) byebye(true); } for (i = 1; i < argc; i++) { if (argv[i][0] == '\0') { continue; } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); usage(); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = true; } else if (strcmp(argv[i],"-version") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); byebye(); } else if (strcmp(argv[i],"-gui") == 0) { #ifdef COMPILE_WITH_GUI gui = true; #else fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n"); #endif } else if (strcmp(argv[i],"-cores") == 0) { #ifdef COMPILE_WITH_MULTI_CORE if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]); usage(true); } argv[i][0] = '\0'; i++; cores = atoi(argv[i]); argv[i][0] = '\0'; #else fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n"); i++; #endif } else if (strcmp(argv[i],"-parse") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: string\n", argv[i]); usage(true); } i++; if (parse_string) free(parse_string); parse_string = strdup(argv[i]); } else if (strcmp(argv[i],"-parse_all") == 0) { if (parse_string) free(parse_string); parse_string = strdup("txyzirndecaup"); } else if (strcmp(argv[i],"-extra") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: string\n", argv[i]); usage(true); } i++; extra_string = argv[i]; } else if (strcmp(argv[i],"-sep") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: separator\n", argv[i]); usage(true); } i++; separator = argv[i]; if (strcmp(separator,"comma") == 0 || strcmp(separator,"komma") == 0) { separator_sign = ','; } else if (strcmp(separator,"tab") == 0) { separator_sign = '\t'; } else if (strcmp(separator,"dot") == 0 || strcmp(separator,"period") == 0) { separator_sign = '.'; } else if (strcmp(separator,"colon") == 0) { separator_sign = ':'; } else if (strcmp(separator,"semicolon") == 0) { separator_sign = ';'; } else if (strcmp(separator,"hyphen") == 0 || strcmp(separator,"minus") == 0) { separator_sign = '-'; } else if (strcmp(separator,"space") == 0) { separator_sign = ' '; } else { fprintf(stderr, "ERROR: unknown seperator '%s'\n",separator); usage(true); } } else if (strcmp(argv[i],"-header") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: comment\n", argv[i]); usage(true); } i++; if (strcmp(argv[i],"comma") == 0 || strcmp(argv[i],"komma") == 0) { header_comment_sign = ','; } else if (strcmp(argv[i],"colon") == 0) { header_comment_sign = ':'; } else if (strcmp(argv[i],"scolon") == 0 || strcmp(argv[i],"semicolon") == 0) { header_comment_sign = ';'; } else if (strcmp(argv[i],"pound") == 0 || strcmp(argv[i],"hash") == 0) { header_comment_sign = '#'; } else if (strcmp(argv[i],"percent") == 0) { header_comment_sign = '%'; } else if (strcmp(argv[i],"dollar") == 0) { header_comment_sign = '$'; } else if (strcmp(argv[i],"star") == 0) { header_comment_sign = '*'; } else { fprintf(stderr, "ERROR: unknown header comment symbol '%s'\n",argv[i]); usage(true); } } else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0)) { lasreadopener.add_file_name(argv[i]); argv[i][0] = '\0'; } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); usage(true); } } #ifdef COMPILE_WITH_GUI if (gui) { return las2txt_gui(argc, argv, &lasreadopener); } #endif #ifdef COMPILE_WITH_MULTI_CORE if ((cores > 1) && (lasreadopener.get_file_name_number() > 1) && (!lasreadopener.is_merged())) { return las2txt_multi_core(argc, argv, &lasreadopener, &laswriteopener, cores); } #endif // check input if (!lasreadopener.active()) { fprintf(stderr,"ERROR: no input specified\n"); byebye(true, argc == 1); } // possibly loop over multiple input files while (lasreadopener.active()) { if (verbose) start_time = taketime(); // open lasreader LASreader* lasreader = lasreadopener.open(); if (lasreader == 0) { fprintf(stderr, "ERROR: could not open lasreader\n"); byebye(true, argc==1); } // (maybe) open laswaveform13reader LASwaveform13reader* laswaveform13reader = lasreadopener.open_waveform13(&lasreader->header); // get a pointer to the header LASheader* header = &(lasreader->header); // open output file FILE* file_out; if (laswriteopener.is_piped()) { file_out = stdout; } else { // create output file name if needed if (laswriteopener.get_file_name() == 0) { if (lasreadopener.get_file_name() == 0) { fprintf(stderr, "ERROR: no output file specified\n"); byebye(true, argc==1); } laswriteopener.make_file_name(lasreadopener.get_file_name(), -2); } const CHAR* file_name_out = laswriteopener.get_file_name(); // open output file file_out = fopen(file_name_out, "w"); // fail if output file does not open if (file_out == 0) { fprintf(stderr, "ERROR: could not open '%s' for write\n", file_name_out); byebye(true, argc==1); } laswriteopener.set_file_name(0); } // maybe PTS or PTX format if (opts) { // look for VRL with PTS or PTX info const LASvlr* ptsVLR = 0; const LASvlr* ptxVLR = 0; if ((ptsVLR = header->get_vlr("LAStools", 2000)) || (ptxVLR = header->get_vlr("LAStools", 2001))) { if ((parse_string == 0) || (strcmp(parse_string, "original") == 0)) { if (parse_string) free(parse_string); if (ptsVLR && (ptsVLR->record_length_after_header >= 32)) { parse_string = strdup((CHAR*)(ptsVLR->data + 16)); } else if (ptxVLR && (ptxVLR->record_length_after_header >= 32)) { parse_string = strdup((CHAR*)(ptxVLR->data + 16)); } else if (ptsVLR) { fprintf(stderr, "WARNING: found VLR for PTS with wrong payload size of %d.\n", ptsVLR->record_length_after_header); } else if (ptxVLR) { fprintf(stderr, "WARNING: found VLR for PTX with wrong payload size of %d.\n", ptxVLR->record_length_after_header); } } } else { fprintf(stderr, "WARNING: found no VLR with PTS or PTX info.\n"); } if (header->version_minor >= 4) { #ifdef _WIN32 fprintf(file_out, "%I64d \012", header->extended_number_of_point_records); #else fprintf(file_out, "%lld \012", header->extended_number_of_point_records); #endif } else { fprintf(file_out, "%u \012", header->number_of_point_records); } if (parse_string && strcmp(parse_string, "xyz") && strcmp(parse_string, "xyzi") && strcmp(parse_string, "xyziRGB") && strcmp(parse_string, "xyzRGB")) { fprintf(stderr, "WARNING: the parse string for PTS should be 'xyz', 'xyzi', 'xyziRGB', or 'xyzRGB'\n"); } if (separator_sign != ' ') { fprintf(stderr, "WARNING: the separator for PTS should be 'space' not '%s'\n", separator); } } else if (optx) { // look for VRL with PTX info const LASvlr* ptxVLR = header->get_vlr("LAStools", 2001); if (ptxVLR && (ptxVLR->record_length_after_header == 272)) { U8* payload = ptxVLR->data; if ((parse_string == 0) || (strcmp(parse_string, "original") == 0)) { if (parse_string) free(parse_string); parse_string = strdup((CHAR*)(payload + 16)); } fprintf(file_out, "%u \012", (U32)((I64*)payload)[4]); // ncols fprintf(file_out, "%u \012", (U32)((I64*)payload)[5]); // nrows fprintf(file_out, "%g %g %g\012", ((F64*)payload)[6], ((F64*)payload)[7], ((F64*)payload)[8]); // translation fprintf(file_out, "%g %g %g\012", ((F64*)payload)[9], ((F64*)payload)[10], ((F64*)payload)[11]); // rotation_row_0 fprintf(file_out, "%g %g %g\012", ((F64*)payload)[12], ((F64*)payload)[13], ((F64*)payload)[14]); // rotation_row_1 fprintf(file_out, "%g %g %g\012", ((F64*)payload)[15], ((F64*)payload)[16], ((F64*)payload)[17]); // rotation_row_2 fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[18], ((F64*)payload)[19], ((F64*)payload)[20], ((F64*)payload)[21]); // transformation_row_0 fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[22], ((F64*)payload)[23], ((F64*)payload)[24], ((F64*)payload)[25]); // transformation_row_0 fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[26], ((F64*)payload)[27], ((F64*)payload)[28], ((F64*)payload)[29]); // transformation_row_0 fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[30], ((F64*)payload)[31], ((F64*)payload)[32], ((F64*)payload)[33]); // transformation_row_0 } else { if (ptxVLR) { fprintf(stderr, "WARNING: found VLR for PTX with wrong payload size of %d.\n", ptxVLR->record_length_after_header); } else { fprintf(stderr, "WARNING: found no VLR with PTX info.\n"); } fprintf(stderr, " outputting PTS instead ...\n"); if (header->version_minor >= 4) { #ifdef _WIN32 fprintf(file_out, "%I64d \012", header->extended_number_of_point_records); #else fprintf(file_out, "%lld \012", header->extended_number_of_point_records); #endif } else { fprintf(file_out, "%u \012", header->number_of_point_records); } } if (parse_string && strcmp(parse_string, "xyz") && strcmp(parse_string, "xyzi") && strcmp(parse_string, "xyziRGB") && strcmp(parse_string, "xyzRGB")) { fprintf(stderr, "WARNING: the parse string for PTX should be 'xyz', 'xyzi', 'xyziRGB', or 'xyzRGB'\n"); } if (separator_sign != ' ') { fprintf(stderr, "WARNING: the separator for PTX should be 'space' not '%s'\n", separator); } } else if (header_comment_sign) { // output header info fprintf(file_out, "%c file signature: '%.4s'\012", header_comment_sign, header->file_signature); fprintf(file_out, "%c file source ID: %d\012", header_comment_sign, header->file_source_ID); fprintf(file_out, "%c reserved (global encoding):%d\012", header_comment_sign, header->global_encoding); fprintf(file_out, "%c project ID GUID data 1-4: %d %d %d '%.8s'\012", header_comment_sign, header->project_ID_GUID_data_1, header->project_ID_GUID_data_2, header->project_ID_GUID_data_3, header->project_ID_GUID_data_4); fprintf(file_out, "%c version major.minor: %d.%d\012", header_comment_sign, header->version_major, header->version_minor); fprintf(file_out, "%c system_identifier: '%.32s'\012", header_comment_sign, header->system_identifier); fprintf(file_out, "%c generating_software: '%.32s'\012", header_comment_sign, header->generating_software); fprintf(file_out, "%c file creation day/year: %d/%d\012", header_comment_sign, header->file_creation_day, header->file_creation_year); fprintf(file_out, "%c header size %d\012", header_comment_sign, header->header_size); fprintf(file_out, "%c offset to point data %u\012", header_comment_sign, header->offset_to_point_data); fprintf(file_out, "%c number var. length records %u\012", header_comment_sign, header->number_of_variable_length_records); fprintf(file_out, "%c point data format %d\012", header_comment_sign, header->point_data_format); fprintf(file_out, "%c point data record length %d\012", header_comment_sign, header->point_data_record_length); fprintf(file_out, "%c number of point records %u\012", header_comment_sign, header->number_of_point_records); fprintf(file_out, "%c number of points by return %u %u %u %u %u\012", header_comment_sign, header->number_of_points_by_return[0], header->number_of_points_by_return[1], header->number_of_points_by_return[2], header->number_of_points_by_return[3], header->number_of_points_by_return[4]); fprintf(file_out, "%c scale factor x y z %g %g %g\012", header_comment_sign, header->x_scale_factor, header->y_scale_factor, header->z_scale_factor); fprintf(file_out, "%c offset x y z ", header_comment_sign); lidardouble2string(printstring, header->x_offset); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->y_offset); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->z_offset); fprintf(file_out, "%s\012", printstring); fprintf(file_out, "%c min x y z ", header_comment_sign); lidardouble2string(printstring, header->min_x, header->x_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->min_y, header->y_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->min_z, header->z_scale_factor); fprintf(file_out, "%s\012", printstring); fprintf(file_out, "%c max x y z ", header_comment_sign); lidardouble2string(printstring, header->max_x, header->x_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->max_y, header->y_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->max_z, header->z_scale_factor); fprintf(file_out, "%s\012", printstring); } // maybe create default parse string if (parse_string == 0) parse_string = strdup("xyz"); // check requested fields and print warnings of necessary i = 0; while (parse_string[i]) { switch (parse_string[i]) { case 'x': // the x coordinate case 'y': // the y coordinate case 'z': // the z coordinate case 'X': // the unscaled raw integer X coordinate case 'Y': // the unscaled raw integer Y coordinate case 'Z': // the unscaled raw integer Z coordinate case 'i': // the intensity case 'a': // the scan angle case 'r': // the number of the return case 'c': // the classification case 'u': // the user data case 'n': // the number of returns of given pulse case 'p': // the point source ID case 'e': // the edge of flight line flag case 'd': // the direction of scan flag case 'm': // the index of the point (count starts at 0) case 'M': // the index of the point (count starts at 0) break; case 't': // the gps-time if (lasreader->point.have_gps_time == false) fprintf (stderr, "WARNING: requested 't' but points do not have gps time\n"); break; case 'R': // the red channel of the RGB field if (lasreader->point.have_rgb == false) fprintf (stderr, "WARNING: requested 'R' but points do not have rgb\n"); break; case 'G': // the green channel of the RGB field if (lasreader->point.have_rgb == false) fprintf (stderr, "WARNING: requested 'G' but points do not have rgb\n"); break; case 'B': // the blue channel of the RGB field if (lasreader->point.have_rgb == false) fprintf (stderr, "WARNING: requested 'B' but points do not have rgb\n"); break; case 'w': // the wavepacket index if (lasreader->point.have_wavepacket == false) fprintf (stderr, "WARNING: requested 'w' but points do not have wavepacket\n"); break; case 'W': // all wavepacket attributes if (lasreader->point.have_wavepacket == false) fprintf (stderr, "WARNING: requested 'W' but points do not have wavepacket\n"); break; case 'V': // the waveform data if (laswaveform13reader == 0) { fprintf (stderr, "WARNING: requested 'V' but no waveform data available\n"); fprintf (stderr, " omitting ...\n"); } break; case ')': case '!': case '@': case '#': case '$': case '%': case '^': case '&': case '*': case '(': diff = true; break; case 'E': if (extra_string == 0) { fprintf (stderr, "WARNING: requested 'E' but no '-extra' specified\n"); parse_string[i] = 's'; } break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if ((parse_string[i] - '0') >= lasreader->header.number_attributes) { fprintf(stderr, "WARNING: attribute '%d' does not exist.\n", (parse_string[i] - '0')); parse_string[i] = 's'; } else { attribute_starts[(parse_string[i] - '0')] = lasreader->header.get_attribute_start((parse_string[i] - '0')); } break; default: fprintf (stderr, "WARNING: requested unknown parse item '%c'\n", parse_string[i]); } i++; } // in case diff is requested int last_XYZ[3] = {0,0,0}; unsigned short last_RGB[4] = {0,0,0}; double last_GPSTIME = 0; // read and convert the points to ASCII #ifdef _WIN32 if (verbose) fprintf(stderr,"processing %I64d points with '%s'.\n", lasreader->npoints, parse_string); #else if (verbose) fprintf(stderr,"processing %lld points with '%s'.\n", lasreader->npoints, parse_string); #endif while (lasreader->read_point()) { i = 0; while (true) { switch (parse_string[i]) { case 'x': // the x coordinate lidardouble2string(printstring, lasreader->point.get_x(), lasreader->header.x_scale_factor); fprintf(file_out, "%s", printstring); break; case 'y': // the y coordinate lidardouble2string(printstring, lasreader->point.get_y(), lasreader->header.y_scale_factor); fprintf(file_out, "%s", printstring); break; case 'z': // the z coordinate lidardouble2string(printstring, lasreader->point.get_z(), lasreader->header.z_scale_factor); fprintf(file_out, "%s", printstring); break; case 'X': // the unscaled raw integer X coordinate fprintf(file_out, "%d", lasreader->point.get_X()); break; case 'Y': // the unscaled raw integer Y coordinate fprintf(file_out, "%d", lasreader->point.get_Y()); break; case 'Z': // the unscaled raw integer Z coordinate fprintf(file_out, "%d", lasreader->point.get_Z()); break; case 't': // the gps-time fprintf(file_out, "%.6f", lasreader->point.get_gps_time()); break; case 'i': // the intensity if (opts) fprintf(file_out, "%d", -2048 + lasreader->point.get_intensity()); else if (optx) { int len; len = sprintf(printstring, "%.3f", 1.0f/4095.0f * lasreader->point.get_intensity()) - 1; while (printstring[len] == '0') len--; if (printstring[len] != '.') len++; printstring[len] = '\0'; fprintf(file_out, "%s", printstring); } else fprintf(file_out, "%d", lasreader->point.get_intensity()); break; case 'a': // the scan angle fprintf(file_out, "%d", lasreader->point.get_scan_angle_rank()); break; case 'r': // the number of the return fprintf(file_out, "%d", lasreader->point.get_return_number()); break; case 'c': // the classification fprintf(file_out, "%d", lasreader->point.get_classification()); break; case 'u': // the user data fprintf(file_out, "%d", lasreader->point.get_user_data()); break; case 'n': // the number of returns of given pulse fprintf(file_out, "%d", lasreader->point.get_number_of_returns()); break; case 'p': // the point source ID fprintf(file_out, "%d", lasreader->point.get_point_source_ID()); break; case 'e': // the edge of flight line flag fprintf(file_out, "%d", lasreader->point.get_edge_of_flight_line()); break; case 'd': // the direction of scan flag fprintf(file_out, "%d", lasreader->point.get_scan_direction_flag()); break; case 'R': // the red channel of the RGB field fprintf(file_out, "%d", lasreader->point.rgb[0]); break; case 'G': // the green channel of the RGB field fprintf(file_out, "%d", lasreader->point.rgb[1]); break; case 'B': // the blue channel of the RGB field fprintf(file_out, "%d", lasreader->point.rgb[2]); break; case 'm': // the index of the point (count starts at 0) #ifdef _WIN32 fprintf(file_out, "%I64d", lasreader->p_count-1); #else fprintf(file_out, "%lld", lasreader->p_count-1); #endif break; case 'M': // the index of the point (count starts at 1) #ifdef _WIN32 fprintf(file_out, "%I64d", lasreader->p_count); #else fprintf(file_out, "%lld", lasreader->p_count); #endif break; case ')': // the raw integer X difference to the last point fprintf(file_out, "%d", lasreader->point.get_X()-last_XYZ[0]); break; case '!': // the raw integer Y difference to the last point fprintf(file_out, "%d", lasreader->point.get_Y()-last_XYZ[1]); break; case '@': // the raw integer Z difference to the last point fprintf(file_out, "%d", lasreader->point.get_Z()-last_XYZ[2]); break; case '#': // the gps-time difference to the last point lidardouble2string(printstring,lasreader->point.gps_time-last_GPSTIME); fprintf(file_out, "%s", printstring); break; case '$': // the R difference to the last point fprintf(file_out, "%d", lasreader->point.rgb[0]-last_RGB[0]); break; case '%': // the G difference to the last point fprintf(file_out, "%d", lasreader->point.rgb[1]-last_RGB[1]); break; case '^': // the B difference to the last point fprintf(file_out, "%d", lasreader->point.rgb[2]-last_RGB[2]); break; case '&': // the byte-wise R difference to the last point fprintf(file_out, "%d%c%d", (lasreader->point.rgb[0]>>8)-(last_RGB[0]>>8), separator_sign, (lasreader->point.rgb[0]&255)-(last_RGB[0]&255)); break; case '*': // the byte-wise G difference to the last point fprintf(file_out, "%d%c%d", (lasreader->point.rgb[1]>>8)-(last_RGB[1]>>8), separator_sign, (lasreader->point.rgb[1]&255)-(last_RGB[1]&255)); break; case '(': // the byte-wise B difference to the last point fprintf(file_out, "%d%c%d", (lasreader->point.rgb[2]>>8)-(last_RGB[2]>>8), separator_sign, (lasreader->point.rgb[2]&255)-(last_RGB[2]&255)); break; case 'w': // the wavepacket index fprintf(file_out, "%d", lasreader->point.wavepacket.getIndex()); break; case 'W': // all wavepacket attributes fprintf(file_out, "%d%c%d%c%d%c%g%c%g%c%g%c%g", lasreader->point.wavepacket.getIndex(), separator_sign, (U32)lasreader->point.wavepacket.getOffset(), separator_sign, lasreader->point.wavepacket.getSize(), separator_sign, lasreader->point.wavepacket.getLocation(), separator_sign, lasreader->point.wavepacket.getXt(), separator_sign, lasreader->point.wavepacket.getYt(), separator_sign, lasreader->point.wavepacket.getZt()); break; case 'V': // the waVeform if (laswaveform13reader && laswaveform13reader->read_waveform(&lasreader->point)) { output_waveform(file_out, separator_sign, laswaveform13reader); } else { fprintf(file_out, "no_waveform"); } break; case 'E': // the extra string fprintf(file_out, "%s", extra_string); break; default: print_attribute(file_out, &lasreader->header, &lasreader->point, (I32)(parse_string[i]-'0'), printstring); } i++; if (parse_string[i]) { fprintf(file_out, "%c", separator_sign); } else { fprintf(file_out, "\012"); break; } } if (diff) { last_XYZ[0] = lasreader->point.get_X(); last_XYZ[1] = lasreader->point.get_Y(); last_XYZ[2] = lasreader->point.get_Z(); last_GPSTIME = lasreader->point.gps_time; last_RGB[0] = lasreader->point.rgb[0]; last_RGB[1] = lasreader->point.rgb[1]; last_RGB[2] = lasreader->point.rgb[2]; } } #ifdef _WIN32 if (verbose) fprintf(stderr,"converting %I64d points of '%s' took %g sec.\n", lasreader->p_count, lasreadopener.get_file_name(), taketime()-start_time); #else if (verbose) fprintf(stderr,"converting %lld points of '%s' took %g sec.\n", lasreader->p_count, lasreadopener.get_file_name(), taketime()-start_time); #endif // close the reader lasreader->close(); delete lasreader; // (maybe) close the waveform reader if (laswaveform13reader) { laswaveform13reader->close(); delete laswaveform13reader; } // close the files if (file_out != stdout) fclose(file_out); } free(parse_string); byebye(false, argc==1); return 0; }
static BOOL print_attribute(FILE* file, const LASheader* header, const LASpoint* point, I32 index, CHAR* printstring) { if (index >= header->number_attributes) { return FALSE; } if (header->attributes[index].data_type == 1) { U8 value; point->get_attribute(attribute_starts[index], value); if (header->attributes[index].has_scale() || header->attributes[index].has_offset()) { F64 temp_d = header->attributes[index].scale[0]*value + header->attributes[index].offset[0]; lidardouble2string(printstring, temp_d, header->attributes[index].scale[0]); fprintf(file, "%s", printstring); } else { fprintf(file, "%d", (I32)value); } } else if (header->attributes[index].data_type == 2) { I8 value; point->get_attribute(attribute_starts[index], value); if (header->attributes[index].has_scale() || header->attributes[index].has_offset()) { F64 temp_d = header->attributes[index].scale[0]*value + header->attributes[index].offset[0]; lidardouble2string(printstring, temp_d, header->attributes[index].scale[0]); fprintf(file, "%s", printstring); } else { fprintf(file, "%d", (I32)value); } } else if (header->attributes[index].data_type == 3) { U16 value; point->get_attribute(attribute_starts[index], value); if (header->attributes[index].has_scale() || header->attributes[index].has_offset()) { F64 temp_d = header->attributes[index].scale[0]*value + header->attributes[index].offset[0]; lidardouble2string(printstring, temp_d, header->attributes[index].scale[0]); fprintf(file, "%s", printstring); } else { fprintf(file, "%d", (I32)value); } } else if (header->attributes[index].data_type == 4) { I16 value; point->get_attribute(attribute_starts[index], value); if (header->attributes[index].has_scale() || header->attributes[index].has_offset()) { F64 temp_d = header->attributes[index].scale[0]*value + header->attributes[index].offset[0]; lidardouble2string(printstring, temp_d, header->attributes[index].scale[0]); fprintf(file, "%s", printstring); } else { fprintf(file, "%d", (I32)value); } } else if (header->attributes[index].data_type == 5) { U32 value; point->get_attribute(attribute_starts[index], value); if (header->attributes[index].has_scale() || header->attributes[index].has_offset()) { F64 temp_d = header->attributes[index].scale[0]*value + header->attributes[index].offset[0]; lidardouble2string(printstring, temp_d, header->attributes[index].scale[0]); fprintf(file, "%s", printstring); } else { fprintf(file, "%d", (I32)value); } } else if (header->attributes[index].data_type == 6) { I32 value; point->get_attribute(attribute_starts[index], value); if (header->attributes[index].has_scale() || header->attributes[index].has_offset()) { F64 temp_d = header->attributes[index].scale[0]*value + header->attributes[index].offset[0]; lidardouble2string(printstring, temp_d, header->attributes[index].scale[0]); fprintf(file, "%s", printstring); } else { fprintf(file, "%d", value); } } else if (header->attributes[index].data_type == 9) { F32 value; point->get_attribute(attribute_starts[index], value); if (header->attributes[index].has_scale() || header->attributes[index].has_offset()) { F64 temp_d = header->attributes[index].scale[0]*value + header->attributes[index].offset[0]; lidardouble2string(printstring, temp_d, header->attributes[index].scale[0]); fprintf(file, "%s", printstring); } else { fprintf(file, "%g", value); } } else if (header->attributes[index].data_type == 10) { F64 value; point->get_attribute(attribute_starts[index], value); if (header->attributes[index].has_scale() || header->attributes[index].has_offset()) { F64 temp_d = header->attributes[index].scale[0]*value + header->attributes[index].offset[0]; lidardouble2string(printstring, temp_d, header->attributes[index].scale[0]); fprintf(file, "%s", printstring); } else { fprintf(file, "%g", value); } } else { fprintf(stderr, "WARNING: attribute %d not (yet) implemented.\n", index); return FALSE; } return TRUE; }
int main(int argc, char *argv[]) { int i; int use_stdin = FALSE; int use_stdout = FALSE; int skip_invalid = FALSE; int verbose = FALSE; char* file_name_in = 0; char* file_name_out = 0; char separator_sign = ' '; char header_comment_sign = '\0'; char* parse_string = "xyz"; char printstring[256]; LASReaderH reader = NULL; LASHeaderH header = NULL; LASPointH p = NULL; FILE* file_out = NULL; int len; uint32_t index = 0; for (i = 1; i < argc; i++) { if ( strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"--help") == 0 ) { usage(); exit(0); } else if ( strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"--verbose") == 0 ) { verbose = TRUE; } else if ( strcmp(argv[i],"-s") == 0 || strcmp(argv[i],"--skip_invalid") == 0 ) { skip_invalid = TRUE; } else if ( strcmp(argv[i], "--parse") == 0 || strcmp(argv[i], "-parse") == 0 ) { i++; parse_string = argv[i]; } else if ( strcmp(argv[i], "--sep") == 0 || strcmp(argv[i], "-sep") == 0 ) { i++; if (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],"scolon") == 0 || 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(); exit(1); } } else if ( strcmp(argv[i], "--header") == 0 || strcmp(argv[i], "--comment") == 0 || strcmp(argv[i], "-header") == 0 || strcmp(argv[i], "-comment") == 0 || strcmp(argv[i], "-head") == 0 ) { i++; if (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 comment symbol '%s'\n",argv[i]); usage(); exit(1); } } else if ( strcmp(argv[i], "--stdin") == 0 || strcmp(argv[i], "-ilas") == 0 ) { use_stdin = TRUE; } else if ( strcmp(argv[i], "--stdout") == 0 ) { use_stdout = TRUE; } else if ( strcmp(argv[i],"--input") == 0 || strcmp(argv[i],"-input") == 0 || strcmp(argv[i],"-i") == 0 || strcmp(argv[i],"-in") == 0 ) { i++; file_name_in = argv[i]; } else if ( strcmp(argv[i],"--output") == 0 || strcmp(argv[i],"--out") == 0 || strcmp(argv[i],"-out") == 0 || strcmp(argv[i],"-o") == 0 ) { i++; file_name_out = argv[i]; } else if (i == argc - 2 && file_name_in == 0 && file_name_out == 0) { file_name_in = argv[i]; } else if (i == argc - 1 && file_name_in == 0 && file_name_out == 0) { file_name_in = argv[i]; } else if (i == argc - 1 && file_name_in && file_name_out == 0) { file_name_out = argv[i]; } else { fprintf(stderr, "ERROR: unknown argument '%s'\n",argv[i]); usage(); exit(1); } } /* end looping through argc/argv */ if (use_stdin) file_name_in = "stdin"; reader = LASReader_Create(file_name_in); if (!reader) { LASError_Print("Unable to read file"); exit(1); } header = LASReader_GetHeader(reader); if (!header) { LASError_Print("Unable to fetch header for file"); exit(1); } if (use_stdout) { file_out = stdout; } else { if (file_name_out == NULL) { if (file_name_in == NULL) { LASError_Print("No input filename was specified"); usage(); exit(1); } len = (int)strlen(file_name_in); file_name_out = strdup(file_name_in); if (file_name_out[len-3] == '.' && file_name_out[len-2] == 'g' && file_name_out[len-1] == 'z') { len = len - 4; } while (len > 0 && file_name_out[len] != '.') { len--; } file_name_out[len] = '.'; file_name_out[len+1] = 't'; file_name_out[len+2] = 'x'; file_name_out[len+3] = 't'; file_name_out[len+4] = '\0'; } file_out = fopen(file_name_out, "w"); if (file_out == 0) { LASError_Print("Could not open file for write"); usage(); exit(1); } } if (verbose) { print_header(stderr, header, file_name_in); } if (header_comment_sign) { fprintf(file_out, "%c file signature: '%s'\012", header_comment_sign, LASHeader_GetFileSignature(header) ); fprintf(file_out, "%c file source ID: %d\012", header_comment_sign, LASHeader_GetFileSourceId(header) ); fprintf(file_out, "%c reserved: %d\012", header_comment_sign, LASHeader_GetReserved(header) ); fprintf(file_out, "%c project ID GUID: %s\012", header_comment_sign, LASHeader_GetProjectId(header) ); fprintf(file_out, "%c version major.minor: %d.%d\012", header_comment_sign, LASHeader_GetVersionMajor(header), LASHeader_GetVersionMinor(header) ); fprintf(file_out, "%c system_identifier: '%s'\012", header_comment_sign, LASHeader_GetSystemId(header) ); fprintf(file_out, "%c generating_software: '%s'\012", header_comment_sign, LASHeader_GetSoftwareId(header) ); fprintf(file_out, "%c file creation day/year: %d/%d\012", header_comment_sign, LASHeader_GetCreationDOY(header), LASHeader_GetCreationYear(header) ); fprintf(file_out, "%c header size %d\012", header_comment_sign, LASHeader_GetHeaderSize(header) ); fprintf(file_out, "%c offset to point data %d\012", header_comment_sign, LASHeader_GetDataOffset(header) ); fprintf(file_out, "%c number var. length records %d\012", header_comment_sign, LASHeader_GetRecordsCount(header) ); fprintf(file_out, "%c point data format %d\012", header_comment_sign, LASHeader_GetDataFormatId(header) ); fprintf(file_out, "%c point data record length %d\012", header_comment_sign, LASHeader_GetDataRecordLength(header) ); fprintf(file_out, "%c number of point records %d\012", header_comment_sign, LASHeader_GetPointRecordsCount(header) ); fprintf(file_out, "%c number of points by return %d %d %d %d %d\012", header_comment_sign, LASHeader_GetPointRecordsByReturnCount(header, 0), LASHeader_GetPointRecordsByReturnCount(header, 1), LASHeader_GetPointRecordsByReturnCount(header, 2), LASHeader_GetPointRecordsByReturnCount(header, 3), LASHeader_GetPointRecordsByReturnCount(header, 4) ); fprintf(file_out, "%c scale factor x y z %.6f %.6f %.6f\n", header_comment_sign, LASHeader_GetScaleX(header), LASHeader_GetScaleY(header), LASHeader_GetScaleZ(header) ); fprintf(file_out, "%c offset x y z %.6f %.6f %.6f\n", header_comment_sign, LASHeader_GetOffsetX(header), LASHeader_GetOffsetY(header), LASHeader_GetOffsetZ(header) ); fprintf(file_out, "%c min x y z %.6f %.6f %.6f\n", header_comment_sign, LASHeader_GetMinX(header), LASHeader_GetMinY(header), LASHeader_GetMinZ(header) ); fprintf(file_out, "%c max x y z %.6f %.6f %.6f\n", header_comment_sign, LASHeader_GetMaxX(header), LASHeader_GetMaxY(header), LASHeader_GetMaxZ(header) ); } p = LASReader_GetNextPoint(reader); while (p) { if (skip_invalid && !LASPoint_IsValid(p)) { if (verbose) { LASError_Print("Skipping writing invalid point..."); } p = LASReader_GetNextPoint(reader); index -=1; continue; } i = 0; for (;;) { LASColorH color = LASPoint_GetColor(p); switch (parse_string[i]) { /* // the x coordinate */ case 'x': lidardouble2string(printstring, LASPoint_GetX(p)); fprintf(file_out, printstring); break; /* // the y coordinate */ case 'y': lidardouble2string(printstring, LASPoint_GetY(p)); fprintf(file_out, printstring); break; /* // the z coordinate */ case 'z': lidardouble2string(printstring, LASPoint_GetZ(p)); fprintf(file_out, printstring); break; /* // the gps-time */ case 't': lidardouble2string(printstring,LASPoint_GetTime(p)); fprintf(file_out, printstring); break; /* // the intensity */ case 'i': fprintf(file_out, "%d", LASPoint_GetIntensity(p)); break; /* the scan angle */ case 'a': fprintf(file_out, "%d", LASPoint_GetScanAngleRank(p)); break; /* the number of the return */ case 'r': fprintf(file_out, "%d", LASPoint_GetReturnNumber(p)); break; /* the classification */ case 'c': fprintf(file_out, "%d", LASPoint_GetClassification(p)); break; /* the user data */ case 'u': fprintf(file_out, "%d", LASPoint_GetUserData(p)); break; /* the number of returns of given pulse */ case 'n': fprintf(file_out, "%d", LASPoint_GetNumberOfReturns(p)); break; /* the red channel color */ case 'R': fprintf(file_out, "%d", LASColor_GetRed(color)); break; /* the green channel color */ case 'G': fprintf(file_out, "%d", LASColor_GetGreen(color)); break; /* the blue channel color */ case 'B': fprintf(file_out, "%d", LASColor_GetBlue(color)); break; case 'M': fprintf(file_out, "%d", index); break; /* case 'p': // the point source ID fprintf(file_out, "%d", lasreader->point.point_source_ID); break; */ /* the edge of flight line flag */ case 'e': fprintf(file_out, "%d", LASPoint_GetFlightLineEdge(p)); break; /* the direction of scan flag */ case 'd': fprintf(file_out, "%d", LASPoint_GetScanDirection(p)); break; } i++; if (parse_string[i]) { fprintf(file_out, "%c", separator_sign); } else { fprintf(file_out, "\012"); break; } LASColor_Destroy(color); } p = LASReader_GetNextPoint(reader); index +=1; } LASReader_Destroy(reader); LASHeader_Destroy(header); fclose(file_out); return 0; }
BOOL LASwriterTXT::write_point(const LASpoint* point) { p_count++; int i = 0; while (true) { switch (parse_string[i]) { case 'x': // the x coordinate lidardouble2string(printstring, header->get_x(point->get_X()), header->x_scale_factor); fprintf(file, "%s", printstring); break; case 'y': // the y coordinate lidardouble2string(printstring, header->get_y(point->get_Y()), header->y_scale_factor); fprintf(file, "%s", printstring); break; case 'z': // the z coordinate lidardouble2string(printstring, header->get_z(point->get_Z()), header->z_scale_factor); fprintf(file, "%s", printstring); break; case 't': // the gps-time fprintf(file, "%.6f", point->get_gps_time()); break; case 'i': // the intensity if (opts) fprintf(file, "%d", -2048 + point->get_intensity()); else if (optx) { int len; len = sprintf(printstring, "%.3f", 1.0f/4095.0f * point->get_intensity()) - 1; while (printstring[len] == '0') len--; if (printstring[len] != '.') len++; printstring[len] = '\0'; fprintf(file, "%s", printstring); } else fprintf(file, "%d", point->get_intensity()); break; case 'a': // the scan angle fprintf(file, "%d", point->get_scan_angle_rank()); break; case 'r': // the number of the return fprintf(file, "%d", point->get_return_number()); break; case 'c': // the classification fprintf(file, "%d", point->get_classification()); break; case 'u': // the user data fprintf(file, "%d", point->get_user_data()); break; case 'n': // the number of returns of given pulse fprintf(file, "%d", point->get_number_of_returns()); break; case 'p': // the point source ID fprintf(file, "%d", point->get_point_source_ID()); break; case 'e': // the edge of flight line flag fprintf(file, "%d", point->get_edge_of_flight_line()); break; case 'd': // the direction of scan flag fprintf(file, "%d", point->get_scan_direction_flag()); break; case 'h': // the withheld flag fprintf(file, "%d", point->get_withheld_flag()); break; case 'k': // the keypoint flag fprintf(file, "%d", point->get_keypoint_flag()); break; case 'g': // the synthetic flag fprintf(file, "%d", point->get_synthetic_flag()); break; case 'o': // the overlap flag fprintf(file, "%d", point->get_extended_overlap_flag()); break; case 'l': // the scanner channel fprintf(file, "%d", point->get_extended_scanner_channel()); break; case 'R': // the red channel of the RGB field if (scale_rgb != 1.0f) fprintf(file, "%.2f", scale_rgb*point->get_rgb()[0]); else fprintf(file, "%d", point->get_rgb()[0]); break; case 'G': // the green channel of the RGB field if (scale_rgb != 1.0f) fprintf(file, "%.2f", scale_rgb*point->get_rgb()[1]); else fprintf(file, "%d", point->get_rgb()[1]); break; case 'B': // the blue channel of the RGB field if (scale_rgb != 1.0f) fprintf(file, "%.2f", scale_rgb*point->get_rgb()[2]); else fprintf(file, "%d", point->get_rgb()[2]); break; case 'm': // the index of the point (count starts at 0) #ifdef _WIN32 fprintf(file, "%I64d", p_count-1); #else fprintf(file, "%lld", p_count-1); #endif break; case 'M': // the index of the point (count starts at 1) #ifdef _WIN32 fprintf(file, "%I64d", p_count); #else fprintf(file, "%lld", p_count); #endif break; case 'w': // the wavepacket descriptor index fprintf(file, "%d", point->wavepacket.getIndex()); break; case 'W': // all wavepacket attributes fprintf(file, "%d%c%d%c%d%c%g%c%.15g%c%.15g%c%.15g", point->wavepacket.getIndex(), separator_sign, (U32)point->wavepacket.getOffset(), separator_sign, point->wavepacket.getSize(), separator_sign, point->wavepacket.getLocation(), separator_sign, point->wavepacket.getXt(), separator_sign, point->wavepacket.getYt(), separator_sign, point->wavepacket.getZt()); break; case 'X': // the unscaled and unoffset integer X coordinate fprintf(file, "%d", point->get_X()); break; case 'Y': // the unscaled and unoffset integer Y coordinate fprintf(file, "%d", point->get_Y()); break; case 'Z': // the unscaled and unoffset integer Z coordinate fprintf(file, "%d", point->get_Z()); break; default: unparse_attribute(point, (I32)(parse_string[i]-'0')); } i++; if (parse_string[i]) { fprintf(file, "%c", separator_sign); } else { fprintf(file, "\012"); break; } } return TRUE; }