Changeset 2865

Timestamp:

06/13/07 12:33:22 (13 years ago)

Author:

sorber

Message:

Improved highlighting of freeforms and polylines. Began refactoring FreeformTool and OverlayNodedObject.

Location:

trunk/loci/visbio/overlays

Files:

• FreeformTool.java (modified) (19 diffs)
• OverlayNodedObject.java (modified) (2 diffs)
• OverlayUtil.java (modified) (6 diffs)

trunk/loci/visbio/overlays/FreeformTool.java

@@ -101 +101 @@
   protected float[][] pre, post;
 
-  /** Point at which mouseDown occurs */
+  /** Point at which mouseDown occurs. */
   protected float downX, downY;
 
@@ -128 +128 @@
     // find closest freeform
     double maxThresh = ERASE_THRESH;
-    Info info = getClosestFreeform(display, dpx, dpy,
-        maxThresh);
-    OverlayFreeform target = info.freeform;
+    DistanceQuery distanceQuery = getClosestFreeform(display, dpx,
+        dpy, maxThresh);
+    OverlayFreeform target = distanceQuery.freeform;
 
     // operate on closest freeform
     if (target != null) {
+      // editing operations on closest freeform
       freeform = target;
 
-      double dist = info.dist;
-      int seg = info.seg;
-      double weight = info.wt;
-
-      if ((seg == 0 && weight == 0.0) ||
-          (seg == freeform.getNumNodes()-2 && weight == 1.0))
+      double dist = distanceQuery.dist;
+      int seg = distanceQuery.seg;
+      double weight = distanceQuery.wt;
+
+      if (distanceQuery.isNearEndNode())
       {
         // near an end node
@@ -177 +177 @@
           else {
             // determine projection on seg.
+            // insert a pair of nodes there, starting a tendril
             float[] a = freeform.getNodeCoords(seg);
             float[] b = freeform.getNodeCoords(seg + 1);
@@ -190 +191 @@
     }
     else { // no freeform was sufficiently close
+      // drawing operations on new freeform
       if (!ctl) {
         // record initial coordinates of freeform
@@ -198 +200 @@
     }
 
+    // stuff you have to do if there's been a change
     overlay.notifyListeners(new TransformEvent(overlay));
     ((OverlayWidget) overlay.getControls()).refreshListSelection();
@@ -237 +240 @@
         float[] tail = f.getNodeCoords(f.getNumNodes()-1);
 
-        double[] headDbl = {(double) head[0], (double) head[1]};
-        double[] tailDbl = {(double) tail[0], (double) tail[1]};
-        //double[] drag = {(double) dx, (double) dy};
-        int[] headPxl = CursorUtil.domainToPixel(display, headDbl);
-        int[] tailPxl = CursorUtil.domainToPixel(display, tailDbl);
-        double[]  headPxlDbl = new double[] {(double) headPxl[0],
-          (double) headPxl[1]};
-        double[] tailPxlDbl = new double[] {(double) tailPxl[0],
-          (double) tailPxl[1]};
-        double[] drag = {dpx, dpy};
-
-        // compare pair of ints with pair of floats
-        double hdist = MathUtil.getDistance(drag, headPxlDbl);
-        double tdist = MathUtil.getDistance(drag, tailPxlDbl);
+        int[] drag = new int[]{px, py};
+        double hdist = getPixelDistanceToClick(display, head, drag);
+        double tdist = getPixelDistanceToClick(display, tail, drag);
 
         boolean isHead = hdist < tdist ? true : false;
@@ -270 +262 @@
         // compute distance from last node
         // DISTANCE COMPUTATION: compare floats and ints
-        float lastX = freeform.getLastNodeX();
-        float lastY = freeform.getLastNodeY();
-        float distX = dx - lastX;
-        float distY = dy - lastY;
-        double dist = Math.sqrt (distX*distX + distY*distY);
-
-        double[] last = new double[]{(double) lastX, (double) lastY};
-        int[] lastPxl = CursorUtil.domainToPixel(display, last);
-
-        double dxPxl = dpx - (double) lastPxl[0];
-        double dyPxl = dpy - (double) lastPxl[1];
-        double distPxl = Math.sqrt (dxPxl*dxPxl + dyPxl*dyPxl);
+        float[] last = {freeform.getLastNodeX(), freeform.getLastNodeY()};
+        double distPxl = getPixelDistanceToClick(display, last, 
+            new int[]{px, py});
 
         if (distPxl > DRAW_THRESH) {
-          float[] s = smooth(new float[]{dx, dy}, new float[] {lastX, lastY});
-          freeform.setNextNode(s[0], s[1]);
+          float[] s = smooth(new float[]{dx, dy}, last);
+          freeform.setNextNode(s);
           double len = freeform.getCurveLength();
-          double[] sDbl = {(double) s[0], (double) s[1]};
-          double delta = MathUtil.getDistance(sDbl, last);
+          double delta = MathUtil.getDistance(s, last);
           freeform.setCurveLength(len + delta);
           // I debated whether to call setBoundaries with every mouseDrag.
           // This is an efficient
-          // method, but updating realtime for erasing requires an O(n)
+          // method, but corresponding update when erasing
+          // erasing requires an O(n)
           // scan of the nodes every time a node is deleted.
           freeform.setBoundaries(s[0], s[1]);
@@ -302 +285 @@
       if (freeform == null) {
         // DISTANCE COMPUTATION compare floats with floats
-        Info info = getClosestFreeform(display,
+        DistanceQuery distanceQuery = getClosestFreeform(display,
             dpx, dpy, ERASE_THRESH);
-        OverlayFreeform target = info.freeform;
+        OverlayFreeform target = distanceQuery.freeform;
         if (target != null) freeform = target;
       }
@@ -310 +293 @@
       if (freeform != null) {
         // delete an end node if you're near enough
-        float[] beg = freeform.getNodeCoords (0);
-        float[] end = freeform.getNodeCoords (freeform.getNumNodes() - 1);
-
-        double[] drag = {dpx, dpy};
-        double[] begDbl = {(double) beg[0], (double) beg[1]};
-        double[] endDbl = {(double) end[0], (double) end[1]};
-        int[] begPxl = CursorUtil.domainToPixel(display, begDbl);
-        int[] endPxl = CursorUtil.domainToPixel(display, endDbl);
-        double[] begPxlDbl = {(double) begPxl[0], (double) begPxl[1]};
-        double[] endPxlDbl = {(double) endPxl[0], (double) endPxl[1]};
-
-        // DISTANCE COMPUTATION ints and floats
-        double bdist = MathUtil.getDistance(drag, begPxlDbl);
-        double edist = MathUtil.getDistance(drag, endPxlDbl);
+        float[] beg = freeform.getNodeCoords(0);
+        float[] end = freeform.getNodeCoords(freeform.getNumNodes() - 1);
+
+        int[] dragPxl = {px, py};
+
+        double bdist = getPixelDistanceToClick(display, beg, dragPxl);
+        double edist = getPixelDistanceToClick(display, beg, dragPxl); 
 
         boolean closerToEnd = edist < bdist ? true : false;
@@ -331 +307 @@
           if (!closerToEnd) freeform.reverseNodes();
           if (ctl) {
-            double[] nearest = new double[2], lastDbl = new double[2];
-            float[] last;
-            double delta;
-            int index;
-            if (closerToEnd) nearest = endDbl;
-            else nearest = begDbl;
+            float[] nearest = new float[2];
+            if (closerToEnd) nearest = end;
+            else nearest = beg;
 
             // adjust curve length
-            index = freeform.getNumNodes()-1; // last node in freef
-            last = freeform.getNodeCoords(index);
-            lastDbl[0] = (double) last[0];
-            lastDbl[1] = (double) last[1];
-            delta = MathUtil.getDistance (nearest, lastDbl);
+            int index = freeform.getNumNodes()-1; // last node in freef
+            float[] last = freeform.getNodeCoords(index);
+            double delta = MathUtil.getDistance(nearest, last);
             freeform.setCurveLength(freeform.getCurveLength() - delta);
 
@@ -556 +527 @@
   }
 
-  /** Wraps distance info and address of a freeform object */
-  protected class Info {
+  /** Wraps distance and address of a freeform object. */
+  protected class DistanceQuery {
     public double dist, wt;
     public int seg;
     public OverlayFreeform freeform;
 
-    public Info(double[] distSegWt, OverlayFreeform f) {
+    /** Constructs a DistanceQuery object. */
+    public DistanceQuery(double[] distSegWt, OverlayFreeform f) {
       this.freeform = f;
       this.dist = distSegWt[0];
@@ -568 +540 @@
       this.wt = distSegWt[2];
     }
-  }
-
-  /** Wraps info for redrawing a curve
+
+    /** Whether the nearest node is an end node. */
+    public boolean isNearEndNode() {
+      return (seg == 0 && wt == 0.0) ||
+        (seg == freeform.getNumNodes()-2 && wt == 1.0);
+    }
+  }
+
+  /** Wraps information for redrawing a curve
    *  Appears like a 'tendril' on screen */
-  private class Tendril {
+  protected class Tendril {
     public int start, stop, tip;
     public boolean nodal;
@@ -658 +636 @@
       }
     }
-
-    /*
-    if (mode == DRAW || mode == EDIT || mode == ERASE) {
-      freeform.setDrawing(true);
-      freeform.setSelected(true);
-    }
-
-    if (mode == DRAW) {
-      // create list of freeforms
-      OverlayObject[] objs = overlay.getObjects();
-      for (int i=0; i<objs.length; i++) {
-        if (objs[i] instanceof OverlayFreeform && objs[i] != freeform) {
-          otherFreefs.add(objs[i]);
-        }
-      }
-    }
-    else {
-      otherFreefs.removeAllElements();
-    }
-
-    if (mode == CHILL && freeform != null) {
-      if (freeform.getNumNodes() <= 1) overlay.removeObject(freeform);
-      else {
-        freeform.computeLength();
-        freeform.updateBoundingBox();
-        freeform.computeGridParameters();
-        freeform.setDrawing(false);
-        freeform = null;
-      }
-    }
-    */
   }
 
@@ -721 +668 @@
    *  the given point
    */
-  /*
-  private OverlayFreeform getClosestFreeform( float dx,
-      float dy, double thresh) {
-    // returns only objects at the current dimensional position
-    OverlayObject[] objects = overlay.getObjects();
-    // Q: Hey, are all of these OverlayFreeforms?
-    // A: No, it returns OverlayObjects of all types
-
-    OverlayFreeform closestFreeform = null;
-    if (objects != null) {
-      double minDistance = Double.MAX_VALUE;
-      for (int i = 0; i < objects.length; i++) {
-        OverlayObject currentObject = objects[i];
-        if (currentObject instanceof OverlayFreeform) {
-          OverlayFreeform currentFreeform = (OverlayFreeform) currentObject;
-          // rough check: is point within EDIT_THRESH of bounding box (fast)
-          if (currentFreeform.getDistance(dx, dy) < thresh) {
-            // fine check: actually compute minimum
-            // distance to freeform (slower)
-            double[] distSegWt =
-              // DISTANCE COMPUTATION
-              // compare float[][] with ints
-              MathUtil.getDistSegWt(currentFreeform.getNodes(), dx, dy);
-            double distance = distSegWt[0];
-            if (distance < thresh && distance < minDistance) {
-              minDistance = distance;
-              closestFreeform = currentFreeform;
-            }
-          } // end (.. < EDIT_THRESH)
-        } // end if
-      } // end for
-    } // end if
-    return closestFreeform;
-  }
-  */
-
-  /** Returns the closest (subject to a threshhold) OverlayFreeform object to
-   *  the given point
-   */
-  protected Info getClosestFreeform(DisplayImpl display, double dpx,
+  protected DistanceQuery getClosestFreeform(DisplayImpl display, double dpx,
       double dpy, double thresh) {
     // returns only objects at the current dimensional position
@@ -791 +699 @@
       } // end for
     } // end if
-    return new Info(min, closestFreeform);
+    return new DistanceQuery(min, closestFreeform);
   }
 
@@ -807 +715 @@
   }
 
-  /** Casts an array of floats to doubles */
+  /** Gets distance in pixels between a click and a point in domain coords. */
+  private double getPixelDistanceToClick(DisplayImpl display, float[] p, int[]
+      click) {
+    // TODO Make this work for N-D arguments (not just 2D)
+    double[] pDbl = new double[] {(double) p[0], (double) p[1]};
+    int[] pPxl = CursorUtil.domainToPixel(display, pDbl);
+    double[] pPxlDbl = new double[] {(double) pPxl[0],
+      (double) pPxl[1]};
+    double[] clickDbl = new double[] {(double) click[0],
+      (double) click[1]};
+    return MathUtil.getDistance(clickDbl, pPxlDbl);
+  }
+
+  /** Casts an array of floats to doubles. */
   private double[][] floatsToPixelDoubles(DisplayImpl d, float[][] nodes) {
     double[][] nodesDbl = new double[nodes.length][nodes[0].length];
@@ -819 +740 @@
   }
 
-  /** Prints node array of current freeform; for debugging */
+  /** Prints node array of current freeform; for debugging. */
   private void printNodes(float[][] nodes) {
     System.out.println("Printing nodes...");
@@ -827 +748 @@
   }
 
-  /** Prints node array of current freeform; for debugging */
+  /** Prints node array of current freeform; for debugging. */
   private void printNodes() {
     if (freeform!=null){
@@ -835 +756 @@
   }
 
-  /** Prints a message for debugging */
+  /** Prints a message for debugging. */
   public void print(String methodName, String message) {
     boolean toggle = true;

trunk/loci/visbio/overlays/OverlayNodedObject.java

@@ -424 +424 @@
   }
 
+  /** Sets coordinates of last node. */
+  public void setLastNode(float[] c) {
+    setLastNode(c[0], c[1]);
+  }
+
   /** Prints node array of current freeform; for debugging */
   private void printNodes(float[][] nodes) {
@@ -441 +446 @@
     Arrays.fill(nodes[1], numNodes++, maxNodes, y);
     // i.e., set all remaining nodes (as per maxNodes) to next node coords
+  }
+
+  /** Sets next node coordinates. */
+  public void setNextNode(float[] c) {
+    setNextNode(c[0], c[1]);
   }
 

trunk/loci/visbio/overlays/OverlayUtil.java

@@ -29 +29 @@
 import java.util.Vector;
 import loci.visbio.view.TransformLink;
+import loci.visbio.util.MathUtil;
 import visad.*;
 import visad.util.CursorUtil;
@@ -516 +517 @@
     int len = 2 * arcLen;
 
-    Vector sets = new Vector(numNodes);
-
-    /*
-    System.out.println("1: isHighlightNode = " + hlt);
-    System.out.println("Thread.currentThread()" + Thread.currentThread());
-    System.out.println("numNodes = " + numNodes);
-    System.out.println("numNodeSets = " + numNodeSets);
-    System.out.println("numSets = " + numSets);
-    System.out.println("hlen = " + hlen);
-    System.out.println("rangeSamples[0].length = " + rangeSamples[0].length);
-    */
-
     // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     // Build nodes sets
     // ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
-
-    for (int i=0; i<numNodes - 1; i++) {
-      float[] v = new float[]{nodes[0][i+1] - nodes[0][i], nodes[1][i+1] -
-          nodes[1][i]};
-
-      if (v[0] == 0 && v[1] == 0) continue;
-        // nodes are colocational
-      // angle of vector perpendicular to line
-      double theta =  Math.PI / 2 + Math.atan2(v[1], v[0]);
-
-      float dx = (float) (delta * Math.cos(theta));
-      float dy = (float) (delta * Math.sin(theta));
-
-      float[] p1 = {nodes[0][i] + dx, nodes[1][i] + dy};
-      float[] p2 = {nodes[0][i+1] + dx, nodes[1][i+1] + dy};
-      float[] p3 = {nodes[0][i] - dx, nodes[1][i] - dy};
-      float[] p4 = {nodes[0][i+1] - dx, nodes[1][i+1] - dy};
-
-      float[][] setSamples = {{p1[0], p2[0], p3[0], p4[0]},
-                              {p1[1], p2[1], p3[1], p4[1]}};
+    
+    int samples = 0;
+    UnionSet unionSet = null;
+    try {
+      unionSet = buildNodesSets(domain, nodes, delta);
+      samples = unionSet.getLength();
+    }
+    catch (VisADException ex) { ex.printStackTrace(); }
+
+    //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+    
+    int hlen = hlt ? len : 0;
+    float[][] rangeSamples = new float[4][samples];
+
+    // fill nodes range samples;
+    Color col = GLOW_COLOR;
+    float r = col.getRed() / 255f;
+    float g = col.getGreen() / 255f;
+    float b = col.getBlue() / 255f;
+
+    // ADJUST THIS to account for circles later
+    Arrays.fill(rangeSamples[0], r);
+    Arrays.fill(rangeSamples[1], g);
+    Arrays.fill(rangeSamples[2], b);
+    Arrays.fill(rangeSamples[3], GLOW_ALPHA);
+
+    // REMOVE this when adding circles later
+    FlatField field = null;
+    try {
+      FunctionType fieldType = new FunctionType(domain, range);
+      field = new FlatField(fieldType, unionSet);
+      field.setSamples(rangeSamples);
+    }
+    catch (VisADException exc) { exc.printStackTrace(); }
+    catch (RemoteException exc) { exc.printStackTrace(); }
+
+    return field;
+
+    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    // Build circle and circle samples
+    // ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+
+    /*
+    System.out.println("2: isHighlightNode = " + hlt);
+    System.out.println("Thread.currentThread()" + Thread.currentThread());
+    */
+    /*
+    Gridded2DSet hltSet = null;
+    if (hlt) {
+      float rad = 2 * delta;
+
+      // assemble a small circle
+      float[][] highlightSetSamples = new float[2][len];
+
+      // top half of circle
+      for (int i=0; i<arcLen; i++) {
+        highlightSetSamples[0][i] = c[0] + rad * ARC[0][i];
+        highlightSetSamples[1][i] = c[1] + rad * ARC[1][i];
+      }
+
+      // bottom half of circle
+      for (int i=0; i<arcLen; i++) {
+        int ndx = arcLen + i;
+        highlightSetSamples[0][ndx] = c[0] + rad * ARC[0][i];
+        highlightSetSamples[1][ndx] = c[1] - rad * ARC[1][i];
+      }
+
       try {
-        sets.add(new Gridded2DSet(domain, setSamples,
-            2, 2, null, null, null, false));
-      }
-
-      catch (VisADException exc) { exc.printStackTrace(); }
-    }
-
-    int hlen = hlt ? len : 0;
-    int goodSets = sets.size();
-    if (goodSets == 0 ) {
-      return null;
-    }
-    else {
-      float[][] rangeSamples = new float[4][hlen + 4 * goodSets];
-
-      // fill nodes range samples;
-      Color col = GLOW_COLOR;
-      float r = col.getRed() / 255f;
-      float g = col.getGreen() / 255f;
-      float b = col.getBlue() / 255f;
-
-      Arrays.fill(rangeSamples[0], 0, 4*goodSets, r);
-      Arrays.fill(rangeSamples[1], 0, 4*goodSets, g);
-      Arrays.fill(rangeSamples[2], 0, 4*goodSets, b);
-      Arrays.fill(rangeSamples[3], 0, 4*goodSets, GLOW_ALPHA);
-
-      // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-      // Build circle and circle samples
-      // ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
-
-      /*
-      System.out.println("2: isHighlightNode = " + hlt);
-      System.out.println("Thread.currentThread()" + Thread.currentThread());
-      */
-      Gridded2DSet hltSet = null;
-      if (hlt) {
-        float rad = 2 * delta;
-
-        // assemble a small circle
-        float[][] highlightSetSamples = new float[2][len];
-
-        // top half of circle
-        for (int i=0; i<arcLen; i++) {
-          highlightSetSamples[0][i] = c[0] + rad * ARC[0][i];
-          highlightSetSamples[1][i] = c[1] + rad * ARC[1][i];
-        }
-
-        // bottom half of circle
-        for (int i=0; i<arcLen; i++) {
-          int ndx = arcLen + i;
-          highlightSetSamples[0][ndx] = c[0] + rad * ARC[0][i];
-          highlightSetSamples[1][ndx] = c[1] - rad * ARC[1][i];
-        }
-
-        try {
-          // build highlight set
-          hltSet = new Gridded2DSet(domain, highlightSetSamples,
-            arcLen, 2, null, null, null, false);
-        }
-        catch (VisADException ex) { ex.printStackTrace(); }
-
-        col = HLT_COLOR;
-        r = col.getRed() / 255f;
-        g = col.getGreen() / 255f;
-        b = col.getBlue() / 255f;
-
-        Arrays.fill(rangeSamples[0], 4*goodSets, 4*goodSets + hlen, r);
-        Arrays.fill(rangeSamples[1], 4*goodSets, 4*goodSets + hlen, g);
-        Arrays.fill(rangeSamples[2], 4*goodSets, 4*goodSets + hlen, b);
-        Arrays.fill(rangeSamples[3], 4*goodSets, 4*goodSets + hlen, HLT_ALPHA);
-
-        sets.add(hltSet);
-      }
+        // build highlight set
+        hltSet = new Gridded2DSet(domain, highlightSetSamples,
+          arcLen, 2, null, null, null, false);
+      }
+      catch (VisADException ex) { ex.printStackTrace(); }
+
+      col = HLT_COLOR;
+      r = col.getRed() / 255f;
+      g = col.getGreen() / 255f;
+      b = col.getBlue() / 255f;
+
+      Arrays.fill(rangeSamples[0], 4*goodSets, 4*goodSets + hlen, r);
+      Arrays.fill(rangeSamples[1], 4*goodSets, 4*goodSets + hlen, g);
+      Arrays.fill(rangeSamples[2], 4*goodSets, 4*goodSets + hlen, b);
+      Arrays.fill(rangeSamples[3], 4*goodSets, 4*goodSets + hlen, HLT_ALPHA);
+
+      sets.add(hltSet);
 
       Gridded2DSet[] trueSets = new Gridded2DSet[sets.size()];
@@ -643 +623 @@
         }
         */
+    /*
         fieldSet = new UnionSet (domain, trueSets);
         FunctionType fieldType = new FunctionType(domain, range);
@@ -653 +634 @@
       return field;
     }
+    */
 
     /*
@@ -833 +815 @@
    */
   public static float getMultiplier(DisplayImpl display) {
+    // This method may be a bit naive, obtaining the multiplier from
+    // only one measurement.
     int[] p1 = {0,0};
     int[] p2 = {0, 1000};
@@ -933 +917 @@
   }
 
+  // put this in ObjectUtil or something
+  /** Connects a pair of VisAD-style 2D arrays of points */
+  public static float[][] adjoin(float[][] a, float b[][]) {
+    int alen = a[0].length;
+    int blen = b[0].length;
+    float[][] result = new float[a.length][alen + blen];
+    for (int j=0; j<a.length; j++) {
+      for (int i=0; i<alen; i++) {
+        result[j][i] = a[j][i];
+      }
+      for (int i=0; i<blen; i++) {
+        result[j][i+alen] = b[j][i];
+      }
+    }
+    return result;
+  }
+
+  /** Given a set of nodes, creates a UnionSet of Gridded2DSets to 
+   *  highlight the nodes. */
+  public static UnionSet buildNodesSets(RealTupleType domain, float[][] nodes,
+      float width) 
+    throws VisADException {
+    int len = nodes[0].length;
+
+    // Create two arrays to store the gridpoints: one to the right of the curve
+    // and another to the left (supposing the curve is oriented in order of
+    // increasing node indices, i.e., the first node is nodes[][0], the last
+    // is nodes[][nodes.length-1])
+    float[][] right = new float[2][len]; // store the gridpts
+    float[][] left = new float[2][len]; 
+
+    if (len <=1) return null;
+
+    for (int i=0; i<len; i++) {
+      float[] rightPt = new float[2];
+      float[] leftPt = new float[2];
+      
+      if (i==0) { // Case 1: the first node
+       
+        float[] p1 = new float[] {nodes[0][0], nodes[1][0]}; // first point
+        float[] p2 = new float[] {nodes[0][1], nodes[1][1]}; // second point
+        // get a perpendicular vector to the right of p2-p1
+        float[] vPerp = MathUtil.getRightPerpendicularVector2D(p2, p1);
+        rightPt = MathUtil.add(p1, MathUtil.scalarMultiply(vPerp, width)); 
+        leftPt = MathUtil.add(p1, MathUtil.scalarMultiply(vPerp, -1f * width));
+      }
+      else if (i == len - 1) { // Case 2: the last node
+
+        float[] p1 = new float[] {nodes[0][i-1], nodes[1][i-1]}; // penultimate
+        float[] p2 = new float[] {nodes[0][i], nodes[1][i]}; // last point
+        // get a perpendicular vector to the right of p2-p1
+        float[] vPerp = MathUtil.getRightPerpendicularVector2D(p2, p1);
+        // add a multiple of this vector to the point p2, the last node in
+        // the curve
+        rightPt = MathUtil.add(p2, MathUtil.scalarMultiply(vPerp, width)); 
+        leftPt = MathUtil.add(p2, MathUtil.scalarMultiply(vPerp, -1f * width));
+      }
+      else { // Case 3: all interior nodes
+
+        float[] p1 = {nodes[0][i-1], nodes[1][i-1]};
+        float[] p2 = {nodes[0][i], nodes[1][i]};
+        float[] p3 = {nodes[0][i+1], nodes[1][i+1]};
+        
+        // obtain unit vectors bisecting p2-p1 and p3-p2
+        float[] bisector = MathUtil.getRightBisectorVector2D(p1, p2, p3);
+        float[] bisectorReflected = MathUtil.scalarMultiply(bisector, -1f);
+
+        // compute angle between the p2-p1 and bisector 
+        float sin = Math.abs(MathUtil.cross2D(bisector,
+              MathUtil.unit(MathUtil.vector(p2, p1))));
+        if (sin < 0.1f) sin = 0.1f; // keep a lower bound on this for safety 
+        // (the value of sin could become really small)
+        
+        // compute offset distance from curve
+        float offset = width / sin;
+
+        rightPt = MathUtil.add(p2, MathUtil.scalarMultiply(bisector, offset));
+        leftPt = MathUtil.add(p2, MathUtil.scalarMultiply(bisectorReflected,
+              offset));
+      } // end else // TEMP
+
+      // copy calculated values to storage arrays
+      right[0][i] = rightPt[0];
+      right[1][i] = rightPt[1];
+      left[0][i] = leftPt[0];
+      left[1][i] = leftPt[1];
+    } // end for
+    
+    // assemble an array of gridded sets representing the highlighting
+    Gridded2DSet[] sets = makeGridded2DSets(domain, nodes, right, left);
+    UnionSet fieldSets = null;
+    fieldSets = new UnionSet(domain, sets);
+
+    return fieldSets;
+  } 
+
+  /** Makes valid Gridded2DSets from the arrays supplied.
+   *  @param nodes The nodes of the noded object
+   *  @param right The points on the right side of the noded object (supposing
+   *  node indices increase from left to right across the screen)
+   *  @param left The points on the left side of the noded object (again
+   *  supposing node indices increase from left to right across the screen)
+   */   
+  public static Gridded2DSet[] makeGridded2DSets(RealTupleType domain,
+      float[][] nodes, float[][] right, float[][] left) {
+    int len = nodes[0].length;
+    Vector sets = new Vector(100);
+    for (int i=0; i<len-1; i++) {
+      float[][] setSamples = {
+        {right[0][i], right[0][i+1], left[0][i], left[0][i+1]},
+        {right[1][i], right[1][i+1], left[1][i], left[1][i+1]}
+      };
+
+      try {
+        Gridded2DSet set = new Gridded2DSet(domain, setSamples, 2, 2, null, 
+            null, null, false);
+        sets.add(set);
+      }
+      catch (VisADException ex) {
+        // If samples form an invalid set, the grid is bow-tie shaped.  
+        // "Uncross" the box just by switching the order of the two
+        // left points
+        setSamples = new float[][]{
+          {right[0][i], right[0][i+1], left[0][i+1], left[0][i]},
+          {right[1][i], right[1][i+1], left[1][i+1], left[1][i]}
+        };
+
+        try { 
+          Gridded2DSet set = new Gridded2DSet(domain, setSamples, 2, 2, null, 
+            null, null, false);
+          sets.add(set);
+        }
+        catch (VisADException ex2) {
+          System.out.println("OverlayUtil: error making Gridded2DSets: " + 
+              "lefth tries produced invalid sets.");
+          ex2.printStackTrace();
+        }
+      }
+    } // end for
+
+    // Convert vector to array
+    Gridded2DSet[] trueSets = new Gridded2DSet[sets.size()];
+    Object[] garbage = sets.toArray(trueSets);
+
+    return trueSets;
+  }
+
+  /** Prints a VisAD style group of points. */
+  public static void print(float[][] points) {
+    for (int i=0; i<points[0].length; i++) {
+      System.out.println("[" + points[0][i] + "," + points[1][i] + "]");
+    }
+  }
+
+  /** Prints a point. */ 
+  public static void print(float x, float y) {
+    System.out.println("[" + x + "," + y + "]");
+  }
+
+  public static void print(float[] p) {
+    print(p[0], p[1]); 
+  }
 }