QuartzComposer Templates

==============JavaScript_Functions==============================
outputs[0] =            Math.SQRT2;
outputs[0] =            Math.SQRT1_2;
outputs[0] =            Math.PI;
outputs[0] =            Math.LOG10E;
outputs[0] =            Math.LOG2E;
outputs[0] =            Math.LN10;
outputs[0] =            Math.LN2;
outputs[0] =            Math.E;
outputs[0] =            Math.sqrt(inputs[0]);
outputs[0] =            Math.sin(n);
outputs[0] =            Math.round(inputs[0]);
outputs[0] =            Math.random();
outputs[0] =            Math.pow(n,2);
outputs[0] =            Math.min(n,0.5);
outputs[0] =            Math.max(n,0.5);
outputs[0] =            Math.log(n);
outputs[0] =            Math.floor(inputs[0]);
outputs[0] =            Math.exp(n);
outputs[0] =            Math.cos(n);
outputs[0] =            Math.ceil(inputs[0]);
rad =                   Math.atan2(y,x);
outputs[0] =            rad * 180/Math.PI;
outputs[0] =            Math.atan(n);
outputs[0] =            Math.asin(n);
outputs[0] =            Math.acos(n);
outputs[0] =            Math.abs(inputs[0]);
outputs[0] =            str.toUpperCase();
outputs[0] =            str.toLowerCase();
str =                   "ABCDEFG";
outputs[0] =            str.substring(2,5);
outputs[0] =            str.substr(2,5);
outputs[0] =            str.slice(2,5);
str =                   "AB:CDE:FG";
result =                str.split(":");
outputs[0] =            result.toString();
str =                   "Sample_sample123";
n =                     str.search(/12/g);
n =                     str.replace(/mp/g,"MP");
n =                     str.match(/mp/g);
n =                     n.length;
str =                   "Quartz Extream";
n =                     str.lastIndexOf("a");
str =                   "Sample";
n =                     str.indexOf("m");
str =                   String.fromCharCode(66);
str =                   "A";
n =                     str.charCodeAt(0);
str =                   "Sample";
n =                     str.charAt(1);
function calc(a,b)      { return a * b;}
outputs[0] =            calc(2,4);
for                     (i in Math) { outputs[0] = i;}
for                     (i=0; i<3; i++) { outputs[0] = i; }
while                   (n<3) { n++; outputs[0] = n; }
do                      { n++;  outputs[0] = n; } while (n<3);
for                     (i=0; i<5; i++) { if (i == 2) continue; outputs[0] = i; }
for                     (i=0; i<10; i++) { outputs[0] = i; if (i == 2) break; }
if                      (n < 30) {outputs[0] = "yes"; }else{ outputs[0] = "no";}
switch(n)               {case 0 :outputs[0]  = "zero"; break;
                         case 1 :outputs[0]  = "one "; break;
                         default:outputs[0]  = "none"; }
 

==============JavaScript_Patch_Template==============================
JavaScriptTemplate.jpg


==============ReadFileIntoArray.qtz/Kineme_String_With_File========
Kineme_String_With_File.jpg

==============ReadFileIntoArray.qtz/String2_2D_Array===============
String2_2D_Array.jpg

var myarray2 =          new Array();

function (
__number                N,
__string                S,
__structure             ArrayOut)
main (
__string                StrinIN)
{ var result =          new Object();
 if                     (!_testMode)
{ myarray =             StrinIN.split("*");
  N =                   myarray.length;
  result.N  =           N;
  for                   (i=0;i<N;i++) 
{ myarray2[i] =         myarray[i].split(":"); }
  result.S  =           myarray2[0][0];
} result.ArrayOut =     myarray2;
  return                result;
}

==============ReadFileIntoArray.qtz/Read_In_2D_Array========
Read_In_2D_Array.jpg

function (
__number               Numb,
__string               T,
__number               X,
__number               Y)
main (
__structure            ArrayIN,
__number               index)
{ var result =         new Object();
  var i =              index;
  var i =              index;
  if                   (!_testMode  )
{ result.Numb =        ArrayIN.length;
  result.T =           ArrayIN[i][0] ;
  result.X =           Number(ArrayIN[i][1]) ;
  result.Y =           Number(ArrayIN[i][2]) ;
} return               result;
}



=============ReadFileIntoArray.qtz/2DArray_Make2========
2DArray_Make2.jpg

var myarray =           new Array();
function (
__number                Numb,
__structure             ArrayOut)
main ( )
{ var result =          new Object();
  myarray[0] =          new Array(.1 , .2 , .3 );
  myarray[1] =          new Array(.2 , .4 , .5 );
  myarray[2] =          new Array(.7 ,-.1 , .1 );
  myarray[3] =          new Array(.8 , .5 , .6 );
  myarray[4] =          new Array(.9 , .5 , .7 );
  result.Numb =         myarray.length;
  result.ArrayOut =     myarray;
  return                result;
}
==============ReadFileIntoArray.qtz/Read_2D_Array========
Read_In_2D_Array.jpg

function (
__number               Numb,
__number               X0,
__number               X1,
__number               X2,
__number               X3)
main (
__structure            ArrayOrList)
{ var result =         new Object();
  if                   (!_testMode)
{ result.Numb =        ArrayOrList.length;
  result.X0 =          ArrayOrList[0][0];
  result.X1 =          ArrayOrList[0][1]; 
  result.X2 =          ArrayOrList[1][0];
  result.X3 =          ArrayOrList[1][1];
} return               result;
}           

=============ReadFileIntoArray.qtz/Read_In_Array========
Read_In_Array.jpg

function (
__number               Numb,
__string               X0,
__string               X1)
main (
__structure            ArrayOrList)
{ var result =         new Object();
  if                   (!_testMode)
{ result.Numb =        ArrayOrList.length;
  result.X0 =          ArrayOrList[0];
  result.X1 =          ArrayOrList[1];
} return               result;
}

=============AALine3.qtz/Plot_SineWave2========
Plot_SineWave2.jpg

=============AALine3.qtz/Plot_SineWave2/Sine_Array_Make========
Sine_Array_Make.jpg

var myarray =           new Array();
function (
__structure             ArrayOut)
main (
__number                NumbPt,
__number                Mag,
__number                Freq,
__number                Phas )
{ var result =          new Object();
  for                   (i=0;i< NumbPt ;i++)
{ myarray[i] =          Mag*Math.sin(2*Math.PI*i*Freq/(NumbPt-1)+Phas);

} result.ArrayOut =     myarray;
  return                result;
}


=============AALine3.qtz/Plot_SineWave2/Scaled_LineArray_0========
Scaled_LineArray_0.jpg

function (
__number               TotalNumb,
__number               X0,
__number               Y0,
__number               X1,
__number               Y1)
main (
__structure            ArrayOrList,
__number               index,
__number               width,
__number               height)
{ var result =         new Object();
  var numbPt =         0;
  var i =              0;
  if                   (!_testMode  )
{ numbPt =             ArrayOrList.length;
  result.TotalNumb =   numbPt;
  i =                  index*numbPt;
  if                   (index <  numbPt )
{ result.Y0 =          height*ArrayOrList[i ]/2;
  result.Y1 =          height*ArrayOrList[i+1]/2;
  result.X0 =          width*i/numbPt - width*0.5;
  result.X1 =          width*(i+1)/numbPt -width*0.5;
} 
} return               result;
}

=============AALine3.qtz/2DArray_Make_0========
2DArray_Make_0.jpg

var myarray2 =          new Array();

function (
__number                Numb,
__structure             ArrayOut)
main ( )
{ var result =          new Object();
  myarray[0] =          new Array(.1 , .2 );
  myarray[1] =          new Array(.2 , .4 );
  myarray[2] =          new Array(.7 ,-.1 );
  myarray[3] =          new Array(.8 , .5 );
  myarray[4] =          new Array(.9 , .5 );
  result.Numb =         myarray.length;
  result.ArrayOut =     myarray;
  return                result;
}

=============AALine3.qtz/Plot_2DArray_0========
 
Plot_2DArray_0.jpg

=============AALine3.qtz/Rand_Array_Make_1========
Rand_Array_Make_1.jpg

var myarray =           new Array();
function (
__number                NumbPt,
__structure             ArrayOut)
main (
__number                Numb )
{ var result =          new Object();
  for                   (i=0;i< Numb ;i++)
{ myarray[i] =          Math.random()-.5 ;

} result.NumbPt =       myarray.length;
  result.ArrayOut =     myarray;
  return                result;
}

=============AALine3.qtz/Plot_Array_1========

Plot_Array_1.jpg

=============ArrrayPlots.qtz/MouseTracksPlot========
MouseTracksPlot.jpg


=============ArrrayPlots.qtz/Track_2DPlot========
Track_2DPlot.jpg


var i =                0;
function (
__number               Num,
__number               i,
__number               X,
__number               Y)
main (
__structure            Arr,
__number               T,
__number               width,
__number               height)
{ var result =         new Object();
  var dt =             0;
  var dx =             1;
  var dy =             0;
  if                   ( T < 1  ) { i = 0; }
  if                   (!_testMode  )
{ numbPt =             Arr.length;
  var stop =           0;
  result.Y =           Arr[i][1] ;
  while               (Arr[i][0] < T & stop < 1)
{ i=i+1;
  if                  (i > numbPt-1 ) { i=numbPt-1;stop = 1  }
}
  if                  (i > 0 ) 
{ dt =                 T - Arr[i-1][0];
  dx =                 Arr[i][0]-Arr[i-1][0];
  dy =                 Arr[i][1]-Arr[i-1][1];
  result.Y =           Arr[i-1][1]+ dt*dy/dx ;
}
  result.Num =         numbPt;
  result.i =           i ;
  result.X =           T*2 -1 ;
} return               result;
}

=============AALine3.qtz/Plot_Array/AALine(Cl)========
AALine(Cl).jpg

kernel                 vec4 drawLine(
vec2                   p1,
vec2                   p2,
float                  Thickness,
__color                Color,
float                  AAWidth)
{ vec2 v =             destCoord();
  vec2                 P;
  float f =            AAWidth/2.0;
  float a =            Thickness - f;
  float b =            Thickness + f;
  float q =            ((v.x-p1.x)*(p2.x-p1.x) + (v.y-p1.y)*(p2.y-p1.y)) /
                       (pow((p2.x-p1.x),2.) + pow((p2.y-p1.y),2.));
  q =                  clamp(q, 0., 1.);
  P.x =                (1.- q)*p1.x + q*p2.x;
  P.y =                (1.- q)*p1.y + q*p2.y;
  float d =            distance(P,v);
  float v =            smoothstep(b, a, d);
  return               vec4(v) * Color;
}

=============MusicWriteTest2.qtz/iTuneReadInfo========
iTuneReadInfo.jpg



=============MusicWriteTest2.qtz/Convert_2_Min_sec========

Convert_2_Min_sec.jpg

=============MusicWriteTest2.qtz/STore2File========
STore2File.jpg


=============MusicWriteTest2.qtz/TextAppend_JavaScript========
TextAppend_JavaScriptTextAppend_JavaScript.jpg

var fullstring=          "";

function (
__string                outputstring)
main (
__boolean               append,
__boolean               reset,
__string                inputstring  )
{ var result =          new Object();
  if                    ( append ) fullstring = fullstring +  inputstring;
  if                    ( reset ) fullstring = ""
  ;
  result.outputstring = fullstring;
  return                result;
}

=============MusicWriteTest2.qtz/Store_Mouse_Values========
Store_Mouse_Values.jpg


=============MusicWriteTest2.qtz/Store_Mouse_Values/X_YInRange?_JavaScript========
X_YInRange%3F_JavaScript.jpg
function (
__number               YES)
main (
__number              Xmouse ,
__number              Ymouse ,
__number              Xcenter ,
__number              Ycenter ,
__number              Range )
{ var result =        new Object();
  result.YES = 1;
  if                  (Xmouse  < Xcenter - Range) result.YES = 0;
  if                  (Xmouse  > Xcenter + Range) result.YES = 0;
  if                  (Ymouse  < Ycenter - Range) result.YES = 0;
  if                  (Ymouse  > Ycenter + Range) result.YES = 0;
  return result;
}

=============MusicWriteTest2.qtz/Store_Mouse_Values/Store_X_Y========
StoreXY.jpg


=============Core_Image_kernel_routine.qtz/invertColor========
invertColor.jpg

kernel vec4     _invertColor(sampler source_image) 
{ vec4            pixValue;
  pixValue =     sample(source_image, samplerCoord(source_image)); 
  unpremultiply( pixValue);
  pixValue.r =   1.0 - pixValue.r;
  pixValue.g =   1.0 - pixValue.g;
  pixValue.b =   1.0 - pixValue.b;
  return         premultiply(pixValue);
}

=============Core_Image_kernel_routine.qtz/sobelFilter========
sobelFilter.jpg

const float       kern00 = -1;
const float       kern01 = -2;
const float       kern02 = -1;
const float       kern10 =  0;
const float       kern11 =  0;
const float       kern12 =  0;
const float       kern20 =  1;
const float       kern21 =  2;
const float       kern22 =  1;

float             getMonoValue(sampler image, const vec2 xy, const vec2 off)
{ return          sample(image,xy +off).r;
}

kernel vec4       sobelFilter(sampler image)
{ float accumV =  0.0;
  float accumH =  0.0;
  const vec2      xy = samplerCoord(image);
  float           pixel; 

  pixel   =       getMonoValue(image, xy, vec2(-1.0, -1.0));
  accumV +=       pixel*kern00;
  accumH +=       pixel*kern00;
  pixel   =       getMonoValue(image, xy, vec2( 0.0, -1.0));
  accumV +=       pixel*kern01;
  accumH +=       pixel*kern10;
  pixel   =       getMonoValue(image, xy, vec2( 1.0, -1.0));
  accumV +=       pixel*kern02;
  accumH +=       pixel*kern20;
  pixel   =       getMonoValue(image, xy, vec2(-1.0,  0.0));
  accumV +=       pixel*kern10;
  accumH +=       pixel*kern01;
  pixel   =       getMonoValue(image, xy, vec2( 0.0,  0.0));
  accumV +=       pixel*kern11;
  accumH +=       pixel*kern11;
  pixel   =       getMonoValue(image, xy, vec2( 1.0,  0.0));
  accumV +=       pixel*kern12;
  accumH +=       pixel*kern21;
  pixel   =       getMonoValue(image, xy, vec2(-1.0,  1.0));
  accumV +=       pixel*kern20;
  accumH +=       pixel*kern02;
  pixel   =       getMonoValue(image, xy, vec2( 0.0,  1.0));
  accumV +=       pixel*kern21;
  accumH +=       pixel*kern12;
  pixel   =       getMonoValue(image, xy, vec2( 1.0,  1.0));
  accumV +=       pixel*kern22;
  accumH +=       pixel*kern22;

  float val =     sqrt(accumH * accumH + accumV * accumV);
  return          vec4(val, val, val, 1.0);
}




StringWriter
StringWriter.jpg


StringReader
ReadDataFile.jpg



Patch to display a value on screen
DisplayValuePatch.jpg


NSString*                   thePath = @"/Users/donsauer/Desktop/zzzz/index.txt";   


convert time   [ floor(a/60) ]  [ a-60*b ]  into [%@:%@ ]

a+ceil(1000*b)
tanh(-a*1000) +1
b*(2*acos(a)/180 -1)+c
=============

if                      (inputs[0] > 0  ) outputs[0] = inputs[1] ;
if                      (inputs[0] < 1  ) outputs[0] = -.5  ;

======================Read_IN_Array================

function (
__number              Numb,
__string              X0,
__string              X1)
main (
__structure           ArrayOrList)
{ var result =        new Object();
  if                  (!_testMode)
{ result.Numb =       ArrayOrList.length;
  result.X0 =         ArrayOrList[0];
  result.X1 =         ArrayOrList[1];
} return              result;
}

=======================String_to_Array================
function (
__string               A0,
__string               A1,
__structure            ArrayOut)
main (
__string               StrinIN)
{ var result =         new Object();
  if                   (!_testMode) 
{ myarray =            StrinIN.split(":");
  result.A0 =          myarray[1].toString();
  result.A1 =          myarray[2].toString();
  result.ArrayOut =    myarray;
} return               result;
}

=======================2D_Array_Make================
var myarray =          new Array();

function (
__structure            ArrayOut)
main ( )
{ var result =         new Object();
  myarray[0] =         new Array(1 , 2 );
  myarray[1] =         new Array(3 , 4 );
  result.ArrayOut =    myarray;
  return               result;
}

=======================2D_Array_Read================
function (
__number               Numb,
__number               X0,
__number               X1,
__number               X2,
__number               X3)
main (
__structure            ArrayOrList)
{ var result =         new Object();
  if                  (!_testMode)
{ result.Numb =        ArrayOrList.length;
  result.X0 =          ArrayOrList[0][0];
  result.X1 =          ArrayOrList[0][1]; 
  result.X2 =          ArrayOrList[1][0];
  result.X3 =          ArrayOrList[1][1];
} return               result;
}

=======================Rand_Str_Make================
function (
__string               StringOut)
main (
__number               Numb )
{ var result =         new Object();
  result.StringOut =   "";
  for                  (i=0;i< Numb;i++)
{ result.StringOut +=  Math.random().toFixed(3)+":";
}
  return               result;
}

=======================Rand_Array_Make================
var myarray =          new Array();

function (
__structure            ArrayOut)
main (
__number               Numb )
{ var result =         new Object();
  for                  (i=0;i< Numb ;i++)
{ myarray[i] =         Math.random();
} result.ArrayOut =    myarray;
  return               result;
}
  
========================JavaScipt_Templates================
var i =                 0;
A =                     new Array("one","two","three");
function (
__string                output,
__number                numb)
main (
__string                value,
__number                index,
__boolean               setvalue )
{ var result =          new Object();
  if                   (setvalue)
{ A[index] =            value;
  result.output =       value;
} else
{ result.output =       A[index];
} result.numb =         index;
  return                result;
}

========================
var nmax    =           -1;
var myarray =           new Array();
myarray[0]  =           new Array( 0.0 , 0 ); 
function (
__number                n_max,
__number                Out0,
__number                Out1     )
main (
__number                In0,
__number                In1,
__number                set_IF_Numb_1,
__number                reset,
__number                n        )
{ var result =          new Object();
  if                   (reset == 1) { nmax = -1; }
  if                   (set_IF_Numb_1 == 1)
{ nmax =                nmax +1;
  myarray[nmax] =       new Array( In0   , In1);
} result.Out0  =        myarray[n][0]; 
  result.Out1  =        myarray[n][1]; 
  result.n_max =        nmax;
  return                result;
}
  
========================

var nmax    =           -1;
var n       =           0;
var myarray =           new Array();
myarray[0]  =           new Array( 0.0 , 0 ); 

function (
__number                n_max,
__number                T0,
__number                V0,
__number                T1,
__number                V1,
__number                N         )
main (
__number                InT,
__number                InV,
__number                ID_Numb,
__number                set_IF_ID_Numb,
__number                reset_Nmax,
__number                T,
__number                reset_N     )
{ var result =          new Object();
  if                   (reset_Nmax == 1) { nmax = -1; }
  if                   (set_IF_ID_Numb == ID_Numb)
{ nmax =                nmax +1;
  myarray[nmax] =       new Array( InT   , InV);
}
  if                   (T == 0) {  n = 0; }
  if                   (0<T && n < nmax-1 )
{ while                (myarray[n+1][0] < T ) {  n = n+1; }
} result.T0  =          myarray[n][0]; 
  result.V0  =          myarray[n][1];
  result.T1  =          myarray[n][0]; 
  result.V1  =          myarray[n][1];
  if                   (n < nmax)     
{ result.T1  =          myarray[n+1][0]; 
  result.V1  =          myarray[n+1][1];
} result.n_max =        nmax;
  result.N =            n;
  return                result;
}
========================
//                      __number, __string, __image, __structure, __boolean
var array =             new Array();
function (
__structure             outputStructure  )
main (
__structure             inputStructure,
__number                increasingScale,
__number                decreasingScale,
__number                time                 )
{ var                   result = new Object();
  if                   (inputStructure != null)
{ for                  (i=0; i<inputStructure.length; ++i)
{ var                   value = inputStructure[i];
  var                   lastValue = array[i];
  if                   (lastValue != null)
{ if                   (value > lastValue) lastValue += increasingScale * (value - lastValue);
  else if              (value < lastValue) lastValue += decreasingScale * (value - lastValue);
  array[i] =            lastValue;
} else
{ array[i] =            value;
}
}
} result.outputStructure = array;
  return result;
}

========================

function (
__number                outputNumber  )
main (
__number                inputNumber[2]  )
{ var result =          new Object();
  result.outputNumber = inputNumber[0] + inputNumber[1];
  return                result;
}

========================

function (
__number                outputNumber)
main (
__number                a,
__number                b)

{ var result =          new Object();
  result.outputNumber = a + b;
  return