// n-dimensional linear interpolation
float recursive_interp(char *bp, long dimcount, t_jit_matrix_info *minfo, long *dim_int, float *dim_frak)
{
float f,x0,x1;
long i;
char *bp0,*bp1;
CLIP_ASSIGN(dimcount,1,JIT_MATRIX_MAX_DIMCOUNT);
i = dimcount-1;
bp0 = bp + dim_int[i]*minfo->dimstride[i];
bp1 = bp + ((dim_int[i]+1)%minfo->dim[i])*minfo->dimstride[i];
if (dimcount==1) {
if (minfo->type==_jit_sym_char) {
x0 = (float)(*((uchar *)bp0))*(1./255.);
x1 = (float)(*((uchar *)bp1))*(1./255.);
} else if (minfo->type==_jit_sym_long) {
x0 = *((t_int32 *)bp0);
x1 = *((t_int32 *)bp1);
} else if (minfo->type==_jit_sym_float32) {
x0 = *((float *)bp0);
x1 = *((float *)bp1);
} else if (minfo->type==_jit_sym_float64) {
x0 = *((double *)bp0);
x1 = *((double *)bp1);
}
} else {
x0 = recursive_interp(bp0,i,minfo,dim_int,dim_frak);
x1 = recursive_interp(bp1,i,minfo,dim_int,dim_frak);
}
f = (x0 * (1.-dim_frak[i])) + (x1 * dim_frak[i]);
return f;
}
void *max_jit_peek_new(t_symbol *s, long argc, t_atom *argv)
{
t_max_jit_peek *x;
long attrstart,i;
t_atom a;
if (x = (t_max_jit_peek *)max_jit_obex_new(max_jit_peek_class,NULL)) { //only max object, no jit object
for (i=0; i<=JIT_MATRIX_MAX_DIMCOUNT+1; i++)
x->vectors[i] = NULL;
x->matrix_name = _jit_sym_nothing;
x->dimcount = 2;
x->plane = 0;
x->interp = 0;
x->normalize = 0;
x->inperform = 0;
x->mvalid = 0;
x->mdata = 0;
attrstart = max_jit_attr_args_offset(argc,argv);
if (attrstart&&argv) {
t_atom_long al;
jit_atom_arg_getsym(&x->matrix_name, 0, attrstart, argv);
if (!jit_atom_arg_getlong(&al, 1, attrstart, argv)) {
C74_ASSERT_FITS_LONG(al);
x->dimcount = (long) al;
}
if (!jit_atom_arg_getlong(&al, 2, attrstart, argv)) {
C74_ASSERT_FITS_LONG(al);
x->plane = (long) al;
}
jit_atom_setsym(&a,x->matrix_name);
max_jit_peek_matrix_name(x,NULL,1,&a);
}
CLIP_ASSIGN(x->dimcount,0,JIT_MATRIX_MAX_DIMCOUNT);
CLIP_ASSIGN(x->dimcount,0,32); //maximum signal inputs
max_jit_attr_args(x,argc,argv); //handle attribute args
dsp_setup((t_pxobject *)x,x->dimcount);
max_jit_obex_dumpout_set(x, outlet_new(x,0L)); //general purpose outlet(rightmost)
outlet_new((t_object *)x, "signal"); //signal output
}
return (x);
}
void jit_freenect_grab_set_tilt(t_jit_freenect_grab *x, void *attr, long argc, t_atom *argv)
{
if(argv){
x->tilt = jit_atom_getlong(argv);
CLIP_ASSIGN(x->tilt, -30, 30);
if(x->device){
freenect_set_tilt_degs(x->device,x->tilt);
}
}
}
t_jit_err jit_gl_videoplane_draw(t_jit_gl_videoplane *x)
{
t_jit_err result = JIT_ERR_NONE;
GLenum prim;
CLIP_ASSIGN (x->nudge,0.,0.5);
prim = (x->gridmode) ? GL_TRIANGLE_STRIP : GL_QUAD_STRIP;
if (x->recalc) {
jit_gl_videoplane_recalc(x);
if (x->displaylist)
{
t_jit_gl_context ctx;
// cache/restore context in case in capture mode
ctx = jit_gl_get_context();
jit_ob3d_set_context(x);
if (x->dlref) {
glDeleteLists(x->dlref,1);
x->dlref = 0;
}
if (x->dlref=glGenLists(1)) {
glNewList(x->dlref, GL_COMPILE);
if (x->chunk&&x->chunk->m_vertex)
draw_grid(x,x->chunk->m_vertex, prim);
glEndList();
}
jit_gl_set_context(ctx);
}
x->recalc = 0;
}
// draw our chunk of OpenGL geometry.
if (x->chunk&&x->chunk->m_vertex) {
if (!jit_attr_getlong(x,gensym("matrixoutput"))) {
if (x->displaylist&&x->dlref)
glCallList(x->dlref);
else
draw_grid(x,x->chunk->m_vertex, prim);
if(jit_attr_getlong(x, _jit_sym_boundcalc))
jit_object_method(x, gensym("calcbounds"), x->chunk, NULL);
} else {
color_surface(x);
result = jit_ob3d_draw_chunk(x->ob3d, x->chunk); //output matrix
}
}
return result;
}
t_jit_err jit_freenect_grab_set_mode(t_jit_freenect_grab *x, void *attr, long ac, t_atom *av){
if(ac < 1){
return JIT_ERR_NONE;
}
if(x->mode != jit_atom_getlong(av)){
long mode = jit_atom_getlong(av);
// TODO: add FREENECT_DEPTH_REGISTERED
CLIP_ASSIGN(mode, 0, 3); // <-- See explanation in build_geometry implementation as to why I'm blocking point cloud output for now - jmp 2011-01-11
/*
if(mode == 4){
if(!x->cloud.points){
allocate_cloud(&x->cloud);
}
if(!x->rgb){
x->rgb = malloc(DEPTH_WIDTH*DEPTH_HEIGHT*3*sizeof(float));
if(!x->rgb){
return JIT_ERR_OUT_OF_MEM;
}
}
}
else{
release_cloud(&x->cloud);
if(x->rgb){
free(x->rgb);
x->rgb = NULL;
}
}
*/
calculate_lut(&x->lut, x->lut_type, mode);
x->mode = mode;
}
return JIT_ERR_NONE;
}
// jit_fluoride_calculate_ndim() -- when x->dimmode==-1, sorts both dimensions together
void jit_fluoride_calculate_ndim(t_jit_fluoride *x, long dimcount, long *dim, long planecount,
t_jit_matrix_info *in_minfo, char *bip, t_jit_matrix_info *out_minfo, char *bop)
{
long i,j,width,height, index;
long glow[3], outpix, lum, tol, bw, tmax, temp, mode;
float indperc;
uchar *ip,*op;
glow[0] = x->glow[0]*255.;
glow[1] = x->glow[1]*255.;
glow[2] = x->glow[2]*255.;
lum = x->lum*255.;
tol = x->tol*255.;
bw = MAX(1,lum-tol);
tmax = MIN(255,(lum+tol));
mode = CLIP_ASSIGN(x->mode,0,1);
if (dimcount<1) return; //safety
switch(dimcount) {
case 1:
dim[1]=1;
case 2:
width = dim[0];
height = dim[1];
switch(mode) {
case 1: // color
for (i=0; i<height; i++) {
ip = bip + i*in_minfo->dimstride[1];
op = bop + i*out_minfo->dimstride[1];
for (j=0; j<width; j++) {
index = (float)(*(ip+1)*.299)+(float)(*(ip+2)*.587)+(float)(*(ip+3)*.114);
if(index<bw) {
*op++ = *ip;
*op++ = *(ip+1);
*op++ = *(ip+2);
*op++ = *(ip+3);
goto ick1;
}
if(index<(lum+1)) {
indperc=((float)(lum-index)*(1./tol));
*op++ = *ip;
outpix = (float)(*(ip+1))*(indperc);
temp = ((float)(glow[0])*(1.-indperc))+outpix;
*op++ = CLAMP(temp,0,255);
outpix = (float)(*(ip+2))*(indperc);
temp = ((float)(glow[1])*(1.-indperc))+outpix;
*op++ = CLAMP(temp,0,255);
outpix = (float)(*(ip+3))*(indperc);
temp = ((float)(glow[2])*(1.-indperc))+outpix;
*op++ = CLAMP(temp,0,255);
}
else {
indperc=((float)(255-index)*(1./(tmax-lum)));
*op++ = *ip;
temp = ((float)(glow[0])*indperc);
*op++ = CLAMP(temp,0,255);
temp = ((float)(glow[1])*indperc);
*op++ = CLAMP(temp,0,255);
temp = ((float)(glow[2])*indperc);
*op++ = CLAMP(temp,0,255);
}
ick1:
;
ip+=4;
}
}
break;
case 0: // b/w
default:
for (i=0; i<height; i++) {
ip = bip + i*in_minfo->dimstride[1];
op = bop + i*out_minfo->dimstride[1];
for (j=0; j<width; j++) {
index = (float)(*(ip+1)*.299)+(float)(*(ip+2)*.587)+(float)(*(ip+3)*.114);
if(index<bw) {
*op++ = *ip;
*op++ = index;
*op++ = index;
*op++ = index;
goto ick;
}
if(index<(lum+1)) {
indperc=((float)(lum-index)*(1./tol));
outpix = (float)(index)*(indperc);
*op++ = *ip;
temp = ((float)(glow[0])*(1.-indperc))+outpix;
*op++ = CLAMP(temp,0,255);
temp = ((float)(glow[1])*(1.-indperc))+outpix;
*op++ = CLAMP(temp,0,255);
temp = ((float)(glow[2])*(1.-indperc))+outpix;
*op++ = CLAMP(temp,0,255);
}
else {
indperc=((float)(255-index)*(1./(tmax-lum)));
*op++ = *ip;
temp = ((float)(glow[0])*indperc);
*op++ = CLAMP(temp,0,255);
temp = ((float)(glow[1])*indperc);
*op++ = CLAMP(temp,0,255);
temp = ((float)(glow[2])*indperc);
*op++ = CLAMP(temp,0,255);
}
ick:
;
ip+=4;
}
}
break;
}
break;
default:
for (i=0; i<dim[dimcount-1]; i++) {
ip = bip + i*in_minfo->dimstride[dimcount-1];
op = bop + i*out_minfo->dimstride[dimcount-1];
jit_fluoride_calculate_ndim(x,dimcount-1,dim,planecount,in_minfo,ip,out_minfo,op);
}
}
}
t_jit_err cv_jit_shift_matrix_calc(t_cv_jit_shift *x, void *inputs, void *outputs)
{
t_jit_err err=JIT_ERR_NONE;
long in_savelock = 0;
t_jit_matrix_info in_minfo;
void *in_matrix;
CvMat source;
CvRect rectangle;
CvBox2D box;
CvConnectedComp component;
CvPoint2D32f vertices[4];
float w,h,c,s;
//Get pointer to matrix
in_matrix = jit_object_method(inputs,_jit_sym_getindex,0);
if (x&&in_matrix)
{
//Lock the matrix
in_savelock = (long) jit_object_method(in_matrix,_jit_sym_lock,1);
//Make sure input is of proper format
jit_object_method(in_matrix,_jit_sym_getinfo,&in_minfo);
if(in_minfo.dimcount != 2)
{
err = JIT_ERR_MISMATCH_DIM;
goto out;
}
if(in_minfo.planecount != 1)
{
err = JIT_ERR_MISMATCH_PLANE;
goto out;
}
if(in_minfo.type != _jit_sym_char)
{
err = JIT_ERR_MISMATCH_TYPE;
goto out;
}
//Don't process if image is too small
if((in_minfo.dim[0] < 2)||(in_minfo.dim[1] < 2))
goto out;
//Calculate start rectangle:
rectangle = cvRect(x->rect[0],x->rect[1],x->rect[2]-x->rect[0],x->rect[3]-x->rect[1]);
CLIP_ASSIGN(rectangle.x,0,in_minfo.dim[0]-1);
CLIP_ASSIGN(rectangle.y,0,in_minfo.dim[1]-1);
CLIP_ASSIGN(rectangle.width,1,in_minfo.dim[0]-rectangle.x);
CLIP_ASSIGN(rectangle.height,1,in_minfo.dim[1]-rectangle.y);
//Convert Jitter matrix to OpenCV matrix
cvJitter2CvMat(in_matrix, &source);
//Calculate camshift
if(x->mode == 1) //Use camshift
cvCamShift(&source, rectangle, cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,(int)x->maxiters,x->epsilon), &component, &box );
else {
cvMeanShift(&source, rectangle, cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,(int)x->maxiters,x->epsilon), &component);
box.angle = 90.f;
box.size = cvSize2D32f(component.rect.width, component.rect.height);
box.center = cvPoint2D32f((float)component.rect.x + (float)component.rect.width * 0.5f,(float)component.rect.y + (float)component.rect.height * 0.5f);
}
//Prepare output
//
jit_atom_setlong(&x->box[0],component.rect.x);
jit_atom_setlong(&x->box[1],component.rect.y);
jit_atom_setlong(&x->box[2],component.rect.x + component.rect.width);
jit_atom_setlong(&x->box[3],component.rect.y + component.rect.height);
x->rect[0]=component.rect.x;
x->rect[1]=component.rect.y;
x->rect[2]=component.rect.x + component.rect.width;
x->rect[3]=component.rect.y + component.rect.height;
//cvBoxPoints(box,vertices);
w = box.size.width * 0.5;
h = box.size.height * 0.5;
c = cos((box.angle - 90.f) * -0.01745329252);
s = sin((box.angle - 90.f) * -0.01745329252);
vertices[0].x = box.center.x - s*h - c*w;
vertices[0].y = box.center.y - c*h + s*w;
vertices[1].x = box.center.x - s*h + c*w;
vertices[1].y = box.center.y - c*h - s*w;
vertices[2].x = box.center.x + s*h + c*w;
vertices[2].y = box.center.y + c*h - s*w;
vertices[3].x = box.center.x + s*h - c*w;
vertices[3].y = box.center.y + c*h + s*w;
jit_atom_setlong(&x->frame[0],(long)vertices[0].x);
jit_atom_setlong(&x->frame[1],(long)vertices[0].y);
jit_atom_setlong(&x->frame[2],(long)vertices[1].x);
jit_atom_setlong(&x->frame[3],(long)vertices[1].y);
jit_atom_setlong(&x->frame[4],(long)vertices[2].x);
jit_atom_setlong(&x->frame[5],(long)vertices[2].y);
jit_atom_setlong(&x->frame[6],(long)vertices[3].x);
jit_atom_setlong(&x->frame[7],(long)vertices[3].y);
x->mass = (float)(component.area / 256.);
}
out:
jit_object_method(in_matrix,gensym("lock"),in_savelock);
return err;
}
t_jit_err jit_coerce_matrix_calc(t_jit_coerce *x, void *inputs, void *outputs)
{
t_jit_err err=JIT_ERR_NONE;
long in_savelock;
t_jit_matrix_info in_minfo,out_minfo;
char *in_bp;
long i,size;
void *in_matrix,*out_matrix;
in_matrix = jit_object_method(inputs,_jit_sym_getindex,0);
out_matrix = jit_object_method(outputs,_jit_sym_getindex,0);
if (x&&in_matrix&&out_matrix) {
in_savelock = (long) jit_object_method(in_matrix,_jit_sym_lock,1);
jit_object_method(in_matrix,_jit_sym_getinfo,&in_minfo);
jit_object_method(out_matrix,_jit_sym_getinfo,&out_minfo);
jit_object_method(in_matrix,_jit_sym_getdata,&in_bp);
if (!in_bp) { err=JIT_ERR_INVALID_INPUT; goto out; }
if (!(out_minfo.flags&JIT_MATRIX_DATA_REFERENCE))
{ err=JIT_ERR_INVALID_OUTPUT; goto out; }
CLIP_ASSIGN(x->planecount,1,32);
if (x->type == _jit_sym_long) {
size = 4;
} else if (x->type == _jit_sym_float32) {
size = 4;
} else if (x->type == _jit_sym_float64) {
size = 8;
} else {
x->type = _jit_sym_char;
size = 1;
}
out_minfo.type = x->type;
out_minfo.planecount = x->planecount;
out_minfo.dimcount = in_minfo.dimcount;
out_minfo.size = in_minfo.size;
out_minfo.dimstride[0] = size * x->planecount;
out_minfo.dim[0] = (in_minfo.dim[0]*in_minfo.dimstride[0])/out_minfo.dimstride[0];
if (out_minfo.dim[0]==0) { err=JIT_ERR_GENERIC; goto out; }
for (i=1; i<in_minfo.dimcount; i++) {
out_minfo.dimstride[i] = in_minfo.dimstride[i];
out_minfo.dim[i] = in_minfo.dim[i];
}
jit_object_method(out_matrix,_jit_sym_setinfo_ex,&out_minfo);
jit_object_method(out_matrix,_jit_sym_data,in_bp);
} else {
return JIT_ERR_INVALID_PTR;
}
out:
jit_object_method(in_matrix,_jit_sym_lock,in_savelock);
return err;
}
t_jit_err cv_jit_lines_matrix_calc(t_cv_jit_lines *x, void *inputs, void *outputs)
{
t_jit_err err = JIT_ERR_NONE;
long in_savelock,out_savelock;
t_jit_matrix_info in_minfo,out_minfo;
char *in_bp,*out_bp;
long i,dimcount,dim[JIT_MATRIX_MAX_DIMCOUNT];
void *in_matrix,*out_matrix;
t_int32 *out;
double thresh1, thresh2, theta, rho;
int houghThresh;
CvMat source;
CvPoint *ln;
in_matrix = jit_object_method(inputs,_jit_sym_getindex,0);
out_matrix = jit_object_method(outputs,_jit_sym_getindex,0);
if (x&&in_matrix&&out_matrix) {
in_savelock = (long) jit_object_method(in_matrix,_jit_sym_lock,1);
out_savelock = (long) jit_object_method(out_matrix,_jit_sym_lock,1);
jit_object_method(in_matrix,_jit_sym_getinfo,&in_minfo);
jit_object_method(out_matrix,_jit_sym_getinfo,&out_minfo);
jit_object_method(in_matrix,_jit_sym_getdata,&in_bp);
if (!in_bp) { err=JIT_ERR_INVALID_INPUT; goto out;}
//compatible types?
if (in_minfo.type!=_jit_sym_char) {
err=JIT_ERR_MISMATCH_TYPE;
goto out;
}
//compatible planes?
if ((in_minfo.planecount!=1)||(out_minfo.planecount!=4)) {
err=JIT_ERR_MISMATCH_PLANE;
goto out;
}
//get dimensions/planecount
dimcount = in_minfo.dimcount;
for (i=0;i<dimcount;i++) {
dim[i] = MIN(in_minfo.dim[i],out_minfo.dim[i]);
}
//Convert input matrix to OpenCV matrices
cvJitter2CvMat(in_matrix, &source);
//Adjust size of edge matrix if need be
if((x->edges->rows != source.rows)||(x->edges->cols != source.cols))
{
cvReleaseMat(&(x->edges));
x->edges = cvCreateMat( source.rows, source.cols, CV_8UC1 );
}
//Calculate parameter values for Hough and Canny algorithms
thresh1 = x->threshold - THRESHOLD_RANGE;
thresh2 = x->threshold + THRESHOLD_RANGE;
CLIP_ASSIGN(thresh1,0,255);
CLIP_ASSIGN(thresh2,0,255);
theta = CV_PI / (180 / (double)x->resolution);
rho = (double)x->resolution;
houghThresh = x->sensitivity;
x->gap = MAX(0,x->gap);
x->length = MAX(0,x->length);
//calculate edges using Canny algorithm
cvCanny( &source, x->edges, thresh1, thresh2, 3 );
//Find lines using the probabilistic Hough transform method
x->lines = cvHoughLines2( x->edges, x->storage, CV_HOUGH_PROBABILISTIC, rho, theta, houghThresh, x->length, x->gap );
//Transfer line information to output matrix
//First adjust matrix size
out_minfo.dim[0] = x->lines->total;
jit_object_method(out_matrix,_jit_sym_setinfo,&out_minfo);
jit_object_method(out_matrix,_jit_sym_getinfo,&out_minfo);
jit_object_method(out_matrix,_jit_sym_getdata,&out_bp);
if (!out_bp) { err=JIT_ERR_INVALID_OUTPUT; goto out;}
//Copy...
out = (t_int32 *)out_bp;
for( i = 0; i < x->lines->total; i++ )
{
ln = (CvPoint*)cvGetSeqElem(x->lines,i);
out[0] = ln[0].x;
out[1] = ln[0].y;
out[2] = ln[1].x;
out[3] = ln[1].y;
out+=4;
}
} else {
return JIT_ERR_INVALID_PTR;
}
out:
jit_object_method(out_matrix,gensym("lock"),out_savelock);
jit_object_method(in_matrix,gensym("lock"),in_savelock);
return err;
}
t_jit_err jit_scissors_matrix_calc(t_jit_scissors *x, void *inputs, void *outputs)
{
t_jit_err err=JIT_ERR_NONE;
long in_savelock, out_savelock, dimmode;
t_jit_matrix_info in_minfo, out_minfo;
char *in_bp, *out_bp;
long i, dimcount, planecount, dim[JIT_MATRIX_MAX_DIMCOUNT];
t_atom a[2];
t_matrix_conv_info conv;
long rows = x->rows, cols = x->cols;
void *in_matrix, *out_matrix;
long maxn = rows * cols;
if (x->max == -1) { // we are not in a Max box
long i = 1;
void *test;
do { // make sure we start at a valid matrix
test = jit_object_method(outputs, _jit_sym_getindex, maxn - i);
if (test) {
maxn -= (i - 1);
}
i++;
} while (!test && (maxn - i >= 0));
if (!test)
return JIT_ERR_INVALID_OUTPUT;
} else
CLIP_ASSIGN(maxn, 0, x->max);
in_matrix = jit_object_method(inputs, _jit_sym_getindex, 0);
out_matrix = jit_object_method(outputs, _jit_sym_getindex, --maxn);
if (x && in_matrix) {
in_savelock = (long) jit_object_method(in_matrix, _jit_sym_lock, 1);
jit_object_method(in_matrix, _jit_sym_getinfo, &in_minfo);
jit_object_method(in_matrix, _jit_sym_getdata, &in_bp);
if (!in_bp) { err=JIT_ERR_INVALID_INPUT; goto out; }
dim[0] = in_minfo.dim[0] / cols;
dim[1] = in_minfo.dim[1] / rows;
memset(&conv, 0, sizeof(t_matrix_conv_info));
for (i = 0; i < JIT_MATRIX_MAX_PLANECOUNT; i++) {
conv.planemap[i] = i;
}
conv.flags = JIT_MATRIX_CONVERT_SRCDIM;
while (out_matrix) {
out_savelock = (long) jit_object_method(out_matrix, _jit_sym_lock, 1);
jit_object_method(out_matrix, _jit_sym_getinfo, &out_minfo);
// safe to always set. only reallocs matrix if necessary
out_minfo.dim[0] = dim[0];
out_minfo.dim[1] = dim[1];
out_minfo.type = in_minfo.type;
out_minfo.planecount = in_minfo.planecount;
jit_object_method(out_matrix, _jit_sym_setinfo, &out_minfo);
jit_object_method(out_matrix, _jit_sym_getinfo, &out_minfo);
// need to get base pointer *after* modifying
jit_object_method(out_matrix, _jit_sym_getdata, &out_bp);
if (!out_bp) { err=JIT_ERR_INVALID_OUTPUT; goto out;}
if ((in_minfo.dimcount!=2)||(out_minfo.dimcount!=2)) {
err=JIT_ERR_MISMATCH_DIM;
goto out;
}
dimcount = out_minfo.dimcount;
planecount = out_minfo.planecount;
conv.srcdimstart[0] = dim[0] * (maxn % cols);
conv.srcdimstart[1] = dim[1] * (maxn / cols);
conv.srcdimend[0] = conv.srcdimstart[0] + dim[0] - 1;
conv.srcdimend[1] = conv.srcdimstart[1] + dim[1] - 1;
jit_object_method(out_matrix, _jit_sym_frommatrix, in_matrix, &conv);
jit_object_method(out_matrix, _jit_sym_lock, out_savelock);
out_matrix = jit_object_method(outputs, _jit_sym_getindex, --maxn);
}
} else {
return JIT_ERR_INVALID_PTR;
}
out:
if (out_matrix)
jit_object_method(out_matrix, _jit_sym_lock, out_savelock);
jit_object_method(in_matrix, _jit_sym_lock, in_savelock);
return err;
}
t_jit_err cv_jit_features_matrix_calc(t_cv_jit_features *x, void *inputs, void *outputs)
{
t_jit_err err=JIT_ERR_NONE;
long in_savelock=0,out_savelock=0;
t_jit_matrix_info in_minfo,out_minfo;
char *out_bp, *in_bp;
void *in_matrix,*out_matrix;
int i;
int roi_w,roi_h,roi_offset;
float *out_data;
CvMat source;
int featureCount = 2048;
//Get pointers to matrices
in_matrix = jit_object_method(inputs,_jit_sym_getindex,0);
out_matrix = jit_object_method(outputs,_jit_sym_getindex,0);
if (x&&in_matrix&&out_matrix)
{
//Lock the matrices
in_savelock = (long) jit_object_method(in_matrix,_jit_sym_lock,1);
out_savelock = (long) jit_object_method(out_matrix,_jit_sym_lock,1);
//Make sure input is of proper format
jit_object_method(in_matrix,_jit_sym_getinfo,&in_minfo);
jit_object_method(out_matrix,_jit_sym_getinfo,&out_minfo);
if(in_minfo.dimcount != 2)
{
err = JIT_ERR_MISMATCH_DIM;
goto out;
}
if(in_minfo.planecount != 1)
{
err = JIT_ERR_MISMATCH_PLANE;
goto out;
}
if(in_minfo.type != _jit_sym_char)
{
err = JIT_ERR_MISMATCH_TYPE;
goto out;
}
//Don't process if one dimension is < 2
if((in_minfo.dim[0] < 2)||(in_minfo.dim[1] < 2))
goto out;
if(x->useroi)
{
CLIP_ASSIGN(x->roi[0],0,in_minfo.dim[0]);
CLIP_ASSIGN(x->roi[1],0,in_minfo.dim[1]);
CLIP_ASSIGN(x->roi[2],0,in_minfo.dim[0]);
CLIP_ASSIGN(x->roi[3],0,in_minfo.dim[1]);
x->roi[0] = MIN(x->roi[0], x->roi[2]);
x->roi[1] = MIN(x->roi[1], x->roi[3]);
x->roi[2] = MAX(x->roi[0], x->roi[2]);
x->roi[3] = MAX(x->roi[1], x->roi[3]);
roi_w = x->roi[2] - x->roi[0];
roi_h = x->roi[3] - x->roi[1];
if(roi_w == 0)
roi_w = in_minfo.dim[0] - x->roi[0];
if(roi_h == 0)
roi_h = in_minfo.dim[1] - x->roi[1];
roi_offset = x->roi[1] * in_minfo.dimstride[1] + x->roi[0];
jit_object_method(in_matrix,_jit_sym_getdata,&in_bp);
//Convert Jitter matrix to OpenCV matrix
cvInitMatHeader( &source, roi_h, roi_w, CV_8UC1, in_bp + roi_offset, in_minfo.dimstride[1] );
}
else
{
//Convert Jitter matrix to OpenCV matrix
cvJitter2CvMat(in_matrix, &source);
}
//Adjust the size of eigImage and tempImage if need be
if((source.cols != x->eigImage->cols)||(source.rows != x->eigImage->rows))
{
cvReleaseMat(&(x->eigImage));
x->eigImage = cvCreateMat( source.rows, source.cols, CV_32FC1 );
cvReleaseMat(&(x->tempImage));
x->tempImage = cvCreateMat( source.rows, source.cols, CV_32FC1 );
}
//Adjust parameters
x->threshold = MAX(0.001,x->threshold);
x->distance = MAX(1,x->distance);
//Calculate
cvGoodFeaturesToTrack( &source, x->eigImage, x->tempImage,x->features, &featureCount,x->threshold, x->distance,NULL, x->aperture,0, 0.04 );
if(x->precision == 1){
int minsize = (x->aperture*2)+5;
//Error check for cvFindCornerSubPix
if((featureCount>0)&&(source.cols > minsize)&&(source.rows > minsize))
cvFindCornerSubPix( &source, x->features, featureCount, cvSize(x->aperture,x->aperture),cvSize(-1,-1),cvTermCriteria(CV_TERMCRIT_ITER, 10, 0.1f));
}
//Prepare output
out_minfo.dim[0] = featureCount;
jit_object_method(out_matrix,_jit_sym_setinfo,&out_minfo);
jit_object_method(out_matrix,_jit_sym_getinfo,&out_minfo);
jit_object_method(out_matrix,_jit_sym_getdata,&out_bp);
if (!out_bp) { err=JIT_ERR_INVALID_OUTPUT; goto out;}
out_data = (float *)out_bp;
if(x->useroi)
{
for(i=0; i < featureCount; i++)
{
out_data[0] = x->features[i].x + x->roi[0];
out_data[1] = x->features[i].y + x->roi[1];
out_data += 2;
}
}
else
{
for(i=0; i < featureCount; i++)
{
out_data[0] = x->features[i].x;
out_data[1] = x->features[i].y;
out_data += 2;
}
}
}
out:
jit_object_method(out_matrix,gensym("lock"),out_savelock);
jit_object_method(in_matrix,gensym("lock"),in_savelock);
return err;
}
t_jit_err xray_jit_distance_matrix_calc(t_xray_jit_distance *x, void *inputs, void *outputs)
{
t_jit_err err=JIT_ERR_NONE;
long in1_savelock,out_savelock;
t_jit_matrix_info in1_minfo,out_minfo;
char *in1_bp,*out_bp;
long i,dimcount,planecount,dim[JIT_MATRIX_MAX_DIMCOUNT];
void *in1_matrix,*out_matrix;
in1_matrix = jit_object_method(inputs,_jit_sym_getindex,0);
out_matrix = jit_object_method(outputs,_jit_sym_getindex,0);
if (x&&in1_matrix&&out_matrix) {
in1_savelock = (long) jit_object_method(in1_matrix,_jit_sym_lock,1);
out_savelock = (long) jit_object_method(out_matrix,_jit_sym_lock,1);
jit_object_method(in1_matrix,_jit_sym_getinfo,&in1_minfo);
jit_object_method(out_matrix,_jit_sym_getinfo,&out_minfo);
jit_object_method(in1_matrix,_jit_sym_getdata,&in1_bp);
jit_object_method(out_matrix,_jit_sym_getdata,&out_bp);
if (!in1_bp) { err=JIT_ERR_INVALID_INPUT; goto out;}
if (!out_bp) { err=JIT_ERR_INVALID_OUTPUT; goto out;}
//compatible types?
if (in1_minfo.type!=out_minfo.type)
{
err=JIT_ERR_MISMATCH_TYPE;
goto out;
}
//compatible planes?
if (in1_minfo.planecount!=out_minfo.planecount&&in1_minfo.planecount!=1)
{
err=JIT_ERR_MISMATCH_PLANE;
error("single plane matrices only");
goto out;
}
//get dimensions/planecount
dimcount = out_minfo.dimcount;
planecount = out_minfo.planecount;
for (i=0;i<dimcount;i++) {
dim[i] = out_minfo.dim[i];
if ((in1_minfo.dim[i]<dim[i])) dim[i] = in1_minfo.dim[i];
}
CLIP_ASSIGN(x->mode, 0, 2);
xray_jit_distance_calculate_ndim(x, dimcount, dim, planecount,
&in1_minfo, in1_bp,
&out_minfo, out_bp);
} else {
return JIT_ERR_INVALID_PTR;
}
out:
jit_object_method(out_matrix,gensym("lock"),out_savelock);
jit_object_method(in1_matrix,gensym("lock"),in1_savelock);
return err;
}
void xray_jit_distance_calculate_ndim(t_xray_jit_distance *x, long dimcount, long *dim, long planecount,
t_jit_matrix_info *in1_minfo, char *bip1,
t_jit_matrix_info *out_minfo, char *bop)
{
long i,j;
uchar *cip1,*cop;
char *lip1, *lop;
long height, width;
long incolspan, outcolspan;
long inrowspan, outrowspan;
uchar cprev;
long lprev;
if (dimcount<1) return; //safety
switch(dimcount) {
case 1:
dim[1]=1;
case 2:
width = dim[0];
height = dim[1];
inrowspan = in1_minfo->dimstride[0];
outrowspan = out_minfo->dimstride[0];
incolspan = in1_minfo->dimstride[1];
outcolspan = out_minfo->dimstride[1];
if (in1_minfo->type==_jit_sym_char)
{
if(x->mode != 0)
{
for(i=0; i < width; i++)
{
cip1 = (uchar *)(bip1 + i);
cop = (uchar *)(bop + i);
*cop = *cip1;
cprev = *cop;
cprev = MIN(cprev, 254);
cprev++;
for(j=1; j < height; j++)
{
cip1 += incolspan;
cop += outcolspan;
*cop = MIN(*cip1, cprev);
cprev = *cop;
cprev = MIN(cprev, 254);
cprev++;
}
cop = (uchar *)(bop + i + (height-1)*outcolspan);
cprev = *cop;
cprev = MIN(cprev, 254);
cprev++;
for(j=height-2; j >= 0; j--)
{
cop -= outcolspan;
*cop = MIN(*cop, cprev);
cprev = *cop;
cprev = MIN(cprev, 254);
cprev++;
}
}
}
if(x->mode != 1)
{
for(j=0; j < height; j++)
{
if(x->mode == 0)
{
cip1 = (uchar *)(bip1 + j*incolspan);
cop = (uchar *)(bop + j*outcolspan);
*cop = *cip1;
cprev = *cop;
CLIP_ASSIGN(cprev, 0, 254);
cprev++;
for(i=1; i < width; i++)
{
cip1++;
cop++;
cprev = MIN(cprev, 254);
cprev = *cop;
CLIP_ASSIGN(cprev, 0, 254);
cprev++;
}
}
else
{
cop = (uchar *)(bop + j*outcolspan);
cprev = *cop;
cprev = MIN(cprev, 254);
cprev++;
for(i=1; i < width; i++)
{
cop++;
*cop = MIN(*cop, cprev);
cprev = *cop;
cprev = MIN(cprev, 254);
cprev++;
}
}
cop = (uchar *)(bop + (width-1) + j*outcolspan);
cprev = *cop;
cprev = MIN(cprev, 254);
cprev++;
for(i=width-2; i >= 0; i--)
{
cop--;
*cop = MIN(*cop, cprev);
cprev = *cop;
cprev = MIN(cprev, 254);
cprev++;
}
}
}
}
if (in1_minfo->type==_jit_sym_long)
{
if(x->mode != 0)
{
for(i=0; i < width; i++)
{
lip1 = bip1 + i*inrowspan;
lop = bop + i*outrowspan;
*(t_int32 *)lop = *(t_int32 *)lip1;
lprev = *(t_int32 *)lop;
lprev++;
for(j=1; j < height; j++)
{
lip1 += incolspan;
lop += outcolspan;
*(t_int32 *)lop = MIN(*(t_int32 *)lip1, lprev);
lprev = *(t_int32 *)lop;
lprev++;
}
lop = bop + i*inrowspan + (height-1)*outcolspan;
lprev = *(t_int32 *)lop;
lprev++;
for(j=height-2; j >= 0; j--)
{
lop -= outcolspan;
*(t_int32 *)lop = MIN(*(t_int32 *)lop, lprev);
lprev = *(t_int32 *)lop;
lprev++;
}
}
}
if(x->mode != 1)
{
for(j=0; j < height; j++)
{
if(x->mode == 0)
{
lip1 = bip1 + j*incolspan;
lop = bop + j*outcolspan;
*lop = *(t_int32 *)lip1;
lprev = *(t_int32 *)lop;
lprev++;
for(i=1; i < width; i++)
{
lip1 += inrowspan;
lop += outrowspan;
*(t_int32 *)lop = MIN(*(t_int32 *)lip1, lprev);
lprev = *(t_int32 *)lop;
lprev++;
}
}
else
{
lop = bop + j*outcolspan;
lprev = *(t_int32 *)lop;
lprev++;
for(i=1; i < width; i++)
{
lop += outrowspan;
*(t_int32 *)lop = MIN(*(t_int32 *)lop, lprev);
lprev = *(t_int32 *)lop;
lprev++;
}
}
lop = bop + (width-1)*inrowspan + j*outcolspan;
lprev = *(t_int32 *)lop;
lprev++;
for(i=width-2; i >= 0; i--)
{
lop -= outrowspan;
*(t_int32 *)lop = MIN(*(t_int32 *)lop, lprev);
lprev = *(t_int32 *)lop;
lprev++;
}
}
}
}
break;
default:
for (i=0;i<dim[dimcount-1];i++) {
cip1 = (uchar *)(bip1 + i*in1_minfo->dimstride[dimcount-1]);
cop = (uchar *)(bop + i*out_minfo->dimstride[dimcount-1]);
xray_jit_distance_calculate_ndim(x,dimcount-1,dim,planecount,in1_minfo,(char *)cip1,out_minfo,(char *)cop);
}
}
}
void jit_alphablend_calculate_ndim(t_jit_alphablend *x, long dimcount, long *dim, long planecount, t_jit_matrix_info *in1_minfo, char *bip1,
t_jit_matrix_info *in2_minfo, char *bip2, t_jit_matrix_info *out_minfo, char *bop)
{
long i,j,k;
uchar *cip1,*cip2,*cop;
float *fip1,*fip2,*fop;
double *dip1,*dip2,*dop;
long calpha,calpha_inv;
float falpha,falpha_inv;
float dalpha,dalpha_inv;
float default_alpha = 1.0;
uchar cdefault_alpha = (uchar)(default_alpha * 255.);
long height,width;
if (dimcount<1) return; //safety
switch(dimcount) {
case 1:
dim[1]=1;
case 2:
width = dim[0];
height = dim[1];
if (in1_minfo->type==_jit_sym_char) {
switch(planecount) {
case 4:
for (i=0; i<height; i++) {
cip1 = (uchar *) bip1 + i*in1_minfo->dimstride[1];
cip2 = (uchar *) bip2 + i*in2_minfo->dimstride[1];
cop = (uchar *) bop + i*out_minfo->dimstride[1];
switch (x->mode) {
case 1: //inverse
for (j=0; j<width; j++) {
calpha_inv = (long)(*cip1++);
calpha = 256 - calpha_inv;
*cop++ = cdefault_alpha;
cip2++; //ignore other alpha channels
*cop++ = (((long)(*cip1++)*calpha)+((long)(*cip2++)*calpha_inv))>>8L;
*cop++ = (((long)(*cip1++)*calpha)+((long)(*cip2++)*calpha_inv))>>8L;
*cop++ = (((long)(*cip1++)*calpha)+((long)(*cip2++)*calpha_inv))>>8L;
}
break;
default:
for (j=0; j<width; j++) {
calpha = (long)(*cip1++);
calpha_inv = 256 - calpha;
*cop++ = cdefault_alpha;
cip2++; //ignore other alpha channels
*cop++ = (((long)(*cip1++)*calpha)+((long)(*cip2++)*calpha_inv))>>8L;
*cop++ = (((long)(*cip1++)*calpha)+((long)(*cip2++)*calpha_inv))>>8L;
*cop++ = (((long)(*cip1++)*calpha)+((long)(*cip2++)*calpha_inv))>>8L;
}
break;
}
}
break;
default:
for (i=0; i<height; i++) {
cip1 = (uchar *) bip1 + i*in1_minfo->dimstride[1];
cip2 = (uchar *) bip2 + i*in2_minfo->dimstride[1];
cop = (uchar *) bop + i*out_minfo->dimstride[1];
switch (x->mode) {
case 1: //inverse
for (j=0; j<width; j++) {
calpha_inv = (long)(*cip1);
calpha = 256 - calpha_inv;
cop[0] = cdefault_alpha;
for (k = 1; k < planecount; k++) {
cop[k] = (((long)(cip1[k])*calpha)+((long)(cip2[k])*calpha_inv))>>8L;
}
cop += planecount;
cip1 += planecount;
cip2 += planecount;
}
break;
default:
for (j=0; j<width; j++) {
calpha = (long)(*cip1);
calpha_inv = 256 - calpha;
cop[0] = cdefault_alpha;
for (k = 1; k < planecount; k++) {
cop[k] = (((long)(cip1[k])*calpha)+((long)(cip2[k])*calpha_inv))>>8L;
}
cop += planecount;
cip1 += planecount;
cip2 += planecount;
}
break;
}
}
break;
}
} else if (in1_minfo->type==_jit_sym_float32) {
switch (planecount) {
case 4:
for (i=0; i<height; i++) {
fip1 = (float *) (bip1 + i*in1_minfo->dimstride[1]);
fip2 = (float *) (bip2 + i*in2_minfo->dimstride[1]);
fop = (float *) (bop + i*out_minfo->dimstride[1]);
switch (x->mode) {
case 1: //inverse
for (j=0; j<width; j++) {
falpha_inv = *fip1++;
CLIP_ASSIGN(falpha_inv,0.,1.);
falpha = 1. - falpha_inv;
*fop++ = default_alpha;
fip2++; //ignore other alpha channels
*fop++ = ((*fip1++)*falpha)+((*fip2++)*falpha_inv);
*fop++ = ((*fip1++)*falpha)+((*fip2++)*falpha_inv);
*fop++ = ((*fip1++)*falpha)+((*fip2++)*falpha_inv);
}
break;
default:
for (j=0; j<width; j++) {
falpha = *fip1++;
CLIP_ASSIGN(falpha,0.,1.);
falpha_inv = 1. - falpha;
*fop++ = default_alpha;
fip2++; //ignore other alpha channels
*fop++ = ((*fip1++)*falpha)+((*fip2++)*falpha_inv);
*fop++ = ((*fip1++)*falpha)+((*fip2++)*falpha_inv);
*fop++ = ((*fip1++)*falpha)+((*fip2++)*falpha_inv);
}
break;
}
}
break;
default:
for (i=0; i<height; i++) {
fip1 = (float *) (bip1 + i*in1_minfo->dimstride[1]);
fip2 = (float *) (bip2 + i*in2_minfo->dimstride[1]);
fop = (float *) (bop + i*out_minfo->dimstride[1]);
switch (x->mode) {
case 1: //inverse
for (j=0; j<width; j++) {
falpha_inv = *fip1;
CLIP_ASSIGN(falpha_inv,0.,1.);
falpha = 1. - falpha_inv;
fop[0] = default_alpha;
for (k = 1; k < planecount; k++) {
fop[k] = ((fip1[k])*falpha)+((fip2[k])*falpha_inv);
}
fop += planecount;
fip1 += planecount;
fip2 += planecount;
}
break;
default:
for (j=0; j<width; j++) {
falpha = *fip1;
CLIP_ASSIGN(falpha,0.,1.);
falpha_inv = 1. - falpha;
fop[0] = default_alpha;
for (k = 1; k < planecount; k++) {
fop[k] = ((fip1[k])*falpha)+((fip2[k])*falpha_inv);
}
fop += planecount;
fip1 += planecount;
fip2 += planecount;
}
break;
}
}
break;
}
} else if (in1_minfo->type==_jit_sym_float64) {
switch (planecount) {
case 4:
for (i=0; i<height; i++) {
dip1 = (double *) (bip1 + i*in1_minfo->dimstride[1]);
dip2 = (double *) (bip2 + i*in2_minfo->dimstride[1]);
dop = (double *) (bop + i*out_minfo->dimstride[1]);
switch (x->mode) {
case 1: //inverse
for (j=0; j<width; j++) {
dalpha_inv = *dip1++;
CLIP_ASSIGN(dalpha_inv,0.,1.);
dalpha = 1. - dalpha_inv;
*dop++ = default_alpha;
dip2++; //ignore other alpha channels
*dop++ = ((*dip1++)*dalpha)+((*dip2++)*dalpha_inv);
*dop++ = ((*dip1++)*dalpha)+((*dip2++)*dalpha_inv);
*dop++ = ((*dip1++)*dalpha)+((*dip2++)*dalpha_inv);
}
break;
default:
for (j=0; j<width; j++) {
dalpha = *dip1++;
CLIP_ASSIGN(dalpha,0.,1.);
dalpha_inv = 1. - dalpha;
*dop++ = default_alpha;
dip2++; //ignore other alpha channels
*dop++ = ((*dip1++)*dalpha)+((*dip2++)*dalpha_inv);
*dop++ = ((*dip1++)*dalpha)+((*dip2++)*dalpha_inv);
*dop++ = ((*dip1++)*dalpha)+((*dip2++)*dalpha_inv);
}
break;
}
}
break;
default:
for (i=0; i<height; i++) {
dip1 = (double *) (bip1 + i*in1_minfo->dimstride[1]);
dip2 = (double *) (bip2 + i*in2_minfo->dimstride[1]);
dop = (double *) (bop + i*out_minfo->dimstride[1]);
switch (x->mode) {
case 1: //inverse
for (j=0; j<width; j++) {
dalpha_inv = *dip1;
CLIP_ASSIGN(dalpha_inv,0.,1.);
dalpha = 1. - dalpha_inv;
dop[0] = default_alpha;
for (k = 1; k < planecount; k++) {
dop[k] = ((dip1[k])*dalpha)+((dip2[k])*dalpha_inv);
}
dop += planecount;
dip1 += planecount;
dip2 += planecount;
}
break;
default:
for (j=0; j<width; j++) {
dalpha = *dip1;
CLIP_ASSIGN(dalpha,0.,1.);
dalpha_inv = 1. - dalpha;
dop[0] = default_alpha;
for (k = 1; k < planecount; k++) {
dop[k] = ((dip1[k])*dalpha)+((dip2[k])*dalpha_inv);
}
dop += planecount;
dip1 += planecount;
dip2 += planecount;
}
break;
}
}
break;
}
}
break;
default:
for (i=0; i<dim[dimcount-1]; i++) {
cip1 = (uchar *) bip1 + i*in1_minfo->dimstride[dimcount-1];
cip2 = (uchar *) bip2 + i*in2_minfo->dimstride[dimcount-1];
cop = (uchar *) bop + i*out_minfo->dimstride[dimcount-1];
jit_alphablend_calculate_ndim(x,dimcount-1,dim,planecount,in1_minfo,(char *)cip1,in2_minfo,(char *)cip2,out_minfo,(char *)cop);
}
}
