Changeset 2903


Ignore:
Timestamp:
06/25/07 13:12:53 (12 years ago)
Author:
sorber
Message:

Incorporated checks into several OverlayNodedObject methods to prevent colocational nodes from being added to/arising in the node array.
Moved most of method to connect freeforms from FreeformTool to OverlayNodedObject.
Added a set of unit tests for OverlayNodedObjects methods.
Added DummyOverlayTransform and DummyImageTransform classes to enable unit testing.

Location:
trunk/loci/visbio
Files:
3 added
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/visbio/VisBio.java

    r1989 r2903  
    2929import loci.visbio.util.InstanceServer; 
    3030import loci.visbio.util.SplashScreen; 
     31// ACS -- import statements below are _temporary_ (for testing) 
     32import loci.visbio.VisBioFrame; 
     33import loci.visbio.data.DataManager; 
    3134 
    3235/** 
     
    125128    Object o = launch(args); 
    126129    if (o == null) System.out.println("VisBio is already running."); 
     130    // ACS - All code below temporary for testing purposes 
     131    else { 
     132      // load sdub data 
     133      VisBioFrame vbf = (VisBioFrame) o; 
     134      DataManager dm = (DataManager) 
     135        vbf.getManager(DataManager.class); 
     136      dm.openSampleData("sdub"); 
     137      // This doesn't work: perhaps sdub data object isn't 'selected,' causing 
     138      // doNewDisplay...() to return prematurely 
     139      // DataControls controls = dm.getControls(); 
     140      // controls.doNewDisplayWithOverlays(); 
     141    } 
     142 
    127143  } 
    128144 
  • trunk/loci/visbio/data/DataControls.java

    r2725 r2903  
    554554    DataTransform data = (DataTransform) e.getSource(); 
    555555    if (data != getSelectedData()) return; 
     556    //System.out.println("transform changed"); // TEMP 
     557    //System.out.println("e.getSource = " + data); // TEMP 
     558    //System.out.println("e.getSource().getClass().getName() = " + 
     559    //    data.getClass().getName()); // TEMP 
    556560    doDataInfo(data); 
    557561  } 
  • trunk/loci/visbio/overlays/FreeformExtension.java

    r2885 r2903  
    186186  public void extend(float[] c) { 
    187187    if (tip < 0) { 
    188       freeform.insertNode(stop, c[0], c[1]); 
     188      freeform.insertNode(stop, c[0], c[1], true); 
    189189      stop++; 
    190190      tip = start + 1; 
     
    192192    else { // later drags 
    193193      float[] prev = getTipCoords(); 
    194       freeform.insertNode(tip+1, prev[0], prev[1]); 
    195       freeform.insertNode(tip+1, c[0], c[1]); 
     194      freeform.insertNode(tip+1, prev[0], prev[1], true); 
     195      freeform.insertNode(tip+1, c[0], c[1], true); 
    196196      tip++; 
    197197      stop += 2; 
     
    218218      float[] newXY = MathUtil.computePtOnSegment(a, b, (float) weight); 
    219219      int insertIndex = seg + 1 + offset; 
    220       freeform.insertNode(insertIndex, newXY[0], newXY[1]); 
     220      freeform.insertNode(insertIndex, newXY[0], newXY[1], true); 
    221221      if (!closerToPost) incrementAll(); 
    222222      endIndex = insertIndex; 
  • trunk/loci/visbio/overlays/FreeformTool.java

    r2885 r2903  
    174174            // never be 0.0 except if seg = 0. 
    175175            if (weight == 1.0) { // nearest point on seg is the end node 
    176               // determine projection on seg. 
    177176              float[] a = freeform.getNodeCoords(seg+1); 
    178               freeform.insertNode(seg+2, a[0], a[1]); 
     177              // TODO move these inserts inside FreeformExtension 
     178              freeform.insertNode(seg+2, a[0], a[1], true); 
    179179              freeformExtension = new FreeformExtension(freeform, seg+1, seg+2, 
    180180                  true); 
     
    186186              float[] b = freeform.getNodeCoords(seg + 1); 
    187187              float[] newXY = MathUtil.computePtOnSegment(a, b, (float) weight); 
    188               freeform.insertNode(seg + 1, newXY[0], newXY[1]); 
    189               freeform.insertNode(seg + 1, newXY[0], newXY[1]); 
     188              // TODO move thes inserts inside FreeformExtension 
     189              freeform.insertNode(seg + 1, newXY[0], newXY[1], true); 
     190              freeform.insertNode(seg + 1, newXY[0], newXY[1], true); 
    190191              freeformExtension = new FreeformExtension(freeform, seg+1, seg+2, 
    191192                  false); 
     
    322323          freeformExtension.stop+1); 
    323324      if (freeformExtension.nodal) { 
    324         freeform.insertNode(freeformExtension.start, c[0], c[1]); 
     325        freeform.insertNode(freeformExtension.start, c[0], c[1], false); 
    325326      } 
    326327    } 
     
    400401    boolean head) 
    401402  { 
     403    // This method combines freeforms f1 and f2 to make a new freeform f3. 
    402404    if (!head) f2.reverseNodes(); 
    403     float[][] f1Nodes = f1.getNodes(); 
    404     float[][] f2Nodes = f2.getNodes(); 
    405     int len1 = f1.getNumNodes(); 
    406     int len2 = f2.getNumNodes(); 
    407     float[][] newNodes = new float[2][len1 + len2]; 
    408  
    409     for (int i=0; i<2; i++) { 
    410       System.arraycopy(f1Nodes[i], 0, newNodes[i], 0, len1);  
    411       System.arraycopy(f2Nodes[i], 0, newNodes[i], len1, len2); 
    412     } 
    413  
    414     OverlayFreeform f3 = new OverlayFreeform (overlay, newNodes); 
     405    OverlayFreeform f3 = f1.connectTo(f2); 
    415406    overlay.removeObject(f1); 
    416407    overlay.removeObject(f2); 
  • trunk/loci/visbio/overlays/OverlayNodedObject.java

    r2900 r2903  
    539539   * before the node at the index provided. 
    540540   */ 
    541   public void insertNode(int index, float x, float y) { 
     541  public void insertNode(int index, float x, float y, boolean colocationalOK) { 
    542542    synchronized (nodesSync) { 
    543543      if (index >= 0 && index < numNodes) { 
     
    547547          resizeNodeArray(maxNodes); 
    548548        } 
    549         for (int j = 0; j < 2; j++) { 
    550           for (int i = numNodes; i > index; i--) { 
    551             // right shift every node right of index by 1 
    552             nodes[j][i] = nodes[j][i-1]; 
     549 
     550        if (colocationalOK) { 
     551          insert(index, x, y); 
     552        }  
     553        else { 
     554          boolean differentFromNext = false; 
     555          boolean differentFromPrev = false; 
     556          boolean notFirst = false; 
     557          float[] c = new float[]{x, y}; 
     558          if (index < numNodes) { 
     559            differentFromNext = MathUtil.areDifferent(getNodeCoords(index), c); 
    553560          } 
    554         } 
    555         nodes[0][index] = x; 
    556         nodes[1][index] = y; 
    557         numNodes++; 
     561          if (index > 0) { 
     562            differentFromPrev = MathUtil.areDifferent(getNodeCoords(index-1), c); 
     563            notFirst = true; 
     564          } 
     565 
     566          /* 
     567           cases where you insert the node 
     568           -index = 0 and different from next 
     569           -index interior and different from next and different from previous 
     570          */ 
     571          if ((!notFirst && differentFromNext) || 
     572              (notFirst && differentFromPrev && differentFromNext)) { 
     573            insert(index, x, y); 
     574 
     575          } 
     576        } 
    558577      } 
    559578      else { 
     
    562581      } 
    563582    } 
     583  } 
     584 
     585  /** Actually inserts a node. */ 
     586  private void insert(int index, float x, float y) { 
     587    for (int j = 0; j < 2; j++) { 
     588      for (int i = numNodes; i > index; i--) { 
     589        // right shift every node right of index by 1 
     590        nodes[j][i] = nodes[j][i-1]; 
     591      } 
     592    } 
     593    nodes[0][index] = x; 
     594    nodes[1][index] = y; 
     595    numNodes++; 
    564596  } 
    565597 
     
    571603    synchronized(nodesSync) { 
    572604      if (0 <= i1 && i2 < numNodes && i1 + 1 < i2 ) { 
    573         int victims = i2 - i1 - 1; 
     605        int ii2 = i2; 
     606        // if adjacent-nodes-to-be are colococational, 
     607        // delete one of them 
     608        if (MathUtil.areSame(getNodeCoords(i1), getNodeCoords(i2)))  
     609          ii2 += 1; 
     610        int victims = ii2 - i1 - 1; 
    574611        float[][] newNodes = new float[2][maxNodes - victims]; 
    575612        System.arraycopy(nodes[0], 0, newNodes[0], 0, i1 + 1); 
    576613        System.arraycopy(nodes[1], 0, newNodes[1], 0, i1 + 1); 
    577         System.arraycopy(nodes[0], i2, newNodes[0], i1+1, maxNodes - i2); 
    578         System.arraycopy(nodes[1], i2, newNodes[1], i1+1, maxNodes - i2); 
     614        System.arraycopy(nodes[0], ii2, newNodes[0], i1+1, maxNodes - ii2); 
     615        System.arraycopy(nodes[1], ii2, newNodes[1], i1+1, maxNodes - ii2); 
    579616        numNodes -= victims; 
    580617        maxNodes -= victims; 
     
    593630        //System.out.println("OverlayObject.deleteNode(" + index +") called. " + 
    594631        //  "numNodes = " + numNodes + ", maxNodes = " + maxNodes); 
    595         float [][] newNodes =  new float[2][numNodes-1]; 
    596         System.arraycopy(nodes[0], 0, newNodes[0], 0, index); 
    597         System.arraycopy(nodes[0], index+1, newNodes[0], index, numNodes-index-1); 
    598         System.arraycopy(nodes[1], 0, newNodes[1], 0, index); 
    599         System.arraycopy(nodes[1], index+1, newNodes[1], index, numNodes-index-1); 
    600         numNodes--; 
     632        int offset; 
     633        if (index > 0 && index < numNodes - 1 &&  
     634            MathUtil.areSame(getNodeCoords(index-1), getNodeCoords(index+1)))  
     635          // colocational nodes exist 
     636          offset = 1; 
     637        else offset = 0; 
     638        float[][] newNodes =  new float[2][numNodes-1-offset]; 
     639        System.arraycopy(nodes[0], 0, newNodes[0], 0, index-offset); 
     640        System.arraycopy(nodes[0], index+1, newNodes[0], index-offset, numNodes-index-1); 
     641        System.arraycopy(nodes[1], 0, newNodes[1], 0, index-offset); 
     642        System.arraycopy(nodes[1], index+1, newNodes[1], index-offset, numNodes-index-1); 
     643        numNodes -= 1 + offset; 
    601644        maxNodes = numNodes; 
    602645        nodes = newNodes; 
     
    692735  } 
    693736 
     737  /**  
     738   * Creates a new freeform by connecting the tail of this freeform to the 
     739   * head of the freeform supplied. 
     740   * @param f2 The freeform to connect to this freeform 
     741   */ 
     742  public OverlayFreeform connectTo(OverlayFreeform f2) { 
     743    float[][] f1Nodes = this.getNodes(); 
     744    float[][] f2Nodes = f2.getNodes(); 
     745    int len1 = f1Nodes[0].length;  
     746    int len2 = f2Nodes[0].length; 
     747 
     748    // Obtain coordinates of last node of f1 and first of f2. 
     749    float[] f1End = {f1Nodes[0][len1-1], f1Nodes[1][len1-1]}; 
     750    float[] f2Beg = {f2Nodes[0][0], f2Nodes[1][0]}; 
     751    // If the last node in f1 and the first node in f2 are the same, 
     752    // this method won't copy the last node of f1 into the node array used to 
     753    // construct f3. 
     754    int offset;  
     755    if (MathUtil.areSame(f1End, f2Beg)) offset = 1;  
     756    else offset = 0; 
     757 
     758    float[][] newNodes = new float[2][len1 + len2 - offset]; 
     759    for (int i=0; i<2; i++) { 
     760      System.arraycopy(f1Nodes[i], 0, newNodes[i], 0, len1-offset);  
     761      System.arraycopy(f2Nodes[i], 0, newNodes[i], len1-offset, len2); 
     762    } 
     763 
     764    OverlayFreeform f3 = new OverlayFreeform (overlay, newNodes); 
     765    return f3; 
     766  } 
     767 
    694768  /** Reverses the node array (and therefore its internal orientation) */ 
    695769  public void reverseNodes() { 
  • trunk/loci/visbio/overlays/OverlayUtil.java

    r2900 r2903  
    974974          float[] v1 = MathUtil.unit(MathUtil.vector(p1, p0)); 
    975975          float[] v2 = MathUtil.unit(MathUtil.vector(p2, p1)); 
    976           if (MathUtil.opposite(v1, v2)) { 
     976          if (MathUtil.areOpposite(v1, v2)) { 
    977977            anti = true; 
    978978            orientationChanged = orientationChanged ? false : true; // toggle 
     
    10171017        float[] v1 = MathUtil.unit(MathUtil.vector(p2, p1)); 
    10181018        float[] v2 = MathUtil.unit(MathUtil.vector(p3, p2)); 
    1019         if (MathUtil.opposite(v1, v2)) { 
     1019        if (MathUtil.areOpposite(v1, v2)) { 
    10201020          // vectors are antiparallel. just use v1 to calculate right and left 
    10211021          float[] vPerp = MathUtil.getRightPerpendicularVector2D(p2, p1);  
  • trunk/loci/visbio/util/MathUtil.java

    r2901 r2903  
    385385   * @param u2 another unit vector  
    386386   */  
    387   public static boolean opposite(float[] v1, float[] v2) { 
    388     if (v1.length != v2.length) return false; 
     387  public static boolean areOpposite(float[] v1, float[] v2) { 
     388   /*    if (v1.length != v2.length) return false; 
    389389    boolean opposite = true; 
    390390    for (int i=0; i<v1.length; i++) { 
     
    395395    } 
    396396    return opposite; 
    397   } 
     397    */ 
     398    return areSame(v1, scalarMultiply(v2, -1f)); 
     399  } 
     400 
     401  /** Tests whether two arrays of floats are identical. */ 
     402  public static boolean areSame(float[] a, float[] b) { 
     403    boolean same = true;  
     404    if (a.length == b.length) {  
     405      for (int i=0; i<a.length; i++){ 
     406        if (a[i] != b[i]) { 
     407          same = false; 
     408          break; 
     409        } 
     410      } 
     411    } 
     412    else same = false; 
     413    return same; 
     414  } 
     415 
     416  /** Tests whether two arrays of floats are different. */ 
     417  public static boolean areDifferent(float[] a, float[] b) { 
     418    return !areSame(a, b); 
     419  } 
     420 
    398421 
    399422  // -- Computational Geometry Methods -- 
  • trunk/loci/visbio/util/MathUtilTest.java

    r2901 r2903  
    188188  } 
    189189 
    190   /** Tests the opposite method */ 
    191   public void testOpposite() { 
     190  /** Tests the same, different, and opposite methods. */ 
     191  public void testSameEtc() { 
    192192    float[] v1 = {0f, 3f, 4f, 5f, -24.65f, 0f, 45f}; 
    193193    float[] v2 = MathUtil.scalarMultiply(v1, -1f); 
    194194    float[] v3 = {v2[0]}; 
    195195     
    196     assertEquals(true, MathUtil.opposite(v1, v2)); 
    197     assertEquals(false, MathUtil.opposite(v1, v3));  
    198   } 
    199  
    200   // -- Computational Geometry Tests 
     196    assertEquals(true, MathUtil.areSame(v1, v1)); 
     197    assertEquals(false, MathUtil.areSame(v1, v2)); 
     198    assertEquals(true, MathUtil.areDifferent(v1, v2)); 
     199    assertEquals(false, MathUtil.areDifferent(v1, v1)); 
     200    assertEquals(true, MathUtil.areOpposite(v1, v2)); 
     201    assertEquals(false, MathUtil.areOpposite(v1, v3));  
     202  } 
     203 
     204  // -- Computational Geometry Tests -- 
    201205 
    202206  /** Tests the MathUtil.inside() method */ 
Note: See TracChangeset for help on using the changeset viewer.