import java.applet.*;
import java.awt.*;
// Tripolar by Scott Snibbe. July 2002.// Commissioned for The Whitney Museum of American Art's Artport.// CODeDOC project. // Tripolar simulates a pendulum swinging above three magnets. The program draws// the complete path that a pendulum would follow if it were released// above the table exactly at the mouse point. This is a well-known// chaotic system - very small changes to the starting position produce// large changes to the path and which magnet on which it unltimately ends.// The program drags the starting position slowly towards the actual// mouse position, so that one can explore points between pixels, simulating// a screen resolution hundreds of times the actual pixel resolution.// The source code demonstrates the "meta-chaos" of the program itself.// A set of key variables defines all the parameters of the simulation.// Changing any of these parameters radically alters the artwork, in most// cases making it non-functional - in some cases the program will hang, // in others the paths will explode, implode or oscillate.// By its title, the program is also meant to suggest the connection between// mental states and these chaotic phenomena - even small, simple physical// systems are as unpredictable and sensitive to initial conditions as our// own minds. Chaos and complexity reign at all scales.public class Tripolar extends Applet implements Runnable
{
// Controls whether we're updating animation
Thread kicker_ = null;
// Indication that animation thread has haltedboolean timeToDie_;
// Milliseconds between frame updatesprivate int speed_;
// Offscreen buffer for double-buffering
Image offScrImage_;
Graphics offScrGC_;
int screenWidth_, screenHeight_;
double centerX_, centerY_;
double scale_;
boolean down_ = false;
Point mousePt_;
double probeX_ = 1e10, probeY_ = 1e10;
// These constants define the artwork - very slight changes to parameters// will make the program, implode, explode, or simply less interesting.// As a work exploring chaotic phenomena, these parameters show the "meta-chaos"// of the program itself - a nonlinear system extremely sensitive to // initial conditions.// These choices also represent the hand of the individual artist in an // algorithmic/technical work.double damping_ = 0.97; // damping constantdouble gravity_ = 0.005; // gravitational constantdouble magnetism_ = 0.1;
double height_ = 0.1; // vertical distance from magnetsdouble mass_ = 1.0; // mass of pendulumdouble dtSim_ = 0.01; // time stepdouble [] magnetX_, magnetY_;
// Thread proc which updates animationpublic void run() {
while (kicker_ != null) {
updateAnimation();
repaint();
try {
if (!timeToDie_) {
Thread.sleep(speed_);
} else {
if (kicker_ != null) {
kicker_.stop();
kicker_ = null;
break;
}
}
} catch (InterruptedException e) {
break;
}
}
}
// Start the appletpublic void start() {
requestFocus();
if (kicker_ == null) {
kicker_ = new Thread(this);
kicker_.start();
}
}
// Stop the applet.public void stop() {
timeToDie_ = true;
}
public void init()
{
speed_ = 33;
screenWidth_ = size().width;
screenHeight_ = size().height;
centerX_ = (double) screenWidth_ / 2.0;
centerY_ = (double) screenHeight_ / 2.0;
scale_ = Math.min(centerX_, centerY_); // scale to normalize// Create offscreen buffer
offScrImage_ = createImage(screenWidth_, screenHeight_);
offScrGC_ = offScrImage_.getGraphics();
// Background color for our applet
setBackground(Color.white);
setForeground(Color.black);
mousePt_ = new Point();
magnetX_ = new double [3];
magnetY_ = new double [3];
setMagnets(0.5);
timeToDie_ = false;
}
// create three magnets at given radius from centervoid setMagnets(double r) {
magnetX_[0] = r * Math.cos(Math.PI/2);
magnetY_[0] = r * Math.sin(Math.PI/2);
magnetX_[1] = r * Math.cos(Math.PI/2 + (2*Math.PI) / 3);
magnetY_[1] = r * Math.sin(Math.PI/2 + (2*Math.PI) / 3);
magnetX_[2] = r * Math.cos(Math.PI/2 - (2*Math.PI) / 3);
magnetY_[2] = r * Math.sin(Math.PI/2 - (2*Math.PI) / 3);
}
// performs the simulation of the pendulum and draws the pathvoid updatePaths(double x, double y, Graphics g) {
double vX=0, vY=0; // velocitydouble fX,fY;
double r, over_rsq, over_rcube;
double dx, dy;
double filtVel = 1;
double lastX, lastY;
int iter = 0;
g.setColor(Color.black);
while (filtVel > 0.1 && iter < 10000) {
iter++;
fX=0;
fY=0; // zero forces// simulate gravitational pull towards center
r = x*x + y*y;
if (r < 0.00001)
r= 0.00001;
over_rsq = 1.0 / r;
fX -= (x * gravity_) * over_rsq;
fY -= (y * gravity_) * over_rsq;
// simulate magnetic forces towards three magnets using // Coulomb's 2nd law - attraction falls off with distance squarefor (int m = 0; m < 3; m++) {
dx = magnetX_[m] - x;
dy = magnetY_[m] - y;
r = Math.sqrt(dx*dx + dy*dy + height_*height_);
if (r < 0.00001)
r = 0.00001;
over_rcube = 1.0 / (r*r*r);
fX += magnetism_ * dx * over_rcube;
fY += magnetism_ * dy * over_rcube;
}
// friction proportional to velocity
fX -= vX*damping_;
fY -= vY*damping_;
// Apply forces using Newton's Law: F=mA
vX += dtSim_ * fX / mass_;
vY += dtSim_ * fY / mass_;
// compute filtered velocity, to determine when the pendulum stops
filtVel = 0.99 * filtVel + 0.1 * Math.max(Math.abs(vX), Math.abs(vY));
lastX = x;
lastY = y;
x += vX;
y += vY;
drawNormalizedLine(lastX, lastY, x, y, g);
}
}
void drawNormalizedLine(double x1, double y1, double x2, double y2, Graphics g) {
g.drawLine((int) Math.round(x1 * scale_ + centerX_),
(int) Math.round(y1 * scale_ + centerY_),
(int) Math.round(x2 * scale_ + centerX_),
(int) Math.round(y2 * scale_ + centerY_));
}
// Override update so that it only calls paint.public void update(Graphics g) {
paint(g);
}
void updateAnimation() {
if (!down_) return;
// interpolate from probe position to mouse positionif (probeX_ == 1e10) {
probeX_ = mousePt_.x;
probeY_ = mousePt_.y;
}
double dx = mousePt_.x - probeX_;
double dy = mousePt_.y - probeY_;
double distSq = dx*dx + dy*dy;
if (distSq > 1) { // exponentially proceed to pixel clicked on
probeX_ += dx/2;
probeY_ += dy/2;
} else { // logarithmically interpolate over last pixel// This allows one to explore values between pixels// by "pulling" the actual probe very slowly towards// the mouse position.
probeX_ += dx * 0.01;
probeY_ += dy * 0.01;
}
}
public void paint(Graphics g)
{
offScrGC_ = offScrImage_.getGraphics();
// Draw all the graphics onto offscreen buffer
offScrGC_.setColor(Color.white);
offScrGC_.fillRect(0, 0, screenWidth_, screenHeight_);
if (probeX_ != 1e10) {
updatePaths((probeX_ - centerX_) / scale_,
(probeY_ - centerY_) / scale_, offScrGC_);
}
// Copy the offscreen buffer onscreen
g.drawImage(offScrImage_, 0, 0, this);
}
public boolean mouseDown(Event evt, int x, int y) {
down_ = true;
mousePt_.setLocation(x, y);
return true;
}
public boolean mouseUp(Event evt, int x, int y) {
down_ = false;
return true;
}
public boolean mouseDrag(Event evt, int x, int y) {
if (down_) {
mousePt_.setLocation(x, y);
}
return true;
}
public boolean mouseEnter(Event evt, int x, int y) {
// Request that events are delivered to our applet
requestFocus();
return true;
}
}