//----------------------------------------------------------------------------------------------------- void K3NGdisplay::print(char * print_string){ print_attribute(print_string, 0); }
void print_classfile(classfile* c, FILE* out){ fprintf(out, "Magic: %x\n", c->magic); fprintf(out, "Minor: %x\n", c->minor_version); fprintf(out, "Major: %x\n", c->major_version); fprintf(out, "Constant Pool Count: %d\n", c->constant_pool_count); for(int i = 0; i < c->constant_pool_count-1; i++){ fprintf(out, "\t%d\t", i + 1); print_constant(c->constant_pool[i], out); fprintf(out, "\n"); } fprintf(out, "Access Flags: %x\n", c->access_flags); fprintf(out, "This class index: %x\n", c->this_class); fprintf(out, "Super class index: %x\n", c->super_class); fprintf(out, "Interface count: %x\n", c->interfaces_count); fprintf(out, "Fields count: %x\n", c->fields_count); for(int i = 0; i < c->fields_count; i++){ print_field(c, c->fields[i], out); } fprintf(out, "Methods count: %x\n", c->methods_count); for(int i = 0; i < c->methods_count; i++){ print_method(c, c->methods[i], out); } fprintf(out, "Attributes count: %x\n", c->attributes_count); for(int i = 0; i < c->attributes_count; i++){ print_attribute(c, c->attributes[i], out); } }
void print_field(classfile* cf, field_info* f, FILE* out){ fprintf(out, "\tField Flags: %x\n", f->access_flags); fprintf(out, "\tField Name: %d <<%s>>\n", f->name_index, get_constant_name(cf, f->name_index)); fprintf(out, "\tField Descriptor: %d\n", f->descriptor_index); fprintf(out, "\tAttribute Count: %d\n", f->attributes_count); for(int i = 0; i < f->attributes_count; i++){ print_attribute(cf, f->attributes[i], out); } }
void print_method(classfile* cf, method_info* m, FILE* out){ fprintf(out, "\tMethod Flags: %x\n", m->access_flags); fprintf(out, "\tMethod Name: %d <<%s>>\n", m->name_index, get_constant_name(cf, m->name_index)); fprintf(out, "\tMethod Descriptor: %d <<%s>>\n", m->descriptor_index, get_constant_name(cf, m->descriptor_index)); fprintf(out, "\tMethod Attribute Count: %d\n", m->attributes_count); for(int i = 0; i < m->attributes_count; i++){ print_attribute(cf, m->attributes[i], out); } }
static void print_type_attr(type *r) { enum attribute_type i; for(i = 0; i < attr_LAST; i++){ attribute *da; if((da = type_attr_present(r, i))) print_attribute(da); } }
//----------------------------------------------------------------------------------------------------- void K3NGdisplay::println(char * print_string){ char workstring[WORK_STRING_SIZE] = ""; strcpy(workstring,print_string); if (strlen(workstring) < (WORK_STRING_SIZE-2)){ strcat(workstring,"\n"); } print_attribute(workstring, 0); }
/* Print all the items of the list */ void print_list_attribute(list_attribute_type *list, FILE *file) { list_attribute_pointer aux; /* If the first item is not found, it prints that the list is EMPTY */ if (!get_first_in_list_attribute(list, &aux)) { fprintf(file, "Attribute List is Empty!!!"); return; } /* Prints the First Object of the List*/ print_attribute(aux->item, file); while (!is_last_attribute(aux, list)) { go_next_attribute(list, &aux); print_attribute(aux->item, file); } }
int print_data( pwr_sAttrRef *arp, FILE *fp) { int sts; char *s; pwr_tClassId classid; char *object_p; pwr_tAName dataname; pwr_tAName objectname; pwr_tAName attributename; pwr_tObjid objid; int object_backup; int array_element = 0; int index; int nr; sts = gdh_AttrrefToName( arp, dataname, sizeof(dataname), cdh_mNName); if ( EVEN(sts)) return sts; strcpy( objectname, dataname); if ( (s = strchr( objectname, '.'))) { *s = 0; object_backup = 0; strcpy( attributename, dataname); if ( (s = strchr( dataname, '['))) { array_element = 1; nr = sscanf( s+1, "%d", &index); if ( nr != 1) return 0; } } else { object_backup = 1; } sts = gdh_NameToObjid( objectname, &objid); if ( EVEN(sts)) return sts; sts = gdh_ObjidToPointer( objid, (void **)&object_p); if ( EVEN(sts)) return sts; sts = gdh_GetObjectClass( objid, &classid); if ( EVEN(sts)) return sts; if ( object_backup) { print_object( objid, classid, object_p, 0, objectname, fp); } else { print_attribute( objid, classid, object_p, attributename, array_element, index, fp); } return 1; }
void print_decl(decl *d, enum pdeclargs mode) { if(mode & PDECL_INDENT) idt_print(); if(d->store) fprintf(cc1_out, "%s ", decl_store_to_str(d->store)); if(fopt_mode & FOPT_ENGLISH){ print_decl_eng(d); }else{ print_type(d->ref, d); } if(mode & PDECL_SYM_OFFSET){ if(d->sym){ const int off = d->sym->type == sym_arg ? d->sym->loc.arg_offset : (int)d->sym->loc.stack_pos; fprintf(cc1_out, " (sym %s, pos = %d)", sym_to_str(d->sym->type), off); }else{ fprintf(cc1_out, " (no sym)"); } } if(mode & PDECL_SIZE && !type_is(d->ref, type_func)){ if(type_is_complete(d->ref)){ const unsigned sz = decl_size(d); const unsigned align = decl_align(d); fprintf(cc1_out, " size %u, align %u", sz, align); }else{ fprintf(cc1_out, " incomplete decl"); } } if(mode & PDECL_NEWLINE) fputc('\n', cc1_out); if(!type_is(d->ref, type_func) && d->bits.var.init.dinit && mode & PDECL_PINIT) { gen_str_indent++; print_decl_init(d->bits.var.init.dinit); gen_str_indent--; } if(mode & PDECL_ATTR){ gen_str_indent++; if(!type_is(d->ref, type_func) && d->bits.var.align) idt_printf("[align={as_int=%d, resolved=%d}]\n", d->bits.var.align->as_int, d->bits.var.align->resolved); print_attribute(d->attr); print_type_attr(d->ref); gen_str_indent--; } if((mode & PDECL_FUNC_DESCEND) && DECL_HAS_FUNC_CODE(d)){ decl **iter; gen_str_indent++; for(iter = d->bits.func.code->symtab->decls; iter && *iter; iter++){ sym *s = (*iter)->sym; if(s) idt_printf("offset of %s = %d\n", (*iter)->spel, s->loc.stack_pos); } idt_printf("function stack space %d\n", d->bits.func.code->symtab->auto_total_size); print_stmt(d->bits.func.code); gen_str_indent--; } }
int main (int argc, char ** argv) { char * filename; int rc = 0; struct dump_struct dump; if (argc < 2 || argc > 4) { fprintf (stderr, "usage: %s [-d [var]|--dump [var]] <filename>\n" ,argv [0] ); return -1; } if (argv [1][0] && argv [1][0] == '-') { if ( !strcmp (argv [1], "-d") || !strcmp (argv [1], "--dump") ) { dump.do_dump = 1; if (argc > 3) { dump.dump_var = argv [2]; filename = argv [3]; printf("%s %s\n",dump.dump_var,filename); } else { dump.dump_var = 0; filename = argv [2]; printf("ALLVARS %s\n",filename); } } else { fprintf (stderr, "usage: %s [-d [var]|--dump [var]] <filename>\n" ,argv [0] ); return -1; } } else { filename = argv [1]; dump.do_dump = 0; dump.dump_var = 0; } have_subfiles = 0; struct adios_bp_buffer_struct_v1 * b = 0; uint32_t version = 0; b = malloc (sizeof (struct adios_bp_buffer_struct_v1)); adios_buffer_struct_init (b); rc = adios_posix_open_read_internal (filename, "", b); if (!rc) { fprintf (stderr, "bpdump: file not found: %s\n", filename); return -1; } adios_posix_read_version (b); adios_parse_version (b, &version); version = version & ADIOS_VERSION_NUM_MASK; printf ("BP format version: %d\n", version); if (version < 2) { fprintf (stderr, "bpdump: This version of bpdump can only dump BP format version 2. " "Use an older bpdump from adios 1.6 to dump this file.\n"); adios_posix_close_internal (b); return -1; } struct adios_index_process_group_struct_v1 * pg_root = 0; struct adios_index_process_group_struct_v1 * pg = 0; struct adios_index_var_struct_v1 * vars_root = 0; struct adios_index_attribute_struct_v1 * attrs_root = 0; printf (DIVIDER); printf ("Process Groups Index:\n"); adios_posix_read_index_offsets (b); adios_parse_index_offsets_v1 (b); /* printf ("End of process groups = %" PRIu64 "\n", b->end_of_pgs); printf ("Process Groups Index Offset = %" PRIu64 "\n", b->pg_index_offset); printf ("Process Groups Index Size = %" PRIu64 "\n", b->pg_size); printf ("Variable Index Offset = %" PRIu64 "\n", b->vars_index_offset); printf ("Variable Index Size = %" PRIu64 "\n", b->vars_size); printf ("Attribute Index Offset = %" PRIu64 "\n", b->attrs_index_offset); printf ("Attribute Index Size = %" PRIu64 "\n", b->attrs_size); */ adios_posix_read_process_group_index (b); adios_parse_process_group_index_v1 (b, &pg_root, NULL); print_process_group_index (pg_root); printf (DIVIDER); printf ("Vars Index:\n"); adios_posix_read_vars_index (b); adios_parse_vars_index_v1 (b, &vars_root, NULL, NULL); print_vars_index (vars_root); printf (DIVIDER); printf ("Attributes Index:\n"); adios_posix_read_attributes_index (b); adios_parse_attributes_index_v1 (b, &attrs_root); print_attributes_index (attrs_root); if (version & ADIOS_VERSION_HAVE_SUBFILE) { printf (DIVIDER); return 0; } uint64_t pg_num = 0; pg = pg_root; while (pg) { pg_num++; /* Avoid processing PG's whose offset is beyond the start of index (they are actually in subfiles) */ /* Note: only variables have subfile index, PG's don't so we need to be this indirect in the test */ if (pg->offset_in_file >= b->pg_index_offset) { printf ("Process Group %" PRIu64 " offset is beyond the footer.", pg_num); if (have_subfiles) { printf (" It is probably in a subfile but bpdump does not process subfiles.\n"); } else { printf (" Since there are no subfiles, this probably means the BP file is corrupt.\n" "offset=%" PRIu64 " footer starts at %" PRIu64 "\n", pg->offset_in_file, b->pg_index_offset); } pg = pg->next; continue; } int var_dims_count = 0; struct var_dim * var_dims = 0; printf (DIVIDER); struct adios_process_group_header_struct_v1 pg_header; struct adios_vars_header_struct_v1 vars_header; struct adios_attributes_header_struct_v1 attrs_header; struct adios_var_header_struct_v1 var_header; struct adios_var_payload_struct_v1 var_payload; struct adios_attribute_struct_v1 attribute; // setup where to read the process group from (and size) b->read_pg_offset = pg->offset_in_file; if (pg->next) { b->read_pg_size = pg->next->offset_in_file - pg->offset_in_file; } else { b->read_pg_size = b->pg_index_offset - pg->offset_in_file; } adios_posix_read_process_group (b); adios_parse_process_group_header_v1 (b, &pg_header); print_process_group_header (pg_num, &pg_header); //printf ("\tSize of group in fil: %" PRIu64 " bytes\n", b->read_pg_size); adios_parse_vars_header_v1 (b, &vars_header); print_vars_header (&vars_header); dump.host_language_fortran = pg_header.host_language_fortran; int i; for (i = 0; i < vars_header.count; i++) { var_payload.payload = 0; adios_parse_var_data_header_v1 (b, &var_header); print_var_header (&var_header); if ( var_header.dims == 0 || ( dump.do_dump && dump.dump_var && !strcasecmp (dump.dump_var, var_header.name) ) ) { // add one for string null terminators var_payload.payload = malloc (var_header.payload_size + 1); adios_parse_var_data_payload_v1 (b, &var_header, &var_payload ,var_header.payload_size ); } else { adios_parse_var_data_payload_v1 (b, &var_header, NULL, 0); } if (var_header.is_dim == adios_flag_yes) { var_dims = realloc (var_dims, (var_dims_count + 1) * sizeof (struct var_dim) ); var_dims [var_dims_count].id = var_header.id; var_dims [var_dims_count].rank = *(unsigned int *) var_payload.payload; var_dims_count++; } if (dump.do_dump) { // make sure the buffer is big enough or send in null print_var_payload (&var_header, &var_payload, &dump ,var_dims_count, var_dims ); } if (var_payload.payload) { free (var_payload.payload); var_payload.payload = 0; } printf ("\n"); } adios_parse_attributes_header_v1 (b, &attrs_header); print_attrs_header (&attrs_header); for (i = 0; i < attrs_header.count; i++) { adios_parse_attribute_v1 (b, &attribute); print_attribute (&attribute); printf ("\n"); } var_dims_count = 0; if (var_dims) free (var_dims); pg = pg->next; } printf (DIVIDER); printf ("End of %s\n", filename); adios_posix_close_internal (b); return 0; }
int main(int argc, char *argv[]) { int i; #ifdef COMPILE_WITH_GUI bool gui = false; #endif #ifdef COMPILE_WITH_MULTI_CORE I32 cores = 1; #endif bool diff = false; bool verbose = false; CHAR separator_sign = ' '; CHAR* separator = "space"; bool opts = false; bool optx = false; CHAR header_comment_sign = '\0'; CHAR* parse_string = 0; CHAR* extra_string = 0; CHAR printstring[512]; double start_time = 0.0; LASreadOpener lasreadopener; LASwriteOpener laswriteopener; laswriteopener.set_format("txt"); if (argc == 1) { #ifdef COMPILE_WITH_GUI return las2txt_gui(argc, argv, 0); #else fprintf(stderr,"las2txt.exe is better run in the command line or via the lastool.exe GUI\n"); CHAR file_name[256]; fprintf(stderr,"enter input file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; lasreadopener.set_file_name(file_name); fprintf(stderr,"enter output file: "); fgets(file_name, 256, stdin); file_name[strlen(file_name)-1] = '\0'; laswriteopener.set_file_name(file_name); #endif } else { for (i = 1; i < argc; i++) { if (argv[i][0] == '–') argv[i][0] = '-'; if (strcmp(argv[i],"-opts") == 0) { opts = TRUE; *argv[i]='\0'; } else if (strcmp(argv[i],"-optx") == 0) { optx = TRUE; *argv[i]='\0'; } } if (!lasreadopener.parse(argc, argv)) byebye(true); if (!laswriteopener.parse(argc, argv)) byebye(true); } for (i = 1; i < argc; i++) { if (argv[i][0] == '\0') { continue; } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"-help") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); usage(); } else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"-verbose") == 0) { verbose = true; } else if (strcmp(argv[i],"-version") == 0) { fprintf(stderr, "LAStools (by [email protected]) version %d\n", LAS_TOOLS_VERSION); byebye(); } else if (strcmp(argv[i],"-gui") == 0) { #ifdef COMPILE_WITH_GUI gui = true; #else fprintf(stderr, "WARNING: not compiled with GUI support. ignoring '-gui' ...\n"); #endif } else if (strcmp(argv[i],"-cores") == 0) { #ifdef COMPILE_WITH_MULTI_CORE if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: number\n", argv[i]); usage(true); } argv[i][0] = '\0'; i++; cores = atoi(argv[i]); argv[i][0] = '\0'; #else fprintf(stderr, "WARNING: not compiled with multi-core batching. ignoring '-cores' ...\n"); i++; #endif } else if (strcmp(argv[i],"-parse") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: string\n", argv[i]); usage(true); } i++; if (parse_string) free(parse_string); parse_string = strdup(argv[i]); } else if (strcmp(argv[i],"-parse_all") == 0) { if (parse_string) free(parse_string); parse_string = strdup("txyzirndecaup"); } else if (strcmp(argv[i],"-extra") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: string\n", argv[i]); usage(true); } i++; extra_string = argv[i]; } else if (strcmp(argv[i],"-sep") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: separator\n", argv[i]); usage(true); } i++; separator = argv[i]; if (strcmp(separator,"comma") == 0 || strcmp(separator,"komma") == 0) { separator_sign = ','; } else if (strcmp(separator,"tab") == 0) { separator_sign = '\t'; } else if (strcmp(separator,"dot") == 0 || strcmp(separator,"period") == 0) { separator_sign = '.'; } else if (strcmp(separator,"colon") == 0) { separator_sign = ':'; } else if (strcmp(separator,"semicolon") == 0) { separator_sign = ';'; } else if (strcmp(separator,"hyphen") == 0 || strcmp(separator,"minus") == 0) { separator_sign = '-'; } else if (strcmp(separator,"space") == 0) { separator_sign = ' '; } else { fprintf(stderr, "ERROR: unknown seperator '%s'\n",separator); usage(true); } } else if (strcmp(argv[i],"-header") == 0) { if ((i+1) >= argc) { fprintf(stderr,"ERROR: '%s' needs 1 argument: comment\n", argv[i]); usage(true); } i++; if (strcmp(argv[i],"comma") == 0 || strcmp(argv[i],"komma") == 0) { header_comment_sign = ','; } else if (strcmp(argv[i],"colon") == 0) { header_comment_sign = ':'; } else if (strcmp(argv[i],"scolon") == 0 || strcmp(argv[i],"semicolon") == 0) { header_comment_sign = ';'; } else if (strcmp(argv[i],"pound") == 0 || strcmp(argv[i],"hash") == 0) { header_comment_sign = '#'; } else if (strcmp(argv[i],"percent") == 0) { header_comment_sign = '%'; } else if (strcmp(argv[i],"dollar") == 0) { header_comment_sign = '$'; } else if (strcmp(argv[i],"star") == 0) { header_comment_sign = '*'; } else { fprintf(stderr, "ERROR: unknown header comment symbol '%s'\n",argv[i]); usage(true); } } else if ((argv[i][0] != '-') && (lasreadopener.get_file_name_number() == 0)) { lasreadopener.add_file_name(argv[i]); argv[i][0] = '\0'; } else { fprintf(stderr, "ERROR: cannot understand argument '%s'\n", argv[i]); usage(true); } } #ifdef COMPILE_WITH_GUI if (gui) { return las2txt_gui(argc, argv, &lasreadopener); } #endif #ifdef COMPILE_WITH_MULTI_CORE if ((cores > 1) && (lasreadopener.get_file_name_number() > 1) && (!lasreadopener.is_merged())) { return las2txt_multi_core(argc, argv, &lasreadopener, &laswriteopener, cores); } #endif // check input if (!lasreadopener.active()) { fprintf(stderr,"ERROR: no input specified\n"); byebye(true, argc == 1); } // possibly loop over multiple input files while (lasreadopener.active()) { if (verbose) start_time = taketime(); // open lasreader LASreader* lasreader = lasreadopener.open(); if (lasreader == 0) { fprintf(stderr, "ERROR: could not open lasreader\n"); byebye(true, argc==1); } // (maybe) open laswaveform13reader LASwaveform13reader* laswaveform13reader = lasreadopener.open_waveform13(&lasreader->header); // get a pointer to the header LASheader* header = &(lasreader->header); // open output file FILE* file_out; if (laswriteopener.is_piped()) { file_out = stdout; } else { // create output file name if needed if (laswriteopener.get_file_name() == 0) { if (lasreadopener.get_file_name() == 0) { fprintf(stderr, "ERROR: no output file specified\n"); byebye(true, argc==1); } laswriteopener.make_file_name(lasreadopener.get_file_name(), -2); } const CHAR* file_name_out = laswriteopener.get_file_name(); // open output file file_out = fopen(file_name_out, "w"); // fail if output file does not open if (file_out == 0) { fprintf(stderr, "ERROR: could not open '%s' for write\n", file_name_out); byebye(true, argc==1); } laswriteopener.set_file_name(0); } // maybe PTS or PTX format if (opts) { // look for VRL with PTS or PTX info const LASvlr* ptsVLR = 0; const LASvlr* ptxVLR = 0; if ((ptsVLR = header->get_vlr("LAStools", 2000)) || (ptxVLR = header->get_vlr("LAStools", 2001))) { if ((parse_string == 0) || (strcmp(parse_string, "original") == 0)) { if (parse_string) free(parse_string); if (ptsVLR && (ptsVLR->record_length_after_header >= 32)) { parse_string = strdup((CHAR*)(ptsVLR->data + 16)); } else if (ptxVLR && (ptxVLR->record_length_after_header >= 32)) { parse_string = strdup((CHAR*)(ptxVLR->data + 16)); } else if (ptsVLR) { fprintf(stderr, "WARNING: found VLR for PTS with wrong payload size of %d.\n", ptsVLR->record_length_after_header); } else if (ptxVLR) { fprintf(stderr, "WARNING: found VLR for PTX with wrong payload size of %d.\n", ptxVLR->record_length_after_header); } } } else { fprintf(stderr, "WARNING: found no VLR with PTS or PTX info.\n"); } if (header->version_minor >= 4) { #ifdef _WIN32 fprintf(file_out, "%I64d \012", header->extended_number_of_point_records); #else fprintf(file_out, "%lld \012", header->extended_number_of_point_records); #endif } else { fprintf(file_out, "%u \012", header->number_of_point_records); } if (parse_string && strcmp(parse_string, "xyz") && strcmp(parse_string, "xyzi") && strcmp(parse_string, "xyziRGB") && strcmp(parse_string, "xyzRGB")) { fprintf(stderr, "WARNING: the parse string for PTS should be 'xyz', 'xyzi', 'xyziRGB', or 'xyzRGB'\n"); } if (separator_sign != ' ') { fprintf(stderr, "WARNING: the separator for PTS should be 'space' not '%s'\n", separator); } } else if (optx) { // look for VRL with PTX info const LASvlr* ptxVLR = header->get_vlr("LAStools", 2001); if (ptxVLR && (ptxVLR->record_length_after_header == 272)) { U8* payload = ptxVLR->data; if ((parse_string == 0) || (strcmp(parse_string, "original") == 0)) { if (parse_string) free(parse_string); parse_string = strdup((CHAR*)(payload + 16)); } fprintf(file_out, "%u \012", (U32)((I64*)payload)[4]); // ncols fprintf(file_out, "%u \012", (U32)((I64*)payload)[5]); // nrows fprintf(file_out, "%g %g %g\012", ((F64*)payload)[6], ((F64*)payload)[7], ((F64*)payload)[8]); // translation fprintf(file_out, "%g %g %g\012", ((F64*)payload)[9], ((F64*)payload)[10], ((F64*)payload)[11]); // rotation_row_0 fprintf(file_out, "%g %g %g\012", ((F64*)payload)[12], ((F64*)payload)[13], ((F64*)payload)[14]); // rotation_row_1 fprintf(file_out, "%g %g %g\012", ((F64*)payload)[15], ((F64*)payload)[16], ((F64*)payload)[17]); // rotation_row_2 fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[18], ((F64*)payload)[19], ((F64*)payload)[20], ((F64*)payload)[21]); // transformation_row_0 fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[22], ((F64*)payload)[23], ((F64*)payload)[24], ((F64*)payload)[25]); // transformation_row_0 fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[26], ((F64*)payload)[27], ((F64*)payload)[28], ((F64*)payload)[29]); // transformation_row_0 fprintf(file_out, "%g %g %g %g\012", ((F64*)payload)[30], ((F64*)payload)[31], ((F64*)payload)[32], ((F64*)payload)[33]); // transformation_row_0 } else { if (ptxVLR) { fprintf(stderr, "WARNING: found VLR for PTX with wrong payload size of %d.\n", ptxVLR->record_length_after_header); } else { fprintf(stderr, "WARNING: found no VLR with PTX info.\n"); } fprintf(stderr, " outputting PTS instead ...\n"); if (header->version_minor >= 4) { #ifdef _WIN32 fprintf(file_out, "%I64d \012", header->extended_number_of_point_records); #else fprintf(file_out, "%lld \012", header->extended_number_of_point_records); #endif } else { fprintf(file_out, "%u \012", header->number_of_point_records); } } if (parse_string && strcmp(parse_string, "xyz") && strcmp(parse_string, "xyzi") && strcmp(parse_string, "xyziRGB") && strcmp(parse_string, "xyzRGB")) { fprintf(stderr, "WARNING: the parse string for PTX should be 'xyz', 'xyzi', 'xyziRGB', or 'xyzRGB'\n"); } if (separator_sign != ' ') { fprintf(stderr, "WARNING: the separator for PTX should be 'space' not '%s'\n", separator); } } else if (header_comment_sign) { // output header info fprintf(file_out, "%c file signature: '%.4s'\012", header_comment_sign, header->file_signature); fprintf(file_out, "%c file source ID: %d\012", header_comment_sign, header->file_source_ID); fprintf(file_out, "%c reserved (global encoding):%d\012", header_comment_sign, header->global_encoding); fprintf(file_out, "%c project ID GUID data 1-4: %d %d %d '%.8s'\012", header_comment_sign, header->project_ID_GUID_data_1, header->project_ID_GUID_data_2, header->project_ID_GUID_data_3, header->project_ID_GUID_data_4); fprintf(file_out, "%c version major.minor: %d.%d\012", header_comment_sign, header->version_major, header->version_minor); fprintf(file_out, "%c system_identifier: '%.32s'\012", header_comment_sign, header->system_identifier); fprintf(file_out, "%c generating_software: '%.32s'\012", header_comment_sign, header->generating_software); fprintf(file_out, "%c file creation day/year: %d/%d\012", header_comment_sign, header->file_creation_day, header->file_creation_year); fprintf(file_out, "%c header size %d\012", header_comment_sign, header->header_size); fprintf(file_out, "%c offset to point data %u\012", header_comment_sign, header->offset_to_point_data); fprintf(file_out, "%c number var. length records %u\012", header_comment_sign, header->number_of_variable_length_records); fprintf(file_out, "%c point data format %d\012", header_comment_sign, header->point_data_format); fprintf(file_out, "%c point data record length %d\012", header_comment_sign, header->point_data_record_length); fprintf(file_out, "%c number of point records %u\012", header_comment_sign, header->number_of_point_records); fprintf(file_out, "%c number of points by return %u %u %u %u %u\012", header_comment_sign, header->number_of_points_by_return[0], header->number_of_points_by_return[1], header->number_of_points_by_return[2], header->number_of_points_by_return[3], header->number_of_points_by_return[4]); fprintf(file_out, "%c scale factor x y z %g %g %g\012", header_comment_sign, header->x_scale_factor, header->y_scale_factor, header->z_scale_factor); fprintf(file_out, "%c offset x y z ", header_comment_sign); lidardouble2string(printstring, header->x_offset); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->y_offset); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->z_offset); fprintf(file_out, "%s\012", printstring); fprintf(file_out, "%c min x y z ", header_comment_sign); lidardouble2string(printstring, header->min_x, header->x_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->min_y, header->y_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->min_z, header->z_scale_factor); fprintf(file_out, "%s\012", printstring); fprintf(file_out, "%c max x y z ", header_comment_sign); lidardouble2string(printstring, header->max_x, header->x_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->max_y, header->y_scale_factor); fprintf(file_out, "%s ", printstring); lidardouble2string(printstring, header->max_z, header->z_scale_factor); fprintf(file_out, "%s\012", printstring); } // maybe create default parse string if (parse_string == 0) parse_string = strdup("xyz"); // check requested fields and print warnings of necessary i = 0; while (parse_string[i]) { switch (parse_string[i]) { case 'x': // the x coordinate case 'y': // the y coordinate case 'z': // the z coordinate case 'X': // the unscaled raw integer X coordinate case 'Y': // the unscaled raw integer Y coordinate case 'Z': // the unscaled raw integer Z coordinate case 'i': // the intensity case 'a': // the scan angle case 'r': // the number of the return case 'c': // the classification case 'u': // the user data case 'n': // the number of returns of given pulse case 'p': // the point source ID case 'e': // the edge of flight line flag case 'd': // the direction of scan flag case 'm': // the index of the point (count starts at 0) case 'M': // the index of the point (count starts at 0) break; case 't': // the gps-time if (lasreader->point.have_gps_time == false) fprintf (stderr, "WARNING: requested 't' but points do not have gps time\n"); break; case 'R': // the red channel of the RGB field if (lasreader->point.have_rgb == false) fprintf (stderr, "WARNING: requested 'R' but points do not have rgb\n"); break; case 'G': // the green channel of the RGB field if (lasreader->point.have_rgb == false) fprintf (stderr, "WARNING: requested 'G' but points do not have rgb\n"); break; case 'B': // the blue channel of the RGB field if (lasreader->point.have_rgb == false) fprintf (stderr, "WARNING: requested 'B' but points do not have rgb\n"); break; case 'w': // the wavepacket index if (lasreader->point.have_wavepacket == false) fprintf (stderr, "WARNING: requested 'w' but points do not have wavepacket\n"); break; case 'W': // all wavepacket attributes if (lasreader->point.have_wavepacket == false) fprintf (stderr, "WARNING: requested 'W' but points do not have wavepacket\n"); break; case 'V': // the waveform data if (laswaveform13reader == 0) { fprintf (stderr, "WARNING: requested 'V' but no waveform data available\n"); fprintf (stderr, " omitting ...\n"); } break; case ')': case '!': case '@': case '#': case '$': case '%': case '^': case '&': case '*': case '(': diff = true; break; case 'E': if (extra_string == 0) { fprintf (stderr, "WARNING: requested 'E' but no '-extra' specified\n"); parse_string[i] = 's'; } break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if ((parse_string[i] - '0') >= lasreader->header.number_attributes) { fprintf(stderr, "WARNING: attribute '%d' does not exist.\n", (parse_string[i] - '0')); parse_string[i] = 's'; } else { attribute_starts[(parse_string[i] - '0')] = lasreader->header.get_attribute_start((parse_string[i] - '0')); } break; default: fprintf (stderr, "WARNING: requested unknown parse item '%c'\n", parse_string[i]); } i++; } // in case diff is requested int last_XYZ[3] = {0,0,0}; unsigned short last_RGB[4] = {0,0,0}; double last_GPSTIME = 0; // read and convert the points to ASCII #ifdef _WIN32 if (verbose) fprintf(stderr,"processing %I64d points with '%s'.\n", lasreader->npoints, parse_string); #else if (verbose) fprintf(stderr,"processing %lld points with '%s'.\n", lasreader->npoints, parse_string); #endif while (lasreader->read_point()) { i = 0; while (true) { switch (parse_string[i]) { case 'x': // the x coordinate lidardouble2string(printstring, lasreader->point.get_x(), lasreader->header.x_scale_factor); fprintf(file_out, "%s", printstring); break; case 'y': // the y coordinate lidardouble2string(printstring, lasreader->point.get_y(), lasreader->header.y_scale_factor); fprintf(file_out, "%s", printstring); break; case 'z': // the z coordinate lidardouble2string(printstring, lasreader->point.get_z(), lasreader->header.z_scale_factor); fprintf(file_out, "%s", printstring); break; case 'X': // the unscaled raw integer X coordinate fprintf(file_out, "%d", lasreader->point.get_X()); break; case 'Y': // the unscaled raw integer Y coordinate fprintf(file_out, "%d", lasreader->point.get_Y()); break; case 'Z': // the unscaled raw integer Z coordinate fprintf(file_out, "%d", lasreader->point.get_Z()); break; case 't': // the gps-time fprintf(file_out, "%.6f", lasreader->point.get_gps_time()); break; case 'i': // the intensity if (opts) fprintf(file_out, "%d", -2048 + lasreader->point.get_intensity()); else if (optx) { int len; len = sprintf(printstring, "%.3f", 1.0f/4095.0f * lasreader->point.get_intensity()) - 1; while (printstring[len] == '0') len--; if (printstring[len] != '.') len++; printstring[len] = '\0'; fprintf(file_out, "%s", printstring); } else fprintf(file_out, "%d", lasreader->point.get_intensity()); break; case 'a': // the scan angle fprintf(file_out, "%d", lasreader->point.get_scan_angle_rank()); break; case 'r': // the number of the return fprintf(file_out, "%d", lasreader->point.get_return_number()); break; case 'c': // the classification fprintf(file_out, "%d", lasreader->point.get_classification()); break; case 'u': // the user data fprintf(file_out, "%d", lasreader->point.get_user_data()); break; case 'n': // the number of returns of given pulse fprintf(file_out, "%d", lasreader->point.get_number_of_returns()); break; case 'p': // the point source ID fprintf(file_out, "%d", lasreader->point.get_point_source_ID()); break; case 'e': // the edge of flight line flag fprintf(file_out, "%d", lasreader->point.get_edge_of_flight_line()); break; case 'd': // the direction of scan flag fprintf(file_out, "%d", lasreader->point.get_scan_direction_flag()); break; case 'R': // the red channel of the RGB field fprintf(file_out, "%d", lasreader->point.rgb[0]); break; case 'G': // the green channel of the RGB field fprintf(file_out, "%d", lasreader->point.rgb[1]); break; case 'B': // the blue channel of the RGB field fprintf(file_out, "%d", lasreader->point.rgb[2]); break; case 'm': // the index of the point (count starts at 0) #ifdef _WIN32 fprintf(file_out, "%I64d", lasreader->p_count-1); #else fprintf(file_out, "%lld", lasreader->p_count-1); #endif break; case 'M': // the index of the point (count starts at 1) #ifdef _WIN32 fprintf(file_out, "%I64d", lasreader->p_count); #else fprintf(file_out, "%lld", lasreader->p_count); #endif break; case ')': // the raw integer X difference to the last point fprintf(file_out, "%d", lasreader->point.get_X()-last_XYZ[0]); break; case '!': // the raw integer Y difference to the last point fprintf(file_out, "%d", lasreader->point.get_Y()-last_XYZ[1]); break; case '@': // the raw integer Z difference to the last point fprintf(file_out, "%d", lasreader->point.get_Z()-last_XYZ[2]); break; case '#': // the gps-time difference to the last point lidardouble2string(printstring,lasreader->point.gps_time-last_GPSTIME); fprintf(file_out, "%s", printstring); break; case '$': // the R difference to the last point fprintf(file_out, "%d", lasreader->point.rgb[0]-last_RGB[0]); break; case '%': // the G difference to the last point fprintf(file_out, "%d", lasreader->point.rgb[1]-last_RGB[1]); break; case '^': // the B difference to the last point fprintf(file_out, "%d", lasreader->point.rgb[2]-last_RGB[2]); break; case '&': // the byte-wise R difference to the last point fprintf(file_out, "%d%c%d", (lasreader->point.rgb[0]>>8)-(last_RGB[0]>>8), separator_sign, (lasreader->point.rgb[0]&255)-(last_RGB[0]&255)); break; case '*': // the byte-wise G difference to the last point fprintf(file_out, "%d%c%d", (lasreader->point.rgb[1]>>8)-(last_RGB[1]>>8), separator_sign, (lasreader->point.rgb[1]&255)-(last_RGB[1]&255)); break; case '(': // the byte-wise B difference to the last point fprintf(file_out, "%d%c%d", (lasreader->point.rgb[2]>>8)-(last_RGB[2]>>8), separator_sign, (lasreader->point.rgb[2]&255)-(last_RGB[2]&255)); break; case 'w': // the wavepacket index fprintf(file_out, "%d", lasreader->point.wavepacket.getIndex()); break; case 'W': // all wavepacket attributes fprintf(file_out, "%d%c%d%c%d%c%g%c%g%c%g%c%g", lasreader->point.wavepacket.getIndex(), separator_sign, (U32)lasreader->point.wavepacket.getOffset(), separator_sign, lasreader->point.wavepacket.getSize(), separator_sign, lasreader->point.wavepacket.getLocation(), separator_sign, lasreader->point.wavepacket.getXt(), separator_sign, lasreader->point.wavepacket.getYt(), separator_sign, lasreader->point.wavepacket.getZt()); break; case 'V': // the waVeform if (laswaveform13reader && laswaveform13reader->read_waveform(&lasreader->point)) { output_waveform(file_out, separator_sign, laswaveform13reader); } else { fprintf(file_out, "no_waveform"); } break; case 'E': // the extra string fprintf(file_out, "%s", extra_string); break; default: print_attribute(file_out, &lasreader->header, &lasreader->point, (I32)(parse_string[i]-'0'), printstring); } i++; if (parse_string[i]) { fprintf(file_out, "%c", separator_sign); } else { fprintf(file_out, "\012"); break; } } if (diff) { last_XYZ[0] = lasreader->point.get_X(); last_XYZ[1] = lasreader->point.get_Y(); last_XYZ[2] = lasreader->point.get_Z(); last_GPSTIME = lasreader->point.gps_time; last_RGB[0] = lasreader->point.rgb[0]; last_RGB[1] = lasreader->point.rgb[1]; last_RGB[2] = lasreader->point.rgb[2]; } } #ifdef _WIN32 if (verbose) fprintf(stderr,"converting %I64d points of '%s' took %g sec.\n", lasreader->p_count, lasreadopener.get_file_name(), taketime()-start_time); #else if (verbose) fprintf(stderr,"converting %lld points of '%s' took %g sec.\n", lasreader->p_count, lasreadopener.get_file_name(), taketime()-start_time); #endif // close the reader lasreader->close(); delete lasreader; // (maybe) close the waveform reader if (laswaveform13reader) { laswaveform13reader->close(); delete laswaveform13reader; } // close the files if (file_out != stdout) fclose(file_out); } free(parse_string); byebye(false, argc==1); return 0; }
//----------------------------------------------------------------------------------------------------- void K3NGdisplay::print_center_entire_row(char * print_string,int y,uint8_t text_attribute){ clear_row(y); print_attribute(print_string,((display_columns/*-1*/)/2)-(length(print_string)/2),y,text_attribute); }
//----------------------------------------------------------------------------------------------------- void K3NGdisplay::print_center(char * print_string,int y,uint8_t text_attribute){ print_attribute(print_string,((display_columns/*-1*/)/2)-(length(print_string)/2),y,text_attribute); }
//----------------------------------------------------------------------------------------------------- void K3NGdisplay::print(char * print_string, int x, int y, uint8_t attribute){ print_attribute(print_string, x, y, attribute); }
//----------------------------------------------------------------------------------------------------- void K3NGdisplay::print(char * print_string, int x, int y){ print_attribute(print_string, x, y, 0); }