示例#1
0
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);
		}
	}
}
示例#4
0
文件: j.gain.cpp 项目: EQ4/JamomaMax
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);
	}
}
示例#6
0
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);
    }
}
示例#7
0
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;
}
示例#8
0
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);
}
示例#10
0
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;
	
}
示例#12
0
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;
		}	
	}
}
示例#13
0
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;
}
示例#14
0
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);
}
示例#15
0
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);
}
示例#16
0
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);
}
示例#17
0
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));
	}
}
示例#18
0
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;
}
示例#19
0
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;
}
示例#20
0
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;
}
示例#21
0
文件: jit.thin.c 项目: CICM/max6-sdk
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;

}
示例#22
0
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;
}
示例#25
0
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;
}
示例#26
0
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;
}
示例#27
0
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];
	}
}
示例#28
0
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;
}
示例#29
0
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);
	}
}
示例#30
0
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);
}