Rachel-Interactive Development Environment

 

 
 photo TIDE_zps1ac62372.jpg
The Interactive Development Environment: bringing the creative process to the art of coding.
TIDE is an attempt to integrate the celebrated traditions of the artistic process and the often sterile environment of programming. The dialogue of creative processes exists in the process of coding as frustration: debugging, fixing, and fidgeting over details until the programmer and program are unified. TIDE attempts to turn this frustration into the exhilaration of dialogue between artist and art.
The environment uses a Kinect to find and track gestures that correspond to values. Processing code is written with these values and saved in a .txt file. The result code creates a simple shape on screen. I want to expand this project to be able to recognize more gestures and patterns, allowing for much more complicated systems to be implemented. Ironically, I found the process of implementing and testing this project generating the very frustration and sterility I was trying to eradicate with the intuitive, free flowing motions I could get with the Kinect.
 

 photo Sketches9a_zps66e2853c.jpg

 photo FinalTxtFileScreen_zpsc25421bb.jpg
 photo FinalProcessingFileScreen_zps52cd8bed.jpg

"""
Rachel Moeller
EMS2 Asignment 9 
The Interactive Development Environment
"""
from pykinect import nui
from pykinect.nui import JointId, SkeletonTrackingState

import pygame
from pygame.color import THECOLORS
from pygame.locals import *
import os
import random

KINECTEVENT = pygame.USEREVENT



def writeFile(filename, contents, mode="wt"):
    #Got this from Kosbie's 15-112 Class
    fout = None
    try:
        fout = open(filename, mode)
        fout.write(contents)
    finally:
        if (fout != None): fout.close()
    return True

def post_frame(frame):
    """Get skeleton events from the Kinect device and post them into the PyGame event queue"""
    try:
        pygame.event.post(pygame.event.Event(KINECTEVENT, skeletons = frame.SkeletonData))
    except:
        # event queue full
        pass

def commitWidth(data):
    """This function adds the width to the file contents."""
    width=data.sizeWidth
    data.contents+=str(width)+","

def commitLength(data):
    """This function adds the width to the file contents."""
    length=data.sizeLength
    data.contents+=str(length)+");\n}\nvoid draw()\n{"

def commitShape(data):
    """This function adds the type of shape to the file contents."""
    data.contents+="\n"
    if(data.shape=="ellipse"):
        data.contents+="ellipse("
        data.shape="ellipse"
    elif(data.shape=="rect"):
        data.contents+="rect("
        data.shape="rect"

def commitShapeLoc(data):
    data.contents+=str((data.sizeWidth/2)-data.radius)+","+str((data.sizeLength/2)-data.radius)+","

def commitRadius(data):
    """This function adds the radius in to the shape definition."""
    radius=data.radius
    data.contents+=str(radius)+","+str(radius)+");\n}"
    data.isComplete=True

def computeShapeLoc(data,r):
    """This function figures out where to begin drawing the shape away from the center
       of the screen."""
    c=data.shapeColor
    x=400-r
    y=300-r
    data.shapeX=x
    data.shapeY=y

def drawShape(data):
    """This function draws the shape into the interface."""
    c=data.shapeColor
    if(not data.hasRadius):
        r=getRadius(data)
        computeShapeLoc(data,r)
    else:r=data.radius
    if(data.shape=="ellipse"):
        pygame.draw.ellipse(data.screen,c,[data.shapeX,data.shapeY,r,r])
    if(data.shape=="rect"):
        pygame.draw.rect(data.screen,c,[data.shapeX,data.shapeY,r,r])

def commitColor(data):
    """Sets the color in the file contents."""
    if(data.color=="red"):
        data.contents+="\nfill(255,0,0);\n"
    if(data.color=="green"):
        data.contents+="\nfill(0,255,0);\n"
    else:
        data.contents+="\nfill(0,0,255);\n"

def commitBG(data):
    """Writes the background command to the file contents."""
    data.contents+="\nbackground(255);\n"

def initBools(data):
    """This funtion inits the boolean variables controlling when
       code pieces are written."""
    data.hasWidth=False
    data.hasLength=False
    data.hasSetup=False
    data.hasBackground=False
    data.hasColor=False
    data.hasShape=False
    data.hasLocation=False
    data.hasRadius=False
    data.isComplete=False

def initJoints(data,skeleton):
    """Defines the Kinect Joints."""
    data.head=skeleton.SkeletonPositions[JointId.Head]
    data.rightHand=skeleton.SkeletonPositions[JointId.HandRight]
    data.leftHand=skeleton.SkeletonPositions[JointId.HandLeft]
    data.hip=skeleton.SkeletonPositions[JointId.HipCenter]

def init(data):
    data.contents="/*TIDE shape*/\nvoid setup()\n{\nsize("
    data.x=10
    data.y=10
    data.space=20
    data.font=pygame.font.Font(None,20)
    data.typeWords=["void"]
    blue=0,0,255
    green=0,255,0
    data.typeColors=[blue,green]
    data.plainTextColor=0,0,0
    data.lineNums=2
    data.sizeWidth=500
    data.sizeLength=500
    data.shapeColor=0,0,0
    data.shape=None
    data.backgroundColor="white"
    data.tracked=False
    data.frameCount=0
    data.headThresh=0.8
    data.displayText="User not detected"
    data.radius=100
    initBools(data)

def redrawAll(data):
    """This function handles display screens"""
    c=255,255,255
    pygame.draw.rect(data.screen,c,[0,0,800,600])
    c=0,0,0
    msg=data.displayText
    font=pygame.font.Font(None,28)
    text=font.render(msg,True,c)
    data.screen.blit(text,[20,20])
    if(data.hasShape):
        drawShape(data)
    pygame.display.flip()

def checkForComplete(data):
    """This function checks to see if every checkpoint in the code has been reached."""
    return data.hasWidth and data.hasLength and data.hasSetup and data.hasBackground and data.hasColor and data.hasShape and data.Location and data.hasRadius


def getBGColor(data):
    """This function sets a background color"""
    data.backgroundColor="white"


def getRadius(data):
    """This function gathers radius information from the kinect."""
    if(not data.hasRadius):
        data.radius=200*abs(data.hip.y-data.head.y)
        data.hasRadius=True
        return 200*abs(data.hip.y-data.head.y)

def getColor(data):
    picker=random.randint(0,4)
    print picker
    if(picker==1):
        data.hasColor=True
        data.shapeColor=255,0,0
        data.color="red"
    if(picker==2):
        data.hasColor=True
        data.shapeColor=0,255,0
        data.color="green"
    else:
        data.hasColor=True
        data.shapeColor=0,0,255
        data.color="blue"

if __name__ == '__main__':
    WINSIZE = 800, 600
    pygame.init()
    class Struct: pass
    data = Struct()
    init(data)
    data.screen = pygame.display.set_mode(WINSIZE,0,16)    
    pygame.display.set_caption('Interactive Environment.')
    data.screen.fill(THECOLORS["white"])

    with nui.Runtime() as kinect:
        kinect.skeleton_engine.enabled = True
        kinect.skeleton_frame_ready += post_frame
        # Main game loop    
        while True:
            e = pygame.event.wait()
            frame = kinect.skeleton_engine.get_next_frame()
            for skeleton in frame.SkeletonData:
                if skeleton.eTrackingState == nui.SkeletonTrackingState.TRACKED:
                    data.tracked=True
                    initJoints(data,skeleton)
                    data.displayText="Need a Shape"
                    if(not data.hasShape):
                        getColor(data)
                        if(data.head.y

Rachel-Final Project

The Interactive Development Environment: bringing the creative process to the art of coding.

TIDE is an attempt to integrate the celebrated traditions of the artistic process and the often sterile environment of programming. The dialogue of creative processes exists in the process of coding as frustration: debugging, fixing, and fidgeting over details until the programmer and program are unified. TIDE attempts to turn this frustration into the exhilaration of dialogue between artist and art.
The environment uses a Kinect to find and track gestures that correspond to values. Processing code is written with these values and saved in a .txt file. The result code creates a simple shape on screen. I want to expand this project to be able to recognize more gestures and patterns, allowing for much more complicated systems to be implemented. Ironically, I found the process of implementing and testing this project generating the very frustration and sterility I was trying to eradicate with the intuitive, free flowing motions I could get with the Kinect.
 photo Sketches9a_zps66e2853c.jpg

 photo FinalTxtFileScreen_zpsc25421bb.jpg
 photo FinalProcessingFileScreen_zps52cd8bed.jpg

Rachel-Final Project Sketches

The RAM Dance Toolkit by Yoko Ando and YCAM fuses two art forms: dance and programming. Using a motion detection system attached to the dancer’s bodies, the program catalogs and predicts the fluid motions of human expression. This project beautifully captures art within technology, though I find the external motion detection system distracting. So much of dance is about the visual body and its contours and forms in space that clunky straps and electronics retract from the performative aspect of the dance as it is captured. Though on-body systems are probably much more accurate than a single plain watching devices like the kinect, they take the magic from the art, turning it more into an ancient practice to be chronicled than a thriving societal pulse monitor.

tangent’s KIHOU is integrates simple beauty and mystery. A bowl of sticky transparent liquid covered in black oil is underlit with LEDs. Air bubbles push the liquids about, forming bubbles and pockets of animation and life within the substance. The design of this object is striking; sleek post post modern lines and minimal color contrasted with a viscous, organic, messy substance. This juxtaposition speaks to society today; to deep urges and desires buried beneath smooth facades. This generates a mysterious aura around the KIHOU object that makes it beautifully vague yet meaningful.

Signal | Noise’s Monolith

By the title, this object is meant to function as an artifact of current society. With clean, reflective surfaces and engaging light seams, the project does embody the design and conceptual concerns of today’s society. Ironically, these concerns mirror the post and lintel forms of ancient human monoliths. The light arrays react to touch, allowing every visitor to become a part of the work, a parallel to the ritualistic nature of ancient human monoliths in which every pilgrim was connected to each other through the common goal. The impact left on the light beam by one visitor is immediately absorbed by the next, so the interactions a viewer has with the object are really significant only to himself and not the object itself. This heightens the intimacy between viewer and object.

Project Ideas:

TIDE
 photo Sketches9a_zps66e2853c.jpg
The Intuitive Development Environment takes input from a Kinect and generates a simple Processing program based on repetitive gestures found in skeletal movements. The code writing process becomes interactive and engaging, and much more akin to the creative impulse and practice of creating art than the stereotypically sterile methods of programming. The motions of the programmer are directly documented by the code, as is the conversation and dialect that forms between the artist and the creation. These connections are spiritual and integral to the creation process, an element I often find missing in the computerized world. The spacial element of this environment is also significant, as it actually does create an environment that is tangible and yet still defined by the user.

 

Meeting Place(Modern Monolith)
 photo Sketches9_zpsfaf8d98c.jpg
This project attempts to connect human concerns over eons and methods with common concepts and concerns with the creative process. Meeting Place consists of two parallel pillars, one for the sun and one for the moon, each with a large central hole carved through the tops. Through out the day and night, motors slowly turn each pillar so that the hole faces the celestial body that pillar is attuned to.LEDs are embedded in each pillar to illuminate them during times when the sun or moon’s light is not visible. This ensures that light is always passing through both openings. A meeting point/holy space is generated between the pillars, a space that is always connected to what is beyond humanity, yet a perpetual human goal. The pillars themselves would be constructed with a  hollow wood armature covered in joint compound to give them a stone texture.

 

 

Rachel-Measuring Device

The Dis-empathy (Awkwardness) Collar

At its most abstract, this device measures the empathetic distance between two people, or awkwardness. A temperature sensor measures the heat rising off the bearer’s body, which increases as the bearer becomes embarrassed. The number displayed corresponds to the level of embarrassment the bearer feels, which is generated by the cumbersome devices as well as the reactions it elicits. The device, while covering up part of the body that flushes with embarrassment, still displays this emotion in quantified form. However, the cold,inorganic numbers cannot convey the emotion, only express its presence. The person interacting with the bearer has no way of knowing what emotion the bearer is experiencing, in fact the bearer might not be experiencing emotion at all as far they know. I think this turns the bearer into a sort of robot, confined to an uncomfortable slave collar of their own emotion, yet unable to release that emotion.

I arrived at this idea through the 7 segment display. I find it cold, emotionless, and robotically ugly. It is connotationless, un-symbolic, and inorganic. It serves a single functional purpose, to convey some information as numbers, stripping that information of interpretation and meaning. I wanted to make something that expanded this quality to the bearer, turning their human emotions into meaningless numbers.
 photo ACollar1_zps55312ffb.jpg

 photo ACollar2_zps91fe5cf1.jpg

 photo EmotionCollarFritz_bb_zps910187c0.jpg

/*Rachel Moeller, Dis-empathy Collar*/
#include 

#include "Adafruit_LEDBackpack.h"
#include "Adafruit_GFX.h"

Adafruit_7segment matrix = Adafruit_7segment();

const int tempPin = 0;

void setup() {
#ifndef __AVR_ATtiny85__
  Serial.begin(9600);
  Serial.println("7 Segment Backpack Test");
#endif
  matrix.begin(0x70);
}

void loop() {
  float emotionLevel=getVoltage(tempPin);
  float num=1.0;
  float outputNum=emotionLevel*100;
  outputNum=map(outputNum,40,90,0,20);
  int outnum=abs(int(outputNum));

  matrix.print(outnum, DEC);
  matrix.writeDisplay();
  delay(2000);
  }

  float getVoltage(int pin)
{

  return (analogRead(pin) * 0.004882814);
}

 

Arduino Shield Looking Outwards

The touch shield allows for a tactile interactive color display surface on the arduino. This shield gives the possibility for small screen based operations that can have a dialogue with a larger/external work. My first thought was of making a personalized control board for a rocket or a creature. To use the shield, the viewer has to hold the arduino or put in on a nearby surface. I like this proximity feature and the intimacy it and its tactile nature provide.

The wave shield allows a project to have medium quality sound playback at varying volumes. This shield has emotional value to me as I have tried to use audio additions with arduino before, with no success. The shield only works with .wav files, which, as a Windows user, I find a pleasant surprise in a world of demanding mp3 or aiff files. This shield is also relatively cheap, and makes me excited to add audio depth and content to my electronic work.

Gameduino is an adapter/sort of shield for running games off of. It has nicer(but not great) graphics capabilities than a regular arduino, and comes with a VGA output and an output for stereo speakers. I was really drawn to the built in VGA, which would allow a project to incorporate a possible physical object related to the arduino and screen based graphics from a projector.

I like that these shields allow the electronics to be transformed from colorful chunks of metal to socially important artifacts. Even browsing the products gave me a sense of social concerns—especially with the attention given to data logging and GPS shields.

 

Sensor Christmas Looking Outwards

The geophone picks up low frequency ground vibrations. I’ve used regular microphones to translate voices and strikes into other outputs, but this sensor presents a subtler way to read viewer’s presence. Though it is intended for seismic use, I’d like to use it to sense footsteps or finger drumming or other sublties. Measuring the frequencies of vibrations and pauses could indicate hesitation or excitement/interest in a viewer, and could provide the art work insights on the viewer’s personality and motivations.

I find the color detector interesting not only because of its use, but its shape. Numerous color detectors could be compiled into a interactive form capable of reacting to a person based on their clothes or even race. The work could also be self interactive, or interactive with another form composed of color detectors, forming dialogues and relationships dynamically with each other or a passing viewer.

The Liquid Flow Meter has especially peaked my interest. Lately I’ve been thinking about totally immersive single or double human capsule environments in which art as experience is constructed by viewer and art object together. I want to use water in these environments, actively flowing and interacting with the viewer, adding layers of depth to the experience. This sensor measures the amount of water passing through it, and with that data I could send signals to valves to constrict or expand water flow based on environmental changes in the work.

Sperm and Egg


This simulation models sperm competing for an egg. The two sperm have different attraction levels to the egg, who is directed about using the mouse. This configuration casts the viewer/interacter as female, evading or pursuing suitors as she pleases. This subtle relationship and flirtation engaging and interesting, both as a viewer myself and in watching others play with the simulation.

I wanted to get in touch with origins of life. I find the actions of creationary forces—sperm and egg, electron and proton, cosmic forces—all have similar behaviors and appearances on a base level. Visually I wanted to make this connection by choosing forms that could serve as a diagram for any creationary situation listed above.

 photo 100_2171_zps263b90ad.jpg

Personal Cave

Caves weigh heavily on human spirituality. The first art—the first human response to nature—began in cave painting and scultpure. Thus in my experience, caves are the incubators of the creative impulse; they are wombs of humanity. This projection is a personal cave. It fits at my desk, where my creative work occurs. Though not visible in the projection, there are dark background cave formations that help to extend the space. The work is a reminder of the origin, purpose, and function of the creator in the world. In addition, this work is meant to accentuate the space. My desk is under a lofted bed, so I work in a sort of figurative,shallow, forced cave. Though I find the space confining and lonely, painting it as a cave gives it the significance it can’t generate by its self. There is also a sense of weight in the piece, as the sitter must be perfectly still to accurately bear the weight of the cave formation as time passes. In subtext, I wanted to add an element of burden, eternity, and waiting to the cave.

This project gave taught me the value of Keystone. The tool was invaluable for positioning the image, as I had a technical difficulty with the frame displaying a white border. Box2d was an interesting experience, if a little difficult to transition into. Visually I want to deepen this project with a visible background and add cave paintings to reinforce content. I want to make it dynamically sense the sitter, so that the water drops can react to a person in motion.
 photo CaveDropsPic_zpsde6b7db3.jpg
 photo 100_2175_zps2d2fda04.jpg
 photo 100_2169_zps86926a37.jpg

Egg Cell

http://cmuems.com/2013/a/wp-content/uploads/sites/2/2013/10/Screen.pdf

Screen
 photo Screen_zps63920d91.jpg

I started thinking about this project with the nature of screens. I thought about old fashioned planetariums I had when I was a child, and how they used screens with holes to project constellations on the ceiling. I wanted to make “personal constellations” with my screen:patterns of holes that generated symbols/ imagery specific to my visual vocabulary. I chose a symbol I use in my work, the egg, as the constellation in this instance.

My simulation plays with the radii of circles. A field of particles is set, then a growth rate force is determined by each particle’s distance to a given point. That force is multiplied by the radius of each circle, plus a little added randomness to the particle’s position, to form a design.I could not figure out how to make a curved boundary, so I set the particles manually. I got several interesting, non-cuttable designs from this, like this:
 photo Lines1_zpsce761670.jpg
I wanted my particles to behave organically as well, forming an egg of cells. Essentially, an egg cell. I want to return to the design with spring connected particles to achieve this.
 photo EMS2ScreenSketch2_zpsaed6dba7.jpg
 photo EMS2ScreenSketch3_zps09c6391c.jpg
 photo EMS2ScreenSketch1_zps32244928.jpg

 

 

/*Rachel Moeller
Particle System:Amebloid 4th Chakric Connections:
                Blood Vessels
9/28/13
*/
class Particle{
  //Center
  float px;
  float py;
  //Velocity
  float vx;
  float vy;
  //Radius
  float radius;
  
  Particle()
  {
   vx=0;
   vy=0;
  }
  
  Particle(float x, float y,float vxx, float vyy, float r)
  {
   px=x;
   py=y; 
   vx=vxx;
   vy=vyy;
   radius=r;
  }
  
  
  
  void update(float friction)
  {
    //friction
    vx*=friction;
    vy*=friction;
    //containment to the window+border
    //condiseration given to maximum radius
    if(px>width-10){vx=-vx;}
    if(px<10){vx=-vx;}
    if(py>height-10){vy=-vy;}
    if(py<10){vy=-vy;}
    //movement
    
    px+=vx;
    py+=vy;
  }
  
 
  
  void render(float gr)
  {
    noFill();
    
    ellipse(px,py,radius*gr,radius*gr);
 
  
  }   
}

Particle[] pArray;
int numParticles;
float emitterX;
float emitterY;
float growthRate;
float originX;
float originY;


void setup()
{
  size(400,400);
  originX=width/2;
  originY=height/2;
  emitterX=(width/2)+50;
  emitterY=(width/2)+50;
  numParticles=260;
  pArray=new Particle[numParticles];
  int j=10;
  int r=2;
  float w2=width/2;
  float a=random(-3,3);
  float ax=random(-3,3);
  float ay=random(-2,2);
 
  pArray[0]=new Particle(w2-5,10,0,0,r);
  pArray[1]=new Particle(w2+5,10,0,0,r);
  //1
  pArray[2]=new Particle(w2-15,25,0,0,r);
  pArray[3]=new Particle(w2,25,0,0,r);
  pArray[4]=new Particle(w2+15,25,0,0,r);
  //2
  pArray[5]=new Particle(w2-35,40,0,0,r);
  pArray[6]=new Particle(w2-20,40,0,0,r);
  pArray[7]=new Particle(w2-7,40,0,0,r);
  pArray[8]=new Particle(w2,40,0,0,r);
  pArray[8]=new Particle(w2+7,40,0,0,r);
  pArray[9]=new Particle(w2+20,40,0,0,r);
  pArray[10]=new Particle(w2+35,40,0,0,r);
  //3
  pArray[11]=new Particle(w2-45,55,0,0,r);
  pArray[12]=new Particle(w2-30,55,0,0,r);
  pArray[13]=new Particle(w2-15,55,0,0,r);
  pArray[14]=new Particle(w2,55,0,0,r);
  pArray[15]=new Particle(w2+15,55,0,0,r);
  pArray[16]=new Particle(w2+30,55,0,0,r);
  pArray[17]=new Particle(w2+45,55,0,0,r);
  //4
  pArray[18]=new Particle(w2-55,70,0,0,r);
  pArray[19]=new Particle(w2-40,70,0,0,r);
  pArray[20]=new Particle(w2-25,70,0,0,r);
  pArray[21]=new Particle(w2-10,70,0,0,r);
  pArray[22]=new Particle(w2+10,70,0,0,r);
  pArray[23]=new Particle(w2+25,70,0,0,r);
  pArray[24]=new Particle(w2+40,70,0,0,r);
  pArray[25]=new Particle(w2+55,70,0,0,r);
  //5
  pArray[26]=new Particle(w2-65,85,0,0,r);
  pArray[27]=new Particle(w2-50,85,0,0,r);
  pArray[28]=new Particle(w2-35,85,0,0,r);
  pArray[29]=new Particle(w2-20,85,0,0,r);
  pArray[30]=new Particle(w2-7,85,0,0,r);
  pArray[31]=new Particle(w2+7,85,0,0,r);
  pArray[32]=new Particle(w2+20,85,0,0,r);
  pArray[33]=new Particle(w2+35,85,0,0,r);
  pArray[34]=new Particle(w2+50,85,0,0,r);
  pArray[35]=new Particle(w2+65,85,0,0,r);
  //6
  pArray[36]=new Particle(w2-75,100,0,0,r*3);
  pArray[37]=new Particle(w2-60,100,0,0,r);
  pArray[38]=new Particle(w2-45,100,0,0,r);
  pArray[39]=new Particle(w2-30,100,0,0,r);
  pArray[40]=new Particle(w2-15,100,0,0,r);
  pArray[41]=new Particle(w2,100,0,0,r);
  pArray[42]=new Particle(w2+15,100,0,0,r);
  pArray[43]=new Particle(w2+30,100,0,0,r);
  pArray[44]=new Particle(w2+45,100,0,0,r);
  pArray[45]=new Particle(w2+60,100,0,0,r);
  pArray[46]=new Particle(w2+75,100,0,0,r*3);
  //7
  pArray[47]=new Particle(w2-85,115,0,0,r*1.4);
  pArray[48]=new Particle(w2-70,115,0,0,r*7);
  pArray[49]=new Particle(w2-55,115,0,0,r);
  pArray[50]=new Particle(w2-40,115,0,0,r);
  pArray[51]=new Particle(w2-25,115,0,0,r);
  pArray[52]=new Particle(w2-10,115,0,0,r);
  pArray[53]=new Particle(w2+10,115,0,0,r);
  pArray[54]=new Particle(w2+25,115,0,0,r);
  pArray[55]=new Particle(w2+40,115,0,0,r);
  pArray[56]=new Particle(w2+55,115,0,0,r);
  pArray[57]=new Particle(w2+70,115,0,0,r*7);
  pArray[58]=new Particle(w2+85,115,0,0,r*1.4);
  //8
  pArray[59]=new Particle(w2-90,130,0,0,r);
  pArray[60]=new Particle(w2-75,130,0,0,r*4);
  pArray[61]=new Particle(w2-60,130+a,0,0,r*5);
  pArray[62]=new Particle(w2-45,130+a,0,0,r);
  pArray[63]=new Particle(w2-30,130+a,0,0,r);
  pArray[64]=new Particle(w2-15,130+a,0,0,r);
  pArray[65]=new Particle(w2,130+a,0,0,r);
  pArray[66]=new Particle(w2+15,130+a,0,0,r);
  pArray[65]=new Particle(w2+30,130+a*3,0,0,r);
  pArray[67]=new Particle(w2+45,130+a,0,0,r);
  pArray[68]=new Particle(w2+60,130+a,0,0,r*5);
  pArray[69]=new Particle(w2+75,130+a,0,0,r*4);
  pArray[70]=new Particle(w2+90,130+a,0,0,r);
  pArray[71]=new Particle(w2,130+a,0,0,r);
  //9
  pArray[72]=new Particle(w2-95,145,0,0,r*2);
  pArray[73]=new Particle(w2-80,145,0,0,r);
  pArray[74]=new Particle(w2-65,145,0,0,r);
  pArray[75]=new Particle(w2-50,145,0,0,r*4);
  pArray[76]=new Particle(w2-35,145,0,0,r);
  pArray[77]=new Particle(w2-20,145,0,0,r);
  pArray[78]=new Particle(w2-7,145,0,0,r);
  pArray[79]=new Particle(w2+7,145,0,0,r);
  pArray[80]=new Particle(w2+20,145,0,0,r);
  pArray[81]=new Particle(w2+35,145,0,0,r);
  pArray[82]=new Particle(w2+50,145,0,0,r*4);
  pArray[83]=new Particle(w2+65,145,0,0,r);
  pArray[84]=new Particle(w2+80,145,0,0,r);
  pArray[85]=new Particle(w2+95,145,0,0,r*2);
  //10
  pArray[86]=new Particle(w2-100,160,0,0,r*2);
  pArray[87]=new Particle(w2-85,160,0,0,r);
  pArray[88]=new Particle(w2-70,160,0,0,r);
  pArray[89]=new Particle(w2-55,160,0,0,r);
  pArray[90]=new Particle(w2-40,160,0,0,r);
  pArray[91]=new Particle(w2-25,160,0,0,r*4);
  pArray[92]=new Particle(w2-10,160,0,0,r);
  pArray[93]=new Particle(w2+10,160,0,0,r);
  pArray[94]=new Particle(w2+25,160,0,0,r*4);
  pArray[95]=new Particle(w2+40,160,0,0,r);
  pArray[96]=new Particle(w2+55,160,0,0,r);
  pArray[97]=new Particle(w2+70,160,0,0,r);
  pArray[98]=new Particle(w2+85,160,0,0,r);
  pArray[99]=new Particle(w2+100,160,0,0,r*2);
  //11
  pArray[100]=new Particle(w2-105,175+a,0,0,r*4);
  pArray[101]=new Particle(w2-90+a,175,0,0,r*2.1);
  pArray[102]=new Particle(w2-75,175+a,0,0,r*2);
  pArray[103]=new Particle(w2-60+a,175,0,0,r);
  pArray[104]=new Particle(w2-45,175,0,0,r);
  pArray[105]=new Particle(w2-30,175,0,0,r*4);
  pArray[106]=new Particle(w2-15,175,0,0,r*5);
  pArray[107]=new Particle(w2,175,0,0,r*7);
  pArray[108]=new Particle(w2,175,0,0,r*5);
  pArray[109]=new Particle(w2+15,175,0,0,r*5);
  pArray[110]=new Particle(w2+30,175,0,0,r*4);
  pArray[111]=new Particle(w2+45,175,0,0,r);
  pArray[112]=new Particle(w2+60,175,0,0,r);
  pArray[113]=new Particle(w2+75,175,0,0,r*2);
  pArray[114]=new Particle(w2+90,175,0,0,r*2.1);
  pArray[115]=new Particle(w2+105,175,0,0,r*4);
  //12
  pArray[116]=new Particle(w2-110,190,0,0,r*1.7);
  pArray[117]=new Particle(w2-95,190,0,0,r*3);
  pArray[118]=new Particle(w2-80,190,0,0,r);
  pArray[119]=new Particle(w2-65,190,0,0,r);
  pArray[120]=new Particle(w2-40,190,0,0,r);
  pArray[121]=new Particle(w2-25,190,0,0,r*1.5);
  pArray[122]=new Particle(w2-10,190,0,0,r*3.5);
  pArray[123]=new Particle(w2+10,190,0,0,r*3.5);
  pArray[124]=new Particle(w2+25,190,0,0,r*1.5);
  pArray[125]=new Particle(w2+40,190,0,0,r);
  pArray[126]=new Particle(w2+65,190,0,0,r);
  pArray[127]=new Particle(w2+80,190,0,0,r);
  pArray[128]=new Particle(w2+95,190,0,0,r*3);
  pArray[129]=new Particle(w2+110,190,0,0,r*1.7);
  //13
  pArray[130]=new Particle(w2-115,205,0,0,r);
  pArray[131]=new Particle(w2-100,205,0,0,r);
  pArray[132]=new Particle(w2-85,205,0,0,r);
  pArray[133]=new Particle(w2-70,205,0,0,r);
  pArray[134]=new Particle(w2-55,205,0,0,r);
  pArray[135]=new Particle(w2-40,205,0,0,r);
  pArray[136]=new Particle(w2-25,205,0,0,r);
  pArray[137]=new Particle(w2-10,205,0,0,r*2);
  pArray[138]=new Particle(w2+10,205,0,0,r*2);
  pArray[139]=new Particle(w2+25,205,0,0,r);
  pArray[140]=new Particle(w2+40,205,0,0,r);
  pArray[141]=new Particle(w2+55,205,0,0,r);
  pArray[142]=new Particle(w2+70,205,0,0,r);
  pArray[143]=new Particle(w2+85,205,0,0,r);
  pArray[144]=new Particle(w2+100,205,0,0,r);
  pArray[145]=new Particle(w2+115,205,0,0,r);
  //14
  //BOTTOM
  pArray[146]=new Particle(w2-115,220,0,0,r*1.5);
  pArray[147]=new Particle(w2-95,220,0,0,r*1.5);
  pArray[148]=new Particle(w2-80,220,0,0,r*1.5);
  pArray[149]=new Particle(w2-65,220,0,0,r*1.5);
  pArray[150]=new Particle(w2-40,220,0,0,r*1.5);
  pArray[151]=new Particle(w2-25,220,0,0,r*1.5);
  pArray[152]=new Particle(w2-10,220,0,0,r*1.5);
  pArray[153]=new Particle(w2+10,220,0,0,r*1.5);
  pArray[154]=new Particle(w2+25,220,0,0,r*1.5);
  pArray[155]=new Particle(w2+40,220,0,0,r*1.5);
  pArray[156]=new Particle(w2+65,220,0,0,r*1.5);
  pArray[157]=new Particle(w2+80,220,0,0,r*1.5);
  pArray[158]=new Particle(w2+95,220,0,0,r*1.5);
  pArray[159]=new Particle(w2+115,220,0,0,r*1.5);
  //15
  pArray[160]=new Particle(w2-110,235,0,0,r*1.5);
  pArray[161]=new Particle(w2-90,235,0,0,r*1.5);
  pArray[162]=new Particle(w2-75,235,0,0,r*1.5);
  pArray[163]=new Particle(w2-60,235,0,0,r*1.5);
  pArray[164]=new Particle(w2-45,235,0,0,r*1.5);
  pArray[165]=new Particle(w2-30,235,0,0,r*1.5);
  pArray[166]=new Particle(w2-15,235,0,0,r*1.5);
  pArray[167]=new Particle(w2,235,0,0,r*1.5);
  pArray[168]=new Particle(w2,235,0,0,r*1.5);
  pArray[169]=new Particle(w2+15,235,0,0,r*1.5);
  pArray[170]=new Particle(w2+30,235,0,0,r*1.5);
  pArray[171]=new Particle(w2+45,235,0,0,r*1.5);
  pArray[172]=new Particle(w2+60,235,0,0,r*1.5);
  pArray[173]=new Particle(w2+75,235,0,0,r*1.5);
  pArray[174]=new Particle(w2+90,235,0,0,r*1.5);
  pArray[175]=new Particle(w2+110,235,0,0,r*1.5);
  // 16
  pArray[176]=new Particle(w2-100,250,0,0,r*1.6);
  pArray[177]=new Particle(w2-85,250,0,0,r*1.6);
  pArray[178]=new Particle(w2-70,250,0,0,r*1.6);
  pArray[179]=new Particle(w2-55,250,0,0,r*1.6);
  pArray[180]=new Particle(w2-40,250,0,0,r*1.6);
  pArray[181]=new Particle(w2-25,250,0,0,r*1.6);
  pArray[182]=new Particle(w2-10,250,0,0,r*1.6);
  pArray[183]=new Particle(w2+10,250,0,0,r*1.6);
  pArray[184]=new Particle(w2+25,250,0,0,r*1.6);
  pArray[185]=new Particle(w2+40,250,0,0,r*1.6);
  pArray[186]=new Particle(w2+55,250,0,0,r*1.6);
  pArray[187]=new Particle(w2+70,250,0,0,r*1.6);
  pArray[188]=new Particle(w2+85,250,0,0,r*1.6);
  pArray[189]=new Particle(w2+100,250,0,0,r*1.6);
  //17
  pArray[190]=new Particle(w2-95,265,0,0,r*2);
  pArray[191]=new Particle(w2-80,265,0,0,r*2);
  pArray[192]=new Particle(w2-65,265,0,0,r*2);
  pArray[193]=new Particle(w2-50,265,0,0,r*2);
  pArray[194]=new Particle(w2-35,265,0,0,r*2);
  pArray[195]=new Particle(w2-20,265,0,0,r*2);
  pArray[196]=new Particle(w2-7,265,0,0,r*2);
  pArray[197]=new Particle(w2+7,265,0,0,r*2);
  pArray[198]=new Particle(w2+20,265,0,0,r*2);
  pArray[199]=new Particle(w2+35,265,0,0,r*2);
  pArray[200]=new Particle(w2+50,265,0,0,r*2);
  pArray[201]=new Particle(w2+65,265,0,0,r*2);
  pArray[202]=new Particle(w2+80,265,0,0,r*2);
  pArray[203]=new Particle(w2+95,265,0,0,r*2);
  //18
  pArray[204]=new Particle(w2-90,280,0,0,r*2);
  pArray[205]=new Particle(w2-75,280,0,0,r*2);
  pArray[206]=new Particle(w2-60,280,0,0,r*2);
  pArray[207]=new Particle(w2-45,280,0,0,r*2);
  pArray[208]=new Particle(w2-30,280,0,0,r*2);
  pArray[209]=new Particle(w2-15,280,0,0,r*2);
  pArray[210]=new Particle(w2,280,0,0,r*2);
  pArray[211]=new Particle(w2+15,280,0,0,r*2);
  pArray[212]=new Particle(w2+30,280,0,0,r*2);
  pArray[213]=new Particle(w2+45,280,0,0,r*2);
  pArray[214]=new Particle(w2+60,280,0,0,r*2);
  pArray[215]=new Particle(w2+75,280,0,0,r*2);
  pArray[216]=new Particle(w2+90,280,0,0,r*2);
  pArray[217]=new Particle(w2,280,0,0,r*2);
  //19
  pArray[218]=new Particle(w2-85+a,295,0,0,r*1.4);
  pArray[219]=new Particle(w2-70+a,295,0,0,r*1.4);
  pArray[220]=new Particle(w2-55+a,295,0,0,r*1.4);
  pArray[221]=new Particle(w2-40,295,0,0,r*1.4);
  pArray[222]=new Particle(w2-25,295+a,0,0,r*1.4);
  pArray[223]=new Particle(w2-10,295+a,0,0,r*1.4);
  pArray[224]=new Particle(w2+10+a,295,0,0,r*1.4);
  pArray[225]=new Particle(w2+25,295,0,0,r*1.4);
  pArray[226]=new Particle(w2+40,295,0,0,r*1.4);
  pArray[227]=new Particle(w2+55,295,0,0,r*1.4);
  pArray[228]=new Particle(w2+70,295,0,0,r*1.4);
  pArray[229]=new Particle(w2+85,295,0,0,r*1.4);
  //20
  //pArray[230]=new Particle(w2-75,310,0,0,10);
  pArray[230]=new Particle(w2-60,310,0,0,r*1.3);
  pArray[231]=new Particle(w2-45,310,0,0,r*1.3);
  pArray[232]=new Particle(w2-30,310,0,0,r*1.3);
  pArray[233]=new Particle(w2-15,310,0,0,r*1.3);
  pArray[234]=new Particle(w2,310,0,0,r*1.3);
  pArray[235]=new Particle(w2+15,310,0,0,r*1.3);
  pArray[236]=new Particle(w2+30,310,0,0,r*1.3);
  pArray[237]=new Particle(w2+45,310,0,0,r*1.3);
  pArray[238]=new Particle(w2+60,310,0,0,r*1.3);
  //21
  pArray[239]=new Particle(w2-55,325+a,0,0,r*1.4);
  pArray[240]=new Particle(w2-35+a,325,0,0,r*1.4);
  pArray[241]=new Particle(w2-20,325,0,0,r*1.4);
  pArray[242]=new Particle(w2-7+a,325+a,0,0,r*1.4);
  pArray[243]=new Particle(w2+7,325+a,0,0,r*1.4);
  pArray[244]=new Particle(w2+20,325,0,0,r*1.4);
  pArray[245]=new Particle(w2+35+a,325,0,0,r*1.4);
  pArray[246]=new Particle(w2+55+a,325,0,0,r*1.4);
  //22
  pArray[247]=new Particle(w2-35,340,0,0,r*1.4);
  pArray[248]=new Particle(w2-15,340,0,0,r*1.4);
  pArray[249]=new Particle(w2,340,0,0,r*1.4);
  pArray[250]=new Particle(w2+15,340,0,0,r*1.4);
  pArray[251]=new Particle(w2+35,340,0,0,r*1.4);
  //23
  pArray[252]=new Particle(w2-20,355,0,0,r*1.5);
  pArray[253]=new Particle(w2-7,355,0,0,r*1.5);
  pArray[254]=new Particle(w2+7,355,0,0,r*1.5);
  pArray[255]=new Particle(w2+20,355,0,0,r*1.5);
  //24+
  pArray[256]=new Particle(w2-72,310,0,0,r);
  pArray[257]=new Particle(w2+3,200,0,0,r);
  pArray[258]=new Particle(w2-2,210,0,0,r*1.5);
  pArray[259]=new Particle(w2+72,310,0,0,r*1.5);
}
    



void draw()
{
   
  background(255);
  for(int i=2;i