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