namaste ranch

I'm trying to rig up a way to detect that the contents of a jit.matrix have changed. Couldn't figure out if/how jit.op might be of service. Seems like comparing the totalled output of jit.iter on the live matrix to that of another matrix storing preceding frame could be useful... similar to a derivative of the example at the end of the jit.iter html help file... but my best attempt to copy it accurately (and subsequently troubleshoot) isn't working. I get low numbers that are likely just the value of the last cell. Also, I'm working with fairly large matrices, so something speedier would be ideal. I tried making a version of that jit.iter help html file that unpacked the channels so I could just run the comparison on a single channel, but I'm still having a problem with that whole construct.

I've included my best efforts at the aforementioned below in case this is the best way and somebody can see what I'm doing wrong. Or perhaps there's a more elegant solution, especially for a large matrix? Thanks!

detecting-change-to-jit-matrix

> I'm trying to rig up a way to detect that the contents of a jit.matrix have changed. Couldn't figure out if/how jit.op might be of service. Seems like comparing the totalled output of jit.iter on the live matrix to that of another matrix storing preceding frame could be useful... similar to a derivative of the example at the end of the jit.iter html help file... but my best attempt to copy it accurately (and subsequently troubleshoot) isn't working. I get low numbers that are likely just the value of the last cell. Also, I'm working with fairly large matrices, so something speedier would be ideal. I tried making a version of that jit.iter help html file that unpacked the channels so I could just run the comparison on a single channel, but I'm still having a problem with that whole construct.

> I've included my best efforts at the aforementioned below in case this is the best way and somebody can see what I'm doing wrong. Or perhaps there's a more elegant solution, especially for a large matrix? Thanks!

> #P number 130 240 63 9 0 0 0 3 0 0 0 221 221 221 222 222 222 0 0 0;

> #P user jit.pwindow 291 77 82 62 0 1 0 0 1 0;

> #P message 404 270 50 196617 255 9 13 19;

> #P newex 404 246 62 196617 prepend set;

> #P newex 404 223 76 196617 vexpr $i1+$i2;

> #P message 382 28 94 196617 importmovie , bang;

> #P newex 382 52 131 196617 jit.matrix 4 char @adapt 1;

> #P user jit.pwindow 17 72 82 62 0 1 0 0 1 0;

> #P newex 130 218 76 196617 vexpr $i1+$i2;

> #P newex 108 97 76 196617 unpack 0 0 0 0;

> #P message 108 23 94 196617 importmovie , bang;

> #P newex 108 47 131 196617 jit.matrix 4 char @adapt 1;

> #P comment 37 168 74 196617 single channel attempt;

> #P comment 294 171 100 196617 just trying to get the help example to work!;

> #P fasten 21 0 24 0 446 191 500 191 500 242 409 242;

> #P fasten 14 1 19 0 402 96 466 96 466 122 446 122;

On 2/28/07, Jeff Burger  wrote:
>
> Hello all,
>
> I'm trying to rig up a way to detect that the contents of a jit.matrix have changed. Couldn't figure out if/how jit.op might be of service. Seems like comparing the totalled output of jit.iter on the live matrix to that of another matrix storing preceding frame could be useful... similar to a derivative of the example at the end of the jit.iter html help file... but my best attempt to copy it accurately (and subsequently troubleshoot) isn't working. I get low numbers that are likely just the value of the last cell. Also, I'm working with fairly large matrices, so something speedier would be ideal. I tried making a version of that jit.iter help html file that unpacked the channels so I could just run the comparison on a single channel, but I'm still having a problem with that whole construct.
>
> I've included my best efforts at the aforementioned below in case this is the best way and somebody can see what I'm doing wrong. Or perhaps there's a more elegant solution, especially for a large matrix? Thanks!
>
> Jeff
>
> #P button 382 113 15 0;
> #P window setfont "Sans Serif" 9.;
> #P number 130 240 63 9 0 0 0 3 0 0 0 221 221 221 222 222 222 0 0 0;
> #P user jit.pwindow 291 77 82 62 0 1 0 0 1 0;
> #P window linecount 2;
> #P message 404 270 50 196617 255 9 13 19;
> #P window linecount 1;
> #P newex 404 246 62 196617 prepend set;
> #P newex 404 223 76 196617 vexpr $i1+$i2;
> #P newex 421 196 36 196617 zl reg;
> #P message 441 171 43 196617 0 0 0 0;
> #P newex 441 149 43 196617 route 0;
> #P newex 441 127 43 196617 route 0;
> #P newex 404 126 27 196617 t l b;
> #P button 355 28 15 0;
> #P message 382 28 94 196617 importmovie , bang;
> #P newex 382 52 131 196617 jit.matrix 4 char @adapt 1;
> #P newex 382 76 41 196617 jit.iter;
> #P user jit.pwindow 17 72 82 62 0 1 0 0 1 0;
> #P newex 130 218 76 196617 vexpr $i1+$i2;
> #P newex 147 189 36 196617 zl reg;
> #P message 167 166 43 196617 0 0 0 0;
> #P newex 167 144 43 196617 route 0;
> #P newex 167 122 43 196617 route 0;
> #P newex 130 121 27 196617 t l b;
> #P newex 108 97 76 196617 unpack 0 0 0 0;
> #P button 81 23 15 0;
> #P message 108 23 94 196617 importmovie , bang;
> #P newex 108 47 131 196617 jit.matrix 4 char @adapt 1;
> #P newex 108 71 41 196617 jit.iter;
> #P window linecount 2;
> #P comment 37 168 74 196617 single channel attempt;
> #P window linecount 3;
> #P comment 294 171 100 196617 just trying to get the help example to work!;
> #P fasten 22 0 23 1 426 221 475 221;
> #P fasten 21 0 24 0 446 191 500 191 500 242 409 242;
> #P fasten 21 0 22 1 446 191 452 191;
> #P connect 20 0 21 0;
> #P connect 19 0 20 0;
> #P fasten 14 1 19 0 402 96 466 96 466 122 446 122;
> #P connect 18 1 22 0;
> #P connect 24 0 25 0;
> #P connect 23 0 24 0;
> #P connect 18 0 23 0;
> #P connect 14 0 28 0;
> #P connect 14 0 18 0;
> #P connect 15 0 26 0;
> #P connect 15 0 14 0;
> #P connect 17 0 15 0;
> #P connect 16 0 15 0;
> #P fasten 11 0 12 1 152 210 201 210;
> #P fasten 10 0 11 1 172 186 178 186;
> #P connect 9 0 10 0;
> #P connect 8 0 9 0;
> #P fasten 2 1 8 0 128 91 192 91 192 117 172 117;
> #P connect 7 1 11 0;
> #P connect 12 0 27 0;
> #P connect 7 0 12 0;
> #P connect 6 1 7 0;
> #P connect 2 0 6 0;
> #P connect 3 0 13 0;
> #P connect 3 0 2 0;
> #P connect 4 0 3 0;
> #P connect 5 0 3 0;
> #P window clipboard copycount 29;
>
>
> --
> www.jeffreypaulburger.com
> www.jpburger.com
>


jit.duh! Just never encountered it before. Thx, Wes!

wesly (or any with know) , if you care to expand on the jit.change a bit.

i have been using unique 1 on my jit.dx.grab with much better preformance

only yestrday i started applying it to jit.qt.movie also (after scanning the

archives for better multi qt playing tips).

adding the unique attribute realy made a big improvment when banging a

does applying a jit.change in importent matrix crossroards is a good one,

stopping un-changed matrix from flowing thru.

and, is it better to speedlim a qt.movie Vs. unique 1 ?

> jit.duh! Just never encountered it before. Thx, Wes!

wesly (or any with know) , if you care to expand on the jit.change a bit.
i have been using unique 1 on my jit.dx.grab with much better preformance
from my cpu.
only yestrday i started applying it to jit.qt.movie also (after scanning the
archives for better multi qt playing tips).
adding the unique attribute realy made a big improvment when banging a
qt.movie to fast for it own good.
my question is a design one.
does applying a jit.change in importent matrix crossroards is a good one,
stopping un-changed matrix from flowing thru.
and, is it better to speedlim a qt.movie Vs. unique 1 ?

On 3/5/07, Jeff Burger  wrote:
>
>
> jit.duh! Just never encountered it before. Thx, Wes!
>
> Jeff
> --
> www.jeffreypaulburger.com
> www.jpburger.com
>

Applying it a jit.qt.movie makes the most sense since this is where

your source material originates and us unadulterated. Further down

the processing chain, I think you'll see little to no improvement both

efficiency-wise and aesthetically. This is because for any moderately

involved processing chain with any feedback you're going to get more

variation and jit.change not save you anything. If you trty to

compensate by setting the jit.change threshold higher, you'll get

> wesly (or any with know) , if you care to expand on the jit.change a bit.

> i have been using unique 1 on my jit.dx.grab with much better preformance

> only yestrday i started applying it to jit.qt.movie also (after scanning the

> archives for better multi qt playing tips).

> adding the unique attribute realy made a big improvment when banging a

> does applying a jit.change in importent matrix crossroards is a good one,

> stopping un-changed matrix from flowing thru.

> and, is it better to speedlim a qt.movie Vs. unique 1 ?

> > jit.duh! Just never encountered it before. Thx, Wes!

Applying it a jit.qt.movie makes the most sense since this is where
your source material originates and us unadulterated.  Further down
the processing chain, I think you'll see little to no improvement both
efficiency-wise and aesthetically.  This is because for any moderately
involved processing chain with any feedback you're going to get more
variation and jit.change not save you anything.  If you trty to
compensate by setting the jit.change threshold higher, you'll get
jumpier results.

On 3/5/07, yair reshef  wrote:
> wesly (or any with know) , if you care to expand on the jit.change a bit.
> i have been using unique 1 on my jit.dx.grab with much better preformance
> from my cpu.
> only yestrday i started applying it to jit.qt.movie also (after scanning the
> archives for better multi qt playing tips).
> adding the unique attribute realy made a big improvment when banging a
> qt.movie to fast for it own good.
> my question is a design one.
> does applying a jit.change in importent matrix crossroards is a good one,
> stopping un-changed matrix from flowing thru.
> and, is it better to speedlim a qt.movie Vs. unique 1 ?
>
>
>
> On 3/5/07, Jeff Burger  wrote:
> >
> > jit.duh! Just never encountered it before. Thx, Wes!
> >
> > Jeff
> > --
> > www.jeffreypaulburger.com
> > www.jpburger.com
> >
>
>
>
>


@unique uses a fairly lightweight method to determine whether a new 

matrix should be sent out or not. Since speedlim/qlim don't know 

anything about the contents of the movie, I would generally opt for 

using @unique, if you need to thin the output of jit.qt.movie.

jit.change has to do a pixel-by-pixel comparison of each incoming 

matrix to the previous one. As such, it's a bit slower. However, it's 

a bit unclear to me what multiple "time thinning" would provide: if 

your movies are being @unique'd, the rate of outgoing matrices isn't 

Am 05.03.2007 um 09:37 schrieb yair reshef:

> does applying a jit.change in importent matrix crossroards is a 

@unique uses a fairly lightweight method to determine whether a new  
matrix should be sent out or not. Since speedlim/qlim don't know  
anything about the contents of the movie, I would generally opt for  
using @unique, if you need to thin the output of jit.qt.movie.

jit.change has to do a pixel-by-pixel comparison of each incoming  
matrix to the previous one. As such, it's a bit slower. However, it's  
a bit unclear to me what multiple "time thinning" would provide: if  
your movies are being @unique'd, the rate of outgoing matrices isn't  
going to speed up as the patch runs.

> does applying a jit.change in importent matrix crossroards is a  
> good one,
> stopping un-changed matrix from flowing thru.
> and, is it better to speedlim a qt.movie Vs. unique 1 ?


i ask because i am hacking the moviebank js example to spit random movies on

one of my functions, which handles the bang routine is not banging the movie

directly but a dummy matrix that the qt.movie is passing matrix into.

if you someone has the time please go over this and see if this can be

the first is newTextures = which is iterated and passed as a 2 member

sequence with the second member a random index of a movie file from the

patchmedia folder, inside the function another function is called,

createMovTexture which handles the creating of new movie textures and the

goneTextures, handles the freepeering of textures etc.

sameTextures is banged with a metro for the actuall playing of the qt.movies

again, any help would be welcomed. im on win/xp btw

//////////////////////////////////////////////////

var dummymatrix = new JitterMatrix(4,"char",vdim[0],vdim[1]);

function sameTextures(){ //this list accepts currently playing texture

movarray[a[i]].matrixcalc(outmatrix[a[i]]/*null*/,outmatrix[a[i]]);

glTextureArray[a[i]].jit_matrix("texMatrix"+a[i]);

function newTextures()//this list will initiate new textures

createMovTexture(vindex,a[1]); //look for this function for

function goneTextures()//this list will deal with gone textures, freepeer

//post(glTextureArray[vindex].name+"nn");

movarray[vindex].matrixcalc(dummymatrix/*null*/,dummymatrix);

vcount = 0; //number of valid movies in folder

filenames[vcount] = fold.pathname + "/" + fold.filename;

outlet(2,vcount); //send number of movies to leftmost outlet

// this function creates movies and binds them to texture absed on the name

//add random run on valid movie names in folder (filenames array)

movarray[name] = new JitterObject(" jit.qt.movie");

glTextureArray[name] = new JitterObject("jit.gl.texture","table");

rv = movarray[name].read(filenames[urn]);

if (rv[1]==1) { // success, read returns an array [filename,success]

outmatrix[name] = new JitterMatrix(4,"char",vdim[0],vdim[1]);

/* Actually only MOPs support the matrixcalc() method. All the

jit_matrix method which requires being sent as a name. So the

glTextureArray[name].jit_matrix("texMatrix"+name);

> @unique uses a fairly lightweight method to determine whether a new

> matrix should be sent out or not. Since speedlim/qlim don't know

> anything about the contents of the movie, I would generally opt for

> using @unique, if you need to thin the output of jit.qt.movie.

> jit.change has to do a pixel-by-pixel comparison of each incoming

> matrix to the previous one. As such, it's a bit slower. However, it's

> a bit unclear to me what multiple "time thinning" would provide: if

> your movies are being @unique'd, the rate of outgoing matrices isn't

> Am 05.03.2007 um 09:37 schrieb yair reshef:

> > does applying a jit.change in importent matrix crossroards is a

> > stopping un-changed matrix from flowing thru.

> > and, is it better to speedlim a qt.movie Vs. unique 1 ?

i ask because i am hacking the moviebank js example to spit random movies on
named textures.
one of my functions, which handles the bang routine is not banging the movie
directly but a dummy matrix that the qt.movie is passing matrix into.
if you someone has the time please go over this and see if this can be
better managed.

the javascript accepts 3 kind of lists.
the first is newTextures = which is iterated and passed as a 2 member
sequence with the second member a random index of a movie file from the
patchmedia folder, inside the function another function is called,
createMovTexture which handles the creating of new movie textures and the
binding to named textures.

sameTextures is banged with a metro for the actuall playing of the qt.movies
.

//////////////////////////////////////////////////
//JS FILE moviebank_totexture.js
//////////////////////////////////////////////////
autowatch=1;
outlets = 3;
post("ncompiledn");
//
var vdim = [512,512];
var vindex = 0;
var vcount = 0;
var movarray = new Array();
var glTextureArray = new Array();
var outmatrix = new Array();
var dummymatrix = new JitterMatrix(4,"char",vdim[0],vdim[1]);
var filenames = new Array();
var texMatrix = new Array();

//
//
function sameTextures(){ //this list accepts currently playing texture
numbers  and use them to bang
var a = arrayfromargs(arguments);
    for(i=0;i
        if (movarray[a[i]]){

movarray[a[i]].matrixcalc(outmatrix[a[i]]/*null*/,outmatrix[a[i]]);
            glTextureArray[a[i]].jit_matrix("texMatrix"+a[i]);
        }
    }
}
//
function newTextures()//this list will initiate new textures
{
var a = arrayfromargs(arguments);
        vindex = a[0];
        createMovTexture(vindex,a[1]); //look for this function for
initializing
        movarray[vindex].frame(0)
        movarray[vindex].start();

}
//
function goneTextures()//this list will deal with gone textures, freepeer
stylie
{
var a = arrayfromargs(arguments);
    for(i=0;i< a.length;i++){
        vindex = a[i];
        movarray[vindex].dispose();
        glTextureArray[vindex].freepeer();
        glTextureArray[vindex].name= false;
        //post(glTextureArray[vindex].name+"nn");
        movarray[vindex].matrixcalc(dummymatrix/*null*/,dummymatrix);
    }
}

//
//read ze folder
function readfolder(foldername)
{
    var fold;
    var i,rv;

    fold = new Folder(foldername);
    fold.typelist = ["MooV"]
    if (fold.count) {
        // build filename array
        vcount = 0; //number of valid movies in folder
        fold.reset();
        filenames = new Array();
        outlet(1,"clear"); //reset umenu
        // dump movienames to ubmenu
        for (i=0;i
            fold.next();
            filenames[vcount] = fold.pathname + "/" + fold.filename;
            outlet(1,"append",fold.filename);
            vcount++;
            }

        outlet(2,vcount); //send number of movies to leftmost outlet
    }
}
//
// this function creates movies and binds them to texture absed on the name
of the blob
//add random run on valid movie names in folder (filenames array)
function createMovTexture(name, urn){
    movarray[name] = new JitterObject(" jit.qt.movie");
    glTextureArray[name] = new JitterObject("jit.gl.texture","table");
    glTextureArray[name].name="m"+name;
    movarray[name].autostart = 0;
    movarray[name].loadram = 1;
    movarray[name].vol = 0;
    movarray[name].unique = 1;
    rv = movarray[name].read(filenames[urn]);
    if (rv[1]==1) { // success, read returns an array [filename,success]
        outmatrix[name] = new JitterMatrix(4,"char",vdim[0],vdim[1]);
        outmatrix[name].name="texMatrix"+name;
            /* Actually only MOPs support the matrixcalc() method. All the
gl objects use the
            jit_matrix method which requires being sent as a name. So the
following:
            texture.jit_matrix(matx.name); */
        glTextureArray[name].jit_matrix("texMatrix"+name);
    }
    //post(glTextureArray[name].name+"nn");
}

On 3/5/07, Jeremy Bernstein  wrote:
>
> @unique uses a fairly lightweight method to determine whether a new
> matrix should be sent out or not. Since speedlim/qlim don't know
> anything about the contents of the movie, I would generally opt for
> using @unique, if you need to thin the output of jit.qt.movie.
>
> jit.change has to do a pixel-by-pixel comparison of each incoming
> matrix to the previous one. As such, it's a bit slower. However, it's
> a bit unclear to me what multiple "time thinning" would provide: if
> your movies are being @unique'd, the rate of outgoing matrices isn't
> going to speed up as the patch runs.
>
> jb
>
> Am 05.03.2007 um 09:37 schrieb yair reshef:
>
> > does applying a jit.change in importent matrix crossroards is a
> > good one,
> > stopping un-changed matrix from flowing thru.
> > and, is it better to speedlim a qt.movie Vs. unique 1 ?
>
>

Detecting change to jit.matrix