void max_jit_print_jit_matrix(t_max_jit_print *x, t_symbol *s, long argc, t_atom *argv)
{
void *matrix;
t_atom a;
long err;
if (argc&&argv) {
//find matrix
matrix = jit_object_findregistered(jit_atom_getsym(argv));
if (matrix&&jit_object_method(matrix, _jit_sym_class_jit_matrix)) {
if (err = jit_print_matrix_calc(max_jit_obex_jitob_get(x), matrix)) {
jit_object_post((t_object *)x,"err: %d", err);
jit_error_code(x,err);
}
jit_atom_setsym(&a,jit_atom_getsym(argv));
}
else {
jit_error_code(x,JIT_ERR_MATRIX_UNKNOWN);
}
outlet_anything(x->matrixout,s,1,&a);
}
else return;
out:
return;
}
t_jit_err jit_gl_hap_setattr_out_name(t_jit_gl_hap *x, void *attr, long ac, t_atom *av)
{
if (ac && av) {
jit_attr_setsym(x->texoutput, _jit_sym_name, jit_atom_getsym(av));
}
return JIT_ERR_NONE;
}
void jit_print_planedelim_set(t_jit_print *x, t_symbol *s, long ac, t_atom *av)
{
t_symbol *tempsym;
char str[2];
if (ac) {
tempsym = jit_atom_getsym(av);
if (tempsym->s_name[0] == '-' || tempsym->s_name[0] == '.' || tempsym->s_name[0] == '\0') {
jit_object_post((t_object *)x,"illegal delimiter");
return;
}
if (tempsym == ps_tab)
str[0] = '\t';
else if (tempsym == ps_cr)
str[0] = '\r';
else if (tempsym == ps_space)
str[0] = 32;
else
str[0] = tempsym->s_name[0];
str[1] = 0;
x->planedelim = gensym(str);
}
}
t_jit_err jit_gl_lua_call_list(t_jit_gl_lua *x, t_symbol *s, long argc, t_atom *argv)
{
int i;
post("method: %s", s->s_name);
for(i=0; i < argc; i++) {
switch(argv[i].a_type) /* first atom is func name */
{
case A_LONG:
post("\t%d", jit_atom_getlong(argv+i));
break;
case A_FLOAT:
post("\t%f", jit_atom_getfloat(argv+i));
break;
case A_SYM:
post("\t%s", jit_atom_getsym(argv+i)->s_name);
break;
}
}
lua_call_function_list(x, s->s_name, argc, argv);
if(x->max_wrapper)
jit_object_method(x->max_wrapper, gensym("out_list"), argc, argv);
return JIT_ERR_NONE;
}
t_jit_err jit_gl_lua_call(t_jit_gl_lua *x, t_symbol *s, long argc, t_atom *argv)
{
t_symbol *function;
char args[257];
long i;
// get the inlet number
if(x->max_wrapper) {
x->last_inlet = max_jit_obex_inletnumber_get(x->max_wrapper);
}
if(argc) {
function = jit_atom_getsym(argv);
for(i=0; i < MIN(argc-1, 255); i++) {
switch(argv[i+1].a_type) /* first atom is func name */
{
case A_LONG:
args[i] = 'i';
break;
case A_FLOAT:
args[i] = 'd';
break;
case A_SYM:
args[i] = 's';
break;
}
}
args[i] = '\0';
lua_call_function_atom(x, function->s_name, args, argc-1, argv+1);
}
return JIT_ERR_NONE;
}
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 lua_call_function_list(t_jit_gl_lua *x, const char *func, long argc, t_atom *argv)
{
long i;
//get global function
lua_getglobal(x->lua, func);
//arguments in a table
lua_newtable(x->lua);
for(i=0; i < argc; i++) {
switch(argv[i].a_type) /* first atom is func name */
{
case A_LONG:
lua_pushinteger(x->lua, jit_atom_getlong(argv+i));
lua_rawseti(x->lua, -2, i+1);
break;
case A_FLOAT:
lua_pushnumber(x->lua, jit_atom_getfloat(argv+i));
lua_rawseti(x->lua, -2, i+1);
break;
case A_SYM:
lua_pushstring(x->lua, jit_atom_getsym(argv+i)->s_name);
lua_rawseti(x->lua, -2, i+1);
break;
}
}
/* do the call */
if(lua_pcall(x->lua, 1, 0, 0) != 0) {
error("error calling %s: %s", func, lua_tostring(x->lua, -1));
}
}
t_jit_err ManualMovementSystem::messageControl(long argc, t_atom* argv){
std::string task;
task = jit_atom_getsym(argv)->s_name;
pSystem::messageControl(argc, argv);
return JIT_ERR_INVALID_INPUT;
}
t_jit_err jit_gl_videoplane_colormode(t_jit_gl_videoplane *x, void *attr, long argc, t_atom *argv)
{
t_symbol *s=jit_atom_getsym(argv);
x->colormode = s;
if (x->texture)
jit_attr_setsym(x->texture,ps_colormode,s);
return JIT_ERR_NONE;
}
t_jit_err jit_gl_terrain_shape(t_jit_gl_terrain *x, void *attr, long argc, t_atom *argv)
{
if (argc&&argv) {
x->shape = jit_atom_getsym(argv);
x->recalc = 1;
}
return JIT_ERR_NONE;
}
void lua_call_function_atom(t_jit_gl_lua *x, const char *func, const char *sig, long argc, t_atom *argv)
{
int narg; /* number of arguments and results */
int debug_idx = -1;
lua_getfield(x->lua, LUA_REGISTRYINDEX, JIT_GL_LUA_TRACEBACK);
debug_idx = lua_gettop(x->lua);
lua_getglobal(x->lua, func); /* push function */
/******************************
push arguments
*/
for(narg = 0; *sig; narg++) {
/* check stack space */
luaL_checkstack(x->lua, 1, "too many arguments");
switch (*sig++) {
case 'd': /* double argument */
lua_pushnumber(x->lua, jit_atom_getfloat(argv+narg));
break;
case 'i': /* int argument */
lua_pushinteger(x->lua, jit_atom_getlong(argv+narg));
break;
case 's': /* string argument */
lua_pushstring(x->lua, jit_atom_getsym(argv+narg)->s_name);
break;
case '>': /* end of arguments */
goto endargs;
default:
error("invalid option (%c)", *(sig - 1));
}
}
endargs:
/* do the call */
//if(lua_pcall(x->lua, narg, nres, -(narg+2)) != 0) {
if(lua_pcall(x->lua, narg, 0, debug_idx) != 0) {
//error("error calling %s: %s", func, lua_tostring(x->lua, -1));
char str[4096];
sprintf(str, "error calling %s: %s", func, lua_tostring(x->lua, -1));
str[4095] = '\0';
lua_post_error(x, str);
lua_pop(x->lua, 1);
}
{
// int top = lua_gettop(x->lua);
lua_remove(x->lua, debug_idx);
}
// printf("stack: %d\n", lua_gettop(x->lua));
}
void script_lua_atoms_to_args(lua_State *L, int argc, t_atom *argv)
{
if(argc > 1) {
int i;
lua_newtable(L);
for(i=0; i < argc; i++) {
switch(argv[i].a_type)
{
case A_LONG:
lua_pushinteger(L, jit_atom_getlong(argv+i));
lua_rawseti(L, -2, i+1);
break;
case A_FLOAT:
lua_pushnumber(L, jit_atom_getfloat(argv+i));
lua_rawseti(L, -2, i+1);
break;
case A_SYM:
lua_pushstring(L, jit_atom_getsym(argv+i)->s_name);
lua_rawseti(L, -2, i+1);
break;
default:
break;
}
}
}
else {
switch(argv[0].a_type)
{
case A_LONG:
lua_pushinteger(L, jit_atom_getlong(argv));
break;
case A_FLOAT:
lua_pushnumber(L, jit_atom_getfloat(argv));
break;
case A_SYM:
lua_pushstring(L, jit_atom_getsym(argv)->s_name);
break;
default:
break;
}
}
}
t_jit_err jit_gl_videoplane_texturename(t_jit_gl_videoplane *x, void *attr, long argc, t_atom *argv)
{
t_symbol *s=jit_atom_getsym(argv);
x->texturename = s;
if (x->texture)
jit_attr_setsym(x->texture,_jit_sym_name,s);
jit_attr_setsym(x,ps_texture,s);
return JIT_ERR_NONE;
}
t_jit_err jit_gl_lua_setfile(t_jit_gl_lua *x, void *attr, long argc, t_atom *argv)
{
if(argc && argv) {
x->file = jit_atom_getsym(argv);
lua_doread(x, x->file, 0, NULL);
jit_attr_setlong(x, gensym("autowatch"), x->autowatch);
jit_gl_lua_load_script(x);
}
return JIT_ERR_NONE;
}
void jit_gl_videoplane_sendtexture(t_jit_gl_videoplane *x, t_symbol *s, int argc, t_atom *argv)
{
if (x->texture) {
s = jit_atom_getsym(argv);
argc--;
if (argc)
argv++;
else
argv = NULL;
object_method_typed(x->texture,s,argc,argv,NULL);
}
}
void jit_gl_hap_sendoutput(t_jit_gl_hap *x, t_symbol *s, int argc, t_atom *argv)
{
if (x->texoutput) {
s = jit_atom_getsym(argv);
argc--;
if (argc) {
argv++;
}
else {
argv = NULL;
}
object_method_typed(x->texoutput,s,argc,argv,NULL);
}
}
//setters/getters
t_jit_err cv_jit_opticalflow_set_method(t_cv_jit_opticalflow *x, void *attr, long ac, t_atom *av){
if(ac < 1){
//Not enough parameters?
return JIT_ERR_NONE;
}
if(!av){
return JIT_ERR_INVALID_PTR;
}
if(av->a_type == A_SYM){
t_symbol *s = jit_atom_getsym(av);
if(s)
x->of->setMethod(s->s_name);
else {
error("Invalid symbol pointer.");
return JIT_ERR_INVALID_PTR;
}
}else{
long m = CLAMP(jit_atom_getlong(av),0,3);
switch(m){
case 0:
x->of->setMethod(OpticalFlow::Block_matching);
break;
case 1:
x->of->setMethod(OpticalFlow::Lucas_Kanade);
break;
case 2:
x->of->setMethod(OpticalFlow::Horn_Schunk);
break;
case 3:
x->of->setMethod(OpticalFlow::Farneback);
break;
}
}
return JIT_ERR_NONE;
}
void jit_gl_videoplane_jit_matrix(t_jit_gl_videoplane *x, t_symbol *s, int argc, t_atom *argv)
{
t_symbol *name;
void *m;
t_jit_matrix_info info;
long dim[2];
if ((name=jit_atom_getsym(argv)) != _jit_sym_nothing) {
m = jit_object_findregistered(name);
if (!m) {
jit_object_error((t_object *)x,"jit.gl.videoplane: couldn't get matrix object!");
return;
}
}
if (x->texture) {
jit_object_method(m, _jit_sym_getinfo, &info);
jit_attr_getlong_array(x->texture,_jit_sym_dim,2,dim);
jit_object_method(x->texture,s,s,argc,argv);
// switch back to matrix input
jit_attr_setsym(x,ps_texture,x->texturename);
}
}
void max_jit_peek_matrix_name(t_max_jit_peek *x, void *attr, long argc, t_atom *argv)
{
t_symbol *name=_jit_sym_nothing;
void *p;
if (argc&&argv) {
name = jit_atom_getsym(argv);
}
//if already something registered with this name, check class_jit_matrix, and handle accordingly
if (p=jit_object_findregistered(name)) {
if (!jit_object_method(p,_jit_sym_class_jit_matrix)) {
jit_object_error((t_object *)x,"jit.peek~: %s exists and is not a matrix");
while (x->inperform) ; // lightweight spinwait
x->mvalid = 0; // mark invalid for perform loop
if (x->matrix_name!=_jit_sym_nothing)
jit_object_detach(x->matrix_name, x);
x->matrix_name = _jit_sym_nothing;
x->mdata = NULL;
return;
}
}
while (x->inperform) ; // lightweight spinwait
x->mvalid = 0; // mark invalid for perform loop
jit_object_detach(x->matrix_name, x);
x->matrix_name = name;
jit_object_attach(x->matrix_name, x);
max_jit_peek_update(x);
while (x->inperform) ; // lightweight spinwait
x->mvalid = 1; // mark valid for perform loop
}
t_jit_err max_jit_str_op_jit_matrix(void *x, t_symbol *s, long argc, t_atom *argv)
{
void *matrix,*matrixout,*mop,*o,*p,*m;
t_atom a;
t_symbol *matrixname;
long err=JIT_ERR_NONE,inlet,i;
method ioproc,mproc;
if (!(mop=max_jit_obex_adornment_get(x,_jit_sym_jit_mop)))
return JIT_ERR_GENERIC;
if (argc&&argv) {
//find matrix
matrixname = jit_atom_getsym(argv);
matrix = jit_object_findregistered(matrixname);
if (matrix&&jit_object_method(matrix, _jit_sym_class_jit_matrix)) {
if (inlet=max_jit_obex_inletnumber_get(x)) {
//right inputs
if ((p=jit_object_method(mop,_jit_sym_getinput,inlet+1)) &&
(m=jit_object_method(p,_jit_sym_getmatrix)))
{
if (ioproc=(method)jit_object_method(p,_jit_sym_getioproc))
(*ioproc)(mop,p,matrix);
else
jit_object_method(m,_jit_sym_frommatrix,matrix,NULL);
} else {
err=JIT_ERR_GENERIC;
}
} else {
//calculate
switch (jit_attr_getlong(mop,_jit_sym_outputmode)) {
case 0: //nada
break;
case 2: //input(no calc)
//pass input through leftmost output
if ((p=jit_object_method(mop,_jit_sym_getoutput,1)) &&
(o=max_jit_mop_io_getoutlet(p)))
{
outlet_anything(o,_jit_sym_jit_matrix,1,argv);
}
break;
case 3: //output(no calc)
max_jit_mop_outputmatrix(x);
break;
default: //calc
//if adapt, resize
// if (jit_attr_getlong(mop,_jit_sym_adapt))
// max_jit_mop_adapt_matrix_all(x,matrix);
if ((p=jit_object_method(mop,_jit_sym_getoutput,1))&&
(ioproc=(method)jit_object_method(p,_jit_sym_getioproc)))
{
(*ioproc)(mop,p,matrix);
}
p = jit_object_method(mop,_jit_sym_getinput,1);
jit_object_method(p,_jit_sym_matrix,matrix);
jit_attr_setsym(p,_jit_sym_matrixname,matrixname);
// if (mproc=(method)max_jit_mop_getmproc(mop)) {
max_jit_str_op_mproc(x,mop);
/* } else {
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);
}
}*/
break;
}
}
} else {
jit_error_code(x,JIT_ERR_MATRIX_UNKNOWN);
}
}
return err;
}
t_jit_err jit_gl_videoplane_drawto_filter(t_jit_gl_videoplane *x, void *attr, long argc, t_atom *argv) {
if(argc && argv && x->texture) {
jit_attr_setsym(x->texture,ps_drawto, jit_atom_getsym(argv));
}
return JIT_ERR_NONE;
}
t_jit_err o_jit_pcl_supervoxel_matrix_calc(t_o_jit_pcl_supervoxel *x, t_symbol *s, long argc, t_atom *argv)
{
void *matrix = NULL;
t_jit_err err = JIT_ERR_NONE;
long in_savelock;
t_jit_matrix_info in_minfo;
char *in_bp;
long i, j;
long dimcount;
long planecount;
long dim[JIT_MATRIX_MAX_DIMCOUNT];
char *fip;
if( argc && argv )
{
matrix = jit_object_findregistered(jit_atom_getsym(argv));
}
else
return JIT_ERR_INVALID_INPUT;
if( matrix == NULL || !jit_object_method(matrix, _jit_sym_class_jit_matrix))
return JIT_ERR_INVALID_PTR;
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)
return JIT_ERR_INVALID_INPUT;
//get dimensions/planecount
dimcount = in_minfo.dimcount;
planecount = in_minfo.planecount;
if( planecount < 6 )
{
object_error((t_object *)x, "requires a 6 plane matrix (xyzrgb)");
err = JIT_ERR_INVALID_INPUT;
goto out;
}
if( in_minfo.type != _jit_sym_float32)
{
object_error((t_object *)x, "received: %s jit.pcl uses only float32 matrixes", in_minfo.type->s_name );
err = JIT_ERR_INVALID_INPUT;
goto out;
}
//if dimsize is 1, treat as infinite domain across that dimension.
//otherwise truncate if less than the output dimsize
for (i=0; i<dimcount; i++) {
dim[i] = in_minfo.dim[i];
if ( in_minfo.dim[i]<dim[i] && in_minfo.dim[i]>1) {
dim[i] = in_minfo.dim[i];
}
}
{
//convert to point cloud
pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZRGBA>);
cloud->width = (uint32_t)dim[0];
cloud->height = (uint32_t)dim[1];
cloud->points.resize (cloud->width * cloud->height);
size_t count = 0;
float _x, _y, _z;
uint8_t _r, _g, _b;
const float bad_point = std::numeric_limits<float>::quiet_NaN();
for (j = 0; j < dim[0]; ++j)
{
fip = in_bp + j * in_minfo.dimstride[0];
for( i = 0; i < dim[1]; ++i)
{
if(count < cloud->points.size())
{
_x = ((float *)fip)[0];
_y = ((float *)fip)[1];
_z = ((float *)fip)[2];
_r = (uint8_t)(((float *)fip)[3] * 255.0);
_g = (uint8_t)(((float *)fip)[4] * 255.0);
_b = (uint8_t)(((float *)fip)[5] * 255.0);
if( !_x && !_y && !_z && !_r && !_g && !_b )
{
cloud->points[count].x = bad_point;
cloud->points[count].y = bad_point;
cloud->points[count].z = bad_point;
cloud->points[count].r = bad_point;
cloud->points[count].g = bad_point;
cloud->points[count].b = bad_point;
cloud->points[count].a = bad_point;
}
else
{
cloud->points[count].x = _x;
cloud->points[count].y = _y;
cloud->points[count].z = _z;
cloud->points[count].r = _r;
cloud->points[count].g = _g;
cloud->points[count].b = _b;
cloud->points[count].a = 255;
}
}
count++;
fip += in_minfo.dimstride[1];
}
}
{
typedef pcl::PointXYZRGBA PointT;
pcl::SupervoxelClustering<PointT> super (x->voxel_resolution, x->seed_resolution);
float concavity_tolerance_threshold = 10;
float smoothness_threshold = 0.1;
uint32_t min_segment_size = 0;
bool use_extended_convexity = false;
bool use_sanity_criterion = false;
if (x->disable_transform)
super.setUseSingleCameraTransform (false);
super.setInputCloud ( cloud );
super.setColorImportance (x->color_importance);
super.setSpatialImportance (x->spatial_importance);
super.setNormalImportance (x->normal_importance);
if( cloud->height > 1)
{
super.setUseSingleCameraTransform (false);
}
std::map <uint32_t, pcl::Supervoxel<PointT>::Ptr > supervoxel_clusters;
super.extract (supervoxel_clusters);
pcl::PointCloud<PointT>::Ptr voxel_centroid_cloud = super.getVoxelCentroidCloud ();
pcl::PointCloud<pcl::PointXYZL>::Ptr labeled_voxel_cloud = super.getLabeledVoxelCloud ();
pcl::PointCloud<pcl::PointNormal>::Ptr sv_normal_cloud = super.makeSupervoxelNormalCloud (supervoxel_clusters);
std::multimap<uint32_t, uint32_t> supervoxel_adjacency;
super.getSupervoxelAdjacency (supervoxel_adjacency);
// LCCP
pcl::LCCPSegmentation<PointT> lccp;
lccp.setConcavityToleranceThreshold (concavity_tolerance_threshold);
lccp.setSanityCheck (use_sanity_criterion);
lccp.setSmoothnessCheck (true, x->voxel_resolution, x->seed_resolution, smoothness_threshold);
uint k_factor = 0;
if (use_extended_convexity)
k_factor = 1;
lccp.setKFactor (k_factor);
lccp.segment (supervoxel_clusters, supervoxel_adjacency);
if (min_segment_size > 0)
{
post ("Merging small segments\n");
lccp.mergeSmallSegments (min_segment_size);
}
pcl::PointCloud<pcl::PointXYZL>::Ptr sv_labeled_cloud = super.getLabeledCloud ();
pcl::PointCloud<pcl::PointXYZL>::Ptr lccp_labeled_cloud = sv_labeled_cloud->makeShared ();
lccp.relabelCloud (*lccp_labeled_cloud);
/*
typedef pcl::LCCPSegmentation<PointT>::SupervoxelAdjacencyList SuperVoxelAdjacencyList;
typedef pcl::LCCPSegmentation<PointT>::VertexIterator VertexIterator;
typedef pcl::LCCPSegmentation<PointT>::AdjacencyIterator AdjacencyIterator;
typedef pcl::LCCPSegmentation<PointT>::EdgeID EdgeID;
SuperVoxelAdjacencyList sv_adjacency_list;
lccp.getSVAdjacencyList (sv_adjacency_list);
*/
std::map<uint32_t, std::set<uint32_t> > segment_supervoxel_map;
lccp.getSegmentSupervoxelMap( segment_supervoxel_map );
std::map<uint32_t, std::set<uint32_t> >::iterator map_iter;
t_osc_bndl_u *bndl = osc_bundle_u_alloc();
char buf[2048];
ssize_t count = 0;
for( map_iter = segment_supervoxel_map.begin(); map_iter != segment_supervoxel_map.end(); ++map_iter)
{
uint32_t group_label = map_iter->first;
// ssize_t ngroup_voxel_pts = map_iter->second.size();
std::set<uint32_t>::iterator pt_id_iter;
for( pt_id_iter = map_iter->second.begin(); pt_id_iter != map_iter->second.end(); ++pt_id_iter)
{
sprintf(buf, "/supervoxel/pt/%ld", ++count);
t_osc_msg_u *supervoxel_group = osc_message_u_allocWithAddress(buf);
t_osc_bndl_u *subbndl = osc_bundle_u_alloc();
t_osc_msg_u *pt_num = osc_message_u_allocWithAddress((char *)"/pt_id");
osc_message_u_appendInt64(pt_num, count);
osc_bundle_u_addMsg(subbndl, pt_num);
t_osc_msg_u *segment_num = osc_message_u_allocWithAddress((char *)"/group_id");
osc_message_u_appendInt32(segment_num, group_label);
osc_bundle_u_addMsg(subbndl, segment_num);
pcl::Supervoxel<pcl::PointXYZRGBA>::Ptr supervoxel = supervoxel_clusters.at( *pt_id_iter );
t_osc_msg_u *centroid = osc_message_u_allocWithAddress((char *)"/centroid/xyz");
osc_message_u_appendFloat(centroid, supervoxel->centroid_.x);
osc_message_u_appendFloat(centroid, supervoxel->centroid_.y);
osc_message_u_appendFloat(centroid, supervoxel->centroid_.z);
osc_bundle_u_addMsg(subbndl, centroid);
t_osc_msg_u *centroid_color = osc_message_u_allocWithAddress((char *)"/centroid/rgb");
osc_message_u_appendFloat(centroid_color, supervoxel->centroid_.r);
osc_message_u_appendFloat(centroid_color, supervoxel->centroid_.g);
osc_message_u_appendFloat(centroid_color, supervoxel->centroid_.b);
osc_bundle_u_addMsg(subbndl, centroid_color);
pcl::PointCloud<pcl::PointXYZRGBA> adjacent_supervoxel_centers;
t_osc_msg_u *adjx = osc_message_u_allocWithAddress((char *)"/adjacent/x");
t_osc_msg_u *adjy = osc_message_u_allocWithAddress((char *)"/adjacent/y");
t_osc_msg_u *adjz = osc_message_u_allocWithAddress((char *)"/adjacent/z");
std::multimap<uint32_t,uint32_t>::iterator adjacent_itr = supervoxel_adjacency.equal_range(*pt_id_iter).first;
for ( ; adjacent_itr!=supervoxel_adjacency.equal_range(*pt_id_iter).second; ++adjacent_itr)
{
pcl::Supervoxel<pcl::PointXYZRGBA>::Ptr neighbor_supervoxel = supervoxel_clusters.at(adjacent_itr->second);
osc_message_u_appendFloat(adjx, neighbor_supervoxel->centroid_.x);
osc_message_u_appendFloat(adjy, neighbor_supervoxel->centroid_.y);
osc_message_u_appendFloat(adjz, neighbor_supervoxel->centroid_.z);
// line from supervoxel->centroid_ to each adjacent_supervoxel_centers
}
osc_bundle_u_addMsg(subbndl, adjx);
osc_bundle_u_addMsg(subbndl, adjy);
osc_bundle_u_addMsg(subbndl, adjz);
osc_message_u_appendBndl_u(supervoxel_group, subbndl);
osc_bundle_u_addMsg(bndl, supervoxel_group);
}
// post("%d %d", group_label, ngroup_voxel_pts);
}
// for( int i = 0; i < lccp_labeled_cloud->points.size(); i++ )
// post("%d %d", lccp_labeled_cloud->points.size(), lccp_labeled_cloud->points[i].label);
/*
std::set<EdgeID> edge_drawn;
//The vertices in the supervoxel adjacency list are the supervoxel centroids
//This iterates through them, finding the edges
std::pair<VertexIterator, VertexIterator> vertex_iterator_range;
vertex_iterator_range = boost::vertices (sv_adjacency_list);
t_osc_bndl_u *bndl = osc_bundle_u_alloc();
char buf[2048];
for (VertexIterator itr = vertex_iterator_range.first; itr != vertex_iterator_range.second; ++itr)
{
const uint32_t sv_label = sv_adjacency_list[*itr];
pcl::Supervoxel<PointT>::Ptr supervoxel = supervoxel_clusters.at (sv_label);
pcl::PointXYZRGBA vert_curr = supervoxel->centroid_;
// pcl::PointXYZL lccp_pt = lccp_labeled_cloud->at ( sv_label );
const uint32_t group_label = lccp_labeled_cloud->at ( sv_label ).label;
// const uint32_t group_label = lccp_labeled_cloud->points[ sv_label ].label;
sprintf(buf, "/supervoxel/%d/%d", group_label, sv_label);
post("%s", buf);
t_osc_msg_u *supervoxel_group = osc_message_u_allocWithAddress(buf);
t_osc_bndl_u *subbndl = osc_bundle_u_alloc();
t_osc_msg_u *centroid = osc_message_u_allocWithAddress((char *)"/centroid/xyz");
osc_message_u_appendFloat(centroid, vert_curr.x);
osc_message_u_appendFloat(centroid, vert_curr.y);
osc_message_u_appendFloat(centroid, vert_curr.z);
osc_bundle_u_addMsg(subbndl, centroid);
t_osc_msg_u *centroid_color = osc_message_u_allocWithAddress((char *)"/centroid/rgb");
osc_message_u_appendFloat(centroid_color, vert_curr.r);
osc_message_u_appendFloat(centroid_color, vert_curr.g);
osc_message_u_appendFloat(centroid_color, vert_curr.b);
osc_bundle_u_addMsg(subbndl, centroid_color);
t_osc_msg_u *adjx = osc_message_u_allocWithAddress((char *)"/adjacent/x");
t_osc_msg_u *adjy = osc_message_u_allocWithAddress((char *)"/adjacent/y");
t_osc_msg_u *adjz = osc_message_u_allocWithAddress((char *)"/adjacent/z");
t_osc_msg_u *is_conv = osc_message_u_allocWithAddress((char *)"/vertex/convex");
std::pair<AdjacencyIterator, AdjacencyIterator> neighbors = boost::adjacent_vertices (*itr, sv_adjacency_list);
for (AdjacencyIterator itr_neighbor = neighbors.first; itr_neighbor != neighbors.second; ++itr_neighbor)
{
EdgeID connecting_edge = boost::edge (*itr, *itr_neighbor, sv_adjacency_list).first; //Get the edge
osc_message_u_appendBool(is_conv, sv_adjacency_list[connecting_edge].is_convex);
const uint32_t sv_neighbor_label = sv_adjacency_list[*itr_neighbor];
pcl::Supervoxel<PointT>::Ptr supervoxel_neigh = supervoxel_clusters.at (sv_neighbor_label);
pcl::PointXYZRGBA vert_neigh = supervoxel_neigh->centroid_;
osc_message_u_appendFloat(adjx, vert_neigh.x);
osc_message_u_appendFloat(adjy, vert_neigh.y);
osc_message_u_appendFloat(adjz, vert_neigh.z);
}
osc_bundle_u_addMsg(subbndl, adjx);
osc_bundle_u_addMsg(subbndl, adjy);
osc_bundle_u_addMsg(subbndl, adjz);
osc_bundle_u_addMsg(subbndl, is_conv);
osc_message_u_appendBndl_u(supervoxel_group, subbndl);
osc_bundle_u_addMsg(bndl, supervoxel_group);
}
post("--------------");
*/
/*
//To make a graph of the supervoxel adjacency, we need to iterate through the supervoxel adjacency multimap
std::multimap<uint32_t,uint32_t>::iterator label_itr = supervoxel_adjacency.begin ();
for ( ; label_itr != supervoxel_adjacency.end (); )
{
//First get the label
uint32_t supervoxel_label = label_itr->first;
pcl::Supervoxel<pcl::PointXYZRGBA>::Ptr supervoxel = supervoxel_clusters.at( supervoxel_label );
sprintf(buf, "/supervoxel/%d", supervoxel_label);
t_osc_msg_u *supervoxel_group = osc_message_u_allocWithAddress(buf);
t_osc_bndl_u *subbndl = osc_bundle_u_alloc();
t_osc_msg_u *centroid = osc_message_u_allocWithAddress((char *)"/centroid/xyz");
osc_message_u_appendFloat(centroid, supervoxel->centroid_.x);
osc_message_u_appendFloat(centroid, supervoxel->centroid_.y);
osc_message_u_appendFloat(centroid, supervoxel->centroid_.z);
osc_bundle_u_addMsg(subbndl, centroid);
t_osc_msg_u *centroid_color = osc_message_u_allocWithAddress((char *)"/centroid/rgb");
osc_message_u_appendFloat(centroid_color, supervoxel->centroid_.r);
osc_message_u_appendFloat(centroid_color, supervoxel->centroid_.g);
osc_message_u_appendFloat(centroid_color, supervoxel->centroid_.b);
osc_bundle_u_addMsg(subbndl, centroid_color);
pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloud_hull_ (new pcl::PointCloud<pcl::PointXYZRGBA>);
std::vector<pcl::Vertices> vertices_;
//get convex hull of supervoxel region:
pcl::ConvexHull<pcl::PointXYZRGBA> hr;
hr.setDimension(3);
hr.setInputCloud(supervoxel->voxels_);
// cloud_hull_.reset (new Cloud); << save on reallocating memory later?
hr.reconstruct (*cloud_hull_, vertices_);
t_osc_msg_u *cvx_x = osc_message_u_allocWithAddress((char *)"/convexhull/pts/x");
t_osc_msg_u *cvx_y = osc_message_u_allocWithAddress((char *)"/convexhull/pts/y");
t_osc_msg_u *cvx_z = osc_message_u_allocWithAddress((char *)"/convexhull/pts/z");
for( long j = 0; j < cloud_hull_->points.size(); ++j)
{
osc_message_u_appendFloat(cvx_x, cloud_hull_->points[j].x);
osc_message_u_appendFloat(cvx_y, cloud_hull_->points[j].y);
osc_message_u_appendFloat(cvx_z, cloud_hull_->points[j].z);
}
osc_bundle_u_addMsg(subbndl, cvx_x);
osc_bundle_u_addMsg(subbndl, cvx_y);
osc_bundle_u_addMsg(subbndl, cvx_z);
t_osc_msg_u *vert0 = osc_message_u_allocWithAddress((char *)"/convexhull/vertex/idx/0");
t_osc_msg_u *vert1 = osc_message_u_allocWithAddress((char *)"/convexhull/vertex/idx/1");
t_osc_msg_u *vert2 = osc_message_u_allocWithAddress((char *)"/convexhull/vertex/idx/2");
std::vector<pcl::Vertices>::iterator iter_vertices;
for( iter_vertices = vertices_.begin(); iter_vertices != vertices_.end(); ++iter_vertices)
{
osc_message_u_appendInt32(vert0, (*iter_vertices).vertices[0]);
osc_message_u_appendInt32(vert1, (*iter_vertices).vertices[1]);
osc_message_u_appendInt32(vert2, (*iter_vertices).vertices[3]);
}
osc_bundle_u_addMsg(subbndl, vert0);
osc_bundle_u_addMsg(subbndl, vert1);
osc_bundle_u_addMsg(subbndl, vert2);
//Now we need to iterate through the adjacent supervoxels and make a point cloud of them
// pcl::PointCloud<pcl::PointXYZRGBA> adjacent_supervoxel_centers;
t_osc_msg_u *adjx = osc_message_u_allocWithAddress((char *)"/adjacent/x");
t_osc_msg_u *adjy = osc_message_u_allocWithAddress((char *)"/adjacent/y");
t_osc_msg_u *adjz = osc_message_u_allocWithAddress((char *)"/adjacent/z");
std::multimap<uint32_t,uint32_t>::iterator adjacent_itr = supervoxel_adjacency.equal_range(supervoxel_label).first;
for ( ; adjacent_itr!=supervoxel_adjacency.equal_range(supervoxel_label).second; ++adjacent_itr)
{
pcl::Supervoxel<pcl::PointXYZRGBA>::Ptr neighbor_supervoxel = supervoxel_clusters.at(adjacent_itr->second);
osc_message_u_appendFloat(adjx, neighbor_supervoxel->centroid_.x);
osc_message_u_appendFloat(adjy, neighbor_supervoxel->centroid_.y);
osc_message_u_appendFloat(adjz, neighbor_supervoxel->centroid_.z);
// line from supervoxel->centroid_ to each adjacent_supervoxel_centers
}
osc_bundle_u_addMsg(subbndl, adjx);
osc_bundle_u_addMsg(subbndl, adjy);
osc_bundle_u_addMsg(subbndl, adjz);
osc_message_u_appendBndl_u(supervoxel_group, subbndl);
osc_bundle_u_addMsg(bndl, supervoxel_group);
//Move iterator forward to next label
label_itr = supervoxel_adjacency.upper_bound (supervoxel_label);
}
*/
omax_util_outletOSC_u(x->outlet, bndl);
if(bndl)
osc_bundle_u_free(bndl);
}
}
out:
jit_object_method(matrix, _jit_sym_lock, in_savelock);
return err;
}
t_jit_err FarfalharSystem::messageControl(long argc, t_atom* argv){
std::string task;
task = jit_atom_getsym(argv)->s_name;
if(task == "setMaxBeating"){
if(argc == 2){
if(argv){
for(int i=0; i<particles->size(); i++){
static_cast<FarfalharParticle*>((*particles)[i])->setMaxBeating(atom_getfloat(argv + 1));
}
}
}
}
else if(task == "setBeatingSpeed"){
if(argc == 2){
if(argv){
for(int i=0; i<particles->size(); i++){
static_cast<FarfalharParticle*>((*particles)[i])->setBeatingSpeed(atom_getfloat(argv + 1));
}
}
}
}
else if(task == "setResolutionProbability"){
if(argc == 2){
if(argv){
for(int i=0; i<particles->size(); i++){
static_cast<FarfalharParticle*>((*particles)[i])->setResolutionProb(atom_getfloat(argv + 1));
}
}
}
}
else if(task == "setNotes"){
if(argc == 9){
if(argv){
for(int i=0; i<particles->size(); i++){
static_cast<FarfalharParticle*>((*particles)[i])->setNotes(argc - 1, argv + 1);
}
}
}
}
else if(task == "redraw"){
if(argc == 2){
if(argv){
redraw = atom_getlong(argv + 1);
}
}
}
else if(task == "collapse"){
if(argc == 2){
if(argv){
collapse = true;
int collapseArg = atom_getlong(argv + 1);
switch(collapseArg){
case 0:
collapse = true;
nota = "G#3";
break;
case 1:
collapse = true;
nota = "Bb3";
break;
case 2:
collapse = true;
nota = "D4";
break;
case 3:
collapse = true;
nota = "F#4";
break;
case 4:
collapse = true;
nota = "G4";
break;
case 5:
collapse = true;
nota = "C5";
break;
case 6:
collapse = true;
nota = "E5";
break;
case 7:
collapse = true;
nota = "A5";
break;
case 8:
collapse = true;
nota = "G3_2";
break;
case 9:
collapse = true;
nota = "F#4_2";
break;
case 10:
collapse = true;
nota = "D5_2";
break;
case 11:
collapse = true;
nota = "E5_2";
break;
case 12:
collapse = true;
nota = "A#5_2";
break;
case 13:
collapse = true;
nota = "B4_3";
break;
}
}
}
return JIT_ERR_NONE;
}
pSystem::messageControl(argc, argv);
return JIT_ERR_INVALID_INPUT;
}
