//游戏退出 void gameExit() { closegraph(); printf("Byebye!\n" ); byebye(); getch(); }
void PeersMgr::linkReady() { QObject::connect(iLink, SIGNAL(disconnected()), this, SLOT(byebye())); QObject::connect(iLink, SIGNAL(readyRead()), this, SLOT(newServerMsg())); qDebug() << "link ready"; emit connected(); QSettings settings; QString username = settings.value(PeersMgr::kKeyUsername, PeersMgr::kDefaultUsername).toString(); QDataStream channel(iLink); channel << QString("hello %1").arg(username); }
static void usage(int return_code, BOOL wait=FALSE) { fprintf(stderr,"Usage:\n"); fprintf(stderr,"lasvalidate -i lidar.las\n"); fprintf(stderr,"lasvalidate -i lidar.laz\n"); fprintf(stderr,"lasvalidate -v -i lidar.las -o report.xml\n"); fprintf(stderr,"lasvalidate -v -i lidar.laz -oxml\n"); fprintf(stderr,"lasvalidate -vv -i tile1.las tile2.las tile3.las -oxml\n"); fprintf(stderr,"lasvalidate -i tile1.laz tile2.laz tile3.laz -o summary.kml\n"); fprintf(stderr,"lasvalidate -vv -i *.las\n"); fprintf(stderr,"lasvalidate -i *.laz -o summary.xml\n"); fprintf(stderr,"lasvalidate -i *.las -oxml\n"); fprintf(stderr,"lasvalidate -i c:\\data\\lidar.las -oxml\n"); fprintf(stderr,"lasvalidate -i ..\\subfolder\\*.las -o summary.xml\n"); fprintf(stderr,"lasvalidate -v -i ..\\..\\flight\\*.laz -o oxml\n"); fprintf(stderr,"lasvalidate -h\n"); byebye(return_code, wait); }
int open_server( char *hostname, short hostport) { int32 server_ip ; char alertstr[MAXLINELENGTH+1] ; int TCP_IP_resp, cn; /* Look up host */ if( _resolve( hostname, (char **)NULL, &server_ip, 1 ) < 0 ) { /* Resolve error */ sprintf( alertstr, "Cannot find server %s",hostname ) ; alert( alertstr ) ; return -1; } event_loop() ; /* Open socket and bind it to address */ if( ( cn = _TCP_open( server_ip, port, 0, TCPBUFSIZ ) ) < 0 ) { alert( "Could not open a socket") ; return -1; } ndb = (NDB *)NULL; /* Wait for connection to be established */ TCP_IP_resp=_TCP_wait_state( cn, TESTABLISH, TIMEOUT ); if( TCP_IP_resp != E_NORMAL ) { if( TCP_IP_resp=-7 ) { alert( "connection refused by remote server"); } else { alert( "could not connect to remote server, unknown error") ; } _TCP_close( cn, TIMEOUT ) ; byebye(1) ; } return cn ; }
void finish(code) { if (code == SIGINT) { char c; ignorf(signal(code, finish)); message("Quit? "); UpdateMesg(); ignore(read(0, &c, 1)); message(""); if ((c & 0377) != 'y') { redisplay(); return; } } if (code) { if (code == SIGHUP) ignorf(signal(code, SIG_IGN)); /* A little privacy */ if (!Crashing) { putstr("Writing modified JOVE buffers..."); Crashing++; jove_exp_p = 0; WtModBuf(); } else putstr("Complete lossage!"); } ttyset(0); Placur(LI - 1, 0); putpad(CE, 1); if (KE) putpad(KE, 1); if (VE) putpad(VE, 1); if (TE) putpad(TE, 1); flusho(); byebye(code); }
int main(int argc, char *argv[]) { int i; #ifdef COMPILE_WITH_GUI bool gui = false; #endif #ifdef COMPILE_WITH_MULTI_CORE I32 cores = 1; #endif bool diff = false; bool verbose = false; CHAR separator_sign = ' '; CHAR* separator = "space"; bool opts = false; bool optx = false; CHAR header_comment_sign = '\0'; CHAR* parse_string = 0; CHAR* extra_string = 0; CHAR printstring[512]; double start_time = 0.0; LASreadOpener lasreadopener; LASwriteOpener laswriteopener; laswriteopener.set_format("txt"); if (argc == 1) { #ifdef COMPILE_WITH_GUI return las2txt_gui(argc, argv, 0); #else fprintf(stderr,"las2txt.exe is better run in the command line or via the lastool.exe GUI\n"); CHAR file_name[256]; fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.set_file_name(file_name); fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; laswriteopener.set_file_name(file_name); #endif } else { for (i = 1; i < argc; i++) { if (argv[i][0] == '–') argv[i][0] = '-'; if (strcmp(argv[i],"-opts") == 0) { opts = TRUE; *argv[i]='\0'; } else if (strcmp(argv[i],"-optx") == 0) { optx = TRUE; *argv[i]='\0'; } } if (!lasreadopener.parse(argc, argv)) byebye(true); if (!laswriteopener.parse(argc, argv)) byebye(true); } for (i = 1; i < argc; i++) { if (argv[i][0] == '\0') { continue; } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); usage(); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = true; } else if (strcmp(argv[i],"-version") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); byebye(); } else if (strcmp(argv[i],"-gui") == 0) { #ifdef COMPILE_WITH_GUI gui = true; #else fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n"); #endif } else if (strcmp(argv[i],"-cores") == 0) { #ifdef COMPILE_WITH_MULTI_CORE if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]); usage(true); } argv[i][0] = '\0'; i++; cores = atoi(argv[i]); argv[i][0] = '\0'; #else fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n"); i++; #endif } else if (strcmp(argv[i],"-parse") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: string\n", argv[i]); usage(true); } i++; if (parse_string) free(parse_string); parse_string = strdup(argv[i]); } else if (strcmp(argv[i],"-parse_all") == 0) { if (parse_string) free(parse_string); parse_string = strdup("txyzirndecaup"); } else if (strcmp(argv[i],"-extra") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: string\n", argv[i]); usage(true); } i++; extra_string = argv[i]; } else if (strcmp(argv[i],"-sep") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: separator\n", argv[i]); usage(true); } i++; separator = argv[i]; if (strcmp(separator,"comma") == 0 || strcmp(separator,"komma") == 0) { separator_sign = ','; } else if (strcmp(separator,"tab") == 0) { separator_sign = '\t'; } else if (strcmp(separator,"dot") == 0 || strcmp(separator,"period") == 0) { separator_sign = '.'; } else if (strcmp(separator,"colon") == 0) { separator_sign = ':'; } else if (strcmp(separator,"semicolon") == 0) { separator_sign = ';'; } else if (strcmp(separator,"hyphen") == 0 || strcmp(separator,"minus") == 0) { separator_sign = '-'; } else if (strcmp(separator,"space") == 0) { separator_sign = ' '; } else { fprintf(stderr, "ERROR: unknown seperator '%s'\n",separator); usage(true); } } else if (strcmp(argv[i],"-header") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: comment\n", argv[i]); usage(true); } i++; if (strcmp(argv[i],"comma") == 0 || strcmp(argv[i],"komma") == 0) { header_comment_sign = ','; } else if (strcmp(argv[i],"colon") == 0) { header_comment_sign = ':'; } else if (strcmp(argv[i],"scolon") == 0 || strcmp(argv[i],"semicolon") == 0) { header_comment_sign = ';'; } else if (strcmp(argv[i],"pound") == 0 || strcmp(argv[i],"hash") == 0) { header_comment_sign = '#'; } else if (strcmp(argv[i],"percent") == 0) { header_comment_sign = '%'; } else if (strcmp(argv[i],"dollar") == 0) { header_comment_sign = '$'; } else if (strcmp(argv[i],"star") == 0) { header_comment_sign = '*'; } else { fprintf(stderr, "ERROR: unknown header comment symbol '%s'\n",argv[i]); usage(true); } } else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0)) { lasreadopener.add_file_name(argv[i]); argv[i][0] = '\0'; } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); usage(true); } } #ifdef COMPILE_WITH_GUI if (gui) { return las2txt_gui(argc, argv, &lasreadopener); } #endif #ifdef COMPILE_WITH_MULTI_CORE if ((cores > 1) && (lasreadopener.get_file_name_number() > 1) && (!lasreadopener.is_merged())) { return las2txt_multi_core(argc, argv, &lasreadopener, &laswriteopener, cores); } #endif // check input if (!lasreadopener.active()) { fprintf(stderr,"ERROR: no input specified\n"); byebye(true, argc == 1); } // possibly loop over multiple input files while (lasreadopener.active()) { if (verbose) start_time = taketime(); // open lasreader LASreader* lasreader = lasreadopener.open(); if (lasreader == 0) { fprintf(stderr, "ERROR: could not open lasreader\n"); byebye(true, argc==1); } // (maybe) open laswaveform13reader LASwaveform13reader* laswaveform13reader = lasreadopener.open_waveform13(&lasreader->header); // get a pointer to the header LASheader* header = &(lasreader->header); // open output file FILE* file_out; if (laswriteopener.is_piped()) { file_out = stdout; } else { // create output file name if needed if (laswriteopener.get_file_name() == 0) { if (lasreadopener.get_file_name() == 0) { fprintf(stderr, "ERROR: no output file specified\n"); byebye(true, argc==1); } laswriteopener.make_file_name(lasreadopener.get_file_name(), -2); } const CHAR* file_name_out = laswriteopener.get_file_name(); // open output file file_out = fopen(file_name_out, "w"); // fail if output file does not open if (file_out == 0) { fprintf(stderr, "ERROR: could not open '%s' for write\n", file_name_out); byebye(true, argc==1); } laswriteopener.set_file_name(0); } // maybe PTS or PTX format if (opts) { // look for VRL with PTS or PTX info const LASvlr* ptsVLR = 0; const LASvlr* ptxVLR = 0; if ((ptsVLR = header->get_vlr("LAStools", 2000)) || (ptxVLR = header->get_vlr("LAStools", 2001))) { if ((parse_string == 0) || (strcmp(parse_string, "original") == 0)) { if (parse_string) free(parse_string); if (ptsVLR && (ptsVLR->record_length_after_header >= 32)) { parse_string = strdup((CHAR*)(ptsVLR->data + 16)); } else if (ptxVLR && (ptxVLR->record_length_after_header >= 32)) { parse_string = strdup((CHAR*)(ptxVLR->data + 16)); } else if (ptsVLR) { fprintf(stderr, "WARNING: found VLR for PTS with wrong payload size of %d.\n", ptsVLR->record_length_after_header); } else if (ptxVLR) { fprintf(stderr, "WARNING: found VLR for PTX with wrong payload size of %d.\n", ptxVLR->record_length_after_header); } } } else { fprintf(stderr, "WARNING: found no VLR with PTS or PTX info.\n"); } if (header->version_minor >= 4) { #ifdef _WIN32 fprintf(file_out, "%I64d \012", header->extended_number_of_point_records); #else fprintf(file_out, "%lld \012", header->extended_number_of_point_records); #endif } else { fprintf(file_out, "%u \012", header->number_of_point_records); } if (parse_string && strcmp(parse_string, "xyz") && strcmp(parse_string, "xyzi") && strcmp(parse_string, "xyziRGB") && strcmp(parse_string, "xyzRGB")) { fprintf(stderr, "WARNING: the parse string for PTS should be 'xyz', 'xyzi', 'xyziRGB', or 'xyzRGB'\n"); } if (separator_sign != ' ') { fprintf(stderr, "WARNING: the separator for PTS should be 'space' not '%s'\n", separator); } } else if (optx) { // look for VRL with PTX info const LASvlr* ptxVLR = header->get_vlr("LAStools", 2001); if (ptxVLR && (ptxVLR->record_length_after_header == 272)) { U8* payload = ptxVLR->data; if ((parse_string == 0) || (strcmp(parse_string, "original") == 0)) { if (parse_string) free(parse_string); parse_string = strdup((CHAR*)(payload + 16)); } fprintf(file_out, "%u \012", (U32)((I64*)payload)[4]); // ncols fprintf(file_out, "%u \012", (U32)((I64*)payload)[5]); // nrows fprintf(file_out, "%g %g %g\012", ((F64*)payload)[6], ((F64*)payload)[7], ((F64*)payload)[8]); // translation fprintf(file_out, "%g %g %g\012", ((F64*)payload)[9], ((F64*)payload)[10], ((F64*)payload)[11]); // rotation_row_0 fprintf(file_out, "%g %g %g\012", ((F64*)payload)[12], ((F64*)payload)[13], ((F64*)payload)[14]); // rotation_row_1 fprintf(file_out, "%g %g %g\012", ((F64*)payload)[15], ((F64*)payload)[16], ((F64*)payload)[17]); // rotation_row_2 fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[18], ((F64*)payload)[19], ((F64*)payload)[20], ((F64*)payload)[21]); // transformation_row_0 fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[22], ((F64*)payload)[23], ((F64*)payload)[24], ((F64*)payload)[25]); // transformation_row_0 fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[26], ((F64*)payload)[27], ((F64*)payload)[28], ((F64*)payload)[29]); // transformation_row_0 fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[30], ((F64*)payload)[31], ((F64*)payload)[32], ((F64*)payload)[33]); // transformation_row_0 } else { if (ptxVLR) { fprintf(stderr, "WARNING: found VLR for PTX with wrong payload size of %d.\n", ptxVLR->record_length_after_header); } else { fprintf(stderr, "WARNING: found no VLR with PTX info.\n"); } fprintf(stderr, " outputting PTS instead ...\n"); if (header->version_minor >= 4) { #ifdef _WIN32 fprintf(file_out, "%I64d \012", header->extended_number_of_point_records); #else fprintf(file_out, "%lld \012", header->extended_number_of_point_records); #endif } else { fprintf(file_out, "%u \012", header->number_of_point_records); } } if (parse_string && strcmp(parse_string, "xyz") && strcmp(parse_string, "xyzi") && strcmp(parse_string, "xyziRGB") && strcmp(parse_string, "xyzRGB")) { fprintf(stderr, "WARNING: the parse string for PTX should be 'xyz', 'xyzi', 'xyziRGB', or 'xyzRGB'\n"); } if (separator_sign != ' ') { fprintf(stderr, "WARNING: the separator for PTX should be 'space' not '%s'\n", separator); } } else if (header_comment_sign) { // output header info fprintf(file_out, "%c file signature: '%.4s'\012", header_comment_sign, header->file_signature); fprintf(file_out, "%c file source ID: %d\012", header_comment_sign, header->file_source_ID); fprintf(file_out, "%c reserved (global encoding):%d\012", header_comment_sign, header->global_encoding); fprintf(file_out, "%c project ID GUID data 1-4: %d %d %d '%.8s'\012", header_comment_sign, header->project_ID_GUID_data_1, header->project_ID_GUID_data_2, header->project_ID_GUID_data_3, header->project_ID_GUID_data_4); fprintf(file_out, "%c version major.minor: %d.%d\012", header_comment_sign, header->version_major, header->version_minor); fprintf(file_out, "%c system_identifier: '%.32s'\012", header_comment_sign, header->system_identifier); fprintf(file_out, "%c generating_software: '%.32s'\012", header_comment_sign, header->generating_software); fprintf(file_out, "%c file creation day/year: %d/%d\012", header_comment_sign, header->file_creation_day, header->file_creation_year); fprintf(file_out, "%c header size %d\012", header_comment_sign, header->header_size); fprintf(file_out, "%c offset to point data %u\012", header_comment_sign, header->offset_to_point_data); fprintf(file_out, "%c number var. length records %u\012", header_comment_sign, header->number_of_variable_length_records); fprintf(file_out, "%c point data format %d\012", header_comment_sign, header->point_data_format); fprintf(file_out, "%c point data record length %d\012", header_comment_sign, header->point_data_record_length); fprintf(file_out, "%c number of point records %u\012", header_comment_sign, header->number_of_point_records); fprintf(file_out, "%c number of points by return %u %u %u %u %u\012", header_comment_sign, header->number_of_points_by_return[0], header->number_of_points_by_return[1], header->number_of_points_by_return[2], header->number_of_points_by_return[3], header->number_of_points_by_return[4]); fprintf(file_out, "%c scale factor x y z %g %g %g\012", header_comment_sign, header->x_scale_factor, header->y_scale_factor, header->z_scale_factor); fprintf(file_out, "%c offset x y z ", header_comment_sign); lidardouble2string(printstring, header->x_offset); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->y_offset); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->z_offset); fprintf(file_out, "%s\012", printstring); fprintf(file_out, "%c min x y z ", header_comment_sign); lidardouble2string(printstring, header->min_x, header->x_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->min_y, header->y_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->min_z, header->z_scale_factor); fprintf(file_out, "%s\012", printstring); fprintf(file_out, "%c max x y z ", header_comment_sign); lidardouble2string(printstring, header->max_x, header->x_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->max_y, header->y_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->max_z, header->z_scale_factor); fprintf(file_out, "%s\012", printstring); } // maybe create default parse string if (parse_string == 0) parse_string = strdup("xyz"); // check requested fields and print warnings of necessary i = 0; while (parse_string[i]) { switch (parse_string[i]) { case 'x': // the x coordinate case 'y': // the y coordinate case 'z': // the z coordinate case 'X': // the unscaled raw integer X coordinate case 'Y': // the unscaled raw integer Y coordinate case 'Z': // the unscaled raw integer Z coordinate case 'i': // the intensity case 'a': // the scan angle case 'r': // the number of the return case 'c': // the classification case 'u': // the user data case 'n': // the number of returns of given pulse case 'p': // the point source ID case 'e': // the edge of flight line flag case 'd': // the direction of scan flag case 'm': // the index of the point (count starts at 0) case 'M': // the index of the point (count starts at 0) break; case 't': // the gps-time if (lasreader->point.have_gps_time == false) fprintf (stderr, "WARNING: requested 't' but points do not have gps time\n"); break; case 'R': // the red channel of the RGB field if (lasreader->point.have_rgb == false) fprintf (stderr, "WARNING: requested 'R' but points do not have rgb\n"); break; case 'G': // the green channel of the RGB field if (lasreader->point.have_rgb == false) fprintf (stderr, "WARNING: requested 'G' but points do not have rgb\n"); break; case 'B': // the blue channel of the RGB field if (lasreader->point.have_rgb == false) fprintf (stderr, "WARNING: requested 'B' but points do not have rgb\n"); break; case 'w': // the wavepacket index if (lasreader->point.have_wavepacket == false) fprintf (stderr, "WARNING: requested 'w' but points do not have wavepacket\n"); break; case 'W': // all wavepacket attributes if (lasreader->point.have_wavepacket == false) fprintf (stderr, "WARNING: requested 'W' but points do not have wavepacket\n"); break; case 'V': // the waveform data if (laswaveform13reader == 0) { fprintf (stderr, "WARNING: requested 'V' but no waveform data available\n"); fprintf (stderr, " omitting ...\n"); } break; case ')': case '!': case '@': case '#': case '$': case '%': case '^': case '&': case '*': case '(': diff = true; break; case 'E': if (extra_string == 0) { fprintf (stderr, "WARNING: requested 'E' but no '-extra' specified\n"); parse_string[i] = 's'; } break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if ((parse_string[i] - '0') >= lasreader->header.number_attributes) { fprintf(stderr, "WARNING: attribute '%d' does not exist.\n", (parse_string[i] - '0')); parse_string[i] = 's'; } else { attribute_starts[(parse_string[i] - '0')] = lasreader->header.get_attribute_start((parse_string[i] - '0')); } break; default: fprintf (stderr, "WARNING: requested unknown parse item '%c'\n", parse_string[i]); } i++; } // in case diff is requested int last_XYZ[3] = {0,0,0}; unsigned short last_RGB[4] = {0,0,0}; double last_GPSTIME = 0; // read and convert the points to ASCII #ifdef _WIN32 if (verbose) fprintf(stderr,"processing %I64d points with '%s'.\n", lasreader->npoints, parse_string); #else if (verbose) fprintf(stderr,"processing %lld points with '%s'.\n", lasreader->npoints, parse_string); #endif while (lasreader->read_point()) { i = 0; while (true) { switch (parse_string[i]) { case 'x': // the x coordinate lidardouble2string(printstring, lasreader->point.get_x(), lasreader->header.x_scale_factor); fprintf(file_out, "%s", printstring); break; case 'y': // the y coordinate lidardouble2string(printstring, lasreader->point.get_y(), lasreader->header.y_scale_factor); fprintf(file_out, "%s", printstring); break; case 'z': // the z coordinate lidardouble2string(printstring, lasreader->point.get_z(), lasreader->header.z_scale_factor); fprintf(file_out, "%s", printstring); break; case 'X': // the unscaled raw integer X coordinate fprintf(file_out, "%d", lasreader->point.get_X()); break; case 'Y': // the unscaled raw integer Y coordinate fprintf(file_out, "%d", lasreader->point.get_Y()); break; case 'Z': // the unscaled raw integer Z coordinate fprintf(file_out, "%d", lasreader->point.get_Z()); break; case 't': // the gps-time fprintf(file_out, "%.6f", lasreader->point.get_gps_time()); break; case 'i': // the intensity if (opts) fprintf(file_out, "%d", -2048 + lasreader->point.get_intensity()); else if (optx) { int len; len = sprintf(printstring, "%.3f", 1.0f/4095.0f * lasreader->point.get_intensity()) - 1; while (printstring[len] == '0') len--; if (printstring[len] != '.') len++; printstring[len] = '\0'; fprintf(file_out, "%s", printstring); } else fprintf(file_out, "%d", lasreader->point.get_intensity()); break; case 'a': // the scan angle fprintf(file_out, "%d", lasreader->point.get_scan_angle_rank()); break; case 'r': // the number of the return fprintf(file_out, "%d", lasreader->point.get_return_number()); break; case 'c': // the classification fprintf(file_out, "%d", lasreader->point.get_classification()); break; case 'u': // the user data fprintf(file_out, "%d", lasreader->point.get_user_data()); break; case 'n': // the number of returns of given pulse fprintf(file_out, "%d", lasreader->point.get_number_of_returns()); break; case 'p': // the point source ID fprintf(file_out, "%d", lasreader->point.get_point_source_ID()); break; case 'e': // the edge of flight line flag fprintf(file_out, "%d", lasreader->point.get_edge_of_flight_line()); break; case 'd': // the direction of scan flag fprintf(file_out, "%d", lasreader->point.get_scan_direction_flag()); break; case 'R': // the red channel of the RGB field fprintf(file_out, "%d", lasreader->point.rgb[0]); break; case 'G': // the green channel of the RGB field fprintf(file_out, "%d", lasreader->point.rgb[1]); break; case 'B': // the blue channel of the RGB field fprintf(file_out, "%d", lasreader->point.rgb[2]); break; case 'm': // the index of the point (count starts at 0) #ifdef _WIN32 fprintf(file_out, "%I64d", lasreader->p_count-1); #else fprintf(file_out, "%lld", lasreader->p_count-1); #endif break; case 'M': // the index of the point (count starts at 1) #ifdef _WIN32 fprintf(file_out, "%I64d", lasreader->p_count); #else fprintf(file_out, "%lld", lasreader->p_count); #endif break; case ')': // the raw integer X difference to the last point fprintf(file_out, "%d", lasreader->point.get_X()-last_XYZ[0]); break; case '!': // the raw integer Y difference to the last point fprintf(file_out, "%d", lasreader->point.get_Y()-last_XYZ[1]); break; case '@': // the raw integer Z difference to the last point fprintf(file_out, "%d", lasreader->point.get_Z()-last_XYZ[2]); break; case '#': // the gps-time difference to the last point lidardouble2string(printstring,lasreader->point.gps_time-last_GPSTIME); fprintf(file_out, "%s", printstring); break; case '$': // the R difference to the last point fprintf(file_out, "%d", lasreader->point.rgb[0]-last_RGB[0]); break; case '%': // the G difference to the last point fprintf(file_out, "%d", lasreader->point.rgb[1]-last_RGB[1]); break; case '^': // the B difference to the last point fprintf(file_out, "%d", lasreader->point.rgb[2]-last_RGB[2]); break; case '&': // the byte-wise R difference to the last point fprintf(file_out, "%d%c%d", (lasreader->point.rgb[0]>>8)-(last_RGB[0]>>8), separator_sign, (lasreader->point.rgb[0]&255)-(last_RGB[0]&255)); break; case '*': // the byte-wise G difference to the last point fprintf(file_out, "%d%c%d", (lasreader->point.rgb[1]>>8)-(last_RGB[1]>>8), separator_sign, (lasreader->point.rgb[1]&255)-(last_RGB[1]&255)); break; case '(': // the byte-wise B difference to the last point fprintf(file_out, "%d%c%d", (lasreader->point.rgb[2]>>8)-(last_RGB[2]>>8), separator_sign, (lasreader->point.rgb[2]&255)-(last_RGB[2]&255)); break; case 'w': // the wavepacket index fprintf(file_out, "%d", lasreader->point.wavepacket.getIndex()); break; case 'W': // all wavepacket attributes fprintf(file_out, "%d%c%d%c%d%c%g%c%g%c%g%c%g", lasreader->point.wavepacket.getIndex(), separator_sign, (U32)lasreader->point.wavepacket.getOffset(), separator_sign, lasreader->point.wavepacket.getSize(), separator_sign, lasreader->point.wavepacket.getLocation(), separator_sign, lasreader->point.wavepacket.getXt(), separator_sign, lasreader->point.wavepacket.getYt(), separator_sign, lasreader->point.wavepacket.getZt()); break; case 'V': // the waVeform if (laswaveform13reader && laswaveform13reader->read_waveform(&lasreader->point)) { output_waveform(file_out, separator_sign, laswaveform13reader); } else { fprintf(file_out, "no_waveform"); } break; case 'E': // the extra string fprintf(file_out, "%s", extra_string); break; default: print_attribute(file_out, &lasreader->header, &lasreader->point, (I32)(parse_string[i]-'0'), printstring); } i++; if (parse_string[i]) { fprintf(file_out, "%c", separator_sign); } else { fprintf(file_out, "\012"); break; } } if (diff) { last_XYZ[0] = lasreader->point.get_X(); last_XYZ[1] = lasreader->point.get_Y(); last_XYZ[2] = lasreader->point.get_Z(); last_GPSTIME = lasreader->point.gps_time; last_RGB[0] = lasreader->point.rgb[0]; last_RGB[1] = lasreader->point.rgb[1]; last_RGB[2] = lasreader->point.rgb[2]; } } #ifdef _WIN32 if (verbose) fprintf(stderr,"converting %I64d points of '%s' took %g sec.\n", lasreader->p_count, lasreadopener.get_file_name(), taketime()-start_time); #else if (verbose) fprintf(stderr,"converting %lld points of '%s' took %g sec.\n", lasreader->p_count, lasreadopener.get_file_name(), taketime()-start_time); #endif // close the reader lasreader->close(); delete lasreader; // (maybe) close the waveform reader if (laswaveform13reader) { laswaveform13reader->close(); delete laswaveform13reader; } // close the files if (file_out != stdout) fclose(file_out); } free(parse_string); byebye(false, argc==1); return 0; }
int main(int argc, char *argv[]) { int i,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 verbose = false; F32 tile_size = 0.0f; U32 threshold = 1000; U32 minimum_points = 100000; I32 maximum_intervals = -20; BOOL append = FALSE; F64 start_time = 0.0; F64 total_start_time = 0.0; LASreadOpener lasreadopener; if (argc == 1) { #ifdef COMPILE_WITH_GUI return lasindex_gui(argc, argv, 0); #else fprintf(stderr,"lasindex.exe is better run in the command line or via the lastool.exe GUI\n"); char file_name[256]; fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.set_file_name(file_name); #endif } else { for (i = 1; i < argc; i++) { if (argv[i][0] == '–') argv[i][0] = '-'; } if (!lasreadopener.parse(argc, argv)) byebye(true); } for (i = 1; i < argc; i++) { if (argv[i][0] == '\0') { continue; } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); usage(); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = true; } else if (strcmp(argv[i],"-version") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); byebye(); } else if (strcmp(argv[i],"-gui") == 0) { #ifdef COMPILE_WITH_GUI gui = true; #else fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n"); #endif } else if (strcmp(argv[i],"-cores") == 0) { #ifdef COMPILE_WITH_MULTI_CORE if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]); usage(true); } argv[i][0] = '\0'; i++; cores = atoi(argv[i]); argv[i][0] = '\0'; #else fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n"); i++; #endif } else if (strcmp(argv[i],"-tile_size") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: size\n", argv[i]); byebye(true); } i++; tile_size = (F32)atof(argv[i]); } else if (strcmp(argv[i],"-maximum") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]); byebye(true); } i++; maximum_intervals = atoi(argv[i]); } else if (strcmp(argv[i],"-minimum") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]); byebye(true); } i++; minimum_points = atoi(argv[i]); } else if (strcmp(argv[i],"-threshold") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: value\n", argv[i]); byebye(true); } i++; threshold = atoi(argv[i]); } else if (strcmp(argv[i],"-append") == 0) { append = TRUE; } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); byebye(true); } } #ifdef COMPILE_WITH_GUI if (gui) { return lasindex_gui(argc, argv, &lasreadopener); } #endif #ifdef COMPILE_WITH_MULTI_CORE if (cores > 1) { if (lasreadopener.get_file_name_number() < 2) { fprintf(stderr,"WARNING: only %u input files. ignoring '-cores %d' ...\n", lasreadopener.get_file_name_number(), cores); } else if (lasreadopener.is_merged()) { fprintf(stderr,"WARNING: input files merged on-the-fly. ignoring '-cores %d' ...\n", cores); } else { return lasindex_multi_core(argc, argv, &lasreadopener, cores); } } #endif // check input if (!lasreadopener.active()) { fprintf(stderr,"ERROR: no input specified\n"); byebye(true, argc==1); } /* // lasquadtree test LASquadtree quadtree; quadtree.setup(0, 99, 0, 99, 10); quadtree.intersect_rectangle(10, 10, 20, 20); quadtree.get_intersected_cells(); while (quadtree.has_intersected_cells()) { F32 min[2],max[2]; quadtree.get_cell_bounding_box(quadtree.intersected_cell, min, max); fprintf(stderr," checking tile %d with %g/%g %g/%g\n", quadtree.intersected_cell, min[0], min[1], max[0], max[1]); } quadtree.intersect_tile(10, 10, 10); quadtree.get_intersected_cells(); while (quadtree.has_intersected_cells()) { F32 min[2],max[2]; quadtree.get_cell_bounding_box(quadtree.intersected_cell, min, max); fprintf(stderr," checking tile %d with %g/%g %g/%g\n", quadtree.intersected_cell, min[0], min[1], max[0], max[1]); } fprintf(stderr,"intersect circle\n"); quadtree.intersect_circle(10, 10, 10); quadtree.get_intersected_cells(); while (quadtree.has_intersected_cells()) { F32 min[2],max[2]; quadtree.get_cell_bounding_box(quadtree.intersected_cell, min, max); fprintf(stderr," checking tile %d with %g/%g %g/%g\n", quadtree.intersected_cell, min[0], min[1], max[0], max[1]); } */ // possibly loop over multiple input files if (verbose && lasreadopener.get_file_name_number() > 1) { total_start_time = taketime(); } while (lasreadopener.active()) { if (verbose) start_time = taketime(); // open lasreader LASreader* lasreader = lasreadopener.open(); if (lasreader == 0) { fprintf(stderr, "ERROR: could not open lasreader\n"); byebye(true, argc==1); } // setup the quadtree LASquadtree* lasquadtree = new LASquadtree; if (tile_size == 0.0f) { F32 t; if (((lasreader->header.max_x - lasreader->header.min_x) < 1000) && ((lasreader->header.max_y - lasreader->header.min_y) < 1000)) { t = 10.0f; } else if (((lasreader->header.max_x - lasreader->header.min_x) < 10000) && ((lasreader->header.max_y - lasreader->header.min_y) < 10000)) { t = 100.0f; } else if (((lasreader->header.max_x - lasreader->header.min_x) < 100000) && ((lasreader->header.max_y - lasreader->header.min_y) < 100000)) { t = 1000.0f; } else if (((lasreader->header.max_x - lasreader->header.min_x) < 1000000) && ((lasreader->header.max_y - lasreader->header.min_y) < 1000000)) { t = 10000.0f; } else { t = 100000.0f; } if (verbose) fprintf(stderr,"no tile size specified. setting it to %g ...\n", t); lasquadtree->setup(lasreader->header.min_x, lasreader->header.max_x, lasreader->header.min_y, lasreader->header.max_y, t); } else { lasquadtree->setup(lasreader->header.min_x, lasreader->header.max_x, lasreader->header.min_y, lasreader->header.max_y, tile_size); } // create index and add points LASindex lasindex; lasindex.prepare(lasquadtree, threshold); while (lasreader->read_point()) lasindex.add(lasreader->point.get_x(), lasreader->point.get_y(), (U32)(lasreader->p_count-1)); // delete the reader lasreader->close(); delete lasreader; // adaptive coarsening lasindex.complete(minimum_points, maximum_intervals); // write to file if (append) { lasindex.append(lasreadopener.get_file_name()); } else { lasindex.write(lasreadopener.get_file_name()); } if (verbose) fprintf(stderr,"done with '%s'. took %g sec.\n", lasreadopener.get_file_name(), taketime()-start_time); } if (verbose && lasreadopener.get_file_name_number() > 1) { fprintf(stderr,"done with %u files. total time %g sec.\n", lasreadopener.get_file_name_number(), taketime()-total_start_time); } byebye(false, argc==1); return 0; }
int main(int argc,char** argv){ if(argc<3){ fprintf(stderr,"Usage:%s <server_port> <server_ip>\n",argv[0]); exit(1); } para.argc=argc; para.argv=argv; char i; pthread_t tid; welcome(); //创一线程与客户和厨房端通信,主线程处理服务器交互界面 if((pthread_create(&tid,NULL,fun_main,NULL))){ perror("pthread_create"); exit(1); } //初始化待处理信息链表头 need_handle_initadress(&pneed_handle_head); one_seat_initadress(&pone_seat); //初始化主界面指针 get_homeifno_memory(&phome); //清空主画面信息 bzero(phome,sizeof(home_info)); #if 1 for(;;){ i=show_home_info(phome,refresh_homepageby_gui); if(phome->home_page_flag) phome->home_page_flag=0; if(i=='e'||i=='q'){ printf("确认退出服务器?(y/n):"); scanf("%c",&i); while(getchar()!='\n'); if(i=='n'||i=='N'); else break; }else if(i=='1'||i=='2'){ phome->home_page_flag=1; }else if(i=='3'); else if(i=='c'||i=='C'){ for(i=0;i<happen_t;i++){ memset(phome->happen[i],0,happen_l); memset(phome->handle_happen[i],0,happen_l); if(i<unknow_t) memset(phome->unknow_happen[i],0,happen_l); } phome->index=0; phome->in=0; phome->hardware_index=0; show_home_info(phome,refresh_homepageby_server); } else{ printf("你要退出服务器吗?(y/n):"); scanf("%c",&i); while(getchar()!='\n'); if(i=='n'||i=='N'); else break; } } byebye(); #endif exit(0); //pthread_exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { int i; #ifdef COMPILE_WITH_GUI bool gui = false; #endif bool verbose = false; bool keep_lastiling = false; U32 chopchop = 0; bool projection_was_set = false; double start_time = 0; LASreadOpener lasreadopener; GeoProjectionConverter geoprojectionconverter; LASwriteOpener laswriteopener; if (argc == 1) { #ifdef COMPILE_WITH_GUI return lasmerge_gui(argc, argv, 0); #else fprintf(stderr,"%s is better run in the command line\n", argv[0]); char file_name[256]; fprintf(stderr,"enter input file 1: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.add_file_name(file_name); fprintf(stderr,"enter input file 2: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.add_file_name(file_name); fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; laswriteopener.set_file_name(file_name); #endif } else { for (i = 1; i < argc; i++) { if (argv[i][0] == '–') argv[i][0] = '-'; } if (!geoprojectionconverter.parse(argc, argv)) byebye(true); if (!lasreadopener.parse(argc, argv)) byebye(true); if (!laswriteopener.parse(argc, argv)) byebye(true); } for (i = 1; i < argc; i++) { if (argv[i][0] == '\0') { continue; } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); usage(); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = true; } else if (strcmp(argv[i],"-version") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); byebye(); } else if (strcmp(argv[i],"-gui") == 0) { #ifdef COMPILE_WITH_GUI gui = true; #else fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n"); #endif } else if (strcmp(argv[i],"-split") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: size\n", argv[i]); byebye(true); } i++; chopchop = atoi(argv[i]); } else if (strcmp(argv[i],"-keep_lastiling") == 0) { keep_lastiling = true; } else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0)) { lasreadopener.add_file_name(argv[i]); argv[i][0] = '\0'; } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); byebye(true); } } #ifdef COMPILE_WITH_GUI if (gui) { return lasmerge_gui(argc, argv, &lasreadopener); } #endif // read all the input files merged lasreadopener.set_merged(TRUE); // maybe we want to keep the lastiling if (keep_lastiling) { lasreadopener.set_keep_lastiling(TRUE); } // we need to precompute the bounding box lasreadopener.set_populate_header(TRUE); // check input and output if (!lasreadopener.active()) { fprintf(stderr, "ERROR: no input specified\n"); byebye(true, argc==1); } if (!laswriteopener.active()) { fprintf(stderr, "ERROR: no output specified\n"); byebye(true, argc==1); } // make sure we do not corrupt the input file if (lasreadopener.get_file_name() && laswriteopener.get_file_name() && (strcmp(lasreadopener.get_file_name(), laswriteopener.get_file_name()) == 0)) { fprintf(stderr, "ERROR: input and output file name are identical\n"); usage(true); } // check if projection info was set in the command line int number_of_keys; GeoProjectionGeoKeys* geo_keys = 0; int num_geo_double_params; double* geo_double_params = 0; if (geoprojectionconverter.has_projection()) { projection_was_set = geoprojectionconverter.get_geo_keys_from_projection(number_of_keys, &geo_keys, num_geo_double_params, &geo_double_params); } if (verbose) start_time = taketime(); LASreader* lasreader = lasreadopener.open(); if (lasreader == 0) { fprintf(stderr, "ERROR: could not open lasreader\n"); byebye(true, argc==1); } #ifdef _WIN32 if (verbose) { fprintf(stderr,"merging headers took %g sec. there are %I64d points in total.\n", taketime()-start_time, lasreader->npoints); start_time = taketime(); } #else if (verbose) { fprintf(stderr,"merging headers took %g sec. there are %lld points in total.\n", taketime()-start_time, lasreader->npoints); start_time = taketime(); } #endif // prepare the header for the surviving points strncpy(lasreader->header.system_identifier, "LAStools (c) by rapidlasso GmbH", 32); lasreader->header.system_identifier[31] = '\0'; char temp[64]; sprintf(temp, "lasmerge (version %d)", LAS_TOOLS_VERSION); strncpy(lasreader->header.generating_software, temp, 32); lasreader->header.generating_software[31] = '\0'; if (projection_was_set) { lasreader->header.set_geo_keys(number_of_keys, (LASvlr_key_entry*)geo_keys); free(geo_keys); if (geo_double_params) { lasreader->header.set_geo_double_params(num_geo_double_params, geo_double_params); free(geo_double_params); } else { lasreader->header.del_geo_double_params(); } lasreader->header.del_geo_ascii_params(); } if (chopchop) { I32 file_number = 0; LASwriter* laswriter = 0; // loop over the points while (lasreader->read_point()) { if (laswriter == 0) { // open the next writer laswriteopener.make_file_name(0, file_number); file_number++; laswriter = laswriteopener.open(&lasreader->header); } laswriter->write_point(&lasreader->point); laswriter->update_inventory(&lasreader->point); if (laswriter->p_count == chopchop) { // close the current writer laswriter->update_header(&lasreader->header, TRUE); laswriter->close(); if (verbose) { fprintf(stderr,"splitting file '%s' took %g sec.\n", laswriteopener.get_file_name(), taketime()-start_time); start_time = taketime(); } delete laswriter; laswriter = 0; } } if (laswriter && laswriter->p_count) { // close the current writer laswriter->update_header(&lasreader->header, TRUE); laswriter->close(); if (verbose) { fprintf(stderr,"splitting file '%s' took %g sec.\n", laswriteopener.get_file_name(), taketime()-start_time); start_time = taketime(); } delete laswriter; laswriter = 0; } } else { // open the writer LASwriter* laswriter = laswriteopener.open(&lasreader->header); if (laswriter == 0) { fprintf(stderr, "ERROR: could not open laswriter\n"); byebye(true, argc==1); } // loop over the points while (lasreader->read_point()) { laswriter->write_point(&lasreader->point); laswriter->update_inventory(&lasreader->point); } // close the writer laswriter->update_header(&lasreader->header, TRUE); laswriter->close(); if (verbose) fprintf(stderr,"merging files took %g sec.\n", taketime()-start_time); delete laswriter; } lasreader->close(); delete lasreader; byebye(false, argc==1); return 0; }
int main(int argc, char** argv) { /* working variables */ int i,j,ifile,nfile,cm,w,w2; FILE *fp; char *cbuf; double *alphavec=NULL; double **cimat=NULL, **semat=NULL, **eimat=NULL; double **ci0mat=NULL, **se0mat=NULL, **ei0mat=NULL; int nalpha; int *orderv; double *obsvec; /* auxiliary info */ char **fnamev; fnamev=NEW_A(argc-1,char*); nfile=0; /* args */ for(i=1;i<argc;i++) { if(argv[i][0] != '-') { fnamev[nfile]=argv[i]; nfile++; } else if(streq(argv[i],"-d")) { if(i+1>=argc || sscanf(argv[i+1],"%d",&debugmode) != 1) byebye(); i+=1; } else if(streq(argv[i],"-v")) { sw_verpose=1; } else if(streq(argv[i],"--no_au")) { sw_au=0; } else if(streq(argv[i],"--no_np")) { sw_bp=0; } else byebye(); } for(ifile=0;ifile<nfile;ifile++) { fp=openfp(fnamev[ifile],fext_ci,"r",&cbuf); printf("\n# reading %s",cbuf); cm=nalpha=0; orderv=fread_ivec(fp,&cm); obsvec=fread_vec(fp,&cm); alphavec=fread_vec(fp,&nalpha); cimat=fread_mat(fp,&cm,&nalpha); semat=fread_mat(fp,&cm,&nalpha); eimat=fread_mat(fp,&cm,&nalpha); ci0mat=fread_mat(fp,&cm,&nalpha); se0mat=fread_mat(fp,&cm,&nalpha); ei0mat=fread_mat(fp,&cm,&nalpha); fclose(fp); printf("\n#"); repchar(' ',17); w=nalpha*(sw_verpose?17:7); w2=w/2-2; if(sw_au) { repchar('-',w2); printf(" au "); repchar('-',w-w2-4); } printf(" |"); if(sw_bp) { repchar('-',w2); printf(" np "); repchar('-',w-w2-4); } printf("\n# %4s %4s","rank","item"); printf(" %6s","obs"); if(sw_au) { for(j=0;j<nalpha;j++) { printf(" %6.3f",alphavec[j]); if(sw_verpose) printf(" %4s %4s","se","ei"); } } printf(" |"); if(sw_bp) { for(j=0;j<nalpha;j++) { printf(" %6.3f",alphavec[j]); if(sw_verpose) printf(" %4s %4s","se","ei"); } } for(i=0;i<cm;i++) { printf("\n# %4d %4d",i+1,orderv[i]+1); printf(" %6.1f",obsvec[i]); if(sw_au){ for(j=0;j<nalpha;j++) { printf(" %6.1f",cimat[i][j]); if(sw_verpose) printf(" %4.1f %4.1f",semat[i][j],eimat[i][j]); } } printf(" |"); if(sw_bp){ for(j=0;j<nalpha;j++) { printf(" %6.1f",ci0mat[i][j]); if(sw_verpose) printf(" %4.1f %4.1f",se0mat[i][j],ei0mat[i][j]); } } } printf("\n"); free_vec(alphavec); free_mat(cimat); free_mat(semat); free_mat(eimat); free_mat(ci0mat); free_mat(se0mat); free_mat(ei0mat); free_ivec(orderv); free_vec(obsvec); } return 0; }
int main(int argc, char *argv[]) { int i; #ifdef COMPILE_WITH_GUI bool gui = false; #endif #ifdef COMPILE_WITH_MULTI_CORE I32 cores = 1; #endif bool verbose = false; bool projection_was_set = false; bool quiet = false; int file_creation_day = -1; int file_creation_year = -1; int set_version_major = -1; int set_version_minor = -1; int set_classification = -1; char* set_system_identifier = 0; char* set_generating_software = 0; bool set_ogc_wkt = false; double start_time = 0.0; LASreadOpener lasreadopener; GeoProjectionConverter geoprojectionconverter; LASwriteOpener laswriteopener; if (argc == 1) { #ifdef COMPILE_WITH_GUI return txt2las_gui(argc, argv, 0); #else char file_name[256]; fprintf(stderr,"%s is better run in the command line\n", argv[0]); fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.set_file_name(file_name); fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; laswriteopener.set_file_name(file_name); #endif } else { // need to get those before lastransform->parse() routine gets them for (i = 1; i < argc; i++) { if (argv[i][0] == '–') argv[i][0] = '-'; if (strcmp(argv[i],"-scale_intensity") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: factor\n", argv[i]); usage(true); } lasreadopener.set_scale_intensity((F32)atof(argv[i+1])); *argv[i]='\0'; *argv[i+1]='\0'; i+=1; } else if (strcmp(argv[i],"-translate_intensity") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: offset\n", argv[i]); usage(true); } lasreadopener.set_translate_intensity((F32)atof(argv[i+1])); *argv[i]='\0'; *argv[i+1]='\0'; i+=1; } else if (strcmp(argv[i],"-translate_then_scale_intensity") == 0) { if ((i+2) >= argc) { fprintf(stderr,"ERROR: '%s' needs 2 arguments: offset factor\n", argv[i]); usage(true); } lasreadopener.set_translate_intensity((F32)atof(argv[i+1])); lasreadopener.set_scale_intensity((F32)atof(argv[i+2])); *argv[i]='\0'; *argv[i+1]='\0'; *argv[i+2]='\0'; i+=2; } else if (strcmp(argv[i],"-scale_scan_angle") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: factor\n", argv[i]); usage(true); } lasreadopener.set_scale_scan_angle((F32)atof(argv[i+1])); *argv[i]='\0'; *argv[i+1]='\0'; i+=1; } } if (!lasreadopener.parse(argc, argv)) byebye(true); if (!geoprojectionconverter.parse(argc, argv)) byebye(true); if (!laswriteopener.parse(argc, argv)) byebye(true); } for (i = 1; i < argc; i++) { if (argv[i][0] == '\0') { continue; } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); usage(); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = true; } else if (strcmp(argv[i],"-version") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); byebye(); } else if (strcmp(argv[i],"-gui") == 0) { #ifdef COMPILE_WITH_GUI gui = true; #else fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n"); #endif } else if (strcmp(argv[i],"-cores") == 0) { #ifdef COMPILE_WITH_MULTI_CORE if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]); usage(true); } argv[i][0] = '\0'; i++; cores = atoi(argv[i]); argv[i][0] = '\0'; #else fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n"); i++; #endif } else if (strcmp(argv[i],"-quiet") == 0) { quiet = true; } else if (strcmp(argv[i],"-parse") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: parse_string\n", argv[i]); usage(true); } i++; lasreadopener.set_parse_string(argv[i]); } else if (strcmp(argv[i],"-skip") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number_of_lines\n", argv[i]); usage(true); } i++; lasreadopener.set_skip_lines(atoi(argv[i])); } else if (strcmp(argv[i],"-set_scale") == 0) { if ((i+3) >= argc) { fprintf(stderr,"ERROR: '%s' needs 3 arguments: x y z\n", argv[i]); usage(true); } F64 scale_factor[3]; i++; sscanf(argv[i], "%lf", &(scale_factor[0])); i++; sscanf(argv[i], "%lf", &(scale_factor[1])); i++; sscanf(argv[i], "%lf", &(scale_factor[2])); lasreadopener.set_scale_factor(scale_factor); } else if (strcmp(argv[i],"-set_offset") == 0) { if ((i+3) >= argc) { fprintf(stderr,"ERROR: '%s' needs 3 arguments: x y z\n", argv[i]); usage(true); } F64 offset[3]; i++; sscanf(argv[i], "%lf", &(offset[0])); i++; sscanf(argv[i], "%lf", &(offset[1])); i++; sscanf(argv[i], "%lf", &(offset[2])); lasreadopener.set_offset(offset); } else if (strcmp(argv[i],"-add_extra") == 0 || strcmp(argv[i],"-add_attribute") == 0) { if ((i+3) >= argc) { fprintf(stderr,"ERROR: '%s' needs at least 3 arguments: data_type name description\n", argv[i]); usage(true); } if (((i+4) < argc) && (atof(argv[i+4]) != 0.0)) { if (((i+5) < argc) && ((atof(argv[i+5]) != 0.0) || (strcmp(argv[i+5], "0") == 0) || (strcmp(argv[i+5], "0.0") == 0))) { if (((i+6) < argc) && (atof(argv[i+6]) != 0.0)) { if (((i+7) < argc) && ((atof(argv[i+7]) != 0.0) || (strcmp(argv[i+7], "0") == 0) || (strcmp(argv[i+7], "0.0") == 0))) { lasreadopener.add_attribute(atoi(argv[i+1]), argv[i+2], argv[i+3], atof(argv[i+4]), atof(argv[i+5]), atof(argv[i+6]), atof(argv[i+7])); i+=7; } else { lasreadopener.add_attribute(atoi(argv[i+1]), argv[i+2], argv[i+3], atof(argv[i+4]), atof(argv[i+5]), atof(argv[i+6])); i+=6; } } else { lasreadopener.add_attribute(atoi(argv[i+1]), argv[i+2], argv[i+3], atof(argv[i+4]), atof(argv[i+5])); i+=5; } } else { lasreadopener.add_attribute(atoi(argv[i+1]), argv[i+2], argv[i+3], atof(argv[i+4])); i+=4; } } else { lasreadopener.add_attribute(atoi(argv[i+1]), argv[i+2], argv[i+3]); i+=3; } } else if (strcmp(argv[i],"-set_creation_date") == 0 || strcmp(argv[i],"-set_file_creation") == 0) { if ((i+2) >= argc) { fprintf(stderr,"ERROR: '%s' needs 2 arguments: day year\n", argv[i]); usage(true); } i++; sscanf(argv[i], "%d", &file_creation_day); i++; sscanf(argv[i], "%d", &file_creation_year); } else if (strcmp(argv[i],"-set_class") == 0 || strcmp(argv[i],"-set_classification") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: value\n", argv[i]); usage(true); } i++; set_classification = atoi(argv[i]); } else if (strcmp(argv[i],"-set_system_identifier") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: name\n", argv[i]); usage(true); } i++; set_system_identifier = argv[i]; } else if (strcmp(argv[i],"-set_generating_software") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: name\n", argv[i]); usage(true); } i++; set_generating_software = argv[i]; } else if (strcmp(argv[i],"-set_ogc_wkt") == 0) { set_ogc_wkt = true; } else if (strcmp(argv[i],"-set_version") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: major.minor\n", argv[i]); usage(true); } i++; if (sscanf(argv[i],"%d.%d",&set_version_major,&set_version_minor) != 2) { fprintf(stderr, "ERROR: cannot understand argument '%s' of '%s'\n", argv[i], argv[i-1]); usage(true); } } else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0)) { lasreadopener.add_file_name(argv[i]); argv[i][0] = '\0'; } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); usage(true); } } #ifdef COMPILE_WITH_GUI if (gui) { return txt2las_gui(argc, argv, &lasreadopener); } #endif #ifdef COMPILE_WITH_MULTI_CORE if (cores > 1) { if (lasreadopener.get_file_name_number() < 2) { fprintf(stderr,"WARNING: only %u input files. ignoring '-cores %d' ...\n", lasreadopener.get_file_name_number(), cores); } else if (lasreadopener.is_merged()) { fprintf(stderr,"WARNING: input files merged on-the-fly. ignoring '-cores %d' ...\n", cores); } else { return txt2las_multi_core(argc, argv, &geoprojectionconverter, &lasreadopener, &laswriteopener, cores); } } #endif // make sure we have input if (!lasreadopener.active()) { fprintf(stderr, "ERROR: no input specified\n"); byebye(true, argc==1); } // make sure that input and output are not *both* piped if (lasreadopener.is_piped() && laswriteopener.is_piped()) { fprintf(stderr, "ERROR: input and output cannot both be piped\n"); byebye(true, argc==1); } // check if projection info was set in the command line int number_of_keys; GeoProjectionGeoKeys* geo_keys = 0; int num_geo_double_params; double* geo_double_params = 0; if (geoprojectionconverter.has_projection()) { projection_was_set = geoprojectionconverter.get_geo_keys_from_projection(number_of_keys, &geo_keys, num_geo_double_params, &geo_double_params); } // loop over multiple input files while (lasreadopener.active()) { if (verbose) start_time = taketime(); // open lasreader LASreader* lasreader = lasreadopener.open(); if (lasreader == 0) { fprintf(stderr, "ERROR: could not open lasreader\n"); byebye(true, argc==1); } // check output if (!laswriteopener.active()) { // create name from input name laswriteopener.make_file_name(lasreadopener.get_file_name(), -2); } // if the output was piped we need to precompute the bounding box, etc ... if (laswriteopener.is_piped()) { // because the output goes to a pipe we have to precompute the header // information with an additional pass. if (verbose) { fprintf(stderr, "piped output. extra read pass over file '%s' ...\n", lasreadopener.get_file_name()); } while (lasreader->read_point()); lasreader->close(); // output some stats if (verbose) { #ifdef _WIN32 fprintf(stderr, "npoints %I64d min %g %g %g max %g %g %g\n", lasreader->npoints, lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z); #else fprintf(stderr, "npoints %lld min %g %g %g max %g %g %g\n", lasreader->npoints, lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z); #endif fprintf(stderr, "return histogram %d %d %d %d %d\n", lasreader->header.number_of_points_by_return[0], lasreader->header.number_of_points_by_return[1], lasreader->header.number_of_points_by_return[2], lasreader->header.number_of_points_by_return[3], lasreader->header.number_of_points_by_return[4]); fprintf(stderr,"took %g sec.\n", taketime()-start_time); start_time = taketime(); } // reopen lasreader for the second pass if (!lasreadopener.reopen(lasreader)) { fprintf(stderr, "ERROR: could not reopen '%s' for main pass\n", lasreadopener.get_file_name()); byebye(true, argc==1); } } // populate header for (i = 0; i < 32; i++) { lasreader->header.system_identifier[i] = '\0'; lasreader->header.generating_software[i] = '\0'; } if (set_system_identifier) { strncpy(lasreader->header.system_identifier, set_system_identifier, 32); lasreader->header.system_identifier[31] = '\0'; } else { strncpy(lasreader->header.system_identifier, "LAStools (c) by rapidlasso GmbH", 32); lasreader->header.system_identifier[31] = '\0'; } if (set_generating_software) { strncpy(lasreader->header.generating_software, set_generating_software, 32); lasreader->header.generating_software[31] = '\0'; } else { char temp[64]; sprintf(temp, "txt2las (version %d)", LAS_TOOLS_VERSION); strncpy(lasreader->header.generating_software, temp, 32); lasreader->header.generating_software[31] = '\0'; } // maybe set creation date #ifdef _WIN32 if (lasreadopener.get_file_name() && file_creation_day == -1 && file_creation_year == -1) { WIN32_FILE_ATTRIBUTE_DATA attr; SYSTEMTIME creation; GetFileAttributesEx(lasreadopener.get_file_name(), GetFileExInfoStandard, &attr); FileTimeToSystemTime(&attr.ftCreationTime, &creation); int startday[13] = {-1, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334}; file_creation_day = startday[creation.wMonth] + creation.wDay; file_creation_year = creation.wYear; // leap year handling if ((((creation.wYear)%4) == 0) && (creation.wMonth > 2)) file_creation_day++; } #endif if (file_creation_day == -1 && file_creation_year == -1) { lasreader->header.file_creation_day = (U16)333; lasreader->header.file_creation_year = (U16)2011; } else { lasreader->header.file_creation_day = (U16)file_creation_day; lasreader->header.file_creation_year = (U16)file_creation_year; } // maybe set version if (set_version_major != -1) lasreader->header.version_major = (U8)set_version_major; if (set_version_minor != -1) lasreader->header.version_minor = (U8)set_version_minor; if (set_version_minor == 3) { lasreader->header.header_size = 235; lasreader->header.offset_to_point_data = 235; } else if (set_version_minor == 4) { lasreader->header.header_size = 375; lasreader->header.offset_to_point_data = 375; } // maybe set projection if (projection_was_set) { lasreader->header.set_geo_keys(number_of_keys, (LASvlr_key_entry*)geo_keys); if (geo_double_params) { lasreader->header.set_geo_double_params(num_geo_double_params, geo_double_params); } else { lasreader->header.del_geo_double_params(); } lasreader->header.del_geo_ascii_params(); if (set_ogc_wkt) // maybe also set the OCG WKT { I32 len = 0; CHAR* ogc_wkt = 0; if (geoprojectionconverter.get_ogc_wkt_from_projection(len, &ogc_wkt, !geoprojectionconverter.has_projection(false))) { lasreader->header.set_geo_wkt_ogc_cs(len, ogc_wkt); free(ogc_wkt); if ((lasreader->header.version_minor >= 4) && (lasreader->header.point_data_format >= 6)) { lasreader->header.set_global_encoding_bit(LAS_TOOLS_GLOBAL_ENCODING_BIT_OGC_WKT_CRS); } } else { fprintf(stderr, "WARNING: cannot produce OCG WKT. ignoring '-set_ogc_wkt' for '%s'\n", lasreadopener.get_file_name()); } } } // open the output LASwriter* laswriter = laswriteopener.open(&lasreader->header); if (laswriter == 0) { fprintf(stderr, "ERROR: could not open laswriter\n"); byebye(true, argc==1); } if (verbose) fprintf(stderr, "reading file '%s' and writing to '%s'\n", lasreadopener.get_file_name(), laswriteopener.get_file_name()); // loop over points while (lasreader->read_point()) { // maybe set classification if (set_classification != -1) { lasreader->point.set_classification(set_classification); } // write the point laswriter->write_point(&lasreader->point); } lasreader->close(); if (!laswriteopener.is_piped()) { laswriter->update_header(&lasreader->header, FALSE, TRUE); if (verbose) { #ifdef _WIN32 fprintf(stderr, "npoints %I64d min %g %g %g max %g %g %g\n", lasreader->npoints, lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z); #else fprintf(stderr, "npoints %lld min %g %g %g max %g %g %g\n", lasreader->npoints, lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z); #endif fprintf(stderr, "return histogram %d %d %d %d %d\n", lasreader->header.number_of_points_by_return[0], lasreader->header.number_of_points_by_return[1], lasreader->header.number_of_points_by_return[2], lasreader->header.number_of_points_by_return[3], lasreader->header.number_of_points_by_return[4]); } } laswriter->close(); delete laswriter; delete lasreader; laswriteopener.set_file_name(0); if (verbose) fprintf(stderr,"took %g sec.\n", taketime()-start_time); } byebye(false, argc==1); return 0; }
void total_winner(void) { struct linked_list *item; struct object *obj; int worth, oldpurse; char c; struct linked_list *bag = NULL; clear(); standout(); addstr(" \n"); addstr(" @ @ @ @ @ @@@ @ @ \n"); addstr(" @ @ @@ @@ @ @ @ @ \n"); addstr(" @ @ @@@ @ @ @ @ @ @@@ @@@@ @@@ @ @@@ @ \n"); addstr(" @@@@ @ @ @ @ @ @ @ @ @ @ @ @ @ @ \n"); addstr(" @ @ @ @ @ @ @ @@@@ @ @ @@@@@ @ @ @ \n"); addstr(" @ @ @ @ @ @@ @ @ @ @ @ @ @ @ @ @ \n"); addstr(" @@@ @@@ @@ @ @ @ @@@@ @@@@ @@@ @@@ @@ @ \n"); addstr(" \n"); addstr(" Congratulations, you have made it to the light of day! \n"); standend(); addstr("\nYou have joined the elite ranks of those who have \n"); addstr("escaped the Dungeons of Doom alive. You journey home \n"); addstr("and sell all your loot at a great profit.\n"); addstr("The White Council approves the recommendation of\n"); if (player.t_ctype == C_FIGHTER) addstr("the fighters guild and appoints you Lord Protector\n"); else if (player.t_ctype == C_ASSASIN) addstr("the assassins guild and appoints you Master Murderer\n"); else if (player.t_ctype == C_NINJA) addstr("the ninja guild and appoints you Master of the Wind\n"); else if (player.t_ctype == C_ILLUSION) addstr("the illusionists guild and appoints you Master Wizard\n"); else if (player.t_ctype == C_MAGICIAN) addstr("the magicians guild and appoints you Master Wizard\n"); else if (player.t_ctype == C_CLERIC) addstr("the temple priests and appoints you Master of the Flowers\n"); else if (player.t_ctype == C_DRUID) addstr("the temple priests and appoints you Master of the Flowers\n"); else if (player.t_ctype == C_RANGER) addstr("the rangers guild and appoints you Master Ranger\n"); else if (player.t_ctype == C_PALADIN) addstr("the paladins guild and appoints you Master Paladin\n"); else if (player.t_ctype == C_THIEF) { addstr("the thieves guild under protest and appoints you\n"); addstr("Master of the Highways\n"); } addstr("of the Land Between the Mountains.\n"); mvaddstr(LINES - 1, 0, spacemsg); refresh(); wait_for(' '); clear(); idenpack(); oldpurse = purse; mvaddstr(0, 0, " Worth Item"); for (c = 'a', item = pack; item != NULL; c++, item = next(item)) { obj = OBJPTR(item); worth = get_worth(obj); purse += worth; if (obj->o_type == ARTIFACT && obj->o_which == TR_PURSE) bag = obj->o_bag; mvprintw(c - 'a' + 1, 0, "%c) %8d %s", c, worth, inv_name(obj, UPPERCASE)); } if (bag != NULL) { mvaddstr(LINES - 1, 0, morestr); refresh(); wait_for(' '); clear(); mvprintw(0, 0, "Contents of the Magic Purse of Yendor:\n"); for (c = 'a', item = bag; item != NULL; c++, item = next(item)) { obj = OBJPTR(item); worth = get_worth(obj); whatis(item); purse += worth; mvprintw(c - 'a' + 1, 0, "%c) %8d %s\n", c, worth, inv_name(obj, UPPERCASE)); } } mvprintw(c - 'a' + 1, 0, " %6d Gold Pieces ", oldpurse); refresh(); if (has_artifact == 255) score(pstats.s_exp, pstats.s_lvl, TOTAL, 0); else score(pstats.s_exp, pstats.s_lvl, WINNER, 0); byebye(); }
void death(int monst) { char **dp = (char **) rip, *killer; struct tm *lt; time_t date; char buf[80]; int c; if (is_wearing(R_RESURRECT) || rnd(wizard ? 3 : 67) == 0) { int die = TRUE; if (resurrect-- == 0) msg("You've run out of lives."); else if (!save_resurrect(ring_value(R_RESURRECT))) msg("Your attempt to return from the grave fails."); else { struct linked_list *item; struct linked_list *next_item; struct object *obj; int rm, flags; coord pos; die = FALSE; msg("You feel a sudden warmth and then nothingness."); teleport(); if (ring_value(R_RESURRECT) > 1 && rnd(10)) { pstats.s_hpt = 2 * pstats.s_const; pstats.s_const = max(pstats.s_const - 1, 3); } else { for (item = pack; item != NULL; item = next_item) { obj = OBJPTR(item); if (obj->o_flags & ISOWNED || obj->o_flags & ISPROT) { next_item = next(item); continue; } flags = obj->o_flags; obj->o_flags &= ~ISCURSED; dropcheck(obj); obj->o_flags = flags; next_item = next(item); rem_pack(obj); if (obj->o_type == ARTIFACT) has_artifact &= ~(1 << obj->o_which); do { rm = rnd_room(); rnd_pos(&rooms[rm], &pos); } while(winat(pos.y, pos.x) != FLOOR); obj->o_pos = pos; add_obj(item, obj->o_pos.y, obj->o_pos.x); } pstats.s_hpt = pstats.s_const; pstats.s_const = max(pstats.s_const - roll(2, 2), 3); } chg_str(roll(1, 4), TRUE, FALSE); pstats.s_lvl = max(pstats.s_lvl, 1); no_command += 2 + rnd(4); if (on(player, ISHUH)) lengthen_fuse(FUSE_UNCONFUSE, rnd(8) + HUHDURATION); else light_fuse(FUSE_UNCONFUSE, 0, rnd(8) + HUHDURATION, AFTER); turn_on(player, ISHUH); light(&hero); } if (die) { wmove(cw, mpos, 0); waddstr(cw, morestr); wrefresh(cw); wait_for(' '); } else return; } time(&date); lt = localtime(&date); clear(); wclear(cw); move(8, 0); while (*dp) printw("%s\n", *dp++); mvaddstr(14, 28 - ((int)(strlen(whoami) + 1) / 2), whoami); sprintf(buf, "%d+%ld Points", pstats.s_lvl, pstats.s_exp); mvaddstr(15, 28 - ((int)(strlen(buf) + 1) / 2), buf); killer = killname(monst,buf); mvaddstr(17, 28 - ((int)(strlen(killer) + 1) / 2), killer); mvaddstr(18, 28, (sprintf(prbuf, "%2d", lt->tm_year), prbuf)); move(LINES - 1, 0); mvaddstr(LINES - 1, 0, retstr); while ((c = readcharw(stdscr)) != '\n' && c != '\r') continue; idenpack(); wrefresh(cw); refresh(); score(pstats.s_exp, pstats.s_lvl, KILLED, monst); byebye(); }
int main(int argc, char *argv[]) { int i; #ifdef COMPILE_WITH_GUI bool gui = false; #endif #ifdef COMPILE_WITH_MULTI_CORE I32 cores = 1; #endif bool verbose = false; bool report_diff = true; bool report_diff_diff = false; bool report_x = true; bool report_y = true; bool report_z = true; bool report_gps = false; bool report_rgb = false; bool output = false; U32 report_lines = 20; U32 array_max = 5000000; bool projection_was_set = false; double start_time = 0; double full_start_time = 0; LASreadOpener lasreadopener; GeoProjectionConverter geoprojectionconverter; LASwriteOpener laswriteopener; if (argc == 1) { #ifdef COMPILE_WITH_GUI return lasprecision_gui(argc, argv, 0); #else fprintf(stderr,"lasprecision.exe is better run in the command line\n"); char file_name[256]; fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.set_file_name(file_name); fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; laswriteopener.set_file_name(file_name); #endif } else { for (i = 1; i < argc; i++) { if (argv[i][0] == '–') argv[i][0] = '-'; if (strcmp(argv[i],"-o") == 0 || strcmp(argv[i],"-olas") == 0 || strcmp(argv[i],"-olaz") == 0 || strcmp(argv[i],"-obin") == 0 || strcmp(argv[i],"-otxt") == 0 || strcmp(argv[i],"-reoffset") == 0 || strcmp(argv[i],"-rescale") == 0) { output = true; break; } } if (!geoprojectionconverter.parse(argc, argv)) byebye(true); if (!lasreadopener.parse(argc, argv)) byebye(true); if (!laswriteopener.parse(argc, argv)) byebye(true); } for (i = 1; i < argc; i++) { if (argv[i][0] == '\0') { continue; } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); usage(); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = true; } else if (strcmp(argv[i],"-version") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); byebye(); } else if (strcmp(argv[i],"-gui") == 0) { #ifdef COMPILE_WITH_GUI gui = true; #else fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n"); #endif } else if (strcmp(argv[i],"-cores") == 0) { #ifdef COMPILE_WITH_MULTI_CORE if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]); usage(true); } argv[i][0] = '\0'; i++; cores = atoi(argv[i]); argv[i][0] = '\0'; #else fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n"); i++; #endif } else if ((strcmp(argv[i],"-diff_diff") == 0) || (strcmp(argv[i],"-diff_diff_only") == 0)) { report_diff_diff = true; report_diff = false; } else if (strcmp(argv[i],"-no_x") == 0) { report_x = false; } else if (strcmp(argv[i],"-no_y") == 0) { report_y = false; } else if (strcmp(argv[i],"-no_z") == 0) { report_z = false; } else if (strcmp(argv[i],"-gps") == 0) { report_gps = true; } else if (strcmp(argv[i],"-rgb") == 0) { report_rgb = true; } else if (strcmp(argv[i],"-number") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: max\n", argv[i]); byebye(true); } i++; array_max = atoi(argv[i]); } else if (strcmp(argv[i],"-lines") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]); byebye(true); } i++; report_lines = atoi(argv[i]); } else if (strcmp(argv[i],"-all") == 0) { array_max = U32_MAX; } else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0)) { lasreadopener.add_file_name(argv[i]); argv[i][0] = '\0'; } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); byebye(true); } } #ifdef COMPILE_WITH_GUI if (gui) { return lasprecision_gui(argc, argv, &lasreadopener); } #endif #ifdef COMPILE_WITH_MULTI_CORE if ((cores > 1) && (lasreadopener.get_file_name_number() > 1) && (!lasreadopener.is_merged())) { return lasprecision_multi_core(argc, argv, &geoprojectionconverter, &lasreadopener, &laswriteopener, cores); } #endif // check input if (!lasreadopener.active()) { fprintf(stderr, "ERROR: no input specified\n"); byebye(true, argc==1); } // make sure we do not corrupt the input file if (lasreadopener.get_file_name() && laswriteopener.get_file_name() && (strcmp(lasreadopener.get_file_name(), laswriteopener.get_file_name()) == 0)) { fprintf(stderr, "ERROR: input and output file name are identical\n"); usage(true); } // check if projection info was set in the command line int number_of_keys; GeoProjectionGeoKeys* geo_keys = 0; int num_geo_double_params; double* geo_double_params = 0; if (geoprojectionconverter.has_projection()) { projection_was_set = geoprojectionconverter.get_geo_keys_from_projection(number_of_keys, &geo_keys, num_geo_double_params, &geo_double_params); } // possibly loop over multiple input files while (lasreadopener.active()) { if (verbose) full_start_time = start_time = taketime(); // open lasreader LASreader* lasreader = lasreadopener.open(); if (lasreader == 0) { fprintf(stderr, "ERROR: could not open lasreader\n"); byebye(true, argc==1); } // run presicion statistics across the first array_max points if (!output) { fprintf(stdout, "original scale factors: %g %g %g\n", lasreader->header.x_scale_factor, lasreader->header.y_scale_factor, lasreader->header.z_scale_factor); // create the arrays int* array_x = 0; int* array_y = 0; int* array_z = 0; if (report_x) { array_x = new int[array_max]; } if (report_y) { array_y = new int[array_max]; } if (report_z) { array_z = new int[array_max]; } double* array_gps = 0; if (report_gps && lasreader->point.have_gps_time) { array_gps = new double[array_max]; } short* array_r = 0; short* array_g = 0; short* array_b = 0; if (report_rgb && lasreader->point.have_rgb) { array_r = new short[array_max]; array_g = new short[array_max]; array_b = new short[array_max]; } // do the first pass fprintf(stderr, "loading first %u of %u points\n", array_max, (U32)lasreader->npoints); // loop over points unsigned int array_count = 0; while ((lasreader->read_point()) && (array_count < array_max)) { if (report_x) { array_x[array_count] = lasreader->point.get_X(); } if (report_y) { array_y[array_count] = lasreader->point.get_Y(); } if (report_z) { array_z[array_count] = lasreader->point.get_Z(); } if (report_gps && lasreader->point.have_gps_time) { array_gps[array_count] = lasreader->point.gps_time; } if (report_rgb && lasreader->point.have_rgb) { array_r[array_count] = lasreader->point.rgb[0]; array_g[array_count] = lasreader->point.rgb[1]; array_b[array_count] = lasreader->point.rgb[2]; } array_count++; } array_max = array_count; // sort values if (report_x) { quicksort_for_ints(array_x, 0, array_max-1); } if (report_y) { quicksort_for_ints(array_y, 0, array_max-1); } if (report_z) { quicksort_for_ints(array_z, 0, array_max-1); } if (report_gps && lasreader->point.have_gps_time) { quicksort_for_doubles(array_gps, 0, array_max-1); } if (report_rgb && lasreader->point.have_rgb) { quicksort_for_shorts(array_r, 0, array_max-1); quicksort_for_shorts(array_g, 0, array_max-1); quicksort_for_shorts(array_b, 0, array_max-1); } // create differences if (report_x) { for (array_count = 1; array_count < array_max; array_count++) { array_x[array_count-1] = array_x[array_count] - array_x[array_count-1]; } } if (report_y) { for (array_count = 1; array_count < array_max; array_count++) { array_y[array_count-1] = array_y[array_count] - array_y[array_count-1]; } } if (report_z) { for (array_count = 1; array_count < array_max; array_count++) { array_z[array_count-1] = array_z[array_count] - array_z[array_count-1]; } } if (report_gps && lasreader->point.have_gps_time) { for (array_count = 1; array_count < array_max; array_count++) { array_gps[array_count-1] = array_gps[array_count] - array_gps[array_count-1]; } } if (report_rgb && lasreader->point.have_rgb) { for (array_count = 1; array_count < array_max; array_count++) { array_r[array_count-1] = array_r[array_count] - array_r[array_count-1]; array_g[array_count-1] = array_g[array_count] - array_g[array_count-1]; array_b[array_count-1] = array_b[array_count] - array_b[array_count-1]; } } // sort differences if (report_x) { quicksort_for_ints(array_x, 0, array_max-2); } if (report_y) { quicksort_for_ints(array_y, 0, array_max-2); } if (report_z) { quicksort_for_ints(array_z, 0, array_max-2); } if (report_gps && lasreader->point.have_gps_time) { quicksort_for_doubles(array_gps, 0, array_max-2); } if (report_rgb && lasreader->point.have_rgb) { quicksort_for_shorts(array_r, 0, array_max-2); quicksort_for_shorts(array_g, 0, array_max-2); quicksort_for_shorts(array_b, 0, array_max-2); } // compute difference of differences, sort them, output histogram // first for X & Y & Z unsigned int count_lines, array_last, array_first; if (report_x) { if (report_diff) fprintf(stdout, "X differences \n"); for (count_lines = 0, array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++) { if (array_x[array_last] != array_x[array_count]) { if (report_diff && (count_lines < report_lines)) { count_lines++; fprintf(stdout, " %10d : %10d %g\n", array_x[array_last], array_count - array_last, lasreader->header.x_scale_factor*array_x[array_last]); } array_x[array_first] = array_x[array_count] - array_x[array_last]; array_last = array_count; array_first++; } } if (report_diff_diff) { fprintf(stdout, "X differences of differences\n"); quicksort_for_ints(array_x, 0, array_first-1); for (array_last = 0, array_count = 1; array_count < array_first; array_count++) { if (array_x[array_last] != array_x[array_count]) { fprintf(stdout, " %10d : %10d\n", array_x[array_last], array_count - array_last); array_last = array_count; } } } } if (report_y) { if (report_diff) fprintf(stdout, "Y differences \n"); for (count_lines = 0, array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++) { if (array_y[array_last] != array_y[array_count]) { if (report_diff && (count_lines < report_lines)) { count_lines++; fprintf(stdout, " %10d : %10d %g\n", array_y[array_last], array_count - array_last, lasreader->header.y_scale_factor*array_y[array_last]); } array_y[array_first] = array_y[array_count] - array_y[array_last]; array_last = array_count; array_first++; } } if (report_diff_diff) { fprintf(stdout, "Y differences of differences\n"); quicksort_for_ints(array_y, 0, array_first-1); for (array_last = 0, array_count = 1; array_count < array_first; array_count++) { if (array_y[array_last] != array_y[array_count]) { fprintf(stdout, " %10d : %10d\n", array_y[array_last], array_count - array_last); array_last = array_count; } } } } if (report_z) { if (report_diff) fprintf(stdout, "Z differences \n"); for (count_lines = 0, array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++) { if (array_z[array_last] != array_z[array_count]) { if (report_diff && (count_lines < report_lines)) { count_lines++; fprintf(stdout, " %10d : %10d %g\n", array_z[array_last], array_count - array_last, lasreader->header.z_scale_factor*array_z[array_last]); } array_z[array_first] = array_z[array_count] - array_z[array_last]; array_last = array_count; array_first++; } } if (report_diff_diff) { fprintf(stdout, "Z differences of differences\n"); quicksort_for_ints(array_z, 0, array_first-1); for (array_last = 0, array_count = 1; array_count < array_first; array_count++) { if (array_z[array_last] != array_z[array_count]) { fprintf(stdout, " %10d : %10d\n", array_z[array_last], array_count - array_last); array_last = array_count; } } } } // then for GPS if (report_gps && lasreader->point.have_gps_time) { if (report_diff) fprintf(stdout, "GPS time differences \n"); for (array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++) { if (array_gps[array_last] != array_gps[array_count]) { if (report_diff) fprintf(stdout, " %.10g : %10d\n", array_gps[array_last], array_count - array_last); array_gps[array_first] = array_gps[array_count] - array_gps[array_last]; array_last = array_count; array_first++; } } if (report_diff_diff) { fprintf(stdout, "GPS time differences of differences\n"); quicksort_for_doubles(array_gps, 0, array_first-1); for (array_last = 0, array_count = 1; array_count < array_first; array_count++) { if (array_gps[array_last] != array_gps[array_count]) { fprintf(stdout, " %.10g : %10d\n", array_gps[array_last], array_count - array_last); array_last = array_count; } } } } // then for R & G & B if (report_rgb && lasreader->point.have_rgb) { if (report_diff) fprintf(stdout, "R differences \n"); for (array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++) { if (array_r[array_last] != array_r[array_count]) { if (report_diff) fprintf(stdout, " %10d : %10d\n", array_r[array_last], array_count - array_last); array_r[array_first] = array_r[array_count] - array_r[array_last]; array_last = array_count; array_first++; } } if (report_diff_diff) { fprintf(stdout, "R differences of differences\n"); quicksort_for_shorts(array_r, 0, array_first-1); for (array_last = 0, array_count = 1; array_count < array_first; array_count++) { if (array_r[array_last] != array_r[array_count]) { fprintf(stdout, " %10d : %10d\n", array_r[array_last], array_count - array_last); array_last = array_count; } } } if (report_diff) fprintf(stdout, "G differences \n"); for (array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++) { if (array_g[array_last] != array_g[array_count]) { if (report_diff) fprintf(stdout, " %10d : %10d\n", array_g[array_last], array_count - array_last); array_g[array_first] = array_g[array_count] - array_g[array_last]; array_last = array_count; array_first++; } } if (report_diff_diff) { fprintf(stdout, "G differences of differences\n"); quicksort_for_shorts(array_g, 0, array_first-1); for (array_last = 0, array_count = 1; array_count < array_first; array_count++) { if (array_g[array_last] != array_g[array_count]) { fprintf(stdout, " %10d : %10d\n", array_g[array_last], array_count - array_last); array_last = array_count; } } } if (report_diff) fprintf(stdout, "B differences \n"); for (array_first = 0, array_last = 0, array_count = 1; array_count < array_max; array_count++) { if (array_b[array_last] != array_b[array_count]) { if (report_diff) fprintf(stdout, " %10d : %10d\n", array_b[array_last], array_count - array_last); array_b[array_first] = array_b[array_count] - array_b[array_last]; array_last = array_count; array_first++; } } if (report_diff_diff) { fprintf(stdout, "B differences of differences\n"); quicksort_for_shorts(array_b, 0, array_first-1); for (array_last = 0, array_count = 1; array_count < array_first; array_count++) { if (array_b[array_last] != array_b[array_count]) { fprintf(stdout, " %10d : %10d\n", array_b[array_last], array_count - array_last); array_last = array_count; } } } } if (array_x) delete [] array_x; if (array_y) delete [] array_y; if (array_z) delete [] array_z; if (array_gps) delete [] array_gps; if (array_r) delete [] array_r; if (array_g) delete [] array_g; if (array_b) delete [] array_b; } else { // check output fprintf(stdout, "new scale factors: %g %g %g\n", lasreader->header.x_scale_factor, lasreader->header.y_scale_factor, lasreader->header.z_scale_factor); // check output if (!laswriteopener.active()) { // create name from input name laswriteopener.make_file_name(lasreadopener.get_file_name()); } // prepare the header for the surviving points strncpy(lasreader->header.system_identifier, "LAStools (c) by rapidlasso GmbH", 32); lasreader->header.system_identifier[31] = '\0'; char temp[64]; sprintf(temp, "lasprecision (%d)", LAS_TOOLS_VERSION); strncpy(lasreader->header.generating_software, temp, 32); lasreader->header.generating_software[31] = '\0'; if (projection_was_set) { lasreader->header.set_geo_keys(number_of_keys, (LASvlr_key_entry*)geo_keys); if (geo_double_params) { lasreader->header.set_geo_double_params(num_geo_double_params, geo_double_params); } else { lasreader->header.del_geo_double_params(); } lasreader->header.del_geo_ascii_params(); } // open laswriter LASwriter* laswriter = laswriteopener.open(&lasreader->header); if (laswriter == 0) { fprintf(stderr, "ERROR: could not open laswriter\n"); usage(argc==1); } // loop over points while (lasreader->read_point()) { laswriter->write_point(&lasreader->point); laswriter->update_inventory(&lasreader->point); } laswriter->update_header(&lasreader->header, TRUE); laswriter->close(); delete laswriter; laswriteopener.set_file_name(0); } lasreader->close(); delete lasreader; } if (projection_was_set) { free(geo_keys); if (geo_double_params) { free(geo_double_params); } } byebye(false, argc==1); return 0; }
int main(int argc, char** argv) { /* working variables */ int i,j; char *fname_in=NULL, *fname_out=NULL; char *cbuf,*fext; FILE *fp; double **mat; int n,m; printf("# %s",rcsid); /* args */ for(i=j=1;i<argc;i++) { if(argv[i][0] != '-') { switch(j) { case 1: fname_in=argv[i]; break; case 2: fname_out=argv[i]; break; default: byebye(); } j++; } else if(streq(argv[i],"--molphy")) { seqmode=SEQ_MOLPHY; } else if(streq(argv[i],"--paml")) { seqmode=SEQ_PAML; } else if(streq(argv[i],"--paup")) { seqmode=SEQ_PAUP; } else if(streq(argv[i],"--puzzle")) { seqmode=SEQ_PUZZLE; } else if(streq(argv[i],"--phyml")) { seqmode=SEQ_PHYML; } else if(streq(argv[i],"-d")) { if(i+1>=argc || sscanf(argv[i+1],"%d",&debugmode) != 1) byebye(); i+=1; } else byebye(); } /* open file */ switch(seqmode) { case SEQ_MOLPHY: fext=fext_molphy; break; case SEQ_PAML: fext=fext_paml; break; case SEQ_PAUP: fext=fext_paup; break; case SEQ_PUZZLE: fext=fext_puzzle; break; case SEQ_PHYML: fext=fext_phyml; break; case SEQ_MT: default: fext=fext_mt; break; } if(fname_in) { fp=openfp(fname_in,fext,"r",&cbuf); printf("\n# reading %s",cbuf); } else { fp=STDIN; printf("\n# reading from stdin"); } /* read file */ n=m=0; switch(seqmode) { case SEQ_MOLPHY: mat = fread_mat_lls(fp, &m, &n); break; case SEQ_PAML: mat = fread_mat_lfh(fp, &m, &n); break; case SEQ_PAUP: mat = fread_mat_paup(fp, &m, &n); break; case SEQ_PUZZLE: mat = fread_mat_puzzle(fp, &m, &n); break; case SEQ_PHYML: mat = fread_mat_phyml(fp, &m, &n); break; case SEQ_MT: default: mat = fread_mat(fp, &m, &n); break; } if(fname_in) {fclose(fp); FREE(cbuf);} printf("\n# M:%d N:%d",m,n); /* write file */ if(fname_in && !fname_out) fname_out=rmvaxt(fname_in); if(fname_out) { fp=openfp(fname_out,fext_mt,"w",&cbuf); printf("\n# writing %s",cbuf); } else { fp=STDOUT; printf("\n# writing to stdout\n"); } fwrite_mat(fp, mat, m, n); if(fname_out) {fclose(fp); FREE(cbuf);} putchar('\n'); exit(0); }
int main(int argc, char *argv[]) { MPI_Init(&argc, &argv); int i; #ifdef COMPILE_WITH_GUI bool gui = false; #endif bool verbose = false; bool keep_lastiling = false; U32 chopchop = 0; bool projection_was_set = false; double start_time = 0; LASreadOpener lasreadopener; GeoProjectionConverter geoprojectionconverter; LASwriteOpener laswriteopener; if (argc == 1) { #ifdef COMPILE_WITH_GUI return lasmerge_gui(argc, argv, 0); #else fprintf(stderr,"%s is better run in the command line\n", argv[0]); char file_name[256]; fprintf(stderr,"enter input file 1: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.add_file_name(file_name); fprintf(stderr,"enter input file 2: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.add_file_name(file_name); fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; laswriteopener.set_file_name(file_name); #endif } else { for (i = 1; i < argc; i++) { if (argv[i][0] == '�') argv[i][0] = '-'; } if (!geoprojectionconverter.parse(argc, argv)) byebye(true); if (!lasreadopener.parse(argc, argv)) byebye(true); if (lasreadopener.get_file_name_number()<2) { fprintf(stderr,"Must specify more than one input file.\n"); byebye(true); // only support merging more than one file } if (!laswriteopener.parse(argc, argv)) byebye(true); } for (i = 1; i < argc; i++) { if (argv[i][0] == '\0') { continue; } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); usage(); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = true; } else if (strcmp(argv[i],"-version") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); byebye(); } else if (strcmp(argv[i],"-gui") == 0) { #ifdef COMPILE_WITH_GUI gui = true; #else fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n"); #endif } else if (strcmp(argv[i],"-split") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: size\n", argv[i]); byebye(true); } i++; chopchop = atoi(argv[i]); } else if (strcmp(argv[i],"-keep_lastiling") == 0) { keep_lastiling = true; } else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0)) { lasreadopener.add_file_name(argv[i]); argv[i][0] = '\0'; } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); byebye(true); } } #ifdef COMPILE_WITH_GUI if (gui) { return lasmerge_gui(argc, argv, &lasreadopener); } #endif // read all the input files merged lasreadopener.set_merged(TRUE); // maybe we want to keep the lastiling if (keep_lastiling) { lasreadopener.set_keep_lastiling(TRUE); } // we need to precompute the bounding box lasreadopener.set_populate_header(TRUE); // check input and output if (!lasreadopener.active()) { fprintf(stderr, "ERROR: no input specified\n"); byebye(true, argc==1); } if (!laswriteopener.active()) { fprintf(stderr, "ERROR: no output specified\n"); byebye(true, argc==1); } // make sure we do not corrupt the input file if (lasreadopener.get_file_name() && laswriteopener.get_file_name() && (strcmp(lasreadopener.get_file_name(), laswriteopener.get_file_name()) == 0)) { fprintf(stderr, "ERROR: input and output file name are identical\n"); usage(true); } // check if projection info was set in the command line int number_of_keys; GeoProjectionGeoKeys* geo_keys = 0; int num_geo_double_params; double* geo_double_params = 0; if (geoprojectionconverter.has_projection()) { projection_was_set = geoprojectionconverter.get_geo_keys_from_projection(number_of_keys, &geo_keys, num_geo_double_params, &geo_double_params); } if (verbose) start_time = taketime(); LASreader* lasreader = lasreadopener.open(); lasreader->populate_rank_points(); LASreaderMerged *lasreadermerged = (LASreaderMerged *)lasreader; I32 process_count = lasreadermerged->get_process_count(); dbg(3, "rank %i, lasreadermerged->npoints %lli", lasreadermerged->get_rank(), lasreadermerged->npoints); for (i=0; i<process_count; i++) { dbg(3, "rank %i, rank_begin_point %lli", lasreadermerged->get_rank(), lasreadermerged->get_rank_begin_index()[i]); for(int j=lasreadermerged->get_file_name_start(); j< lasreadermerged->get_file_name_number(); j++) { dbg(3, "rank %i, number %i name %s count %lli, begin", lasreadermerged->get_rank(), j, lasreadermerged->get_file_names()[j], lasreadermerged->get_file_point_counts()[j]); } } dbg(3,"type of reader returned: class %s and declared name %s", typeid(*lasreader).name(), quote(*lasreader)); if (lasreader == 0) { fprintf(stderr, "ERROR: could not open lasreader\n"); byebye(true, argc==1); } #ifdef _WIN32 if (verbose) { fprintf(stderr,"merging headers took %g sec. there are %I64d points in total.\n", taketime()-start_time, lasreader->npoints); start_time = taketime(); } #else if (verbose) { fprintf(stderr,"merging headers took %g sec. there are %lld points in total.\n", taketime()-start_time, lasreader->npoints); start_time = taketime(); } #endif // prepare the header for the surviving points strncpy(lasreader->header.system_identifier, "LAStools (c) by rapidlasso GmbH", 32); lasreader->header.system_identifier[31] = '\0'; char temp[64]; sprintf(temp, "lasmerge (version %d)", LAS_TOOLS_VERSION); strncpy(lasreader->header.generating_software, temp, 32); lasreader->header.generating_software[31] = '\0'; if (projection_was_set) { lasreader->header.set_geo_keys(number_of_keys, (LASvlr_key_entry*)geo_keys); free(geo_keys); if (geo_double_params) { lasreader->header.set_geo_double_params(num_geo_double_params, geo_double_params); free(geo_double_params); } else { lasreader->header.del_geo_double_params(); } lasreader->header.del_geo_ascii_params(); } if (chopchop) { I32 file_number = 0; LASwriter* laswriter = 0; // loop over the points while (lasreader->read_point()) { if (laswriter == 0) { // open the next writer laswriteopener.make_file_name(0, file_number); file_number++; laswriter = laswriteopener.open(&lasreader->header); } laswriter->write_point(&lasreader->point); laswriter->update_inventory(&lasreader->point); if (laswriter->p_count == chopchop) { // close the current writer laswriter->update_header(&lasreader->header, TRUE); laswriter->close(); if (verbose) { fprintf(stderr,"splitting file '%s' took %g sec.\n", laswriteopener.get_file_name(), taketime()-start_time); start_time = taketime(); } delete laswriter; laswriter = 0; } } if (laswriter && laswriter->p_count) { // close the current writer laswriter->update_header(&lasreader->header, TRUE); laswriter->close(); if (verbose) { fprintf(stderr,"splitting file '%s' took %g sec.\n", laswriteopener.get_file_name(), taketime()-start_time); start_time = taketime(); } delete laswriter; laswriter = 0; } } else { // wait for all processes to open their input files MPI_Barrier(MPI_COMM_WORLD); // all processes open a writer LASwriter* laswriter = laswriteopener.open (&lasreader->header); // set the write file pointer... no filter support, assumes all input file's points are written to output file //ByteStreamOutFileLE *bs = (ByteStreamOutFileLE*) laswriter->get_stream (); <-- this is the ByteStreamOut type for las files ByteStreamOut *bs = laswriter->get_stream (); I64 begin_index = (lasreadermerged->get_rank_begin_index())[lasreadermerged->get_rank ()]; bs->seek (lasreader->header.point_data_record_length * begin_index + lasreader->header.offset_to_point_data); if (laswriter == 0) { fprintf (stderr, "ERROR: could not open laswriter\n"); byebye (true, argc == 1); } // wait for all processes to open the output file and set their write file pointers. MPI_Barrier(MPI_COMM_WORLD); // loop over the points while (lasreader->read_point()) { laswriter->write_point(&lasreader->point); laswriter->update_inventory(&lasreader->point); } int rank = lasreadermerged->get_rank(); if(rank!=0) { laswriter->close(FALSE); } MPI_Barrier(MPI_COMM_WORLD); // not needed since reduce causes barrier, used for testing // this whole MPI_Reduce section is not technically needed since we don't yet support point filtering, // It was implemented now to ensure that it will work when point filtering of input files is supported MPI_Reduce(&(laswriter->inventory.extended_number_of_point_records), &extended_number_of_point_records, 1, MPI_LONG_LONG_INT, MPI_SUM, 0, MPI_COMM_WORLD); int i; for(i=0; i<16; i++) { MPI_Reduce(&(laswriter->inventory.extended_number_of_points_by_return[i]), &extended_number_of_points_by_return[i], 1, MPI_LONG_LONG_INT, MPI_SUM, 0, MPI_COMM_WORLD); } MPI_Reduce(&(laswriter->inventory.max_X), &max_X, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD); MPI_Reduce(&(laswriter->inventory.min_X), &min_X, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD); MPI_Reduce(&(laswriter->inventory.max_Y), &max_Y, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD); MPI_Reduce(&(laswriter->inventory.min_Y), &min_Y, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD); MPI_Reduce(&(laswriter->inventory.max_Z), &max_Z, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD); MPI_Reduce(&(laswriter->inventory.min_Z), &min_Z, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD); if(rank==0) { dbg(3, "extended_number_of_point_records %lli", extended_number_of_point_records); laswriter->inventory.extended_number_of_point_records = extended_number_of_point_records; for(i=0; i<16; i++) { laswriter->inventory.extended_number_of_points_by_return[i] = extended_number_of_points_by_return[i]; } laswriter->inventory.max_X = max_X; laswriter->inventory.min_X = min_X; laswriter->inventory.max_Y = max_Y; laswriter->inventory.min_Y = min_Y; laswriter->inventory.max_Z = max_Z; laswriter->inventory.min_Z = min_Z; } dbg(3, "rank %i, point data record length %i", lasreadermerged->get_rank(), lasreader->header.point_data_record_length); // close the writer if(rank==0) { // update header should only be called with TRUE when using the MPI_Reduce calls above, // lasreadopener.open(), called above, generates a correct header for the output file, provided no points are filtered during the read laswriter->update_header(&lasreader->header, TRUE); laswriter->close(FALSE); } if (verbose) fprintf(stderr,"merging files took %g sec.\n", taketime()-start_time); delete laswriter; } MPI_Finalize(); lasreader->close(); delete lasreader; byebye(false, argc==1); return 0; }
int main(int argc, char *argv[]) { int i; int is_mpi = 1; int debug = 0; bool verbose = false; bool force = false; // fixed header changes int set_version_major = -1; int set_version_minor = -1; int set_point_data_format = -1; int set_point_data_record_length = -1; int set_gps_time_endcoding = -1; // variable header changes bool remove_extra_header = false; bool remove_all_variable_length_records = false; int remove_variable_length_record = -1; int remove_variable_length_record_from = -1; int remove_variable_length_record_to = -1; bool remove_tiling_vlr = false; bool remove_original_vlr = false; // extract a subsequence //unsigned int subsequence_start = 0; //unsigned int subsequence_stop = U32_MAX; I64 subsequence_start = 0; I64 subsequence_stop = I64_MAX; // fix files with corrupt points bool clip_to_bounding_box = false; double start_time = 0; time_t wall_start_time; time_t wall_end_time; LASreadOpener lasreadopener; //if(is_mpi)lasreadopener.setIsMpi(TRUE); GeoProjectionConverter geoprojectionconverter; LASwriteOpener laswriteopener; if(is_mpi)laswriteopener.setIsMpi(TRUE); int process_count = 1; int rank = 0; start_time = taketime(); time(&wall_start_time); if (is_mpi){ MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD,&process_count); MPI_Comm_rank(MPI_COMM_WORLD,&rank); if(debug) printf ("MPI task %d has started...\n", rank); } if (argc == 1) { fprintf(stderr,"las2las.exe is better run in the command line or via the lastool.exe GUI\n"); char file_name[256]; fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.set_file_name(file_name); fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; laswriteopener.set_file_name(file_name); } else { for (i = 1; i < argc; i++) { //if (argv[i][0] == '�') argv[i][0] = '-'; if (strcmp(argv[i],"-week_to_adjusted") == 0) { set_gps_time_endcoding = 1; } else if (strcmp(argv[i],"-adjusted_to_week") == 0) { set_gps_time_endcoding = 0; } } if (!geoprojectionconverter.parse(argc, argv)) byebye(true); if (!lasreadopener.parse(argc, argv)) byebye(true); if (!laswriteopener.parse(argc, argv)) byebye(true); } for (i = 1; i < argc; i++) { if (argv[i][0] == '\0') { continue; } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); usage(); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = true; } else if (strcmp(argv[i],"-version") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); byebye(); } else if (strcmp(argv[i],"-gui") == 0) { fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n"); } else if (strcmp(argv[i],"-cores") == 0) { fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n"); i++; } else if (strcmp(argv[i],"-force") == 0) { force = true; } else if (strcmp(argv[i],"-subseq") == 0) { if ((i+2) >= argc) { fprintf(stderr,"ERROR: '%s' needs 2 arguments: start stop\n", argv[i]); byebye(true); } subsequence_start = (unsigned int)atoi(argv[i+1]); subsequence_stop = (unsigned int)atoi(argv[i+2]); i+=2; } else if (strcmp(argv[i],"-start_at_point") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: start\n", argv[i]); byebye(true); } subsequence_start = (unsigned int)atoi(argv[i+1]); i+=1; } else if (strcmp(argv[i],"-stop_at_point") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: stop\n", argv[i]); byebye(true); } subsequence_stop = (unsigned int)atoi(argv[i+1]); i+=1; } else if (strcmp(argv[i],"-set_version") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: major.minor\n", argv[i]); byebye(true); } if (sscanf(argv[i+1],"%d.%d",&set_version_major,&set_version_minor) != 2) { fprintf(stderr, "ERROR: cannot understand argument '%s' for '%s'\n", argv[i+1], argv[i]); usage(true); } i+=1; } else if (strcmp(argv[i],"-set_version_major") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: major\n", argv[i]); byebye(true); } set_version_major = atoi(argv[i+1]); i+=1; } else if (strcmp(argv[i],"-set_version_minor") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: minor\n", argv[i]); byebye(true); } set_version_minor = atoi(argv[i+1]); i+=1; } else if (strcmp(argv[i],"-remove_extra") == 0) { remove_extra_header = true; } else if (strcmp(argv[i],"-remove_all_vlrs") == 0) { remove_all_variable_length_records = true; } else if (strcmp(argv[i],"-remove_vlr") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]); byebye(true); } remove_variable_length_record = atoi(argv[i+1]); remove_variable_length_record_from = -1; remove_variable_length_record_to = -1; i++; } else if (strcmp(argv[i],"-remove_vlrs_from_to") == 0) { if ((i+2) >= argc) { fprintf(stderr,"ERROR: '%s' needs 2 arguments: start end\n", argv[i]); byebye(true); } remove_variable_length_record = -1; remove_variable_length_record_from = atoi(argv[i+1]); remove_variable_length_record_to = atoi(argv[i+2]); i+=2; } else if (strcmp(argv[i],"-remove_tiling_vlr") == 0) { remove_tiling_vlr = true; i++; } else if (strcmp(argv[i],"-remove_original_vlr") == 0) { remove_original_vlr = true; i++; } else if (strcmp(argv[i],"-set_point_type") == 0 || strcmp(argv[i],"-set_point_data_format") == 0 || strcmp(argv[i],"-point_type") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: type\n", argv[i]); byebye(true); } set_point_data_format = atoi(argv[i+1]); i++; } else if (strcmp(argv[i],"-set_point_data_record_length") == 0 || strcmp(argv[i],"-set_point_size") == 0 || strcmp(argv[i],"-point_size") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: size\n", argv[i]); byebye(true); } set_point_data_record_length = atoi(argv[i+1]); i++; } else if (strcmp(argv[i],"-clip_to_bounding_box") == 0 || strcmp(argv[i],"-clip_to_bb") == 0) { clip_to_bounding_box = true; } else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0)) { lasreadopener.add_file_name(argv[i]); argv[i][0] = '\0'; } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); usage(true); } } // check input if (!lasreadopener.active()) { fprintf(stderr,"ERROR: no input specified\n"); usage(true, argc==1); } BOOL extra_pass = laswriteopener.is_piped(); // for piped output we need an extra pass if (extra_pass) { if (lasreadopener.is_piped()) { fprintf(stderr, "ERROR: input and output cannot both be piped\n"); usage(true); } } // make sure we do not corrupt the input file if (lasreadopener.get_file_name() && laswriteopener.get_file_name() && (strcmp(lasreadopener.get_file_name(), laswriteopener.get_file_name()) == 0)) { fprintf(stderr, "ERROR: input and output file name are identical\n"); usage(true); } // possibly loop over multiple input files while (lasreadopener.active()) { // if (verbose) start_time = taketime(); // open lasreader LASreader* lasreader = lasreadopener.open(); if (lasreader == 0) { fprintf(stderr, "ERROR: could not open lasreader\n"); usage(true, argc==1); } // store the inventory for the header LASinventory lasinventory; // the point we write sometimes needs to be copied LASpoint* point = 0; // prepare the header for output if (set_gps_time_endcoding != -1) { if (set_gps_time_endcoding == 0) { if ((lasreader->header.global_encoding & 1) == 0) { fprintf(stderr, "WARNING: global encoding indicates file already in GPS week time\n"); if (force) { fprintf(stderr, " forced conversion.\n"); } else { fprintf(stderr, " use '-force' to force conversion.\n"); byebye(true); } } else { lasreader->header.global_encoding &= ~1; } } else if (set_gps_time_endcoding == 1) { if ((lasreader->header.global_encoding & 1) == 1) { fprintf(stderr, "WARNING: global encoding indicates file already in Adjusted Standard GPS time\n"); if (force) { fprintf(stderr, " forced conversion.\n"); } else { fprintf(stderr, " use '-force' to force conversion.\n"); byebye(true); } } else { lasreader->header.global_encoding |= 1; } } } if (set_version_major != -1) { if (set_version_major != 1) { fprintf(stderr, "ERROR: unknown version_major %d\n", set_version_major); byebye(true); } lasreader->header.version_major = (U8)set_version_major; } if (set_version_minor >= 0) { if (set_version_minor > 4) { fprintf(stderr, "ERROR: unknown version_minor %d\n", set_version_minor); byebye(true); } if (set_version_minor < 3) { if (lasreader->header.version_minor == 3) { lasreader->header.header_size -= 8; lasreader->header.offset_to_point_data -= 8; } else if (lasreader->header.version_minor >= 4) { lasreader->header.header_size -= (8 + 140); lasreader->header.offset_to_point_data -= (8 + 140); } } else if (set_version_minor == 3) { if (lasreader->header.version_minor < 3) { lasreader->header.header_size += 8; lasreader->header.offset_to_point_data += 8; lasreader->header.start_of_waveform_data_packet_record = 0; } else if (lasreader->header.version_minor >= 4) { lasreader->header.header_size -= 140; lasreader->header.offset_to_point_data -= 140; } } else if (set_version_minor == 4) { if (lasreader->header.version_minor < 3) { lasreader->header.header_size += (8 + 140); lasreader->header.offset_to_point_data += (8 + 140); lasreader->header.start_of_waveform_data_packet_record = 0; } else if (lasreader->header.version_minor == 3) { lasreader->header.header_size += 140; lasreader->header.offset_to_point_data += 140; } } if ((set_version_minor <= 3) && (lasreader->header.version_minor >= 4)) { if (lasreader->header.point_data_format > 5) { switch (lasreader->header.point_data_format) { case 6: fprintf(stderr, "WARNING: downgrading point_data_format from %d to 1\n", lasreader->header.point_data_format); lasreader->header.point_data_format = 1; fprintf(stderr, " and point_data_record_length from %d to %d\n", lasreader->header.point_data_record_length, lasreader->header.point_data_record_length - 2); lasreader->header.point_data_record_length -= 2; break; case 7: fprintf(stderr, "WARNING: downgrading point_data_format from %d to 3\n", lasreader->header.point_data_format); lasreader->header.point_data_format = 3; fprintf(stderr, " and point_data_record_length from %d to %d\n", lasreader->header.point_data_record_length, lasreader->header.point_data_record_length - 2); lasreader->header.point_data_record_length -= 2; break; case 8: fprintf(stderr, "WARNING: downgrading point_data_format from %d to 3\n", lasreader->header.point_data_format); lasreader->header.point_data_format = 3; fprintf(stderr, " and point_data_record_length from %d to %d\n", lasreader->header.point_data_record_length, lasreader->header.point_data_record_length - 4); lasreader->header.point_data_record_length -= 4; break; case 9: fprintf(stderr, "WARNING: downgrading point_data_format from %d to 4\n", lasreader->header.point_data_format); lasreader->header.point_data_format = 4; fprintf(stderr, " and point_data_record_length from %d to %d\n", lasreader->header.point_data_record_length, lasreader->header.point_data_record_length - 2); lasreader->header.point_data_record_length -= 2; break; case 10: fprintf(stderr, "WARNING: downgrading point_data_format from %d to 5\n", lasreader->header.point_data_format); lasreader->header.point_data_format = 5; fprintf(stderr, " and point_data_record_length from %d to %d\n", lasreader->header.point_data_record_length, lasreader->header.point_data_record_length - 4); lasreader->header.point_data_record_length -= 4; break; default: fprintf(stderr, "ERROR: unknown point_data_format %d\n", lasreader->header.point_data_format); byebye(true); } } point = new LASpoint; point->init(&lasreader->header, lasreader->header.point_data_format, lasreader->header.point_data_record_length); } lasreader->header.version_minor = (U8)set_version_minor; } // are we supposed to change the point data format if (set_point_data_format != -1) { if (set_point_data_format < 0 || set_point_data_format > 10) { fprintf(stderr, "ERROR: unknown point_data_format %d\n", set_point_data_format); byebye(true); } // depending on the conversion we may need to copy the point if (convert_point_type_from_to[lasreader->header.point_data_format][set_point_data_format]) { if (point == 0) point = new LASpoint; } lasreader->header.point_data_format = (U8)set_point_data_format; lasreader->header.clean_laszip(); switch (lasreader->header.point_data_format) { case 0: lasreader->header.point_data_record_length = 20; break; case 1: lasreader->header.point_data_record_length = 28; break; case 2: lasreader->header.point_data_record_length = 26; break; case 3: lasreader->header.point_data_record_length = 34; break; case 4: lasreader->header.point_data_record_length = 57; break; case 5: lasreader->header.point_data_record_length = 63; break; case 6: lasreader->header.point_data_record_length = 30; break; case 7: lasreader->header.point_data_record_length = 36; break; case 8: lasreader->header.point_data_record_length = 38; break; case 9: lasreader->header.point_data_record_length = 59; break; case 10: lasreader->header.point_data_record_length = 67; break; } } // are we supposed to change the point data record length if (set_point_data_record_length != -1) { I32 num_extra_bytes = 0; switch (lasreader->header.point_data_format) { case 0: num_extra_bytes = set_point_data_record_length - 20; break; case 1: num_extra_bytes = set_point_data_record_length - 28; break; case 2: num_extra_bytes = set_point_data_record_length - 26; break; case 3: num_extra_bytes = set_point_data_record_length - 34; break; case 4: num_extra_bytes = set_point_data_record_length - 57; break; case 5: num_extra_bytes = set_point_data_record_length - 63; break; case 6: num_extra_bytes = set_point_data_record_length - 30; break; case 7: num_extra_bytes = set_point_data_record_length - 36; break; case 8: num_extra_bytes = set_point_data_record_length - 38; break; case 9: num_extra_bytes = set_point_data_record_length - 59; break; case 10: num_extra_bytes = set_point_data_record_length - 67; break; } if (num_extra_bytes < 0) { fprintf(stderr, "ERROR: point_data_format %d needs record length of at least %d\n", lasreader->header.point_data_format, set_point_data_record_length - num_extra_bytes); byebye(true); } if (lasreader->header.point_data_record_length < set_point_data_record_length) { if (!point) point = new LASpoint; } lasreader->header.point_data_record_length = (U16)set_point_data_record_length; lasreader->header.clean_laszip(); } // if the point needs to be copied set up the data fields if (point) { point->init(&lasreader->header, lasreader->header.point_data_format, lasreader->header.point_data_record_length); } // maybe we should remove some stuff if (remove_extra_header) { lasreader->header.clean_user_data_in_header(); lasreader->header.clean_user_data_after_header(); } if (remove_all_variable_length_records) { lasreader->header.clean_vlrs(); } else { if (remove_variable_length_record != -1) { lasreader->header.remove_vlr(remove_variable_length_record); } if (remove_variable_length_record_from != -1) { for (i = remove_variable_length_record_to; i >= remove_variable_length_record_from; i--) { lasreader->header.remove_vlr(i); } } } if (remove_tiling_vlr) { lasreader->header.clean_lastiling(); } if (remove_original_vlr) { lasreader->header.clean_lasoriginal(); } // maybe we should add / change the projection information LASquantizer* reproject_quantizer = 0; LASquantizer* saved_quantizer = 0; if (geoprojectionconverter.has_projection(true) || geoprojectionconverter.has_projection(false)) { if (!geoprojectionconverter.has_projection(true) && lasreader->header.vlr_geo_keys) { geoprojectionconverter.set_projection_from_geo_keys(lasreader->header.vlr_geo_keys[0].number_of_keys, (GeoProjectionGeoKeys*)lasreader->header.vlr_geo_key_entries, lasreader->header.vlr_geo_ascii_params, lasreader->header.vlr_geo_double_params); } if (geoprojectionconverter.has_projection(true) && geoprojectionconverter.has_projection(false)) { reproject_quantizer = new LASquantizer(); double point[3]; point[0] = (lasreader->header.min_x+lasreader->header.max_x)/2; point[1] = (lasreader->header.min_y+lasreader->header.max_y)/2; point[2] = (lasreader->header.min_z+lasreader->header.max_z)/2; geoprojectionconverter.to_target(point); reproject_quantizer->x_scale_factor = geoprojectionconverter.get_target_precision(); reproject_quantizer->y_scale_factor = geoprojectionconverter.get_target_precision(); reproject_quantizer->z_scale_factor = lasreader->header.z_scale_factor; reproject_quantizer->x_offset = ((I64)((point[0]/reproject_quantizer->x_scale_factor)/10000000))*10000000*reproject_quantizer->x_scale_factor; reproject_quantizer->y_offset = ((I64)((point[1]/reproject_quantizer->y_scale_factor)/10000000))*10000000*reproject_quantizer->y_scale_factor; reproject_quantizer->z_offset = ((I64)((point[2]/reproject_quantizer->z_scale_factor)/10000000))*10000000*reproject_quantizer->z_scale_factor; } int number_of_keys; GeoProjectionGeoKeys* geo_keys = 0; int num_geo_double_params; double* geo_double_params = 0; if (geoprojectionconverter.get_geo_keys_from_projection(number_of_keys, &geo_keys, num_geo_double_params, &geo_double_params, !geoprojectionconverter.has_projection(false))) { lasreader->header.set_geo_keys(number_of_keys, (LASvlr_key_entry*)geo_keys); free(geo_keys); if (geo_double_params) { lasreader->header.set_geo_double_params(num_geo_double_params, geo_double_params); free(geo_double_params); } else { lasreader->header.del_geo_double_params(); } lasreader->header.del_geo_ascii_params(); } } // do we need an extra pass BOOL extra_pass = laswriteopener.is_piped(); // for piped output we need an extra pass if (extra_pass) { if (lasreadopener.is_piped()) { fprintf(stderr, "ERROR: input and output cannot both be piped\n"); usage(true); } if (verbose) fprintf(stderr, "extra pass for piped output: reading %lld points ...\n", lasreader->npoints); // maybe seek to start position if (subsequence_start) lasreader->seek(subsequence_start); while (lasreader->read_point()) { if (lasreader->p_count > subsequence_stop) break; if (clip_to_bounding_box) { if (!lasreader->point.inside_box(lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z)) { continue; } } if (reproject_quantizer) { lasreader->point.compute_coordinates(); geoprojectionconverter.to_target(lasreader->point.coordinates); lasreader->point.compute_XYZ(reproject_quantizer); } lasinventory.add(&lasreader->point); } lasreader->close(); lasreader->header.number_of_point_records = lasinventory.number_of_point_records; for (i = 0; i < 5; i++) lasreader->header.number_of_points_by_return[i] = lasinventory.number_of_points_by_return[i+1]; if (reproject_quantizer) lasreader->header = *reproject_quantizer; lasreader->header.max_x = lasreader->header.get_x(lasinventory.max_X); lasreader->header.min_x = lasreader->header.get_x(lasinventory.min_X); lasreader->header.max_y = lasreader->header.get_y(lasinventory.max_Y); lasreader->header.min_y = lasreader->header.get_y(lasinventory.min_Y); lasreader->header.max_z = lasreader->header.get_z(lasinventory.max_Z); lasreader->header.min_z = lasreader->header.get_z(lasinventory.min_Z); // if (verbose) { fprintf(stderr,"extra pass took %g sec.\n", taketime()-start_time); start_time = taketime(); } if (verbose) fprintf(stderr, "piped output: reading %lld and writing %d points ...\n", lasreader->npoints, lasinventory.number_of_point_records); } else { if (reproject_quantizer) { saved_quantizer = new LASquantizer(); *saved_quantizer = lasreader->header; lasreader->header = *reproject_quantizer; } //if (verbose) fprintf(stderr, "reading %lld and writing all surviving points ...\n", lasreader->npoints); } // check output if (!laswriteopener.active()) { // create name from input name laswriteopener.make_file_name(lasreadopener.get_file_name()); } // prepare the header for the surviving points strncpy(lasreader->header.system_identifier, "LAStools (c) by rapidlasso GmbH", 32); lasreader->header.system_identifier[31] = '\0'; char temp[64]; sprintf(temp, "las2las (version %d)", LAS_TOOLS_VERSION); strncpy(lasreader->header.generating_software, temp, 32); lasreader->header.generating_software[31] = '\0'; LASwriter* laswriter = 0; // open laswriter if(is_mpi){ // remove any existing out file, before opening with MPI_File_open if(rank==0){ remove(laswriteopener.get_file_name()); } MPI_Barrier(MPI_COMM_WORLD); } laswriter = laswriteopener.open(&lasreader->header); if (laswriter == 0) { fprintf(stderr, "ERROR: could not open laswriter\n"); byebye(true, argc==1); } // ************************************************************************************************** if(is_mpi == 1){ // jdw, we do this because only rank 0 now writes the header in laswriter_las.cpp MPI_File fh = laswriter->get_MPI_File(); MPI_Offset offset; //MPI_File_get_position(fh, &offset); //printf ("offset %lld, rank %i fh %lld\n", offset, rank, fh); if(rank==0){ MPI_File_get_position(fh, &offset); } MPI_Bcast(&offset, 1, MPI_OFFSET, 0, MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); MPI_File_seek(fh, offset, MPI_SEEK_SET); } // **************************************************************************************************** // for piped output we need to re-open the input file if (extra_pass) { if (!lasreadopener.reopen(lasreader)) { fprintf(stderr, "ERROR: could not re-open lasreader\n"); byebye(true); } } else { if (reproject_quantizer) { lasreader->header = *saved_quantizer; delete saved_quantizer; } } // maybe seek to start position if (subsequence_start) lasreader->seek(subsequence_start); // loop over points if (point) { while (lasreader->read_point()) { if (lasreader->p_count > subsequence_stop) break; if (clip_to_bounding_box) { if (!lasreader->point.inside_box(lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z)) { continue; } } if (reproject_quantizer) { lasreader->point.compute_coordinates(); geoprojectionconverter.to_target(lasreader->point.coordinates); lasreader->point.compute_XYZ(reproject_quantizer); } *point = lasreader->point; laswriter->write_point(point); // without extra pass we need inventory of surviving points if (!extra_pass) laswriter->update_inventory(point); } delete point; point = 0; } else // ***************************** MPI ******************************************************** { // ***** Determine the start and stop points for this process ***** I64 left_over_count = lasreader->npoints % process_count; I64 process_points = lasreader->npoints / process_count; subsequence_start = rank*process_points; subsequence_stop = subsequence_start + process_points; if(rank == process_count-1) subsequence_stop += left_over_count; // ***** Set the input stream file offset for this process ***** // subsequence_start parameter gets cast to U32 in the implementation of seek and overflows for large files // manually set the file offset instead for now //((LASreaderLAS*)lasreader)->stream->seek(subsequence_start); I64 header_end_read_position = lasreader->get_Stream()->tell(); //printf("header end %lld subseqence_start * 28 %lld rank %i\n", header_end_read_position, subsequence_start*28, rank); lasreader->p_count = subsequence_start; lasreader->get_Stream()->seek(header_end_read_position + subsequence_start*28); //printf("seek pos first loop %lld rank %i\n", lasreader->get_Stream()->tell(), rank); if (verbose) fprintf(stderr, "reading %lli points, rank %i\n", subsequence_stop - subsequence_start, rank); // *****Read the file for the first time ***** // this first read and filter of the file is to gather a count of points that pass the filter so that // write offsets can be set. I64 filtered_count = 0; //while (lasreader->read_point()){ lasreader->MPI_END_POINT = subsequence_stop; while (lasreader->read_point()) { filtered_count++; } // ***** Gather and set the write offset for this process ***** I64* filtered_counts = (I64*)malloc(process_count * sizeof(I64)); if(is_mpi)MPI_Barrier(MPI_COMM_WORLD); filtered_counts[rank] = filtered_count; if(is_mpi)MPI_Allgather(&filtered_count, 1, MPI_LONG_LONG, filtered_counts, 1, MPI_LONG_LONG, MPI_COMM_WORLD); if(is_mpi)MPI_Barrier(MPI_COMM_WORLD); if(debug) printf("filtered count %lli rank %i\n", filtered_counts[rank], rank); if(is_mpi)MPI_Barrier(MPI_COMM_WORLD); I64 write_point_offset = 0; for (int k=0; k < rank; k++){ write_point_offset += filtered_counts[k]; } if(is_mpi){ MPI_File fh = laswriter->get_MPI_File(); MPI_Offset cur = 0; // jdw, todo, remove the hardcoding by adding methods to read point size from reader MPI_File_seek(fh, write_point_offset*28, MPI_SEEK_CUR); if(debug){ MPI_File_get_position(fh, &cur); printf ("rank %i, write offset %lld\n", rank, write_point_offset*28); } } if(is_mpi)MPI_Barrier(MPI_COMM_WORLD); // ***** Read and filter the input file again, this time write the filtered point since output file offset in now known amd set ***** //lasreader->seek(subsequence_start); // subsequence_start parameter gets cast to U32 in the implementation and overflows for large files // manually set the file offset instead for now //printf("header end %lld subseqence_start * 28 %lld rank %i\n", header_end_read_position, subsequence_start*28, rank); lasreader->p_count = subsequence_start; lasreader->get_Stream()->seek(header_end_read_position + subsequence_start*28); //printf("seek pos second loop %lld rank %i\n", lasreader->get_Stream()->tell(), rank); lasreader->MPI_END_POINT = subsequence_stop; while (lasreader->read_point()) { //if (lasreader->p_count > subsequence_stop) break; //if (clip_to_bounding_box) //{ // if (!lasreader->point.inside_box(lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z)) // { // continue; // } // } if (reproject_quantizer) { lasreader->point.compute_coordinates(); geoprojectionconverter.to_target(lasreader->point.coordinates); lasreader->point.compute_XYZ(reproject_quantizer); } laswriter->write_point(&lasreader->point); // without extra pass we need inventory of surviving points if (!extra_pass){ laswriter->update_inventory(&lasreader->point); } } //***** this is part of an mpi write optimization ***** laswriter->get_Stream()->flushBytes(); } // without the extra pass we need to fix the header now // ***** do the inventory reconciliation ***** // ***** Reduce inventory information in rank 0 ***** if (is_mpi){ U32 number_of_point_records = 0; U32 number_of_points_by_return[8]; for(int i = 0; i<8; i++)number_of_points_by_return[i] = 0; I32 max_X = 0; I32 min_X = 0; I32 max_Y = 0; I32 min_Y = 0; I32 max_Z = 0; I32 min_Z = 0; MPI_Reduce(&laswriter->inventory.number_of_point_records, &number_of_point_records, 1, MPI_UNSIGNED, MPI_SUM, 0, MPI_COMM_WORLD); MPI_Reduce(laswriter->inventory.number_of_points_by_return, number_of_points_by_return, 8, MPI_UNSIGNED, MPI_SUM, 0, MPI_COMM_WORLD); MPI_Reduce(&laswriter->inventory.max_X, &max_X, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD); MPI_Reduce(&laswriter->inventory.min_X, &min_X, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD); MPI_Reduce(&laswriter->inventory.max_Y, &max_Y, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD); MPI_Reduce(&laswriter->inventory.min_Y, &min_Y, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD); MPI_Reduce(&laswriter->inventory.max_Z, &max_Z, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD); MPI_Reduce(&laswriter->inventory.min_Z, &min_Z, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD); if (rank ==0){ laswriter->inventory.number_of_point_records = number_of_point_records; for(int i=0; i<8; i++)laswriter->inventory.number_of_points_by_return[i] = number_of_points_by_return[i]; laswriter->inventory.max_X = max_X; laswriter->inventory.min_X = min_X; laswriter->inventory.max_Y = max_Y; laswriter->inventory.min_Y = min_Y; laswriter->inventory.max_Z = max_Z; laswriter->inventory.min_Z = min_Z; } } if(rank == 0){ if (!extra_pass) { if (reproject_quantizer) lasreader->header = *reproject_quantizer; laswriter->update_header(&lasreader->header, TRUE); } } if(is_mpi)MPI_Barrier(MPI_COMM_WORLD); if (verbose) { fprintf(stderr,"%lli surviving points written by rank: %i\n", laswriter->p_count, rank); } laswriter->close(FALSE); if(is_mpi)MPI_Barrier(MPI_COMM_WORLD); delete laswriter; lasreader->close(); delete lasreader; if (reproject_quantizer) delete reproject_quantizer; } if(is_mpi)MPI_Finalize(); time(&wall_end_time); if (verbose) { fprintf(stderr,"total time %.f sec, cpu time: %g sec. rank: %i\n", difftime(wall_end_time, wall_start_time), taketime()-start_time, rank); } return 0; }
int main(int argc, char *argv[]) { int i; #ifdef COMPILE_WITH_GUI bool gui = false; #endif #ifdef COMPILE_WITH_MULTI_CORE I32 cores = 1; #endif bool verbose = false; bool force = false; // fixed header changes int set_version_major = -1; int set_version_minor = -1; int set_point_data_format = -1; int set_point_data_record_length = -1; int set_gps_time_endcoding = -1; // variable header changes bool remove_extra_header = false; bool remove_all_variable_length_records = false; int remove_variable_length_record = -1; bool remove_tiling_vlr = false; bool remove_original_vlr = false; // extract a subsequence unsigned int subsequence_start = 0; unsigned int subsequence_stop = U32_MAX; // fix files with corrupt points bool clip_to_bounding_box = false; double start_time = 0; LASreadOpener lasreadopener; GeoProjectionConverter geoprojectionconverter; LASwriteOpener laswriteopener; if (argc == 1) { #ifdef COMPILE_WITH_GUI return las2las_gui(argc, argv, 0); #else fprintf(stderr,"las2las.exe is better run in the command line or via the lastool.exe GUI\n"); char file_name[256]; fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.set_file_name(file_name); fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; laswriteopener.set_file_name(file_name); #endif } else { for (i = 1; i < argc; i++) { if (argv[i][0] == '–') argv[i][0] = '-'; if (strcmp(argv[i],"-week_to_adjusted") == 0) { set_gps_time_endcoding = 1; } else if (strcmp(argv[i],"-adjusted_to_week") == 0) { set_gps_time_endcoding = 0; } } if (!geoprojectionconverter.parse(argc, argv)) byebye(true); if (!lasreadopener.parse(argc, argv)) byebye(true); if (!laswriteopener.parse(argc, argv)) byebye(true); } for (i = 1; i < argc; i++) { if (argv[i][0] == '\0') { continue; } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); usage(); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = true; } else if (strcmp(argv[i],"-version") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); byebye(); } else if (strcmp(argv[i],"-gui") == 0) { #ifdef COMPILE_WITH_GUI gui = true; #else fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n"); #endif } else if (strcmp(argv[i],"-cores") == 0) { #ifdef COMPILE_WITH_MULTI_CORE if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]); usage(true); } argv[i][0] = '\0'; i++; cores = atoi(argv[i]); argv[i][0] = '\0'; #else fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n"); #endif } else if (strcmp(argv[i],"-force") == 0) { force = true; } else if (strcmp(argv[i],"-subseq") == 0) { if ((i+2) >= argc) { fprintf(stderr,"ERROR: '%s' needs 2 arguments: start stop\n", argv[i]); byebye(true); } subsequence_start = (unsigned int)atoi(argv[i+1]); subsequence_stop = (unsigned int)atoi(argv[i+2]); i+=2; } else if (strcmp(argv[i],"-start_at_point") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: start\n", argv[i]); byebye(true); } subsequence_start = (unsigned int)atoi(argv[i+1]); i+=1; } else if (strcmp(argv[i],"-stop_at_point") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: stop\n", argv[i]); byebye(true); } subsequence_stop = (unsigned int)atoi(argv[i+1]); i+=1; } else if (strcmp(argv[i],"-set_version") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: major.minor\n", argv[i]); byebye(true); } if (sscanf(argv[i+1],"%d.%d",&set_version_major,&set_version_minor) != 2) { fprintf(stderr, "ERROR: cannot understand argument '%s' for '%s'\n", argv[i+1], argv[i]); usage(true); } i+=1; } else if (strcmp(argv[i],"-set_version_major") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: major\n", argv[i]); byebye(true); } set_version_major = atoi(argv[i+1]); i+=1; } else if (strcmp(argv[i],"-set_version_minor") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: minor\n", argv[i]); byebye(true); } set_version_minor = atoi(argv[i+1]); i+=1; } else if (strcmp(argv[i],"-remove_extra") == 0) { remove_extra_header = true; } else if (strcmp(argv[i],"-remove_all_vlrs") == 0 || strcmp(argv[i],"-remove_all_vlr") == 0) { remove_all_variable_length_records = true; } else if (strcmp(argv[i],"-remove_vlr") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]); byebye(true); } remove_variable_length_record = atoi(argv[i+1]); i++; } else if (strcmp(argv[i],"-remove_tiling_vlr") == 0) { remove_tiling_vlr = true; i++; } else if (strcmp(argv[i],"-remove_original_vlr") == 0) { remove_original_vlr = true; i++; } else if (strcmp(argv[i],"-point_type") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: type\n", argv[i]); byebye(true); } set_point_data_format = atoi(argv[i+1]); i++; } else if (strcmp(argv[i],"-point_size") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: size\n", argv[i]); byebye(true); } set_point_data_record_length = atoi(argv[i+1]); i++; } else if (strcmp(argv[i],"-clip_to_bounding_box") == 0 || strcmp(argv[i],"-clip_to_bbox") == 0) { clip_to_bounding_box = true; } else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0)) { lasreadopener.add_file_name(argv[i]); argv[i][0] = '\0'; } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); usage(true); } } #ifdef COMPILE_WITH_GUI if (gui) { return las2las_gui(argc, argv, &lasreadopener); } #endif #ifdef COMPILE_WITH_MULTI_CORE if ((cores > 1) && (lasreadopener.get_file_name_number() > 1) && (!lasreadopener.get_merged())) { return las2las_multi_core(argc, argv, &geoprojectionconverter, &lasreadopener, &laswriteopener, cores); } #endif // check input if (!lasreadopener.active()) { fprintf(stderr,"ERROR: no input specified\n"); usage(true, argc==1); } BOOL extra_pass = laswriteopener.is_piped(); // for piped output we need an extra pass if (extra_pass) { if (lasreadopener.is_piped()) { fprintf(stderr, "ERROR: input and output cannot both be piped\n"); usage(true); } } // make sure we do not corrupt the input file if (lasreadopener.get_file_name() && laswriteopener.get_file_name() && (strcmp(lasreadopener.get_file_name(), laswriteopener.get_file_name()) == 0)) { fprintf(stderr, "ERROR: input and output file name are identical\n"); usage(true); } // possibly loop over multiple input files while (lasreadopener.active()) { if (verbose) start_time = taketime(); // open lasreader LASreader* lasreader = lasreadopener.open(); if (lasreader == 0) { fprintf(stderr, "ERROR: could not open lasreader\n"); usage(true, argc==1); } // store the inventory for the header LASinventory lasinventory; // the point we write sometimes needs to be copied LASpoint* point = 0; // prepare the header for output if (set_gps_time_endcoding != -1) { if (set_gps_time_endcoding == 0) { if ((lasreader->header.global_encoding & 1) == 0) { fprintf(stderr, "WARNING: global encoding indicates file already in GPS week time\n"); if (force) { fprintf(stderr, " forced conversion.\n"); } else { fprintf(stderr, " use '-force' to force conversion.\n"); byebye(true); } } else { lasreader->header.global_encoding &= ~1; } } else if (set_gps_time_endcoding == 1) { if ((lasreader->header.global_encoding & 1) == 1) { fprintf(stderr, "WARNING: global encoding indicates file already in Adjusted Standard GPS time\n"); if (force) { fprintf(stderr, " forced conversion.\n"); } else { fprintf(stderr, " use '-force' to force conversion.\n"); byebye(true); } } else { lasreader->header.global_encoding |= 1; } } } if (set_version_major != -1) { if (set_version_major != 1) { fprintf(stderr, "ERROR: unknown version_major %d\n", set_version_major); byebye(true); } lasreader->header.version_major = (U8)set_version_major; } if (set_version_minor >= 0) { if (set_version_minor > 4) { fprintf(stderr, "ERROR: unknown version_minor %d\n", set_version_minor); byebye(true); } if (set_version_minor < 3) { if (lasreader->header.version_minor == 3) { lasreader->header.header_size -= 8; lasreader->header.offset_to_point_data -= 8; } else if (lasreader->header.version_minor >= 4) { lasreader->header.header_size -= (8 + 140); lasreader->header.offset_to_point_data -= (8 + 140); } } else if (set_version_minor == 3) { if (lasreader->header.version_minor < 3) { lasreader->header.header_size += 8; lasreader->header.offset_to_point_data += 8; lasreader->header.start_of_waveform_data_packet_record = 0; } else if (lasreader->header.version_minor >= 4) { lasreader->header.header_size -= 140; lasreader->header.offset_to_point_data -= 140; } } else if (set_version_minor == 4) { if (lasreader->header.version_minor < 3) { lasreader->header.header_size += (8 + 140); lasreader->header.offset_to_point_data += (8 + 140); lasreader->header.start_of_waveform_data_packet_record = 0; } else if (lasreader->header.version_minor == 3) { lasreader->header.header_size += 140; lasreader->header.offset_to_point_data += 140; } } lasreader->header.version_minor = (U8)set_version_minor; } // are we supposed to change the point data format if (set_point_data_format != -1) { if (set_point_data_format < 0 || set_point_data_format >= 6) { fprintf(stderr, "ERROR: unknown point_data_format %d\n", set_point_data_format); byebye(true); } // depending on the conversion we may need to copy the point if (convert_point_type_from_to[lasreader->header.point_data_format][set_point_data_format]) { point = new LASpoint; } lasreader->header.point_data_format = (U8)set_point_data_format; lasreader->header.clean_laszip(); switch (lasreader->header.point_data_format) { case 0: lasreader->header.point_data_record_length = 20; break; case 1: lasreader->header.point_data_record_length = 28; break; case 2: lasreader->header.point_data_record_length = 26; break; case 3: lasreader->header.point_data_record_length = 34; break; case 4: lasreader->header.point_data_record_length = 57; break; case 5: lasreader->header.point_data_record_length = 63; break; } } // are we supposed to change the point data record length if (set_point_data_record_length != -1) { I32 num_extra_bytes = 0; switch (lasreader->header.point_data_format) { case 0: num_extra_bytes = set_point_data_record_length - 20; break; case 1: num_extra_bytes = set_point_data_record_length - 28; break; case 2: num_extra_bytes = set_point_data_record_length - 26; break; case 3: num_extra_bytes = set_point_data_record_length - 34; break; case 4: num_extra_bytes = set_point_data_record_length - 57; break; case 5: num_extra_bytes = set_point_data_record_length - 63; break; } if (num_extra_bytes < 0) { fprintf(stderr, "ERROR: point_data_format %d needs record length of at least %d\n", lasreader->header.point_data_format, set_point_data_record_length - num_extra_bytes); byebye(true); } if (lasreader->header.point_data_record_length < set_point_data_record_length) { if (!point) point = new LASpoint; } lasreader->header.point_data_record_length = (U16)set_point_data_record_length; lasreader->header.clean_laszip(); } // if the point needs to be copied set up the data fields if (point) { point->init(&lasreader->header, lasreader->header.point_data_format, lasreader->header.point_data_record_length); } // maybe we should remove some stuff if (remove_extra_header) { lasreader->header.clean_user_data_in_header(); lasreader->header.clean_user_data_after_header(); } if (remove_all_variable_length_records) { lasreader->header.clean_vlrs(); } if (remove_variable_length_record != -1) { lasreader->header.remove_vlr(remove_variable_length_record); } if (remove_tiling_vlr) { lasreader->header.clean_lastiling(); } if (remove_original_vlr) { lasreader->header.clean_lasoriginal(); } // maybe we should add / change the projection information LASquantizer* reproject_quantizer = 0; LASquantizer* saved_quantizer = 0; if (geoprojectionconverter.has_projection(true) || geoprojectionconverter.has_projection(false)) { if (!geoprojectionconverter.has_projection(true) && lasreader->header.vlr_geo_keys) { geoprojectionconverter.set_projection_from_geo_keys(lasreader->header.vlr_geo_keys[0].number_of_keys, (GeoProjectionGeoKeys*)lasreader->header.vlr_geo_key_entries, lasreader->header.vlr_geo_ascii_params, lasreader->header.vlr_geo_double_params); } if (geoprojectionconverter.has_projection(true) && geoprojectionconverter.has_projection(false)) { reproject_quantizer = new LASquantizer(); double point[3]; point[0] = (lasreader->header.min_x+lasreader->header.max_x)/2; point[1] = (lasreader->header.min_y+lasreader->header.max_y)/2; point[2] = (lasreader->header.min_z+lasreader->header.max_z)/2; geoprojectionconverter.to_target(point); reproject_quantizer->x_scale_factor = geoprojectionconverter.get_target_precision(); reproject_quantizer->y_scale_factor = geoprojectionconverter.get_target_precision(); reproject_quantizer->z_scale_factor = lasreader->header.z_scale_factor; reproject_quantizer->x_offset = ((I64)((point[0]/reproject_quantizer->x_scale_factor)/10000000))*10000000*reproject_quantizer->x_scale_factor; reproject_quantizer->y_offset = ((I64)((point[1]/reproject_quantizer->y_scale_factor)/10000000))*10000000*reproject_quantizer->y_scale_factor; reproject_quantizer->z_offset = ((I64)((point[2]/reproject_quantizer->z_scale_factor)/10000000))*10000000*reproject_quantizer->z_scale_factor; } int number_of_keys; GeoProjectionGeoKeys* geo_keys = 0; int num_geo_double_params; double* geo_double_params = 0; if (geoprojectionconverter.get_geo_keys_from_projection(number_of_keys, &geo_keys, num_geo_double_params, &geo_double_params, !geoprojectionconverter.has_projection(false))) { lasreader->header.set_geo_keys(number_of_keys, (LASvlr_key_entry*)geo_keys); free(geo_keys); if (geo_double_params) { lasreader->header.set_geo_double_params(num_geo_double_params, geo_double_params); free(geo_double_params); } else { lasreader->header.del_geo_double_params(); } lasreader->header.del_geo_ascii_params(); } } // do we need an extra pass BOOL extra_pass = laswriteopener.is_piped(); // for piped output we need an extra pass if (extra_pass) { if (lasreadopener.is_piped()) { fprintf(stderr, "ERROR: input and output cannot both be piped\n"); usage(true); } #ifdef _WIN32 if (verbose) fprintf(stderr, "extra pass for piped output: reading %I64d points ...\n", lasreader->npoints); #else if (verbose) fprintf(stderr, "extra pass for piped output: reading %lld points ...\n", lasreader->npoints); #endif // maybe seek to start position if (subsequence_start) lasreader->seek(subsequence_start); while (lasreader->read_point()) { if (lasreader->p_count > subsequence_stop) break; if (clip_to_bounding_box) { if (!lasreader->point.inside_box(lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z)) { continue; } } if (reproject_quantizer) { lasreader->point.compute_coordinates(); geoprojectionconverter.to_target(lasreader->point.coordinates); lasreader->point.compute_xyz(reproject_quantizer); } lasinventory.add(&lasreader->point); } lasreader->close(); lasreader->header.number_of_point_records = lasinventory.number_of_point_records; for (i = 0; i < 5; i++) lasreader->header.number_of_points_by_return[i] = lasinventory.number_of_points_by_return[i+1]; if (reproject_quantizer) lasreader->header = *reproject_quantizer; lasreader->header.max_x = lasreader->header.get_x(lasinventory.raw_max_x); lasreader->header.min_x = lasreader->header.get_x(lasinventory.raw_min_x); lasreader->header.max_y = lasreader->header.get_y(lasinventory.raw_max_y); lasreader->header.min_y = lasreader->header.get_y(lasinventory.raw_min_y); lasreader->header.max_z = lasreader->header.get_z(lasinventory.raw_max_z); lasreader->header.min_z = lasreader->header.get_z(lasinventory.raw_min_z); if (verbose) { fprintf(stderr,"extra pass took %g sec.\n", taketime()-start_time); start_time = taketime(); } #ifdef _WIN32 if (verbose) fprintf(stderr, "piped output: reading %I64d and writing %u points ...\n", lasreader->npoints, lasinventory.number_of_point_records); #else if (verbose) fprintf(stderr, "piped output: reading %lld and writing %u points ...\n", lasreader->npoints, lasinventory.number_of_point_records); #endif } else { if (reproject_quantizer) { saved_quantizer = new LASquantizer(); *saved_quantizer = lasreader->header; lasreader->header = *reproject_quantizer; } #ifdef _WIN32 if (verbose) fprintf(stderr, "reading %I64d and writing all surviving points ...\n", lasreader->npoints); #else if (verbose) fprintf(stderr, "reading %lld and writing all surviving points ...\n", lasreader->npoints); #endif } // check output if (!laswriteopener.active()) { // create name from input name laswriteopener.make_file_name(lasreadopener.get_file_name()); } // prepare the header for the surviving points strncpy(lasreader->header.system_identifier, "LAStools (c) by Martin Isenburg", 32); lasreader->header.system_identifier[31] = '\0'; char temp[64]; sprintf(temp, "las2las (version %d)", LAS_TOOLS_VERSION); strncpy(lasreader->header.generating_software, temp, 32); lasreader->header.generating_software[31] = '\0'; // open laswriter LASwriter* laswriter = laswriteopener.open(&lasreader->header); if (laswriter == 0) { fprintf(stderr, "ERROR: could not open laswriter\n"); byebye(true, argc==1); } // for piped output we need to re-open the input file if (extra_pass) { if (!lasreadopener.reopen(lasreader)) { fprintf(stderr, "ERROR: could not re-open lasreader\n"); byebye(true); } } else { if (reproject_quantizer) { lasreader->header = *saved_quantizer; delete saved_quantizer; } } // maybe seek to start position if (subsequence_start) lasreader->seek(subsequence_start); // loop over points if (point) { while (lasreader->read_point()) { if (lasreader->p_count > subsequence_stop) break; if (clip_to_bounding_box) { if (!lasreader->point.inside_box(lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z)) { continue; } } if (reproject_quantizer) { lasreader->point.compute_coordinates(); geoprojectionconverter.to_target(lasreader->point.coordinates); lasreader->point.compute_xyz(reproject_quantizer); } *point = lasreader->point; laswriter->write_point(point); // without extra pass we need inventory of surviving points if (!extra_pass) laswriter->update_inventory(point); } delete point; point = 0; } else { while (lasreader->read_point()) { if (lasreader->p_count > subsequence_stop) break; if (clip_to_bounding_box) { if (!lasreader->point.inside_box(lasreader->header.min_x, lasreader->header.min_y, lasreader->header.min_z, lasreader->header.max_x, lasreader->header.max_y, lasreader->header.max_z)) { continue; } } if (reproject_quantizer) { lasreader->point.compute_coordinates(); geoprojectionconverter.to_target(lasreader->point.coordinates); lasreader->point.compute_xyz(reproject_quantizer); } laswriter->write_point(&lasreader->point); // without extra pass we need inventory of surviving points if (!extra_pass) laswriter->update_inventory(&lasreader->point); } } // without the extra pass we need to fix the header now if (!extra_pass) { if (reproject_quantizer) lasreader->header = *reproject_quantizer; laswriter->update_header(&lasreader->header, TRUE); if (verbose) { fprintf(stderr,"total time: %g sec. written %u surviving points.\n", taketime()-start_time, (U32)laswriter->p_count); } } else { if (verbose) { fprintf(stderr,"main pass took %g sec.\n", taketime()-start_time); } } laswriter->close(); delete laswriter; lasreader->close(); delete lasreader; if (reproject_quantizer) delete reproject_quantizer; laswriteopener.set_file_name(0); } byebye(false, argc==1); return 0; }
int main(int argc, char *argv[]) { double start_time = 0.0; char* file_name_in = 0; char* file_name_out = 0; // load LASzip DLL if (laszip_load_dll()) { fprintf(stderr,"DLL ERROR: loading LASzip DLL\n"); byebye(true, argc==1); } // get version of LASzip DLL laszip_U8 version_major; laszip_U8 version_minor; laszip_U16 version_revision; laszip_U32 version_build; if (laszip_get_version(&version_major, &version_minor, &version_revision, &version_build)) { fprintf(stderr,"DLL ERROR: getting LASzip DLL version number\n"); byebye(true, argc==1); } fprintf(stderr,"LASzip DLL v%d.%d r%d (build %d)\n", (int)version_major, (int)version_minor, (int)version_revision, (int)version_build); if (argc == 1) { char file_name[256]; fprintf(stderr,"%s is better run in the command line\n", argv[0]); fprintf(stderr,"enter input file%s: ", ((EXAMPLE == EXAMPLE_THREE) ? " (not used)" : "")); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; file_name_in = strdup(file_name); fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; file_name_out = strdup(file_name); } else if (argc == 3) { file_name_in = strdup(argv[1]); file_name_out = strdup(argv[2]); } else { if ((argc != 2) || (strcmp(argv[1], "-h") != 0)) { fprintf(stderr, "ERROR: cannot understand arguments\n"); } usage(); } start_time = taketime(); if (EXAMPLE == EXAMPLE_ONE) { fprintf(stderr,"running EXAMPLE_ONE\n"); // create the reader laszip_POINTER laszip_reader; if (laszip_create(&laszip_reader)) { fprintf(stderr,"DLL ERROR: creating laszip reader\n"); byebye(true, argc==1); } // open the reader laszip_BOOL is_compressed = 0; if (laszip_open_reader(laszip_reader, file_name_in, &is_compressed)) { fprintf(stderr,"DLL ERROR: opening laszip reader for '%s'\n", file_name_in); byebye(true, argc==1, laszip_reader); } fprintf(stderr,"file '%s' is %scompressed\n", file_name_in, (is_compressed ? "" : "un")); // get a pointer to the header of the reader that was just populated laszip_header* header; if (laszip_get_header_pointer(laszip_reader, &header)) { fprintf(stderr,"DLL ERROR: getting header pointer from laszip reader\n"); byebye(true, argc==1, laszip_reader); } // report how many points the file has fprintf(stderr,"file '%s' contains %u points\n", file_name_in, header->number_of_point_records); // get a pointer to the points that will be read laszip_point* point; if (laszip_get_point_pointer(laszip_reader, &point)) { fprintf(stderr,"DLL ERROR: getting point pointer from laszip reader\n"); byebye(true, argc==1, laszip_reader); } // create the writer laszip_POINTER laszip_writer; if (laszip_create(&laszip_writer)) { fprintf(stderr,"DLL ERROR: creating laszip writer\n"); byebye(true, argc==1); } // initialize the header for the writer using the header of the reader if (laszip_set_header(laszip_writer, header)) { fprintf(stderr,"DLL ERROR: setting header for laszip writer\n"); byebye(true, argc==1, laszip_writer); } // open the writer laszip_BOOL compress = (strstr(file_name_out, ".laz") != 0); if (laszip_open_writer(laszip_writer, file_name_out, compress)) { fprintf(stderr,"DLL ERROR: opening laszip writer for '%d'\n", file_name_out); byebye(true, argc==1, laszip_writer); } fprintf(stderr,"writing file '%s' %scompressed\n", file_name_out, (compress ? "" : "un")); // read the points laszip_U32 count = 0; while (count < header->number_of_point_records) { // read a point if (laszip_read_point(laszip_reader)) { fprintf(stderr,"DLL ERROR: reading point %u\n", count); byebye(true, argc==1, laszip_reader); } // copy the point if (laszip_set_point(laszip_writer, point)) { fprintf(stderr,"DLL ERROR: setting point %u\n", count); byebye(true, argc==1, laszip_writer); } // write the point if (laszip_write_point(laszip_writer)) { fprintf(stderr,"DLL ERROR: writing point %u\n", count); byebye(true, argc==1, laszip_writer); } count++; } fprintf(stderr,"successfully read and written %u points\n", count); // close the writer if (laszip_close_writer(laszip_writer)) { fprintf(stderr,"DLL ERROR: closing laszip writer\n"); byebye(true, argc==1, laszip_writer); } // destroy the writer if (laszip_destroy(laszip_writer)) { fprintf(stderr,"DLL ERROR: destroying laszip writer\n"); byebye(true, argc==1); } // close the reader if (laszip_close_reader(laszip_reader)) { fprintf(stderr,"DLL ERROR: closing laszip reader\n"); byebye(true, argc==1, laszip_reader); } // destroy the reader if (laszip_destroy(laszip_reader)) { fprintf(stderr,"DLL ERROR: destroying laszip reader\n"); byebye(true, argc==1); } fprintf(stderr,"total time: %g sec for reading %scompressed and writing %scompressed\n", taketime()-start_time, (is_compressed ? "" : "un"), (compress ? "" : "un")); } // EXAMPLE_ONE if (EXAMPLE == EXAMPLE_TWO) { fprintf(stderr,"running EXAMPLE_TWO\n"); // create the reader laszip_POINTER laszip_reader; if (laszip_create(&laszip_reader)) { fprintf(stderr,"DLL ERROR: creating laszip reader\n"); byebye(true, argc==1); } // open the reader laszip_BOOL is_compressed = 0; if (laszip_open_reader(laszip_reader, file_name_in, &is_compressed)) { fprintf(stderr,"DLL ERROR: opening laszip reader for '%s'\n", file_name_in); byebye(true, argc==1, laszip_reader); } fprintf(stderr,"file '%s' is %scompressed\n", file_name_in, (is_compressed ? "" : "un")); // get a pointer to the header of the reader that was just populated laszip_header* header_read; if (laszip_get_header_pointer(laszip_reader, &header_read)) { fprintf(stderr,"DLL ERROR: getting header pointer from laszip reader\n"); byebye(true, argc==1, laszip_reader); } // report how many points the file has fprintf(stderr,"file '%s' contains %u points\n", file_name_in, header_read->number_of_point_records); // create the writer laszip_POINTER laszip_writer; if (laszip_create(&laszip_writer)) { fprintf(stderr,"DLL ERROR: creating laszip writer\n"); byebye(true, argc==1); } // get a pointer to the header of the writer so we can populate it laszip_header* header_write; if (laszip_get_header_pointer(laszip_writer, &header_write)) { fprintf(stderr,"DLL ERROR: getting header pointer from laszip writer\n"); byebye(true, argc==1, laszip_writer); } // copy entries from the reader header to the writer header laszip_U32 i; header_write->file_source_ID = header_read->file_source_ID; header_write->global_encoding = header_read->global_encoding; header_write->project_ID_GUID_data_1 = header_read->project_ID_GUID_data_1; header_write->project_ID_GUID_data_2 = header_read->project_ID_GUID_data_2; header_write->project_ID_GUID_data_3 = header_read->project_ID_GUID_data_3; memcpy(header_write->project_ID_GUID_data_4, header_read->project_ID_GUID_data_4, 8); header_write->version_major = header_read->version_major; header_write->version_minor = header_read->version_minor; memcpy(header_write->system_identifier, header_read->system_identifier, 32); memcpy(header_write->generating_software, header_read->generating_software, 32); header_write->file_creation_day = header_read->file_creation_day; header_write->file_creation_year = header_read->file_creation_year; header_write->header_size = header_read->header_size; header_write->offset_to_point_data = header_read->header_size; /* note !!! */ header_write->number_of_variable_length_records = header_read->number_of_variable_length_records; header_write->point_data_format = header_read->point_data_format; header_write->point_data_record_length = header_read->point_data_record_length; header_write->number_of_point_records = header_read->number_of_point_records; for (i = 0; i < 5; i++) { header_write->number_of_points_by_return[i] = header_read->number_of_points_by_return[i]; } header_write->x_scale_factor = header_read->x_scale_factor; header_write->y_scale_factor = header_read->y_scale_factor; header_write->z_scale_factor = header_read->z_scale_factor; header_write->x_offset = header_read->x_offset; header_write->y_offset = header_read->y_offset; header_write->z_offset = header_read->z_offset; header_write->max_x = header_read->max_x; header_write->min_x = header_read->min_x; header_write->max_y = header_read->max_y; header_write->min_y = header_read->min_y; header_write->max_z = header_read->max_z; header_write->min_z = header_read->min_z; // LAS 1.3 and higher only header_write->start_of_waveform_data_packet_record = header_read->start_of_waveform_data_packet_record; // LAS 1.4 and higher only header_write->start_of_first_extended_variable_length_record = header_read->start_of_first_extended_variable_length_record; header_write->number_of_extended_variable_length_records = header_read->number_of_extended_variable_length_records; header_write->extended_number_of_point_records = header_read->extended_number_of_point_records; for (i = 0; i < 15; i++) { header_write->extended_number_of_points_by_return[i] = header_read->extended_number_of_points_by_return[i]; } // we may modify output because we omit any user defined data that may be ** the header if (header_read->user_data_in_header_size) { header_write->header_size -= header_read->user_data_in_header_size; header_write->offset_to_point_data -= header_read->user_data_in_header_size; fprintf(stderr,"omitting %d bytes of user_data_in_header\n", header_read->user_data_after_header_size); } // add all the VLRs if (header_read->number_of_variable_length_records) { fprintf(stderr,"offset_to_point_data before adding %u VLRs is %d\n", header_read->number_of_variable_length_records, (laszip_I32)header_write->offset_to_point_data); for (i = 0; i < header_read->number_of_variable_length_records; i++) { if (laszip_add_vlr(laszip_writer, &(header_read->vlrs[i]))) { fprintf(stderr,"DLL ERROR: adding VLR %u of %u to the header of the laszip writer\n", i+i, header_read->number_of_variable_length_records); byebye(true, argc==1, laszip_writer); } fprintf(stderr," after adding VLR number %u is %d\n", i+1, (laszip_I32)header_write->offset_to_point_data); } } // we may modify output because we omit any user defined data that may be *after* the header if (header_read->user_data_after_header_size) { fprintf(stderr,"omitting %d bytes of user_data_after_header\n", header_read->user_data_after_header_size); } // open the writer laszip_BOOL compress = (strstr(file_name_out, ".laz") != 0); if (laszip_open_writer(laszip_writer, file_name_out, compress)) { fprintf(stderr,"DLL ERROR: opening laszip writer for '%d'\n", file_name_out); byebye(true, argc==1, laszip_writer); } fprintf(stderr,"writing file '%s' %scompressed\n", file_name_out, (compress ? "" : "un")); // get a pointer to the point of the reader will be read laszip_point* point_read; if (laszip_get_point_pointer(laszip_reader, &point_read)) { fprintf(stderr,"DLL ERROR: getting point pointer from laszip reader\n"); byebye(true, argc==1, laszip_reader); } // get a pointer to the point of the writer that we will populate and write laszip_point* point_write; if (laszip_get_point_pointer(laszip_writer, &point_write)) { fprintf(stderr,"DLL ERROR: getting point pointer from laszip writer\n"); byebye(true, argc==1, laszip_writer); } // read the points laszip_U32 count = 0; while (count < header_read->number_of_point_records) { // read a point if (laszip_read_point(laszip_reader)) { fprintf(stderr,"DLL ERROR: reading point %u\n", count); byebye(true, argc==1, laszip_reader); } // copy the point point_write->X = point_read->X; point_write->Y = point_read->Y; point_write->Z = point_read->Z; point_write->intensity = point_read->intensity; point_write->return_number = point_read->return_number; point_write->number_of_returns_of_given_pulse = point_read->number_of_returns_of_given_pulse; point_write->scan_direction_flag = point_read->scan_direction_flag; point_write->edge_of_flight_line = point_read->edge_of_flight_line; point_write->classification = point_read->classification; point_write->scan_angle_rank = point_read->scan_angle_rank; point_write->user_data = point_read->user_data; point_write->point_source_ID = point_read->point_source_ID; point_write->gps_time = point_read->gps_time; memcpy(point_write->rgb, point_read->rgb, 8); memcpy(point_write->wave_packet, point_read->wave_packet, 29); // LAS 1.4 only point_write->extended_point_type = point_read->extended_point_type; point_write->extended_scanner_channel = point_read->extended_scanner_channel; point_write->extended_classification_flags = point_read->extended_classification_flags; point_write->extended_classification = point_read->extended_classification; point_write->extended_return_number = point_read->extended_return_number; point_write->extended_number_of_returns_of_given_pulse = point_read->extended_number_of_returns_of_given_pulse; point_write->extended_scan_angle = point_read->extended_scan_angle; if (point_read->num_extra_bytes) { memcpy(point_write->extra_bytes, point_read->extra_bytes, point_read->num_extra_bytes); } // write the point if (laszip_write_point(laszip_writer)) { fprintf(stderr,"DLL ERROR: writing point %u\n", count); byebye(true, argc==1, laszip_writer); } count++; } fprintf(stderr,"successfully read and written %u points\n", count); // close the writer if (laszip_close_writer(laszip_writer)) { fprintf(stderr,"DLL ERROR: closing laszip writer\n"); byebye(true, argc==1, laszip_writer); } // destroy the writer if (laszip_destroy(laszip_writer)) { fprintf(stderr,"DLL ERROR: destroying laszip writer\n"); byebye(true, argc==1); } // close the reader if (laszip_close_reader(laszip_reader)) { fprintf(stderr,"DLL ERROR: closing laszip reader\n"); byebye(true, argc==1, laszip_reader); } // destroy the reader if (laszip_destroy(laszip_reader)) { fprintf(stderr,"DLL ERROR: destroying laszip reader\n"); byebye(true, argc==1); } fprintf(stderr,"total time: %g sec for reading %scompressed and writing %scompressed\n", taketime()-start_time, (is_compressed ? "" : "un"), (compress ? "" : "un")); } // EXAMPLE_TWO if (EXAMPLE == EXAMPLE_THREE) { fprintf(stderr,"running EXAMPLE_THREE\n"); // create the writer laszip_POINTER laszip_writer; if (laszip_create(&laszip_writer)) { fprintf(stderr,"DLL ERROR: creating laszip writer\n"); byebye(true, argc==1); } // get a pointer to the header of the writer so we can populate it laszip_header* header; if (laszip_get_header_pointer(laszip_writer, &header)) { fprintf(stderr,"DLL ERROR: getting header pointer from laszip writer\n"); byebye(true, argc==1, laszip_writer); } // populate the header header->global_encoding = 0; // see LAS specification for details header->version_major = 1; header->version_minor = 2; strncpy(header->system_identifier, "my LAS file writer", 32); header->file_creation_day = 120; header->file_creation_year = 2013; header->point_data_format = 1; header->point_data_record_length = 28; header->number_of_point_records = 5; header->number_of_points_by_return[0] = 3; header->number_of_points_by_return[1] = 2; header->max_x = 630499.95; header->min_x = 630498.56; header->max_y = 4834749.66; header->min_y = 4834748.73; header->max_z = 63.68; header->min_z = 61.33; // optional: use the bounding box and the scale factor to create a "good" offset if (laszip_auto_offset(laszip_writer)) { fprintf(stderr,"DLL ERROR: during automatic offset creation\n"); byebye(true, argc==1, laszip_writer); } // create some funny VLR laszip_vlr funny_vlr; memset(&funny_vlr, 0, sizeof(laszip_vlr)); strcpy(funny_vlr.user_id, "funny"); funny_vlr.record_id = 12345; funny_vlr.record_length_after_header = 0; strcpy(funny_vlr.description, "just a funny VLR"); // add the funny VLR fprintf(stderr,"offset_to_point_data before adding funny VLR is : %d\n", (laszip_I32)header->offset_to_point_data); if (laszip_add_vlr(laszip_writer, &funny_vlr)) { fprintf(stderr,"DLL ERROR: adding funny VLR to the header\n"); byebye(true, argc==1, laszip_writer); } // create the geokeys with the projection information laszip_geokey_struct key_entries[5]; // projected coordinates key_entries[0].key_id = 1024; // GTModelTypeGeoKey key_entries[0].tiff_tag_location = 0; key_entries[0].count = 1; key_entries[0].value_offset = 1; // ModelTypeProjected // projection key_entries[1].key_id = 3072; // ProjectedCSTypeGeoKey key_entries[1].tiff_tag_location = 0; key_entries[1].count = 1; key_entries[1].value_offset = 32613; // PCS_WGS84_UTM_zone_13N // horizontal units key_entries[2].key_id = 3076; // ProjLinearUnitsGeoKey key_entries[2].tiff_tag_location = 0; key_entries[2].count = 1; key_entries[2].value_offset = 9001; // meters // vertical units key_entries[3].key_id = 4099; // VerticalUnitsGeoKey key_entries[3].tiff_tag_location = 0; key_entries[3].count = 1; key_entries[3].value_offset = 9001; // meters // vertical datum key_entries[4].key_id = 4096; // VerticalCSTypeGeoKey key_entries[4].tiff_tag_location = 0; key_entries[4].count = 1; key_entries[4].value_offset = 5030; // WGS84 // add the geokeys (create or replace the appropriate VLR) fprintf(stderr," before adding projection VLR : %d\n", (laszip_I32)header->offset_to_point_data); if (laszip_set_geokeys(laszip_writer, 5, key_entries)) { fprintf(stderr,"DLL ERROR: adding funny VLR to the header\n"); byebye(true, argc==1, laszip_writer); } fprintf(stderr," after adding two VLRs : %d\n", (laszip_I32)header->offset_to_point_data); // open the writer laszip_BOOL compress = (strstr(file_name_out, ".laz") != 0); if (laszip_open_writer(laszip_writer, file_name_out, compress)) { fprintf(stderr,"DLL ERROR: opening laszip writer for '%d'\n", file_name_out); byebye(true, argc==1, laszip_writer); } fprintf(stderr,"writing file '%s' %scompressed\n", file_name_out, (compress ? "" : "un")); // get a pointer to the point of the writer that we will populate and write laszip_point* point; if (laszip_get_point_pointer(laszip_writer, &point)) { fprintf(stderr,"DLL ERROR: getting point pointer from laszip writer\n"); byebye(true, argc==1, laszip_writer); } // write five points laszip_I64 count = 0; laszip_F64 coordinates[3]; // populate the first point coordinates[0] = 630499.95; coordinates[1] = 4834749.17; coordinates[2] = 62.15; if (laszip_set_coordinates(laszip_writer, coordinates)) { fprintf(stderr,"DLL ERROR: setting coordinates for point %u\n", (laszip_U32)count); byebye(true, argc==1, laszip_writer); } point->intensity = 60; point->return_number = 2; point->number_of_returns_of_given_pulse = 2; point->classification = 2; point->scan_angle_rank = 21; point->gps_time = 413162.560400; // write the first point if (laszip_write_point(laszip_writer)) { fprintf(stderr,"DLL ERROR: writing point %u\n", (laszip_U32)count); byebye(true, argc==1, laszip_writer); } count++; // populate the second point coordinates[0] = 630499.83; coordinates[1] = 4834748.88; coordinates[2] = 62.68; if (laszip_set_coordinates(laszip_writer, coordinates)) { fprintf(stderr,"DLL ERROR: setting coordinates for point %u\n", (laszip_U32)count); byebye(true, argc==1, laszip_writer); } point->intensity = 90; point->return_number = 1; point->number_of_returns_of_given_pulse = 1; point->classification = 1; point->scan_angle_rank = 21; point->gps_time = 413162.563600; // write the second point if (laszip_write_point(laszip_writer)) { fprintf(stderr,"DLL ERROR: writing point %u\n", (laszip_U32)count); byebye(true, argc==1, laszip_writer); } count++; // populate the third point coordinates[0] = 630499.54; coordinates[1] = 4834749.66; coordinates[2] = 62.66; if (laszip_set_coordinates(laszip_writer, coordinates)) { fprintf(stderr,"DLL ERROR: setting coordinates for point %u\n", (laszip_U32)count); byebye(true, argc==1, laszip_writer); } point->intensity = 70; point->return_number = 1; point->number_of_returns_of_given_pulse = 1; point->classification = 1; point->scan_angle_rank = 22; point->gps_time = 413162.566800; // write the third point if (laszip_write_point(laszip_writer)) { fprintf(stderr,"DLL ERROR: writing point %u\n", (laszip_U32)count); byebye(true, argc==1, laszip_writer); } count++; // populate the fourth point coordinates[0] = 630498.56; coordinates[1] = 4834749.41; coordinates[2] = 63.68; if (laszip_set_coordinates(laszip_writer, coordinates)) { fprintf(stderr,"DLL ERROR: setting coordinates for point %u\n", (laszip_U32)count); byebye(true, argc==1, laszip_writer); } point->intensity = 20; point->return_number = 1; point->number_of_returns_of_given_pulse = 2; point->classification = 3; point->scan_angle_rank = 22; point->gps_time = 413162.580200; // write the fourth point if (laszip_write_point(laszip_writer)) { fprintf(stderr,"DLL ERROR: writing point %u\n", (laszip_U32)count); byebye(true, argc==1, laszip_writer); } count++; // populate the fifth point coordinates[0] = 630498.80; coordinates[1] = 4834748.73; coordinates[2] = 62.16; if (laszip_set_coordinates(laszip_writer, coordinates)) { fprintf(stderr,"DLL ERROR: setting coordinates for point %u\n", (laszip_U32)count); byebye(true, argc==1, laszip_writer); } point->intensity = 110; point->return_number = 2; point->number_of_returns_of_given_pulse = 2; point->classification = 2; point->scan_angle_rank = 22; point->gps_time = 413162.580200; // write the fifth point if (laszip_write_point(laszip_writer)) { fprintf(stderr,"DLL ERROR: writing point %u\n", (laszip_U32)count); byebye(true, argc==1, laszip_writer); } count++; // get the number of points written so far if (laszip_get_point_count(laszip_writer, &count)) { fprintf(stderr,"DLL ERROR: getting point count\n"); byebye(true, argc==1, laszip_writer); } fprintf(stderr,"successfully written %u points\n", (laszip_U32)count); // close the writer if (laszip_close_writer(laszip_writer)) { fprintf(stderr,"DLL ERROR: closing laszip writer\n"); byebye(true, argc==1, laszip_writer); } // destroy the writer if (laszip_destroy(laszip_writer)) { fprintf(stderr,"DLL ERROR: destroying laszip writer\n"); byebye(true, argc==1); } fprintf(stderr,"total time: %g sec for writing %scompressed\n", taketime()-start_time, (compress ? "" : "un")); } // EXAMPLE_THREE if (EXAMPLE == EXAMPLE_FOUR) { fprintf(stderr,"running EXAMPLE_FOUR\n"); // create the reader laszip_POINTER laszip_reader; if (laszip_create(&laszip_reader)) { fprintf(stderr,"DLL ERROR: creating laszip reader\n"); byebye(true, argc==1); } // signal that spatial queries are coming laszip_BOOL exploit = 1; if (laszip_exploit_spatial_index(laszip_reader, exploit)) { fprintf(stderr,"DLL ERROR: signaling laszip reader that spatial queries are coming for '%s'\n", file_name_in); byebye(true, argc==1, laszip_reader); } // open the reader laszip_BOOL is_compressed = 0; if (laszip_open_reader(laszip_reader, file_name_in, &is_compressed)) { fprintf(stderr,"DLL ERROR: opening laszip reader for '%s'\n", file_name_in); byebye(true, argc==1, laszip_reader); } fprintf(stderr,"file '%s' is %scompressed\n", file_name_in, (is_compressed ? "" : "un")); // check whether spatial indexing information is available laszip_BOOL is_indexed = 0; laszip_BOOL is_appended = 0; if (laszip_has_spatial_index(laszip_reader, &is_indexed, &is_appended)) { fprintf(stderr,"DLL ERROR: checking laszip reader whether spatial indexing information is present for '%s'\n", file_name_in); byebye(true, argc==1, laszip_reader); } fprintf(stderr,"file '%s' does %shave spatial indexing information\n", file_name_in, (is_indexed ? "" : "not ")); // get a pointer to the header of the reader that was just populated laszip_header* header; if (laszip_get_header_pointer(laszip_reader, &header)) { fprintf(stderr,"DLL ERROR: getting header pointer from laszip reader\n"); byebye(true, argc==1, laszip_reader); } // report how many points the file has fprintf(stderr,"file '%s' contains %u points\n", file_name_in, header->number_of_point_records); // create a rectangular box enclosing a subset of points at the center of the full bounding box const laszip_F64 sub = 0.05; laszip_F64 mid_x = (header->min_x + header->max_x) / 2; laszip_F64 mid_y = (header->min_y + header->max_y) / 2; laszip_F64 range_x = header->max_x - header->min_x; laszip_F64 range_y = header->max_y - header->min_y; laszip_F64 sub_min_x = mid_x - sub * range_x; laszip_F64 sub_min_y = mid_y - sub * range_y; laszip_F64 sub_max_x = mid_x + sub * range_x; laszip_F64 sub_max_y = mid_y + sub * range_y; // request the reader to only read this specified rectangular subset of points laszip_BOOL is_empty = 0; if (laszip_inside_rectangle(laszip_reader, sub_min_x, sub_min_y, sub_max_x, sub_max_y, &is_empty)) { fprintf(stderr,"DLL ERROR: requesting points inside of rectangle [%g,%g] (%g,%g) from laszip reader\n", sub_min_x, sub_min_y, sub_max_x, sub_max_y); byebye(true, argc==1, laszip_reader); } // get a pointer to the points that will be read laszip_point* point; if (laszip_get_point_pointer(laszip_reader, &point)) { fprintf(stderr,"DLL ERROR: getting point pointer from laszip reader\n"); byebye(true, argc==1, laszip_reader); } // create the writer laszip_POINTER laszip_writer; if (laszip_create(&laszip_writer)) { fprintf(stderr,"DLL ERROR: creating laszip writer\n"); byebye(true, argc==1); } // initialize the header for the writer using the header of the reader if (laszip_set_header(laszip_writer, header)) { fprintf(stderr,"DLL ERROR: setting header for laszip writer\n"); byebye(true, argc==1, laszip_writer); } // open the writer laszip_BOOL compress = (strstr(file_name_out, ".laz") != 0); if (laszip_open_writer(laszip_writer, file_name_out, compress)) { fprintf(stderr,"DLL ERROR: opening laszip writer for '%d'\n", file_name_out); byebye(true, argc==1, laszip_writer); } fprintf(stderr,"writing file '%s' %scompressed\n", file_name_out, (compress ? "" : "un")); // read the points laszip_U32 count = 0; laszip_BOOL is_done = 0; while (count < header->number_of_point_records) { // read a point if (laszip_read_inside_point(laszip_reader, &is_done)) { fprintf(stderr,"DLL ERROR: reading point %u\n", count); byebye(true, argc==1, laszip_reader); } // are we done reading if (is_done) { break; } // copy the point if (laszip_set_point(laszip_writer, point)) { fprintf(stderr,"DLL ERROR: setting point %u\n", count); byebye(true, argc==1, laszip_writer); } // write the point if (laszip_write_point(laszip_writer)) { fprintf(stderr,"DLL ERROR: writing point %u\n", count); byebye(true, argc==1, laszip_writer); } // update the inventory if (laszip_update_inventory(laszip_writer)) { fprintf(stderr,"DLL ERROR: updating inventory for point %u\n", count); byebye(true, argc==1, laszip_writer); } count++; } fprintf(stderr,"successfully read and written %u points\n", count); // close the writer if (laszip_close_writer(laszip_writer)) { fprintf(stderr,"DLL ERROR: closing laszip writer\n"); byebye(true, argc==1, laszip_writer); } // destroy the writer if (laszip_destroy(laszip_writer)) { fprintf(stderr,"DLL ERROR: destroying laszip writer\n"); byebye(true, argc==1); } // close the reader if (laszip_close_reader(laszip_reader)) { fprintf(stderr,"DLL ERROR: closing laszip reader\n"); byebye(true, argc==1, laszip_reader); } // destroy the reader if (laszip_destroy(laszip_reader)) { fprintf(stderr,"DLL ERROR: destroying laszip reader\n"); byebye(true, argc==1); } fprintf(stderr,"total time: %g sec for reading %scompressed and writing %scompressed\n", taketime()-start_time, (is_compressed ? "" : "un"), (compress ? "" : "un")); } // EXAMPLE_FOUR if (EXAMPLE == EXAMPLE_FIVE) { fprintf(stderr,"running EXAMPLE_FIVE\n"); // create the reader laszip_POINTER laszip_reader; if (laszip_create(&laszip_reader)) { fprintf(stderr,"DLL ERROR: creating laszip reader\n"); byebye(true, argc==1); } // open the reader laszip_BOOL is_compressed = 0; if (laszip_open_reader(laszip_reader, file_name_in, &is_compressed)) { fprintf(stderr,"DLL ERROR: opening laszip reader for '%s'\n", file_name_in); byebye(true, argc==1, laszip_reader); } fprintf(stderr,"file '%s' is %scompressed\n", file_name_in, (is_compressed ? "" : "un")); // get a pointer to the header of the reader that was just populated laszip_header* header; if (laszip_get_header_pointer(laszip_reader, &header)) { fprintf(stderr,"DLL ERROR: getting header pointer from laszip reader\n"); byebye(true, argc==1, laszip_reader); } // report how many points the file has fprintf(stderr,"file '%s' contains %u points\n", file_name_in, header->number_of_point_records); // get a pointer to the points that will be read laszip_point* point; if (laszip_get_point_pointer(laszip_reader, &point)) { fprintf(stderr,"DLL ERROR: getting point pointer from laszip reader\n"); byebye(true, argc==1, laszip_reader); } // create the writer laszip_POINTER laszip_writer; if (laszip_create(&laszip_writer)) { fprintf(stderr,"DLL ERROR: creating laszip writer\n"); byebye(true, argc==1); } // initialize the header for the writer using the header of the reader if (laszip_set_header(laszip_writer, header)) { fprintf(stderr,"DLL ERROR: setting header for laszip writer\n"); byebye(true, argc==1, laszip_writer); } // enable the creation of spatial indices laszip_BOOL create = 1; laszip_BOOL append = 0; /* not supported yet */ if (laszip_create_spatial_index(laszip_writer, create, append)) { fprintf(stderr,"DLL ERROR: signaling laszip writer to create spatial indexing information\n"); byebye(true, argc==1, laszip_writer); } // open the writer laszip_BOOL compress = (strstr(file_name_out, ".laz") != 0); if (laszip_open_writer(laszip_writer, file_name_out, compress)) { fprintf(stderr,"DLL ERROR: opening laszip writer for '%d'\n", file_name_out); byebye(true, argc==1, laszip_writer); } fprintf(stderr,"writing file '%s' spatially indexed and %scompressed\n", file_name_out, (compress ? "" : "un")); // read the points laszip_U32 count = 0; while (count < header->number_of_point_records) { // read a point if (laszip_read_point(laszip_reader)) { fprintf(stderr,"DLL ERROR: reading point %u\n", count); byebye(true, argc==1, laszip_reader); } // copy the point if (laszip_set_point(laszip_writer, point)) { fprintf(stderr,"DLL ERROR: setting point %u\n", count); byebye(true, argc==1, laszip_writer); } // write the point if (laszip_write_indexed_point(laszip_writer)) { fprintf(stderr,"DLL ERROR: writing indexed point %u\n", count); byebye(true, argc==1, laszip_writer); } count++; } fprintf(stderr,"successfully read and written %u indexed points\n", count); // close the writer if (laszip_close_writer(laszip_writer)) { fprintf(stderr,"DLL ERROR: closing laszip writer\n"); byebye(true, argc==1, laszip_writer); } // destroy the writer if (laszip_destroy(laszip_writer)) { fprintf(stderr,"DLL ERROR: destroying laszip writer\n"); byebye(true, argc==1); } // close the reader if (laszip_close_reader(laszip_reader)) { fprintf(stderr,"DLL ERROR: closing laszip reader\n"); byebye(true, argc==1, laszip_reader); } // destroy the reader if (laszip_destroy(laszip_reader)) { fprintf(stderr,"DLL ERROR: destroying laszip reader\n"); byebye(true, argc==1); } fprintf(stderr,"total time: %g sec for reading %scompressed and writing indexed & %scompressed\n", taketime()-start_time, (is_compressed ? "" : "un"), (compress ? "" : "un")); } // EXAMPLE_FIVE // unload LASzip DLL if (laszip_unload_dll()) { fprintf(stderr,"DLL ERROR: unloading LASzip DLL\n"); byebye(true, argc==1); } return 0; }
int main(int argc, char *argv[]) { int i; BOOL verbose = TRUE; BOOL very_verbose = TRUE; F64 start_time = 0.0; F64 full_start_time = 0.0; const CHAR* xml_output_file = 0; BOOL one_report_per_file = FALSE; U32 num_pass = 0; U32 num_fail = 0; U32 num_warning = 0; fprintf(stderr, "This is version '%s' of the LAS validator. Please contact\n", "GRiD-1"); fprintf(stderr, "me at '*****@*****.**' if you disagree with\n"); fprintf(stderr, "validation reports, want additional checks, or find bugs as\n"); fprintf(stderr, "the software is still under development. Your feedback will\n"); fprintf(stderr, "help to finish it sooner.\n"); LASreadOpener lasreadopener; if (argc == 1) { fprintf(stderr,"lasvalidate.exe is best run with arguments in the command line\n"); char file_name[256]; fprintf(stderr,"enter input LAS file name: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.set_file_name(file_name); fprintf(stderr,"enter output XML file name: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; xml_output_file = strdup(file_name); } for (i = 1; i < argc; i++) { if (strcmp(argv[i],"-version") == 0) { fprintf(stderr, "\nlasvalidate %d with LASread (v %d.%d %d) and LAScheck (v %d.%d %d) by rapidlasso GmbH\n", VALIDATE_VERSION, LASREAD_VERSION_MAJOR, LASREAD_VERSION_MINOR, LASREAD_BUILD_DATE, LASCHECK_VERSION_MAJOR, LASCHECK_VERSION_MINOR, LASCHECK_BUILD_DATE); byebye(LAS_VALIDATE_SUCCESS); } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { lasreadopener.usage(); usage(LAS_VALIDATE_SUCCESS); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = TRUE; } else if (strcmp(argv[i],"-vv") == 0 || strcmp(argv[i],"-very_verbose") == 0) { verbose = TRUE; very_verbose = TRUE; } else if (strcmp(argv[i],"-i") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs at least 1 argument: file_name or wild_card\n", argv[i]); usage(LAS_VALIDATE_WRONG_COMMAND_LINE_SYNTAX); } i+=1; do { lasreadopener.add_file_name(argv[i]); i+=1; } while (i < argc && *argv[i] != '-'); i-=1; } else if (strcmp(argv[i],"-irec") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs at least 1 argument: directory_name\n", argv[i]); usage(LAS_VALIDATE_WRONG_COMMAND_LINE_SYNTAX); } i+=1; do { lasreadopener.add_directory(argv[i], TRUE); i+=1; } while (i < argc && *argv[i] != '-'); i-=1; } else if (strcmp(argv[i],"-stdin") == 0) { lasreadopener.set_piped(TRUE); } else if (strcmp(argv[i],"-lof") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: list_of_files\n", argv[i]); usage(LAS_VALIDATE_WRONG_COMMAND_LINE_SYNTAX); } FILE* file = fopen(argv[i+1], "r"); if (file == 0) { fprintf(stderr, "ERROR: cannot open '%s'\n", argv[i+1]); return FALSE; } char line[1024]; while (fgets(line, 1024, file)) { // find end of line int len = strlen(line) - 1; // remove extra white spaces and line return at the end while (len > 0 && ((line[len] == '\n') || (line[len] == ' ') || (line[len] == '\t') || (line[len] == '\012'))) { line[len] = '\0'; len--; } lasreadopener.add_file_name(line); } fclose(file); i+=1; } else if (strcmp(argv[i],"-o") == 0) { i++; xml_output_file = argv[i]; } else if (strcmp(argv[i],"-oxml") == 0) { one_report_per_file = TRUE; } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); usage(LAS_VALIDATE_WRONG_COMMAND_LINE_SYNTAX); } } // in verbose mode we measure the total time if (verbose) full_start_time = taketime(); // check input if (!lasreadopener.is_active()) { fprintf(stderr,"ERROR: no input specified\n"); byebye(LAS_VALIDATE_NO_INPUT_SPECIFIED, argc == 1); } // output logging XMLwriter xmlwriter; if (lasreadopener.is_active()) { if (xml_output_file) { one_report_per_file = FALSE; } else if (!one_report_per_file) { xml_output_file = "validate.xml"; } } // maybe we are doing one summary report if (xml_output_file) { if (!xmlwriter.open(xml_output_file, "LASvalidator")) { byebye(LAS_VALIDATE_WRITE_PERMISSION_ERROR, argc == 1); } } // accumulated pass U32 total_pass = VALIDATE_PASS; // possibly loop over multiple input files while (lasreadopener.is_active()) { // in very verbose mode we measure the time for each file if (very_verbose) start_time = taketime(); // open lasreader LASreader* lasreader = lasreadopener.open(); if (lasreader == 0) { fprintf(stderr, "ERROR: could not open lasreader\n"); byebye(LAS_VALIDATE_INPUT_FILE_NOT_FOUND, argc == 1); } // get a pointer to the header LASheader* lasheader = &lasreader->header; // maybe we are doing one report per file if (one_report_per_file) { int len = strlen(lasreadopener.get_path()); CHAR* current_xml_output_file = (CHAR*)malloc(len + 5); strcpy(current_xml_output_file, lasreadopener.get_path()); current_xml_output_file[len-4] = '_'; current_xml_output_file[len-3] = 'L'; current_xml_output_file[len-2] = 'V'; current_xml_output_file[len-1] = 'S'; current_xml_output_file[len ] = '.'; current_xml_output_file[len+1] = 'x'; current_xml_output_file[len+2] = 'm'; current_xml_output_file[len+3] = 'l'; current_xml_output_file[len+4] = '\0'; if (!xmlwriter.open(current_xml_output_file, "LASvalidator")) { byebye(LAS_VALIDATE_WRITE_PERMISSION_ERROR, argc == 1); } free(current_xml_output_file); } // start a new report xmlwriter.begin("report"); // report description of file xmlwriter.beginsub("file"); xmlwriter.write("name", lasreadopener.get_file_name()); xmlwriter.write("path", lasreadopener.get_path()); CHAR temp[32]; sprintf(temp, "%d.%d", lasheader->version_major, lasheader->version_minor); xmlwriter.write("version", temp); strncpy(temp, lasheader->system_identifier, 32); temp[31] = '\0'; xmlwriter.write("system_identifier", temp); strncpy(temp, lasheader->generating_software, 32); temp[31] = '\0'; xmlwriter.write("generating_software", temp); xmlwriter.write("point_data_format", lasheader->point_data_format); CHAR crsdescription[512]; strcpy(crsdescription, "not valid or not specified"); if (lasheader->fails == 0) { // header was loaded. now parse and check. LAScheck lascheck(lasheader); while (lasreader->read_point()) { lascheck.parse(&lasreader->point); } // check header and points and get CRS description lascheck.check(lasheader, crsdescription); } xmlwriter.write("CRS", crsdescription); xmlwriter.endsub("file"); // report the verdict U32 pass = (lasheader->fails ? VALIDATE_FAIL : VALIDATE_PASS); if (lasheader->warnings) pass |= VALIDATE_WARNING; xmlwriter.beginsub("summary"); xmlwriter.write((pass == VALIDATE_PASS ? "pass" : ((pass & VALIDATE_FAIL) ? "fail" : "warning"))); xmlwriter.endsub("summary"); // report details (if necessary) if (pass != VALIDATE_PASS) { xmlwriter.beginsub("details"); for (i = 0; i < lasheader->fail_num; i+=2) { xmlwriter.write(lasheader->fails[i], "fail", lasheader->fails[i+1]); } for (i = 0; i < lasheader->warning_num; i+=2) { xmlwriter.write(lasheader->warnings[i], "warning", lasheader->warnings[i+1]); } xmlwriter.endsub("details"); total_pass |= pass; if (pass & VALIDATE_FAIL) { num_fail++; } else { num_warning++; } } else { num_pass++; } // end the report xmlwriter.end("report"); // maybe we are doing one report per file if (one_report_per_file) { // report the total verdict xmlwriter.begin("total"); xmlwriter.write((total_pass == VALIDATE_PASS ? "pass" : ((total_pass & VALIDATE_FAIL) ? "fail" : "warning"))); xmlwriter.beginsub("details"); xmlwriter.write("pass", num_pass); xmlwriter.write("warning", num_warning); xmlwriter.write("fail", num_fail); xmlwriter.endsub("details"); xmlwriter.end("total"); num_pass = 0; num_warning = 0; num_fail = 0; // write which validator was used write_version(xmlwriter); // write which command line was used write_command_line(xmlwriter, argc, argv); // close the LASvalidator XML output file xmlwriter.close("LASvalidator"); } lasreader->close(); delete lasreader; // in very verbose mode we report the time for each file if (very_verbose) { fprintf(stderr,"needed %.2f sec for '%s'\n", taketime()-start_time, lasreadopener.get_file_name()); start_time = taketime(); } } // maybe we are doing one summary report if (!one_report_per_file) { // report the total verdict xmlwriter.begin("total"); xmlwriter.write((total_pass == 0 ? "pass" : ((total_pass & 1) ? "fail" : "warning"))); xmlwriter.beginsub("details"); xmlwriter.write("pass", num_pass); xmlwriter.write("warning", num_warning); xmlwriter.write("fail", num_fail); xmlwriter.endsub("details"); xmlwriter.end("total"); // write which validator was used write_version(xmlwriter); // write which command line was used write_command_line(xmlwriter, argc, argv); // close the LASvalidator XML output file xmlwriter.close("LASvalidator"); } // in verbose mode we report the total time if (verbose && (lasreadopener.get_file_name_number() > 1)) { fprintf(stderr,"done. total time %.2f sec.\n", taketime()-full_start_time); } byebye(argc==1); return 0; }
int main(int argc, char *argv[]) { int i; bool verbose = false; double start_time = 0.0; LASreadOpener lasreadopener; LASwriteOpener laswriteopener; if (argc == 1) { fprintf(stderr,"%s is better run in the command line\n", argv[0]); char file_name[256]; fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.set_file_name(file_name); fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; laswriteopener.set_file_name(file_name); } else { lasreadopener.parse(argc, argv); laswriteopener.parse(argc, argv); } for (i = 1; i < argc; i++) { if (argv[i][0] == '\0') { continue; } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { usage(); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = true; } else if (i == argc - 2 && !lasreadopener.active() && !laswriteopener.active()) { lasreadopener.set_file_name(argv[i]); } else if (i == argc - 1 && !lasreadopener.active() && !laswriteopener.active()) { lasreadopener.set_file_name(argv[i]); } else if (i == argc - 1 && lasreadopener.active() && !laswriteopener.active()) { laswriteopener.set_file_name(argv[i]); } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); usage(); } } if (verbose) start_time = taketime(); // check input & output if (!lasreadopener.active()) { fprintf(stderr,"ERROR: no input specified\n"); usage(argc == 1); } if (!laswriteopener.active()) { fprintf(stderr,"ERROR: no output specified\n"); usage(argc == 1); } // open lasreader LASreader* lasreader = lasreadopener.open(); if (lasreader == 0) { fprintf(stderr, "ERROR: could not open lasreader\n"); byebye(argc==1); } // open laswriter LASwriter* laswriter = laswriteopener.open(&lasreader->header); if (laswriter == 0) { fprintf(stderr, "ERROR: could not open laswriter\n"); byebye(argc==1); } #ifdef _WIN32 if (verbose) fprintf(stderr, "reading %I64d points from '%s' and writing them modified to '%s'.\n", lasreader->npoints, lasreadopener.get_file_name(), laswriteopener.get_file_name()); #else if (verbose) fprintf(stderr, "reading %lld points from '%s' and writing them modified to '%s'.\n", lasreader->npoints, lasreadopener.get_file_name(), laswriteopener.get_file_name()); #endif // loop over points and modify them // where there is a point to read while (lasreader->read_point()) { // modify the point lasreader->point.set_point_source_ID(1020); lasreader->point.set_user_data(42); if (lasreader->point.get_classification() == 12) lasreader->point.set_classification(1); lasreader->point.set_Z(lasreader->point.get_Z() + 10); // write the modified point laswriter->write_point(&lasreader->point); // add it to the inventory laswriter->update_inventory(&lasreader->point); } laswriter->update_header(&lasreader->header, TRUE); I64 total_bytes = laswriter->close(); delete laswriter; #ifdef _WIN32 if (verbose) fprintf(stderr,"total time: %g sec %I64d bytes for %I64d points\n", taketime()-start_time, total_bytes, lasreader->p_count); #else if (verbose) fprintf(stderr,"total time: %g sec %lld bytes for %lld points\n", taketime()-start_time, total_bytes, lasreader->p_count); #endif lasreader->close(); delete lasreader; return 0; }
int main(int argc, char** argv) { /* working variables */ int i,j,mf; FILE *fp; char *cbuf,**infiles,**outfiles; printf("# %s",rcsid); /* args */ for(i=j=1;i<argc;i++) { if(argv[i][0] != '-') { switch(j) { case 1: fname_mt=argv[i]; break; case 2: fname_rmt=argv[i]; break; default: byebye(); } j++; } else if(streq(argv[i],"-s")) { if(i+1>=argc || sscanf(argv[i+1],"%lu",&seed) != 1) byebye(); i+=1; } else if(streq(argv[i],"-p")) { if(i+1>=argc) byebye(); fname_pa=argv[i+1]; i+=1; } else if(streq(argv[i],"-b")) { if(i+1>=argc || sscanf(argv[i+1],"%lf",&bbfact) != 1) byebye(); i+=1; } else if(streq(argv[i],"-f")) { sw_fastrep=1; } else if(streq(argv[i],"-g")) { sw_multi=1; } else if(streq(argv[i],"--molphy")) { seqmode=SEQ_MOLPHY; } else if(streq(argv[i],"--paml")) { seqmode=SEQ_PAML; } else if(streq(argv[i],"--paup")) { seqmode=SEQ_PAUP; } else if(streq(argv[i],"--puzzle")) { seqmode=SEQ_PUZZLE; } else if(streq(argv[i],"--phyml")) { seqmode=SEQ_PHYML; } else if(streq(argv[i],"-d")) { if(i+1>=argc || sscanf(argv[i+1],"%d",&debugmode) != 1) byebye(); i+=1; } else byebye(); } /* random seed */ smrand(seed); /* reading parameters */ if(fname_pa!=NULL) { fp=openfp(fname_pa,fext_pa,"r",&cbuf); printf("\n# reading %s",cbuf); kk=0; rr=fread_vec(fp,&kk); bb=fread_ivec(fp,&kk); fclose(fp); FREE(cbuf); } else { if(sw_fastrep) {kk=kk00; rr=rr00; bb=bb00;} else {kk=kk0; rr=rr0; bb=bb0;} } for(i=0;i<kk;i++) bb[i] *= bbfact; printf("\n# seed:%lu (MT19937 generator)",seed); printf("\n# K:%d",kk); printf("\n# R:"); for(i=0;i<kk;i++) printf("%g ",rr[i]); printf("\n# B:"); for(i=0;i<kk;i++) printf("%d ",bb[i]); if(sw_multi) { if(fname_mt) fp=openfp(fname_mt,fext_svt,"r",&cbuf); else fp=STDIN; mf=0; infiles=fread_svec(fp,&mf); if(fname_mt) {fclose(fp); FREE(cbuf);} if(fname_rmt) { fp=openfp(fname_rmt,fext_svt,"r",&cbuf); outfiles=fread_svec(fp,&mf); fclose(fp); FREE(cbuf); } else { outfiles=NEW_A(mf,char*); for(i=0;i<mf;i++) outfiles[i]=rmvaxt(infiles[i]); } for(i=0;i<mf;i++) { printf("\n# %d/%d %s %s",i+1,mf,infiles[i],outfiles[i]); genrmt(infiles[i],outfiles[i]); } } else { if(fname_mt && !fname_rmt) fname_rmt=rmvaxt(fname_mt);