ShaheenGandhi.pde

   1 import toxi.geom.Vec3D;
   2 import toxi.geom.Matrix4x4;
   3
   4 class HelixPattern extends SCPattern {
   5
   6   // Stores a line in point + vector form
   7   private class Line {
   8     private final PVector origin;
   9     private final PVector vector;
  10
  11     Line(PVector pt, PVector v) {
  12       origin = pt;
  13       vector = v.get();
  14       vector.normalize();
  15     }
  16
  17     PVector getPoint() {
  18       return origin;
  19     }
  20
  21     PVector getVector() {
  22       return vector;
  23     }
  24
  25     PVector getPointAt(final float t) {
  26       return PVector.add(origin, PVector.mult(vector, t));
  27     }
  28
  29     boolean isColinear(final PVector pt) {
  30       PVector projected = projectPoint(pt);
  31       return projected.x==pt.x && projected.y==pt.y && projected.z==pt.z;
  32     }
  33
  34     float getTValue(final PVector pt) {
  35       PVector subtraction = PVector.sub(pt, origin);
  36       return subtraction.dot(vector);
  37     }
  38
  39     PVector projectPoint(final PVector pt) {
  40       return getPointAt(getTValue(pt));
  41     }
  42
  43     PVector rotatePoint(final PVector p, final float t) {
  44       final PVector o = origin;
  45       final PVector v = vector;
  46
  47       final float cost = cos(t);
  48       final float sint = sin(t);
  49
  50       float x = (o.x*(v.y*v.y + v.z*v.z) - v.x*(o.y*v.y + o.z*v.z - v.x*p.x - v.y*p.y - v.z*p.z))*(1 - cost) + p.x*cost + (-o.z*v.y + o.y*v.z - v.z*p.y + v.y*p.z)*sint;
  51       float y = (o.y*(v.x*v.x + v.z*v.z) - v.y*(o.x*v.x + o.z*v.z - v.x*p.x - v.y*p.y - v.z*p.z))*(1 - cost) + p.y*cost + (o.z*v.x - o.x*v.z + v.z*p.x - v.x*p.z)*sint;
  52       float z = (o.z*(v.x*v.x + v.y*v.y) - v.z*(o.x*v.x + o.y*v.y - v.x*p.x - v.y*p.y - v.z*p.z))*(1 - cost) + p.z*cost + (-o.y*v.x + o.x*v.y - v.y*p.x + v.x*p.y)*sint;
  53       return new PVector(x, y, z);
  54     }
  55   }
  56
  57   private class Helix {
  58     private final Line axis;
  59     private final float period; // period of coil
  60     private final float rotationPeriod; // animation period
  61     private final float radius; // radius of coil
  62     private final float girth; // girth of coil
  63     private final PVector referencePoint;
  64     private float phase;
  65     private PVector phaseNormal;
  66
  67     Helix(Line axis, float period, float radius, float girth, float phase, float rotationPeriod) {
  68       this.axis = axis;
  69       this.period = period;
  70       this.radius = radius;
  71       this.girth = girth;
  72       this.phase = phase;
  73       this.rotationPeriod = rotationPeriod;
  74
  75       // Generate a normal that will rotate to
  76       // produce the helical shape.
  77       PVector pt = new PVector(0, 1, 0);
  78       if (this.axis.isColinear(pt)) {
  79         pt = new PVector(0, 0, 1);
  80         if (this.axis.isColinear(pt)) {
  81           pt = new PVector(0, 1, 1);
  82         }
  83       }
  84
  85       this.referencePoint = pt;
  86
  87       // The normal is calculated by the cross product of the axis
  88       // and a random point that is not colinear with it.
  89       phaseNormal = axis.getVector().cross(referencePoint);
  90       phaseNormal.normalize();
  91       phaseNormal.mult(radius);
  92     }
  93
  94     Line getAxis() {
  95       return axis;
  96     }
  97
  98     PVector getPhaseNormal() {
  99       return phaseNormal;
 100     }
 101
 102     float getPhase() {
 103       return phase;
 104     }
 105
 106     void step(int deltaMs) {
 107       // Rotate
 108       if (rotationPeriod != 0) {
 109         this.phase = (phase + ((float)deltaMs / (float)rotationPeriod) * TWO_PI);
 110       }
 111     }
 112
 113     PVector pointOnToroidalAxis(float t) {
 114       PVector p = axis.getPointAt(t);
 115       PVector middle = PVector.add(p, phaseNormal);
 116       return axis.rotatePoint(middle, (t / period) * TWO_PI + phase);
 117     }
 118
 119     color colorOfPoint(final PVector p) {
 120       final float t = axis.getTValue(p);
 121       final PVector axisPoint = axis.getPointAt(t);
 122
 123       // For performance reasons, cut out points that are outside of
 124       // the tube where the toroidal coil lives.
 125       if (abs(PVector.dist(p, axisPoint) - radius) > girth*.5f) {
 126         return color(0,0,0);
 127       }
 128
 129       // Find the appropriate point for the current rotation
 130       // of the helix.
 131       PVector toroidPoint = axisPoint;
 132       toroidPoint.add(phaseNormal);
 133       toroidPoint = axis.rotatePoint(toroidPoint, (t / period) * TWO_PI + phase);
 134
 135       // The rotated point represents the middle of the girth of
 136       // the helix.  Figure out if the current point is inside that
 137       // region.
 138       float d = PVector.dist(p, toroidPoint);
 139
 140       // Soften edges by fading brightness.
 141       float b = constrain(100*(1 - ((d-.5*girth)/(girth*.5))), 0, 100);
 142       return color((lx.getBaseHuef() + (360*(phase / TWO_PI)))%360, 80, b);
 143     }
 144   }
 145
 146   private final Helix h1;
 147   private final Helix h2;
 148
 149   private final BasicParameter helix1On = new BasicParameter("H1ON", 1);
 150   private final BasicParameter helix2On = new BasicParameter("H2ON", 1);
 151   private final BasicParameter basePairsOn = new BasicParameter("BPON", 1);
 152
 153   private static final float helixCoilPeriod = 100;
 154   private static final float helixCoilRadius = 45;
 155   private static final float helixCoilGirth = 20;
 156   private static final float helixCoilRotationPeriod = 10000;
 157
 158   private static final float spokePeriod = 40;
 159   private static final float spokeGirth = 10;
 160   private static final float spokePhase = 10;
 161   private static final float spokeRadius = 35; // helixCoilRadius - helixCoilGirth*.5f;
 162
 163   public HelixPattern(GLucose glucose) {
 164     super(glucose);
 165
 166     addParameter(helix1On);
 167     addParameter(helix2On);
 168     addParameter(basePairsOn);
 169
 170     PVector origin = new PVector(100, 50, 45);
 171     PVector axis = new PVector(1,0,0);
 172
 173     h1 = new Helix(
 174       new Line(origin, axis),
 175       helixCoilPeriod,
 176       helixCoilRadius,
 177       helixCoilGirth,
 178       0,
 179       helixCoilRotationPeriod);
 180     h2 = new Helix(
 181       new Line(origin, axis),
 182       helixCoilPeriod,
 183       helixCoilRadius,
 184       helixCoilGirth,
 185       PI,
 186       helixCoilRotationPeriod);
 187   }
 188
 189   private color calculateSpokeColor(final color h1c, final color h2c, final PVector pt) {
 190     // Find the closest spoke's t-value and calculate its
 191     // axis.  Until everything animates in the model reference
 192     // frame, this has to be calculated at every step because
 193     // the helices rotate.
 194     Line axis = h1.getAxis();
 195     float t = axis.getTValue(pt) + spokePhase;
 196     float spokeAxisTValue = floor(((t + spokePeriod/2) / spokePeriod)) * spokePeriod;
 197     PVector h1point = axis.getPointAt(t);
 198     h1point.add(h1.getPhaseNormal());
 199     h1point = axis.rotatePoint(h1point, (t / helixCoilPeriod) * TWO_PI + h1.getPhase());
 200     // TODO(shaheen) investigate why h1.getAxis().getPointAt(spokeAxisTValue) doesn't quite
 201     // have the same value as finding the middle between h1point and h2point.
 202     PVector spokeCenter = h1.getAxis().getPointAt(spokeAxisTValue);
 203     PVector spokeVector = PVector.sub(h1point, spokeCenter);
 204     spokeVector.normalize();
 205     Line spokeLine = new Line(h1point, spokeVector);
 206     PVector pointOnSpoke = spokeLine.projectPoint(pt);
 207     float b = ((PVector.dist(pt, pointOnSpoke) < spokeGirth) && (PVector.dist(pointOnSpoke, spokeCenter) < spokeRadius)) ? 100.f : 0.f;
 208     return color(100, 80.f, b);
 209   }
 210
 211   void run(int deltaMs) {
 212     boolean h1on = helix1On.getValue() > 0.5;
 213     boolean h2on = helix2On.getValue() > 0.5;
 214     boolean spokesOn = (float)basePairsOn.getValue() > 0.5;
 215
 216     h1.step(deltaMs);
 217     h2.step(deltaMs);
 218
 219     for (Point p : model.points) {
 220       PVector pt = new PVector(p.x,p.y,p.z);
 221       color h1c = h1.colorOfPoint(pt);
 222       color h2c = h2.colorOfPoint(pt);
 223       color spokeColor = calculateSpokeColor(h1c, h2c, pt);
 224
 225       if (!h1on) {
 226         h1c = color(0,0,0);
 227       }
 228
 229       if (!h2on) {
 230         h2c = color(0,0,0);
 231       }
 232
 233       if (!spokesOn) {
 234         spokeColor = color(0,0,0);
 235       }
 236
 237       // The helices are positioned to not overlap.  If that changes,
 238       // a better blending formula is probably needed.
 239       colors[p.index] = blendColor(blendColor(h1c, h2c, ADD), spokeColor, ADD);
 240     }
 241   }
 242 }
 243