main(int argc, char *argv[]) { int i,j; char *s; char *progname; Transform *trans; progname = argv[0]; while (--argc > 0 && (*++argv)[0]=='-') { for (s = argv[0]+1; *s; s++) switch (*s) { case 's': trans = new_transform(); trans->type = SCALE; trans->x = atof (*++argv); trans->y = atof (*++argv); trans->z = atof (*++argv); argc -= 3; break; case 't': trans = new_transform(); trans->type = TRANSLATE; trans->x = atof (*++argv); trans->y = atof (*++argv); trans->z = atof (*++argv); argc -= 3; break; case 'r': trans = new_transform(); trans->type = ROTATE; trans->angle = atof (*++argv); trans->x = atof (*++argv); trans->y = atof (*++argv); trans->z = atof (*++argv); argc -= 4; break; default: fprintf (stderr, "usage: %s [flags] <in.ply >out.ply\n", progname); fprintf (stderr, " -t xtrans ytrans ztrans\n"); fprintf (stderr, " -s xscale yscale zscale\n"); fprintf (stderr, " -r angle (in degrees) xaxis yaxis zaxis\n"); fprintf (stderr, "\n"); fprintf (stderr, "Transformations are applied in the order in which they appear\n"); fprintf (stderr, "in the command line. There is no limit on the number of\n"); fprintf (stderr, "transformations that may be used.\n"); exit (-1); break; } } read_file(); transform(); write_file(); }
int validate(struct parsestate* psp, struct streamstate* stp) { int rc; struct mapping* document = stp->document; struct mapping* trmapping = NULL; struct keyvalue* kv; kv = find_keyvalue(document->kvlist, "TRANSFORMATIONS"); if (! kv) return error_failed_to_find_transformations(psp); if (kv->type != KV_MAPPING) return error_transformations_not_proper_yaml_map(psp, kv); trmapping = kv->map; for (kv = trmapping->kvlist; kv; kv=kv->nxt) { if (kv->type != KV_MAPPING) return error_transformation_not_proper_yaml_map(psp, kv); struct transform* tr = psp->trlist = new_transform(psp, psp->trlist); tr->kv = kv; rc = validate_transform(psp, tr, kv->map); if (rc) return 1; } return 0; }
/** tries to register current frame onto previous frame. This is the most simple algorithm: shift images to all possible positions and calc summed error Shift with minimal error is selected. */ Transform calcShiftRGBSimple(MotionDetect* md) { int x = 0, y = 0; int i, j; int minerror = INT_MAX; int bpp = (md->fi.pFormat == PF_RGB) ?3 :4; for (i = -md->maxShift; i <= md->maxShift; i++) { for (j = -md->maxShift; j <= md->maxShift; j++) { int error = compareImg(md->curr, md->prev, md->fi.width, md->fi.height, bpp, i, j); if (error < minerror) { minerror = error; x = i; y = j; } } } return new_transform(x, y, 0, 0, 0); }
/** tries to register current frame onto previous frame. (only the luminance is used) This is the most simple algorithm: shift images to all possible positions and calc summed error Shift with minimal error is selected. */ Transform calcShiftYUVSimple(MotionDetect* md) { int x = 0, y = 0; int i, j; unsigned char *Y_c, *Y_p;// , *Cb, *Cr; #ifdef STABVERBOSE FILE *f = NULL; char buffer[32]; ds_snprintf(buffer, sizeof(buffer), "f%04i.dat", md->frameNum); f = fopen(buffer, "w"); fprintf(f, "# splot \"%s\"\n", buffer); #endif // we only use the luminance part of the image Y_c = md->curr; // Cb_c = md->curr + md->fi.width*md->fi.height; //Cr_c = md->curr + 5*md->fi.width*md->fi.height/4; Y_p = md->prev; //Cb_p = md->prev + md->fi.width*md->fi.height; //Cr_p = md->prev + 5*md->fi.width*md->fi.height/4; int minerror = INT_MAX; for (i = -md->maxShift; i <= md->maxShift; i++) { for (j = -md->maxShift; j <= md->maxShift; j++) { int error = compareImg(Y_c, Y_p, md->fi.width, md->fi.height, 1, i, j); #ifdef STABVERBOSE fprintf(f, "%i %i %f\n", i, j, error); #endif if (error < minerror) { minerror = error; x = i; y = j; } } } #ifdef STABVERBOSE fclose(f); ds_log_msg(md->modName, "Minerror: %f\n", minerror); #endif return new_transform(x, y, 0, 0, 0); }
static const char * parse_transform_expr (const char *expr) { int delim; int i, j, rc; char *str, *beg, *cur; const char *p; int cflags = 0; struct transform *tf = new_transform (); if (expr[0] != 's') { if (strncmp (expr, "flags=", 6) == 0) { transform_flags = 0; for (expr += 6; *expr; expr++) { if (*expr == ';') { expr++; break; } if (parse_xform_flags (&transform_flags, *expr)) USAGE_ERROR ((0, 0, _("Unknown transform flag: %c"), *expr)); } return expr; } USAGE_ERROR ((0, 0, _("Invalid transform expression"))); } delim = expr[1]; /* Scan regular expression */ for (i = 2; expr[i] && expr[i] != delim; i++) if (expr[i] == '\\' && expr[i+1]) i++; if (expr[i] != delim) USAGE_ERROR ((0, 0, _("Invalid transform expression"))); /* Scan replacement expression */ for (j = i + 1; expr[j] && expr[j] != delim; j++) if (expr[j] == '\\' && expr[j+1]) j++; if (expr[j] != delim) USAGE_ERROR ((0, 0, _("Invalid transform expression"))); /* Check flags */ tf->transform_type = transform_first; tf->flags = transform_flags; for (p = expr + j + 1; *p && *p != ';'; p++) switch (*p) { case 'g': tf->transform_type = transform_global; break; case 'i': cflags |= REG_ICASE; break; case 'x': cflags |= REG_EXTENDED; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': tf->match_number = strtoul (p, (char**) &p, 0); p--; break; default: if (parse_xform_flags (&tf->flags, *p)) USAGE_ERROR ((0, 0, _("Unknown flag in transform expression: %c"), *p)); } if (*p == ';') p++; /* Extract and compile regex */ str = xmalloc (i - 1); memcpy (str, expr + 2, i - 2); str[i - 2] = 0; rc = regcomp (&tf->regex, str, cflags); if (rc) { char errbuf[512]; regerror (rc, &tf->regex, errbuf, sizeof (errbuf)); USAGE_ERROR ((0, 0, _("Invalid transform expression: %s"), errbuf)); } if (str[0] == '^' || str[strlen (str) - 1] == '$') tf->transform_type = transform_first; free (str); /* Extract and compile replacement expr */ i++; str = xmalloc (j - i + 1); memcpy (str, expr + i, j - i); str[j - i] = 0; for (cur = beg = str; *cur;) { if (*cur == '\\') { size_t n; add_literal_segment (tf, beg, cur); switch (*++cur) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': n = strtoul (cur, &cur, 10); if (n > tf->regex.re_nsub) USAGE_ERROR ((0, 0, _("Invalid transform replacement: back reference out of range"))); add_backref_segment (tf, n); break; case '\\': add_char_segment (tf, '\\'); cur++; break; case 'a': add_char_segment (tf, '\a'); cur++; break; case 'b': add_char_segment (tf, '\b'); cur++; break; case 'f': add_char_segment (tf, '\f'); cur++; break; case 'n': add_char_segment (tf, '\n'); cur++; break; case 'r': add_char_segment (tf, '\r'); cur++; break; case 't': add_char_segment (tf, '\t'); cur++; break; case 'v': add_char_segment (tf, '\v'); cur++; break; case '&': add_char_segment (tf, '&'); cur++; break; case 'L': /* Turn the replacement to lowercase until a '\U' or '\E' is found, */ add_case_ctl_segment (tf, ctl_locase); cur++; break; case 'l': /* Turn the next character to lowercase, */ add_case_ctl_segment (tf, ctl_locase_next); cur++; break; case 'U': /* Turn the replacement to uppercase until a '\L' or '\E' is found, */ add_case_ctl_segment (tf, ctl_upcase); cur++; break; case 'u': /* Turn the next character to uppercase, */ add_case_ctl_segment (tf, ctl_upcase_next); cur++; break; case 'E': /* Stop case conversion started by '\L' or '\U'. */ add_case_ctl_segment (tf, ctl_stop); cur++; break; default: /* Try to be nice */ { char buf[2]; buf[0] = '\\'; buf[1] = *cur; add_literal_segment (tf, buf, buf + 2); } cur++; break; } beg = cur; } else if (*cur == '&') { add_literal_segment (tf, beg, cur); add_backref_segment (tf, 0); beg = ++cur; } else cur++; } add_literal_segment (tf, beg, cur); return p; }
trans2D_t *new_scaling_transform(double sx, double sy) { return new_transform(sx, 0.0, 0.0, 0.0, sy, 0.0, 0.0, 0.0, 1.0); }
trans2D_t *new_rotation_transform(double theta) { return new_transform(cos(theta), -sin(theta), 0.0, sin(theta), cos(theta), 0.0, 0.0, 0.0, 1.0); }
trans2D_t *new_translation_transform(double tx, double ty) { return new_transform(1.0, 0.0, tx, 0.0, 1.0, ty, 0.0, 0.0, 1.0); }
/* Create a new 2D transform from the given 3x3 matrix */ trans2D_t *new_transform_vector(double *V) { return new_transform(V[0], V[1], V[2], V[3], V[4], V[5], V[6], V[7], V[8]); }
t_obj *load_obj(const char *file) { t_obj *obj; int fd; char *line; char **tmp; t_object *object; char *mtllib; char last; int offset; int i; mtllib = NULL; last = 0; offset = 0; i = 0; object = new_object(); if ((obj = ft_memalloc(sizeof(t_obj))) == NULL) return (NULL); obj->transform = new_transform(); if ((fd = open(file, O_RDONLY)) == -1) { exit_error("Can't find .obj"); return (NULL); } while (get_next_line(fd, &line) != 0) { i++; tmp = ft_strsplit(line, ' '); if (ft_strlen(line) == 1 && last == 'f') { gen_buffers(object); offset += object->vertex.size; add_elem(&obj->objects, object); last = 0; object = new_object(); ft_freetab((void **)tmp); ft_memdel((void **)&line); continue ; } if (ft_tabsize((void **)tmp) < 2) { ft_freetab((void **)tmp); ft_memdel((void **)&line); continue ; } if (ft_strcmp(tmp[0], "usemtl") == 0) object->usemtl = ft_strdup(tmp[1]); if (!add_v_f(object, tmp, &last, offset) && ft_strcmp(tmp[0], "mtllib") == 0) mtllib = ft_strdup(line + 7); ft_freetab((void **)tmp); ft_memdel((void **)&line); } if (line) ft_memdel((void **)&line); gen_buffers(object); add_elem(&obj->objects, object); if (mtllib) { load_material_lib(obj, mtllib, (char *)file); ft_memdel((void **)&mtllib); } return (obj); }
/* create a zero initialized transform*/ Transform null_transform(void) { return new_transform(0, 0, 0, 0, 0); }