Harmonic Ratios with Processing

[Thunderwave]

I have been working hard on this idea of mine that went from losing decimal point places to harmonic ratios.

I plan to have a gui interface for all to play with in time.

It's an IFS process, z = z*a*(b+c),
C is an incremental value and A is a chosen ratio.
X and Y run this function exactly the same so it becomes linear only if the values are the same and are increased at the same rate.  Intriguing things happen when the values are different.

I made a bunch of examples using harmonic ratios, 1/1, 1/2, 2/3, 4/5, etc.  These are ratios used in most musical scales but inverted as opposed to 1/1, 1/2, 1/3, 1/4.  Think of it as frequencies(Hz), 1/1 = 440 (A), 1/2 = 220 (Low A), 2/3 (D), 4/5 (F), a minor chord in second inversion.  The catch is that the dimensions are also effecting the ratios as well as the speed at which X and Y phase in and out of each others harmonies while each equation increases by a variable.  Color also has to be defined to show the real battle of harmony.  The fractal aspect of this is when the images show similar aspects at many levels.  Not all values will show this aspect.   There's also a catch all aspect: how many iterations of the equation happens before each X and Y increase to the Next X and Y.  This magically makes extreme differences.  Wish I had more time to map out why.

Still, it's been fun.

If anyone wants to try processing and give advice on how to make it better, please do.  i.e.  I'm new to this; images are very rigid; lines run through them (I think I know why); coloring is not easy for me to manage; what would happen if it got turned into a complex plane; how to map out one pixel at a time without layering over them with a new pixel; what if it could do your laundry and clean your dishes?; etc...

The choices for, ratio, speed, dimensions and colors will be hopefully available for user input.  I'm new to all this and not many people have time to help out or understand the project.

It was originally for music but I have decided to make it available for artwork as well.   "Processing" is an open source program to write visual java applications. 

Code:

/////////////////////////////////////////////////
// Creative Commons Licensing                  //
// Nick Carlson                                //
// arcana23@yahoo.com                          //
// Please give me credit when you use this.    //
// ******************************************* //
// A project based on harmonic ratios.         //
// z = z * ratio * i++                         //
// where i is a very small number.             //
// include ratio of width and heighth.         //
// include ratio of increase between x and y.  //
//             ----------------                //
// Ratio Flux Version 0.2.07 b                 //
/////////////////////////////////////////////////


double x = 0.1; //x=x*xa*(xb+xbcount)
double xa = 0.49;
double xb = 0.0;
double xbcount = 0.00001;

double y = 0.1;  //y=y*ya*(yb+ybcount)
double ya = 0.5;
double yb = 0.0;
double ybcount = 0.00002;

int z = 576;  //while(i <= area){while(j < z){do equations}}
int xwin = 576;
int ywin = 576;
int area = xwin * ywin;
int xint = 0; //whole number integer x
int yint = 0; //whole number integer y

void setup()
{
  size(xwin, ywin, P2D);
  background(255);
  loadPixels();
  noLoop();
}

void draw()
{
  int i = 0;
  while (i <= area)
  {   
    int j = 0; 
    while (j < z)
    {
      x = x * xa;
      x = x * xb;
      x = x * 100; //create a whole number integer
      xint = (int) x;
      xint = xint%xwin;
         
      y = y * ya;
      y = y * yb;
      y = y * 100;
      yint = (int) y;
      yint = yint%ywin;
        
      pixels[yint*width+xint] = color(j % 255, j*2 % 255, j*4 % 255);
      
      y = y * 0.1; //lose decimal points
      if((y > ywin) || (y <= 0.))
      {
        y = 0.1; //start over
      }
        
      x = x * 0.1;
      if((x > xwin) || (x <= 0.)) 
      {
        x = 0.1;
      }
        
      xb = xb + xbcount; 
      yb = yb + ybcount;
      
      j++;
    }
    
    i++;
  }   
  
  updatePixels();
}

[Thunderwave]

This one has intriguing layering effects and overlapping.

[Tglad]

These are moire patterns. A type of interference pattern. If you do a google image search for this you will see that they crop up all over the place. Typical example is when a tv loses its horizontal synch. You can also see it when two gratings overlap.

[jehovajah]

Moire or not they are of interest, particularly if the research on them is extensive.

Crop up all over the place? Hmm... Do they appear in crop circles as a point of interest?

The ratios are of great interest as they give some insight into the structure of aggregate numbering systems and their relationship to their progenitor: Ratios of proportions.

As you may know the foundational notion of the set FS is now the Logos Response which gives rise to these rationic fields as data sets. How we interpret them through our processing systems give rise to our 3d experience of the set notFS.

This is cool and inspiring work.

Note this cd effect when reviewing the nature of light, for example.

The musical rhythm you are after should also be made apparent.