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