t_jit_err max_jit_gradient_outputmatrix(t_max_jit_gradient *x) { void *mop,*o,*p; long err=JIT_ERR_NONE; t_atom a; if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop))) return JIT_ERR_GENERIC; if (jit_attr_getlong(mop,_jit_sym_outputmode)) { if (err=(t_jit_err) jit_object_method( max_jit_obex_jitob_get(x), _jit_sym_matrix_calc, jit_object_method(mop,_jit_sym_getinputlist), jit_object_method(mop,_jit_sym_getoutputlist))) { jit_error_code(x,err); } else { if ((p=jit_object_method(mop,_jit_sym_getoutput,1)) && (o=max_jit_mop_io_getoutlet(p))) { jit_atom_setsym(&a,jit_attr_getsym(p,_jit_sym_matrixname)); outlet_anything(o,_jit_sym_jit_matrix,1,&a); } } } return err; }
t_jit_err jit_indices2jit(t_jit_pcl_voxel *x, pcl::IndicesConstPtr idx, t_jit_matrix_info *out_minfo, void **out_matrix) { char *out_bp = NULL; long *lop; //***** // send back to jitter jit_object_method(*out_matrix, _jit_sym_getinfo, out_minfo); out_minfo->dim[0] = idx->size(); out_minfo->dim[1] = 1; out_minfo->type = _jit_sym_long; out_minfo->planecount = 1; 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) { object_error((t_object *)x, "no output data" ); return JIT_ERR_INVALID_OUTPUT; } long j = 0; for (std::vector<int>::const_iterator p = idx->begin(); p != idx->end(); p++) { lop = (long *)(out_bp + (j++) * out_minfo->dimstride[0]); lop[0] = (*p); post("%d", *p); } return JIT_ERR_NONE; }
void max_jit_realsense_grab_outputmatrix(t_max_jit_realsense_grab *x) { // post("%s", __FUNCTION__); t_atom a; long outputmode = max_jit_mop_getoutputmode(x); void *mop = max_jit_obex_adornment_get(x, _jit_sym_jit_mop); t_jit_err err; if (outputmode&&mop) { //always output unless output mode is none if (outputmode == 1) { if (err = (t_jit_err)jit_object_method( max_jit_obex_jitob_get(x), _jit_sym_matrix_calc, jit_object_method(mop, _jit_sym_getinputlist), jit_object_method(mop, _jit_sym_getoutputlist))) { jit_error_code(x, err); } else { max_jit_mop_outputmatrix(x); } } else { max_jit_mop_outputmatrix(x); } } }
t_jit_err GainMatrixCalc(t_gain* self, void *inputs, void *outputs) { t_jit_err err = JIT_ERR_NONE; long in_savelock; long out_savelock; void *in_matrix; void *out_matrix; in_matrix = jit_object_method(inputs,_jit_sym_getindex,0); out_matrix = jit_object_method(outputs,_jit_sym_getindex,0); if (self && in_matrix && out_matrix) { in_savelock = TTMatrixReferenceJitterMatrix(*self->m_x, in_matrix, false); // we're just scaling, and this is a trivial example, so we don't copy out_savelock = TTMatrixReferenceJitterMatrix(*self->m_y, out_matrix, false); // we're just scaling, and this is a trivial example, so we don't copy self->m_gain->calculate(*self->m_x, *self->m_y); jit_object_method(out_matrix, _jit_sym_lock, out_savelock); jit_object_method(in_matrix, _jit_sym_lock, in_savelock); } else return JIT_ERR_INVALID_PTR; return err; }
void max_xray_jit_levelsetseg_mproc(t_max_xray_jit_levelsetseg *x, void *mop) { t_jit_err err; t_jit_matrix_info tmpinfo; void *o; long changed=0; t_atom a; if (x->last==LSS_LAST_VAL) { tmpinfo = x->lastinfo; o = max_jit_mop_getinput(x,2); jit_object_method(o,_jit_sym_getinfo,&x->lastinfo); if (tmpinfo.type!=x->lastinfo.type) changed = TRUE; else if (tmpinfo.planecount!=x->lastinfo.planecount) changed = TRUE; if (changed) jit_object_method(o,_jit_sym_setall,0L,1,jit_atom_setfloat(&a,x->val)); } if (err=(t_jit_err) jit_object_method( max_jit_obex_jitob_get(x), _jit_sym_matrix_calc, jit_object_method(mop,_jit_sym_getinputlist), jit_object_method(mop,_jit_sym_getoutputlist))) { jit_error_code(x,err); } else { max_jit_mop_outputmatrix(x); } }
void max_jit_kinect2_outputmatrix(t_max_jit_kinect2 *x) { long outputmode = max_jit_mop_getoutputmode(x); void *mop = max_jit_obex_adornment_get(x,_jit_sym_jit_mop); t_jit_err err; if (outputmode && mop) { //always output unless output mode is none if (outputmode==2) // pass input case, but since jit.kinect2 has no input then this means no output { return; } if (outputmode==1) { if ((err = (t_jit_err)jit_object_method(max_jit_obex_jitob_get(x), _jit_sym_matrix_calc, jit_object_method(mop,_jit_sym_getinputlist), jit_object_method(mop,_jit_sym_getoutputlist)))) { if (err != JIT_ERR_HW_UNAVAILABLE) jit_error_code(x,err); return; } } max_jit_mop_outputmatrix(x); } }
t_jit_err jit_tml_fakeDepth_init(void) { long attrflags=0; t_jit_object *attr; t_jit_object *mop, *o; _jit_tml_fakeDepth_class = jit_class_new("jit_tml_fakeDepth",(method)jit_tml_fakeDepth_new,(method)jit_tml_fakeDepth_free, sizeof(t_jit_tml_fakeDepth),A_CANT,0L); //A_CANT = untyped // add mop mop = jit_object_new(_jit_sym_jit_mop,2,1); // 1 matrix input / 1 matrix output // need this for getting correct matrix_info from 2nd input matrix.... (see jit.concat.c...) jit_mop_input_nolink(mop,2); o= jit_object_method(mop,_jit_sym_getinput,2); jit_object_method(o,_jit_sym_ioproc,jit_mop_ioproc_copy_adapt); jit_class_addadornment(_jit_tml_fakeDepth_class,mop); // add methods jit_class_addmethod(_jit_tml_fakeDepth_class, (method)jit_tml_fakeDepth_matrix_calc, "matrix_calc", A_CANT, 0L); //Add attributes attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW; jit_class_register(_jit_tml_fakeDepth_class); return JIT_ERR_NONE; }
t_jit_err jit_ys_pixelweightmat_init(void) { long attrflags=0; t_jit_object *attr; t_jit_object *mop, *o; _jit_ys_pixelweightmat_class = jit_class_new("jit_ys_pixelweightmat",(method)jit_ys_pixelweightmat_new,(method)jit_ys_pixelweightmat_free, sizeof(t_jit_ys_pixelweightmat),A_CANT,0L); //A_CANT = untyped // add mop mop = jit_object_new(_jit_sym_jit_mop,2,1); // 1 matrix input / 1 matrix output // need this for getting correct matrix_info from 2nd input matrix.... (see jit.concat.c...) jit_mop_input_nolink(mop,2); o= jit_object_method(mop,_jit_sym_getinput,2); jit_object_method(o,_jit_sym_ioproc,jit_mop_ioproc_copy_adapt); jit_class_addadornment(_jit_ys_pixelweightmat_class,mop); // add methods jit_class_addmethod(_jit_ys_pixelweightmat_class, (method)jit_ys_pixelweightmat_matrix_calc, "matrix_calc", A_CANT, 0L); //Add attributes attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW; attr = jit_object_new( _jit_sym_jit_attr_offset_array,"param",_jit_sym_float32, JIT_MATRIX_MAX_PLANECOUNT, attrflags,(method)0L,(method)0L, calcoffset(t_jit_ys_pixelweightmat,paramcount),calcoffset(t_jit_ys_pixelweightmat,param)); jit_class_addattr(_jit_ys_pixelweightmat_class,attr); jit_class_register(_jit_ys_pixelweightmat_class); return JIT_ERR_NONE; }
void *max_jit_submatrix_new(t_symbol *s, long argc, t_atom *argv) { t_max_jit_submatrix *x; void *o,*m,*mop,*p; t_jit_matrix_info info; if (x=(t_max_jit_submatrix *)max_jit_obex_new(max_jit_submatrix_class,gensym("jit_submatrix"))) { if (o=jit_object_new(gensym("jit_submatrix"))) { max_jit_obex_jitob_set(x,o); max_jit_obex_dumpout_set(x,outlet_new(x,NULL)); max_jit_mop_setup(x); max_jit_mop_inputs(x); max_jit_mop_outputs(x); mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop); jit_attr_setlong(mop,gensym("adapt"),0); jit_attr_setlong(mop,gensym("caninplace"),0); jit_attr_setlong(mop,gensym("outputmode"),1); //make the output matrix a data reference w/NULL data pointer m = max_jit_mop_getoutput(x,1); jit_object_method(m,_jit_sym_getinfo,&info); jit_object_method(m,gensym("freedata")); info.flags = JIT_MATRIX_DATA_REFERENCE; info.size = 0; p = NULL; jit_object_method(m,_jit_sym_setinfo_ex,&info); jit_object_method(m,_jit_sym_data,p); max_jit_attr_args(x,argc,argv); } else { jit_object_error((t_object *)x,"jit.submatrix: could not allocate object"); freeobject((t_object *) x); x = NULL; } } return (x); }
t_jit_err jit_gl_hap_dest_changed(t_jit_gl_hap *x) { t_symbol *dest_name = _jit_sym_nothing; t_jit_gl_drawinfo drawinfo; dest_name = jit_attr_getsym(x, gensym("drawto")); if(x->hapglsl) { jit_attr_setsym(x->hapglsl, gensym("drawto"), dest_name); jit_object_method(x->hapglsl, gensym("readbuffer"), jit_gl_hap_glsl_jxs); } if(x->texoutput) jit_attr_setsym(x->texoutput, gensym("drawto"), dest_name); if(x->fboid != 0) { glDeleteFramebuffersEXT(1, &x->fboid); x->fboid = 0; } jit_object_method(x->texoutput, gensym("set_rebuild")); // our texture has to be bound in the new context before we can use it // http://cycling74.com/forums/topic.php?id=29197 jit_gl_drawinfo_setup(x, &drawinfo); jit_gl_bindtexture(&drawinfo, jit_attr_getsym(x->texoutput, _jit_sym_name), 0); jit_gl_unbindtexture(&drawinfo, jit_attr_getsym(x->texoutput, _jit_sym_name), 0); return JIT_ERR_NONE; }
t_jit_err jit_gl_terrain_dim(t_jit_gl_terrain *x, void *attr, long argc, t_atom *argv) { if (argc&&argv&&x->chunk&&x->chunk->m_vertex) { t_jit_matrix_info info; jit_object_method(x->chunk->m_vertex,_jit_sym_dim, argc, argv); jit_object_method(x->chunk->m_vertex,_jit_sym_getinfo,&info); x->dim[0] = info.dim[0]; x->dim[1] = info.dim[1]; x->recalc = 1; // CLIP(x->dim[0], 0, x->maxdim[0]); // CLIP(x->dim[1], 0, x->maxdim[1]); //important to calc_getTexCoords(x); // when dimensions change } return JIT_ERR_NONE; }
void max_jit_str_op_mproc(t_max_jit_str_op *x, void *mop) { long err; void *o; long ac = 1; t_atom a[2]; t_symbol *s; o = max_jit_obex_jitob_get(x); jit_attr_setlong(o, gensym("adaptflag"), jit_attr_getlong(mop, _jit_sym_adapt)); if (err=(t_jit_err) jit_object_method( max_jit_obex_jitob_get(x), _jit_sym_matrix_calc, jit_object_method(mop,_jit_sym_getinputlist), jit_object_method(mop,_jit_sym_getoutputlist))) { jit_error_code(x,err); } else { s = jit_attr_getsym(o, gensym("op")); switch(jit_attr_getlong(o, gensym("outmode"))) { case 0: max_jit_mop_outputmatrix(x); break; case 2: ac = 2; jit_atom_setlong(&a[1], jit_attr_getlong(o, gensym("outlong2"))); case 1: jit_atom_setlong(&a[0], jit_attr_getlong(o, gensym("outlong"))); max_jit_obex_dumpout(x, s, ac, a); break; } } }
t_jit_err StencilMatrixCalc(StencilObjectPtr self, void *inputs, void *outputs) { t_jit_err err = JIT_ERR_NONE; long in_savelock; long out_savelock; void *in_matrix; void *out_matrix; in_matrix = jit_object_method(inputs,_jit_sym_getindex,0); out_matrix = jit_object_method(outputs,_jit_sym_getindex,0); if (self && in_matrix && out_matrix) { in_savelock = TTMatrixReferenceJitterMatrix(self->x, in_matrix); out_savelock = TTMatrixReferenceJitterMatrix(self->y, out_matrix); TTMatrixCopyDataFromJitterMatrix(self->x, in_matrix); self->stencilObject->calculate(self->x, self->y); TTMatrixCopyDataToJitterMatrix(self->y, out_matrix); jit_object_method(out_matrix, _jit_sym_lock, out_savelock); jit_object_method(in_matrix, _jit_sym_lock, in_savelock); } else return JIT_ERR_INVALID_PTR; return err; }
void *max_jit_str_op_new(t_symbol *s, long argc, t_atom *argv) { t_max_jit_str_op *x; void *o, *m; t_jit_matrix_info info; if (x=(t_max_jit_str_op *)max_jit_obex_new(max_jit_str_op_class,gensym("jit_str_op"))) { if (o=jit_object_new(gensym("jit_str_op"))) { max_jit_mop_setup_simple(x,o,argc,argv); m = max_jit_mop_getinput(x, 2); jit_object_method(m, _jit_sym_getinfo, &info); info.type = _jit_sym_char; info.planecount = 1; info.dimcount = 1; info.dim[0] = 1; jit_object_method(m, _jit_sym_setinfo, &info); max_jit_attr_args(x,argc,argv); } else { jit_object_error((t_object *)x,"jit.str.op: could not allocate object"); freeobject(x); x = NULL; } } return (x); }
void *max_jit_histogram_new(t_symbol *s, long argc, t_atom *argv) { t_max_jit_histogram *x; void *o,*m; t_jit_matrix_info info; long dim=256; t_symbol *type=_jit_sym_long; if (x=(t_max_jit_histogram *)max_jit_obex_new(max_jit_histogram_class,gensym("jit_histogram"))) { if (o=jit_object_new(gensym("jit_histogram"))) { max_jit_mop_setup_simple(x,o,argc,argv); //default long 256 output(plane is linked) if (argc>=3) { if ((argv[0].a_type==A_LONG)&&(argv[1].a_type==A_SYM)&&(argv[2].a_type==A_LONG)) { type = jit_atom_getsym(argv+1); if (type!=_jit_sym_char) type = _jit_sym_long; dim = jit_atom_getlong(argv+2); } } m = max_jit_mop_getoutput(x,1); jit_object_method(m,_jit_sym_getinfo,&info); info.type = type; info.dimcount = 1; info.dim[0] = dim; jit_object_method(m,_jit_sym_setinfo,&info); max_jit_attr_args(x,argc,argv); } else { jit_object_error((t_object *)x,"jit.histogram: could not allocate object"); freeobject((t_object *) x); x = NULL; } } return (x); }
void *max_jit_rgb2luma_new(t_symbol *s, long argc, t_atom *argv) { t_max_jit_rgb2luma *x; void *o,*m; t_jit_matrix_info info; if (x=(t_max_jit_rgb2luma *)max_jit_obex_new(max_jit_rgb2luma_class,gensym("jit_rgb2luma"))) { if (o=jit_object_new(gensym("jit_rgb2luma"))) { max_jit_mop_setup_simple(x,o,argc,argv); //1-plane char out m = max_jit_mop_getoutput(x,1); jit_object_method(m,_jit_sym_getinfo,&info); info.type = _jit_sym_char; info.planecount = 1; info.dimcount = 2; // info.dim[0] = 160; // info.dim[1] = 120; jit_object_method(m,_jit_sym_setinfo,&info); max_jit_attr_args(x,argc,argv); } else { jit_object_error((t_object *)x,"jit.rgb2luma: could not allocate object"); freeobject((t_object *) x); x = NULL; } } return (x); }
void max_jit_la_diagproduct_mproc(t_max_jit_la_diagproduct *x, void *mop) { t_jit_err err; long ac; t_atom *av=NULL; void *o; o=max_jit_obex_jitob_get(x); if (err=(t_jit_err) jit_object_method( o, _jit_sym_matrix_calc, jit_object_method(mop,_jit_sym_getinputlist), jit_object_method(mop,_jit_sym_getoutputlist))) { jit_error_code(x,err); } else { jit_object_method(o,ps_getresult,&ac,&av); switch(ac) { case 1: outlet_float(x->valout,jit_atom_getfloat(av)); break; case 2: outlet_anything(x->valout,_jit_sym_list,2,av); break; } if (av) jit_freebytes(av,(ac)*sizeof(t_atom)); } }
t_jit_err jit_fluoride_matrix_calc(t_jit_fluoride *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]; 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); 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); jit_object_method(out_matrix,_jit_sym_getdata,&out_bp); if (!in_bp) { err=JIT_ERR_GENERIC; goto out;} if (!out_bp) { err=JIT_ERR_GENERIC; goto out;} //compatible types? if ((in_minfo.type!=_jit_sym_char)||(in_minfo.type!=out_minfo.type)) { err=JIT_ERR_MISMATCH_TYPE; goto out; } //compatible planes? if ((in_minfo.planecount!=4)||(out_minfo.planecount!=4)) { err=JIT_ERR_MISMATCH_PLANE; goto out; } //get dimensions/planecount dimcount = out_minfo.dimcount; planecount = out_minfo.planecount; for (i=0; i<dimcount; i++) { dim[i] = MIN(in_minfo.dim[i],out_minfo.dim[i]); } //calculate jit_parallel_ndim_simplecalc2((method)jit_fluoride_calculate_ndim, x, dimcount, dim, planecount, &in_minfo, in_bp, &out_minfo, out_bp, 0 /* flags1 */, 0 /* flags2 */); } else { return JIT_ERR_INVALID_PTR; } out: 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 jit_map_matrix_calc(t_jit_map *x, void *inputs, void *outputs) { t_jit_err err=JIT_ERR_NONE; long in_savelock,in2_savelock,out_savelock; t_jit_matrix_info in_minfo,out_minfo; char *in_bp,*out_bp; long i,dimcount,planecount,dim[JIT_MATRIX_MAX_DIMCOUNT]; t_jit_map_vecdata vecdata; 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); 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); jit_object_method(out_matrix,_jit_sym_getdata,&out_bp); if (!in_bp) { err=JIT_ERR_INVALID_INPUT; goto out;} if (!out_bp) { err=JIT_ERR_INVALID_OUTPUT; goto out;} //compatible types? if (in_minfo.type!=out_minfo.type) { err=JIT_ERR_MISMATCH_TYPE; goto out; } //get dimensions/planecount dimcount = out_minfo.dimcount; planecount = out_minfo.planecount; for (i=0;i<dimcount;i++) { //if dimsize is 1, treat as infinite domain across that dimension. //otherwise truncate if less than the output dimsize dim[i] = out_minfo.dim[i]; if ((in_minfo.dim[i]<dim[i])&&in_minfo.dim[i]>1) { dim[i] = in_minfo.dim[i]; } } jit_map_getvecdata(x,&vecdata); jit_parallel_ndim_simplecalc2((method)jit_map_calculate_ndim, &vecdata, dimcount, dim, planecount, &in_minfo, in_bp, &out_minfo, out_bp, 0 /* flags1 */, 0 /* flags2 */); } else { return JIT_ERR_INVALID_PTR; } out: 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_moments_matrix_calc(t_cv_jit_moments *x, void *inputs, void *outputs) { t_jit_err err = JIT_ERR_NONE; long in_savelock; t_jit_matrix_info in_minfo; uchar *in_bp; long i,dimcount,dim[JIT_MATRIX_MAX_DIMCOUNT]; void *matrix; matrix = jit_object_method(inputs,_jit_sym_getindex,0); if (x&&matrix) { in_savelock = (long) jit_object_method(matrix,_jit_sym_lock,1); jit_object_method(matrix,_jit_sym_getinfo,&in_minfo); jit_object_method(matrix,_jit_sym_getdata,&in_bp); if (!in_bp) { err=JIT_ERR_INVALID_INPUT; goto out; } //compatible planes? if (in_minfo.planecount!=1) { err = JIT_ERR_MISMATCH_PLANE; goto out; } //compatible dims? if (in_minfo.dimcount!=2) { err = JIT_ERR_MISMATCH_DIM; goto out; } //get dimensions/planecount dimcount = in_minfo.dimcount; for (i=0;i<dimcount;i++) { dim[i] = in_minfo.dim[i]; } //calculate clear_val(x); cv_jit_moments_calculate(x, dim, &in_minfo, in_bp); } else { return JIT_ERR_INVALID_PTR; } out: jit_object_method(matrix,gensym("lock"),in_savelock); return err; }
t_jit_err jit_thin_matrix_calc(t_jit_thin *x, void *inputs, void *outputs) { t_jit_err err=JIT_ERR_NONE; long i,dimcount,in_savelock; char *in_bp; t_jit_matrix_info in_minfo,out_minfo,tmp_minfo; void *in_matrix,*out_matrix,*tmp_matrix=NULL; 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(in_matrix,_jit_sym_getdata,&in_bp); if (!in_bp) { err = JIT_ERR_INVALID_INPUT; goto out; } tmp_minfo = in_minfo; tmp_minfo.flags = JIT_MATRIX_DATA_REFERENCE|JIT_MATRIX_DATA_FLAGS_USE; dimcount = 0; for (i=0;i<in_minfo.dimcount;i++) { if (in_minfo.dim[i]>1) { tmp_minfo.dim[dimcount] = in_minfo.dim[i]; tmp_minfo.dimstride[dimcount] = in_minfo.dimstride[i]; dimcount++; } } if (dimcount==0) { dimcount = 1; tmp_minfo.dim[0] = 1; tmp_minfo.dimstride[0] = 0; } tmp_minfo.dimcount = dimcount; tmp_matrix = jit_object_new(_jit_sym_jit_matrix,&tmp_minfo); if (!tmp_matrix) { err = JIT_ERR_OUT_OF_MEM; goto out; } jit_object_method(tmp_matrix,gensym("data"),in_bp); out_minfo = tmp_minfo; out_minfo.flags = 0; err = (t_jit_err) jit_object_method(out_matrix,_jit_sym_setinfo,&out_minfo); if (err) goto out; jit_object_method(out_matrix,_jit_sym_frommatrix,tmp_matrix,NULL); } else { return JIT_ERR_INVALID_PTR; } out: if (tmp_matrix) jit_object_free(tmp_matrix); jit_object_method(in_matrix,_jit_sym_lock,in_savelock); return err; }
t_jit_err xray_jit_cumsum_matrix_calc(t_xray_jit_cumsum *x, void *inputs, void *outputs) { t_jit_err err=JIT_ERR_NONE; long in1_savelock, out1_savelock; t_jit_matrix_info in1_minfo, out1_minfo; char *in1_bp, *out1_bp; long i,dimcount,planecount,dim[JIT_MATRIX_MAX_DIMCOUNT]; void *in1_matrix, *out1_matrix; in1_matrix = jit_object_method(inputs,_jit_sym_getindex,0); out1_matrix = jit_object_method(outputs,_jit_sym_getindex,0); if (x&&in1_matrix&&out1_matrix) { in1_savelock = (long) jit_object_method(in1_matrix,_jit_sym_lock,1); out1_savelock = (long) jit_object_method(out1_matrix,_jit_sym_lock,1); jit_object_method(in1_matrix,_jit_sym_getinfo,&in1_minfo); jit_object_method(out1_matrix,_jit_sym_getinfo,&out1_minfo); jit_object_method(in1_matrix,_jit_sym_getdata,&in1_bp); jit_object_method(out1_matrix,_jit_sym_getdata,&out1_bp); if (!in1_bp) { err=JIT_ERR_INVALID_INPUT; goto out;} if (!out1_bp) { err=JIT_ERR_INVALID_OUTPUT; goto out;} //compatible types? if (in1_minfo.type!=out1_minfo.type) { err=JIT_ERR_MISMATCH_TYPE; goto out; } //get dimensions/planecount dimcount = in1_minfo.dimcount; planecount = in1_minfo.planecount; for (i=0; i< dimcount;i++) { dim[i] = in1_minfo.dim[i]; } xray_jit_cumsum_calculate_ndim(x, dimcount, dim, planecount, &in1_minfo, in1_bp, &out1_minfo, out1_bp); } else { return JIT_ERR_INVALID_PTR; } out: jit_object_method(out1_matrix,gensym("lock"),out1_savelock); jit_object_method(in1_matrix,gensym("lock"),in1_savelock); return err; }
void max_xray_jit_levelsetseg_val(t_max_xray_jit_levelsetseg *x, void *attr, short argc, t_atom *argv) { void *o; if (o=max_jit_mop_getinput(x,2)) { jit_object_method(o,_jit_sym_getinfo,&x->lastinfo); jit_object_method(o,_jit_sym_setall,0L,(long)argc,argv); x->last = LSS_LAST_VAL; x->val = jit_atom_getfloat(&argv[0]); } }
t_jit_err jit_openlase_trace_matrix_calc(t_jit_openlase_trace *x, void *inputs, void *outputs) { t_jit_err err=JIT_ERR_NONE; long in_savelock; t_jit_matrix_info in_minfo; char *in_bp; long dimcount; void *in_matrix; int width, height; unsigned bytesperrow; in_matrix = jit_object_method(inputs,_jit_sym_getindex,0); 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; x->planecount = 0; goto out;} //get dimensions/planecount dimcount = in_minfo.dimcount; if (dimcount != 2) { object_post((t_object *)x, "requires matrix dimension equals to 2"); err=JIT_ERR_INVALID_INPUT; goto out; } width = in_minfo.dim[0]; height = in_minfo.dim[1]; bytesperrow = in_minfo.dimstride[1]; // check matrix type if (in_minfo.type != _jit_sym_char) { object_post((t_object *)x, "requires matrix type is char"); err=JIT_ERR_INVALID_INPUT; goto out; } if (in_minfo.planecount != 1) { object_post((t_object *)x, "requires matrix has just one plane"); err=JIT_ERR_INVALID_INPUT; goto out; } openlase_initialize(x, width, height); openlase_trace(x, width, height, (uint8_t*)in_bp, bytesperrow); } else { return JIT_ERR_INVALID_PTR; } out: jit_object_method(in_matrix,_jit_sym_lock,in_savelock); return err; }
t_jit_err jit_gl_videoplane_dim(t_jit_gl_videoplane *x, void *attr, long argc, t_atom *argv) { if (argc&&argv&&x->chunk&&x->chunk->m_vertex) { t_jit_matrix_info info; jit_object_method(x->chunk->m_vertex,_jit_sym_dim, argc, argv); jit_object_method(x->chunk->m_vertex,_jit_sym_getinfo,&info); x->dim[0] = info.dim[0]; x->dim[1] = info.dim[1]; x->recalc = 1; } return JIT_ERR_NONE; }
t_jit_err xray_jit_fdm_init(void) { long attrflags=0; t_jit_object *attr,*mop,*o; t_symbol *atsym; t_atom a[1]; atsym = gensym("jit_attr_offset"); _xray_jit_fdm_class = jit_class_new("xray_jit_fdm",(method)xray_jit_fdm_new,(method)xray_jit_fdm_free, sizeof(t_xray_jit_fdm),0L); //add mop mop = jit_object_new(_jit_sym_jit_mop,1,1); jit_mop_single_planecount(mop,1); jit_atom_setsym(a,_jit_sym_float32); o = jit_object_method(mop,_jit_sym_getoutput,1); jit_object_method(o,_jit_sym_types,1,a); jit_class_addadornment(_xray_jit_fdm_class,mop); //add methods jit_class_addmethod(_xray_jit_fdm_class, (method)xray_jit_fdm_matrix_calc, "matrix_calc", A_CANT, 0L); //add attributes attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW; //spacestep attr = jit_object_new(atsym,"spacestep",_jit_sym_float32,attrflags, (method)0L,(method)0L,calcoffset(t_xray_jit_fdm,spacestep)); jit_class_addattr(_xray_jit_fdm_class,attr); //direction attr = jit_object_new(_jit_sym_jit_attr_offset,"direction",_jit_sym_symbol,attrflags, (method)0L,(method)0L,calcoffset(t_xray_jit_fdm, direction)); jit_class_addattr(_xray_jit_fdm_class,attr); //generate symbols ps_x = gensym("x"); ps_y = gensym("y"); ps_xx = gensym("xx"); ps_xy = gensym("xy"); ps_yx = gensym("yx"); ps_yy = gensym("yy"); jit_class_register(_xray_jit_fdm_class); return JIT_ERR_NONE; }
void max_jit_op_val(t_max_jit_op *x, void *attr, short argc, t_atom *argv) { void *o; long i; if (o=max_jit_mop_getinput(x,2)) { jit_object_method(o,_jit_sym_getinfo,&x->lastinfo); jit_object_method(o,_jit_sym_setall,0L,(long)argc,argv); x->last = OP_LAST_VAL; x->valcount = MIN(argc,JIT_MATRIX_MAX_PLANECOUNT); for (i=0;i<x->valcount;i++) x->val[i] = argv[i]; } }
t_jit_err jit_field_mesh_volume_to_mesh(t_jit_field_mesh *x, t_jit_field_grid *grid) { t_object *vertex_matrix = (t_object *)jit_object_method(x->vertex_matrix, gensym("getmatrix")); if(x->mode == gensym("particle")) { jit_field_grid_volume_to_mesh_points(grid, vertex_matrix, x->isolevel); } else { // mode == gensym("mesh") t_object *normal_matrix = (t_object *)jit_object_method(x->normal_matrix, gensym("getmatrix")); t_object *index_matrix = (t_object *)jit_object_method(x->index_matrix, gensym("getmatrix")); jit_field_grid_volume_to_mesh_quads(grid, vertex_matrix, normal_matrix, index_matrix, x->isolevel); } return JIT_ERR_NONE; }
void max_jit_3m_mproc(t_max_jit_3m *x, void *mop) { t_jit_err err; if (err=(t_jit_err) jit_object_method( max_jit_obex_jitob_get(x), _jit_sym_matrix_calc, jit_object_method(mop,_jit_sym_getinputlist), jit_object_method(mop,_jit_sym_getoutputlist))) { jit_error_code(x,err); } else { max_jit_3m_bang(x); } }
void *max_jit_dmxmap_new(t_symbol *s, long argc, t_atom *argv) { t_max_jit_dmxmap *x; void *o,*m; t_jit_matrix_info info; long n; if (x = (t_max_jit_dmxmap *)max_jit_obex_new(class_max_jit_dmxmap,gensym("jit_dmxmap"))) { if (o=jit_object_new(gensym("jit_dmxmap"))) { attr_args_process(x, argc, argv); argc = attr_args_offset(argc, argv); max_jit_obex_jitob_set(x, o); max_jit_obex_dumpout_set(x, outlet_new(x,NULL)); max_jit_mop_setup(x); max_jit_mop_inputs(x); max_jit_mop_outputs(x); if(argc == 1) n = jit_atom_getlong(&argv[0]); else n = 512; m = max_jit_mop_getoutput(x, 1); jit_object_method(m, _jit_sym_getinfo, &info); info.type = _jit_sym_char; info.planecount = 1; info.dimcount = 1; info.dim[0] = n; info.dimstride[0] = 1; info.dimstride[1] = n; jit_object_method(m, _jit_sym_setinfo, &info); //max_jit_obex_jitob_set(x,o); //max_jit_attr_args(x,argc,argv); } else { jit_object_error((t_object *)x,"jit.dmxmap: out of memory"); freeobject((void *)x); x = NULL; goto out; } } out: return (x); }