int SCOPE replay__newselect(const struct syscall_regs * regs) { int32_t eax = read_int32(); int n; uint32_t inp; uint32_t outp; uint32_t exp; read_obj(n); read_obj(inp); read_obj(outp); read_obj(exp); ASSERT(n == regs->ebx, regs, ""); ASSERT(inp == regs->ecx, regs, ""); ASSERT(outp == regs->edx, regs, ""); ASSERT(exp == regs->esi, regs, ""); int fd_bytes = FDS_BYTES(n); if (inp != 0) read_mem(inp, fd_bytes); if (outp != 0) read_mem(outp, fd_bytes); if (exp != 0) read_mem(exp, fd_bytes); return eax; }
int main (int argc, char const ** argv) { typedef double Scalar; typedef Eigen::Matrix<Scalar, 3, Eigen::Dynamic> Vertices; std::string file_source; std::string file_target; std::string file_source_reg; ///--- Option parsing if(argc==1){ std::cout << "examples: " << std::endl; std::cout << "./sparseicp data/hippo_0.obj data/hippo_1.obj data/hippo_0.obj__REG__hippo_1.obj" << std::endl; // std::cout << "./sparseicp data/bunny.obj data/bunny_cut2.obj data/bunny.obj__REG__bunny_cut2.obj" << std::endl; exit(0); } else if(argc==4) { file_source = argv[1]; file_target = argv[2]; file_source_reg = argv[3]; } else { std::cout << "argument error!" << std::endl; exit(0); } ///--- Model that will be rigidly transformed Vertices vertices_source; read_obj(vertices_source, file_source); std::cout << "source: " << vertices_source.rows() << "x" << vertices_source.cols() << std::endl; ///--- Model that source will be aligned to Vertices vertices_target; read_obj(vertices_target, file_target); std::cout << "target: " << vertices_target.rows() << "x" << vertices_target.cols() << std::endl; ///--- Execute registration auto tic = std::chrono::steady_clock::now(); SICP::Parameters pars; pars.p = .5; pars.max_icp = 15; pars.print_icpn = true; SICP::point_to_point(vertices_source, vertices_target, pars); auto toc = std::chrono::steady_clock::now(); ///--- Write result to file write_obj_replaceverts(file_source, vertices_source, file_source_reg); ///--- Print execution time double time_ms = std::chrono::duration <double, std::milli> (toc-tic).count(); std::cout << "sparseicp registered source to target in: " << time_ms << "ms" << std::endl; return 0; }
int main(int argc, char** argv) { for (int i = 0; i < M.GetLayers(); i++) { M.Show(i); printf("\n"); } current_elevator_i = M.getElevatorI(); current_elevator_j = M.getElevatorJ(); fvc = read_obj("flashlight.obj", fv, ftv, fn); initGLUT(&argc, argv); initGLEW(); initOpenGL(); glutKeyboardFunc(Movement); glutWarpPointer(200, 200); glutMotionFunc(MouseActiveMotion); glutPassiveMotionFunc(MouseMotion); glutMouseFunc(MouseButtons); glutMainLoop(); freeVAO(); freeVBO(); cleanShaders(); return 0; }
bool read_mesh(Surface_mesh& mesh, const std::string& filename) { // extract file extension std::string::size_type dot(filename.rfind(".")); if (dot == std::string::npos) return false; std::string ext = filename.substr(dot+1, filename.length()-dot-1); std::transform(ext.begin(), ext.end(), ext.begin(), tolower); // extension determines reader if (ext == "off") { return read_off(mesh, filename); } else if (ext == "obj") { return read_obj(mesh, filename); } else if (ext == "stl") { return read_stl(mesh, filename); } // we didn't find a reader module return false; }
SchObj interact() { SchPort* port; show_prompt(); port = (SchPort*)make_input_port_stream(stdin); return read_obj( port ); }
static COMMAND_FUNC( do_read_obj ) { Data_Obj *dp; FILE *fp; const char *s; dp=PICK_OBJ(""); s=NAMEOF("input file"); if( dp == NO_OBJ ) return; #ifdef QUIP_DEBUG //if( debug ) dptrace(dp); #endif /* QUIP_DEBUG */ // reading is tricker for non-ram, because // we must create the copy, then read into // the copy, then xfer to the device... INSIST_RAM_OBJ(dp,"do_read_obj") if( strcmp(s,"-") && strcmp(s,"stdin") ){ fp=TRY_OPEN( s, "r" ); if( !fp ) return; read_ascii_data(QSP_ARG dp,fp,s,expect_exact_count); } else { /* read from stdin, no problem... */ read_obj(QSP_ARG dp); } }
void output_gettimeofday(int nr) { int32_t ret = read_eax(); if (ret >= 0) { uintptr_t TP, TZP; read_obj(TP); read_obj(TZP); if (TP != 0) skip(sizeof(struct k_timeval)); if (TZP != 0) skip(sizeof(struct k_timezone)); } printf("gettimeofday:\t%d\n", ret); }
/* * Get the contents of an attribute */ static unsigned long get_obj(const char *name) { if (!read_obj(name)) return 0; return atol(buffer); }
int SCOPE replay_ioctl(const struct syscall_regs * regs) { struct syscall_regs saved_regs; read_obj(saved_regs); /* check */ ASSERT(saved_regs.ebx == regs->ebx, regs, ""); ASSERT(saved_regs.ecx == regs->ecx, regs, ""); ASSERT(saved_regs.edx == regs->edx, regs, ""); int fd = regs->ebx; int cmd = regs->ecx; int arg = regs->edx; switch (_IOC_TYPE(cmd)) { case 'T': return replay_tty_ioctl(fd, cmd, arg, regs); case 0x12: return replay_blk_ioctl(fd, cmd, arg, regs); default: INJ_ERROR("no such ioctl command: 0x%x\n", cmd); __exit(-1); } return 0; }
void output_rt_sigprocmask(int nr) { int32_t ret = read_eax(); if (ret == 0) { int sigsetsize; read_obj(sigsetsize); if (sigsetsize == sizeof(k_sigset_t)) { int32_t oset; read_obj(oset); if (oset) skip(sigsetsize); } } printf("rt_sigprocmask:\t%d\n", ret); }
int SCOPE replay_gettimeofday(const struct syscall_regs * regs) { int32_t eax = read_int32(); if (eax >= 0) { uintptr_t TP, TZP; read_obj(TP); read_obj(TZP); ASSERT(TP == regs->ebx, regs, "TP inconsistent\n"); ASSERT(TZP == regs->ecx, regs, "TZP inconsistent\n"); if (TP != 0) read_mem(TP, sizeof(struct k_timeval)); if (TZP != 0) read_mem(TZP, sizeof(struct k_timezone)); } return eax; }
bool read_objlist(SerialIn &in, ObjectList& list, const Config& config) { uint32_t len; in >= len; list.resize(len); for (size_t i = 0; i != len; ++i) { if (!read_obj(in, list[i], config)) return false; } return in.in_; }
void output_time(int nr) { printf("time:\t%d\n", read_eax()); uint32_t ebx; read_obj(ebx); if (ebx != 0) skip(sizeof(time_t)); }
void obj_to_bin(char const *from, char const *to, float scale) { IxRead *rd = IxRead::readFromFile(from); IxWrite *wr = IxWrite::writeToFile(to); ModelWriter *mw = ModelWriter::writeToFile(wr); read_obj(rd, mw, scale, dirname(from)); delete mw; delete rd; }
void output_rt_sigaction(int nr) { int32_t ret = read_eax(); if (ret == 0) { int sigsetsize; uintptr_t act; uintptr_t oact; read_obj(sigsetsize); read_obj(oact); read_obj(act); if (sigsetsize == sizeof(k_sigset_t)) { if (oact != 0) skip(sizeof(struct k_sigaction)); } printf("rt_sigaction(act=0x%x, oact=0x%x):\t%d\n", act, oact, ret); } else { printf("rt_sigaction:\t%d\n", ret); } }
int read_array(DBusMessageIter * args, char *list[30]) { DBusMessageIter subiter; int num_of_dev = 0; int type = dbus_message_iter_get_arg_type(args); if (type == DBUS_TYPE_ARRAY) { dbus_message_iter_recurse(args, &subiter); int sub_type = dbus_message_iter_get_arg_type(&subiter); if (sub_type == DBUS_TYPE_OBJECT_PATH) num_of_dev = read_obj(&subiter, list); } return(num_of_dev); }
void output__newselect(int nr) { int retval; retval = read_eax(); printf("_newselect:\t0x%x\n", retval); int n; uint32_t inp, outp, exp; read_obj(n); read_obj(inp); read_obj(outp); read_obj(exp); int fd_bytes = FDS_BYTES(n); if (inp != 0) skip(fd_bytes); if (outp != 0) skip(fd_bytes); if (exp != 0) skip(fd_bytes); }
int main(int argc, char *argv[]) { MESH *m; switch(argc) { case 2: m = read_obj(argv[1]); gen_normals(m); printf("Verts=%d, Face=%d, Normal=%d\n", m->nv, m->nf, m->nn); break; case 3: m = read_obj(argv[1]); gen_normals(m); gen_vertex_normals(m); mesh_bound(m->v, m->nv); write_file(argv[2], m); break; default: printf("user error.\n"); return 1; } return 0; }
main ( int argc, char *argv[] ) /******************************************************************************/ /* Purpose: MAIN is the main program for OBJ_TO_PLY. Author: Greg Turk */ { int i; int j; int num_major = 20; int num_minor = 20; char *progname; float r_major = 1; float r_minor = 0.5; char *s; progname = argv[0]; while (--argc > 0 && (*++argv)[0]=='-') { for (s = argv[0]+1; *s; s++) switch (*s) { case 'f': flip_vertex_order = 1 - flip_vertex_order; break; #if 0 case 't': texture_coords = 1 - texture_coords; break; #endif default: usage (progname); exit (-1); break; } } read_obj ( ); write_file ( ); return; }
int read_obj( int fd, object *obj_ptr ) { int n, cnt, ret=0; otag *op; otag **prev; object *obj; if ( read_single_obj(fd, obj_ptr ) != 0 ) { return(-1); } /* now look for things contained in it */ n = read(fd, &cnt, sizeof(int)); if(n < sizeof(int)) { /* no more objects to read is not an error */ return(0); } prev = &obj_ptr->first_obj; while(cnt > 0) { cnt--; op = (otag *)malloc(sizeof(otag)); if(op) { obj = (object *)malloc(sizeof(object)); if(obj) { if(read_obj(fd, obj) < 0) { free(obj); ret = -1; break; } obj->parent_obj = obj_ptr; op->obj = obj; op->next_tag = 0; *prev = op; prev = &op->next_tag; } else merror("read_obj", FATAL); } else merror("read_obj", FATAL); } return(ret); }
static unsigned long get_obj_and_str(const char *name, char **x) { unsigned long result = 0; char *p; *x = NULL; if (!read_obj(name)) { x = NULL; return 0; } result = strtoul(buffer, &p, 10); while (*p == ' ') p++; if (*p) *x = strdup(p); return result; }
bool read_poly(PolygonMesh& mesh, const std::string& filename) { std::size_t found = filename.find_last_of('.'); if (found == std::string::npos) { return false; } std::string ext = filename.substr(found + 1); std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower); if (ext == "obj") { return read_obj(mesh, filename); } return false; }
bool read_objset(SerialIn &in, ObjectSet& list, const Config& config) { #if 0 ObjectList lst; if (!read_objlist(in, lst, config)) return false; list.~ObjectSet(); new (&list) ObjectSet(lst.begin(), lst.end()); #else uint32_t len; in >= len; for (size_t i = 0; i != len; ++i) { rptr<Elf> obj; if (!read_obj(in, obj, config)) return false; list.insert(obj); } #endif return in.in_; }
int main(int argc, char *argv[]) { int i,j; char *s; char *progname; int num_major = 20; int num_minor = 20; float r_major = 1; float r_minor = 0.5; progname = argv[0]; if(argc<3){ usage (progname); return 0; } read_obj(argv[1]); write_file(argv[2]); }
int send_create_object(const char *filename) { int i; if ((i = new_object()) >= 0) { struct object *o = get_object(i); struct object_mesh *m = NULL; if (read_obj(filename, o)) { int j, n = vecnum(o->mv); o->count = 1; /* Send the object header. */ send_event(EVENT_CREATE_OBJECT); send_index(n); /* Send the vertices and meshes. */ send_vector(o->vv); for (j = 0; j < n; ++j) { m = (struct object_mesh *) vecget(o->mv, j); send_index (m->brush); send_vector(m->fv); send_vector(m->ev); } /* Encapsulate this object in an entity. */ return send_create_entity(TYPE_OBJECT, i); } } return -1; }
SchObj read_sharp_sequence( SchPort* port ) { unsigned int c = SCH_GETC(port); char *s, *format; char msg[256]; /* TODO hard code */ int size; switch(c) { case 't': s = token(port); if ( STRLEN(s) != 0 ) { format="#t followed by garbage \"%s\""; sprintf(msg,format,s); EXCEPTION(msg); break; } else { return SCH_TRUE; } case 'f': s = token(port); if ( STRLEN(s) != 0 ) { format="#f followed by garbage \"%s\""; sprintf(msg,format,s); EXCEPTION(msg); break; } else { return SCH_FALSE; } case '\\': c = SCH_GETC(port); size = get_char_size(c); if ( size > 1 ) { unsigned int c4 = (unsigned char)c; while ( --size > 0 && (c = SCH_GETC(port)) ) { c4 = ((c4 << 8) | (unsigned char)c); } return make_char(c4); } else { s = token(port); if ( strlen(s) == 0 ) { return make_char(c); } else if (c == 's') { if ( strcmp(s,"pace") == 0 ) { return make_char(' '); } } else if (c == 'n') { if ( strcmp(s,"ewline") == 0 ) { return make_char('\n'); } } else if (c == 't') { if ( strcmp(s,"ab") == 0 ) { return make_char('\t'); } } else if (c == 'f') { if ( strcmp(s,"ormfeed") == 0 ) { return make_char('\f'); } } else if (c == 'r') { if ( strcmp(s,"eturn") == 0 ) { return make_char('\r'); } } else { char msg[256]; char* format="unknown character #\\%c%s"; sprintf(msg,format,c,s); EXCEPTION(msg); } } break; case '(': { SchObj x, vec; size = 0; SchVecLList* lst = make_vec_llist(); while ( (x = read_obj(port)) != SCH_KOKKA ) { vec_push(lst,x); size++; } vec = (SchObj)make_vec_from_list(lst,size); return vec; } case 'b': s = token(port); return read_number(s, 2); case 'o': s = token(port); return read_number(s, 8); case 'd': s = token(port); return read_number(s, 10); case 'x': s = token(port); return read_number(s, 16); default: format = "unknown syntax #%c"; sprintf(msg,format,c); EXCEPTION(msg); } return SCH_UNDEFINE; }
static OBJ parse(FILE *f, HASHTAB t, OBJ *ep){ OBJ d; int shared; d = read_obj(f,ep); if (*ep) return NIL; if (isVal(d)) { return d; } else if (isRefToCell(d)) { WORD lab = getLabel(d); int i; HASHENTRY e; i = lab % HASHSIZE; for (e = t->tab[i]; e; e = e->next) { if (e->label == lab) { /* increment RC of refered cell and return it. */ _incRc(_header(e->obj),1); return e->obj; } } /* Format error. */ copy_some(__ABinFile_AinvalidFormat,1); *ep = __ABinFile_AinvalidFormat; return NIL; } else if ((shared = isSharedCell(d)) || isExclCell(d)) { int sz = getSize(d), fs = getFlags(d), i; intptr_t flds; OBJ * data; OBJ ob; WORD lab; if (shared) { lab = (WORD)read_obj(f,ep); if (*ep) return NIL; if (!isRefToCell(lab)){ copy_some(__ABinFile_AinvalidFormat,1); *ep = __ABinFile_AinvalidFormat; return NIL; } } if (sz % flat_offset_ssize == big_escape_ssize){ flds = (intptr_t)read_obj(f,ep); if (*ep) return NIL; ob = _bigAlloc(flds); _mkHeader(_header(ob),sz,1); ((BCELL)ob)->size = pack_word(flds); data = _bdata(ob); } else { flds = sz % flat_offset_ssize; _alloc(flds,ob); _mkHeader(_header(ob),sz,1); data = _data(ob); } _flags(_header(ob)) = fs; if (shared){ HASHENTRY e; lab = getLabel(lab); e = newEntry(); e->label = lab; e->obj = ob; i = lab % HASHSIZE; e->next = t->tab[i]; t->tab[i] = e; } if (sz >= flat_offset_ssize) { if (fs & (1 << byte_flat_sflag)){ /* read two words and rest as char stream */ /* (UPDATE STRING FORMAT) */ unsigned char * cdata = (unsigned char*)(data+2); int ch, cflds = (flds-2) * sizeof(OBJ); data[0] = read_obj(f,ep); data[1] = read_obj(f,ep); for (i = 0; i < cflds && !*ep; i++) { if ((ch = getc(f)) != EOF){ cdata[i] = ch; } else get_unix_failure(errno,*ep); } } else { /* read contents of unstructured cell. */ for (i = 0; i < flds && !*ep; i++) { data[i] = read_obj(f,ep); } } } else { /* recursivly parse structured cell. */ for (i = 0; i < flds && !*ep; i++) { data[i] = parse(f,t,ep); } } /* process closures */ if (tst_sflag(ob, closure_sflag)){ char msgbuf[128]; char * msg = link_closure(ob); if (msg){ strcpy(msgbuf, (char*) data_denotation(__ABinFile_AlinkErrorPrefix)); strcat(msgbuf, (char*) data_denotation(((CLOSURE)ob)->symbolid)); strcat(msgbuf,"': "); strcat(msgbuf,msg); *ep = declare_failure_answer(msgbuf); return NIL; } } return ob; } else { copy_some(__ABinFile_AinvalidFormat,1); *ep = __ABinFile_AinvalidFormat; return NIL; } }
SchObj read_obj_via_port( SchPort* port ) { return read_obj(port); }
SchObj read_obj( SchPort* port ) { unsigned int c; do { c = SCH_GETC(port); } while ( ch_class(c) == CL_WHITESPACE ); if ( c == ((unsigned char)EOF) ) { /* c -> 0x 00 00 00 ff, EOF -> 0x ff */ return SCH_EOF; } CLEAR_BUF(token_buffer_); if ( ch_class(c) == CL_DECIMALNUMBER || c == '-' || c == '+') { unsigned int c0 = c; PUSH_BUF(token_buffer_,c0); c = SCH_GETC(port); if ( (c0 == '-' || c0 == '+') && (ch_class(c) != CL_DECIMALNUMBER) ) { SCH_UNGETC(c,port); return SCH_SYMBOL(TO_S_BUF(token_buffer_)); } while ( ch_class(c) & (CL_DECIMALNUMBER) || c == '.' || c == '/' ) { PUSH_BUF(token_buffer_,c); c = SCH_GETC(port); } SCH_UNGETC(c,port); return read_number(TO_S_BUF(token_buffer_),10); } else if ( ch_class(c) == CL_LIST_END ) { return SCH_KOKKA; } else if ( ch_class(c) == CL_LIST_BEGIN ) { SchObj x = read_obj(port); SchObj p_val = SCH_LIST1(x); SchObj p_last = p_val; if ( x == SCH_KOKKA ) { return SCH_NIL; } for (;;) { x = read_obj( port ); if ( x == SCH_KOKKA ) { return p_val; } else if ( x == SCH_DOT || x == SCH_SYMBOL(".") ) { SCH_SET_CDR( p_last, read_obj(port) ); if ( read_obj( port ) != SCH_KOKKA ) { EXCEPTION("right parenthesis ')' missing"); } return p_val; } else { SchObj p_y = SCH_LIST1(x); SCH_SET_CDR(p_last,p_y); p_last = p_y; } } } else if ( c == '"' ) { unsigned int prev = c; while ( (c = SCH_GETC(port)) != '"' || prev == '\\') { if ( prev == '\\' ) { switch(c) { case '"': POP_BUF(token_buffer_); PUSH_BUF(token_buffer_,'\"'); break; case 'n': POP_BUF(token_buffer_); PUSH_BUF(token_buffer_,'\n'); break; case 't': POP_BUF(token_buffer_); PUSH_BUF(token_buffer_,'\t'); break; default: break; } } else { PUSH_BUF(token_buffer_,c); } prev = c; } return SCH_STRING(TO_S_BUF(token_buffer_)); } else if ( c == '\'' ) { return SCH_LIST2(SCH_SYMBOL("quote"),read_obj(port)); } else if ( c == '`' ) { return SCH_LIST2( SCH_SYMBOL("quasiquote"), read_obj(port) ); } else if ( c == ',' ) { if ( (c = SCH_GETC(port)) == '@' ) { return SCH_LIST2( SCH_SYMBOL("unquote-splicing"), read_obj(port) ); } else { SCH_UNGETC(c,port); return SCH_LIST2( SCH_SYMBOL("unquote"), read_obj(port) ); } } else if ( c == ';' ) { while ( (c = SCH_GETC(port)) != '\n' ) { if (c == (unsigned char)EOF) { return (SchObj)SCH_EOF; } } return read_obj( port ); } else if ( c == '#') { return read_sharp_sequence(port); } else { do { PUSH_BUF(token_buffer_,c); c = SCH_GETC(port); } while ( ch_class(c) & (CL_IDENTIFIER|CL_DECIMALNUMBER) ); SCH_UNGETC(c,port); return SCH_SYMBOL(TO_S_BUF(token_buffer_)); } }
SchObj sch_read_string( char* str ) { SchPort* port; port = (SchPort*)make_input_port_string( str ); return read_obj( port ); }