Changeset 2477


Ignore:
Timestamp:
03/16/07 18:54:47 (13 years ago)
Author:
sorber
Message:

TransientSelectBox now based on pixel coordinates, no longer rotates with domain coordinate system.
Added mnemonic for Export button, deleted some old test code from OverlayTransform.

Location:
trunk/loci/visbio/overlays
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/visbio/overlays/OverlayTransform.java

    r2428 r2477  
    734734        tool.mouseDown(e, px, py, 
    735735          (float) coords[0], (float) coords[1], pos, e.getModifiers()); 
    736         /* 
    737         //  Temporary testing junk 
    738         // pixel coords  
    739         System.out.println("Pixel coords (native) = (" + px + "," + py + ")"); // TEMP 
    740         // pixel to cursor 
    741         double[] ccoords = DisplayUtil.pixelToCursor(display, px, py);  
    742         System.out.println("pixelToCursor coords = (" + ccoords[0] + "," + ccoords[1]); 
    743         // cursor to domain 
    744         double[] dcoords  = DisplayUtil.cursorToDomain(display, ccoords); 
    745         System.out.println("cursorToDomain coords = (" + dcoords[0] + "," + dcoords[1]); 
    746         System.out.println("pixelToDomain coords = (" + coords[0] + "," + coords[1]); 
    747  
    748         // domain to cursor 
    749         double[] dccoords = DisplayUtil.domainToCursor(display, dcoords); 
    750         System.out.println("domainToCursor coords = (" + dccoords[0] + "," + dccoords[1]); 
    751  
    752         // cursor to pixel  
    753         int[] cpcoords = DisplayUtil.cursorToPixel(display, dccoords); // TEMP 
    754         System.out.println("cursorToPixel coords = (" + cpcoords[0] + "," + cpcoords[1]); 
    755         */ 
    756736      } 
    757737    } 
  • trunk/loci/visbio/overlays/OverlayWidget.java

    r2428 r2477  
    303303    export = new JButton("Export overlays..."); 
    304304    export.addActionListener(this); 
    305     if (!LAFUtil.isMacLookAndFeel()) save.setMnemonic('e'); 
     305    if (!LAFUtil.isMacLookAndFeel()) export.setMnemonic('e'); 
    306306    export.setToolTipText("Exports overlays to a .xls file on disk"); 
    307307 
  • trunk/loci/visbio/overlays/PointerTool.java

    r2246 r2477  
    2525 
    2626import java.awt.event.InputEvent; 
     27import java.util.Vector; 
    2728import loci.visbio.data.TransformEvent; 
     29import loci.visbio.util.MathUtil; 
    2830import visad.DisplayEvent; 
    29 import java.util.Vector; 
     31import visad.DisplayImpl; 
    3032 
    3133/** PointerTool is the tool for manipulating existing overlays. */ 
     
    7173    boolean shift = (mods & InputEvent.SHIFT_MASK) != 0; 
    7274    boolean ctrl = (mods & InputEvent.CTRL_MASK) != 0; 
     75 
     76    DisplayImpl display = (DisplayImpl) e.getDisplay(); 
    7377     
    7478    // pick nearest object 
     
    135139 
    136140      // instantiate selection box 
    137       select = new TransientSelectBox(overlay, dx, dy); 
     141      select = new TransientSelectBox(overlay, display, px, py); 
    138142      overlay.addTSB (select); 
    139143    } 
     
    186190    } else if (select != null) { 
    187191      // extend selection box 
    188       select.setCorner(dx, dy); 
     192      select.setCorner(px, py); 
    189193 
    190194      // select objects inside the box 
     
    195199        float ox1, ox2, oy1, oy2; 
    196200 
     201        // object corners 
    197202        ox1 = bounds[i][0]; 
    198203        oy1 = bounds[i][1]; 
     
    201206 
    202207        // un-oriented (disoriented?) box coordinates 
    203         tx1 = select.getX1(); 
    204         tx2 = select.getX2(); 
    205         ty1 = select.getY1(); 
    206         ty2 = select.getY2(); 
    207  
    208         // assign oriented coordinates of seletion box 
    209         if (tx1 < tx2) { 
    210           bx1 = tx1; 
    211           bx2 = tx2; 
    212         } 
    213         else { 
    214           bx1 = tx2; 
    215           bx2 = tx1; 
    216         } 
    217         if (ty1 < ty2) { 
    218           by1 = ty1; 
    219           by2 = ty2; 
    220         } 
    221         else { 
    222           by1 = ty2; 
    223           by2 = ty1; 
    224         } 
    225  
    226         // determine whether object i is inside or outside of selection box  
    227         boolean inside = false; 
    228         if (bx1 < ox1 && ox1 < bx2 && bx1 < ox2 && ox2 < bx2 && 
    229           by1 < oy1 && oy1 < by2 && by1 < oy2 && oy2 < by2) 
    230         { 
    231           inside = true; 
    232         } 
    233  
    234         // code for static list refresh 
    235         // (add a refreshListSelection line to mouseUp 
     208        double[][] c = select.getCornersDomain(); 
     209 
     210        // selection box corners 'c' 
    236211        /* 
    237         if (inside) { 
    238           if (ctrl && !shift) objs[i].setSelected(!selected[i]); 
    239           else objs[i].setSelected(true); 
    240         } 
    241         else { 
    242           if (shift || ctrl) objs[i].setSelected(selected[i]); 
    243           else objs[i].setSelected(false); 
    244         } 
    245         */ 
     212         * 0----1 
     213         * |    | 
     214         * |    | 
     215         * 3----2 
     216         */ 
     217         
     218        // express object corners in terms of TSB edge vectors 
     219        double[] v1 = {c[1][0] - c[0][0], c[1][1] - c[0][1]}; 
     220        double[] v2 = {c[3][0] - c[0][0], c[3][1] - c[0][1]}; 
     221 
     222        // iterate through all points of bounding box 
     223        // and check whether they're inside  
     224        boolean inside = true;  
     225        for (int j = 0; j<bounds[0].length && inside; j++) { 
     226          int xndx = j < 2 ? 0 : 2; 
     227          int yndx = j % 2 == 0 ? 1 : 3; 
     228          double[] p = {bounds[i][xndx], bounds[i][yndx]}; 
     229          double[] vp = {p[0] - c[0][0], p[1] - c[0][1]}; 
     230 
     231          double cos1 = (vp[0] * v1[0] + vp[1] * v1[1]) /  
     232            (Math.sqrt(vp[0]*vp[0] + vp[1]*vp[1] + v1[0]*v1[0] + v1[1]*v1[1])); 
     233           
     234          double cos2 = (vp[0] * v2[0] + vp[1] * v2[1]) /  
     235            (Math.sqrt(vp[0]*vp[0] + vp[1]*vp[1] + v2[0]*v2[0] + v2[1]*v2[1])); 
     236 
     237          if (cos1 < 0 || cos2 < 0)  inside = false; 
     238          else { 
     239            // determine projection of point on edge vectors 
     240            // if projection is longer than either edge vector, you're too far. 
     241            double[] proj1 = MathUtil.getProjection(c[0], c[3], p, false); 
     242            double[] proj2 = MathUtil.getProjection(c[0], c[1], p, false); 
     243              
     244            double d1 = MathUtil.getDistance(proj1, c[0]); 
     245            double d2 = MathUtil.getDistance(proj2, c[0]); 
     246 
     247            double dv1 = MathUtil.getDistance(c[0], c[3]); 
     248            double dv2 = MathUtil.getDistance(c[0], c[1]); 
     249 
     250            if (d1 > dv1 || d2 > dv2) inside = false; 
     251          } 
     252        } // end for  
    246253 
    247254        // code for dynamic list refresh 
  • trunk/loci/visbio/overlays/TransientSelectBox.java

    r2246 r2477  
    2424package loci.visbio.overlays; 
    2525 
     26import java.awt.Color; 
    2627import java.rmi.RemoteException; 
    2728import java.util.Arrays; 
     29import loci.visbio.util.DisplayUtil; 
    2830import visad.*; 
    29 import java.awt.Color; 
    3031 
    3132/** 
     
    4647 
    4748  /** Boundaries of box */ 
    48   private float x1, x2, y1, y2; 
     49  private int x1, x2, y1, y2; 
    4950 
    5051  /** Parent Transform */ 
     52  // not sure if this is useful at all 
    5153  private OverlayTransform overlay; 
     54 
     55  /** Associated display */ 
     56  private DisplayImpl display; 
    5257 
    5358  // -- Constructor -- 
     
    5560  /** Constructs a selection box. 
    5661   */ 
    57   public TransientSelectBox(OverlayTransform overlay, 
    58     float downX, float downY) 
     62  public TransientSelectBox(OverlayTransform overlay, DisplayImpl display, 
     63    int downX, int downY) 
    5964  { 
    6065    this.overlay = overlay; 
     66    this.display = display; 
    6167    x1 = downX; 
    6268    x2 = downX; 
     
    7076 
    7177  /** Sets coordinates of draggable box corner */ 
    72   public void setCorner (float x, float y) { 
     78  public void setCorner (int x, int y) { 
    7379    x2 = x; 
    7480    y2 = y; 
    7581  } 
     82 
     83  /** Returns the display on which this TSB exists */ 
     84  public DisplayImpl getActiveDisplay() { return display; } 
    7685 
    7786  /** Returns a VisAD data object representing this box. 
     
    8796    TupleType range = overlay.getRangeType(); 
    8897 
     98    /* 
     99     * 1------2 
     100     * |      | 
     101     * |      | 
     102     * 4------3 
     103     */ 
     104    double[] d1 = DisplayUtil.pixelToDomain(getActiveDisplay(), x1, y1); 
     105    double[] d2 = DisplayUtil.pixelToDomain(getActiveDisplay(), x2, y1); 
     106    double[] d3 = DisplayUtil.pixelToDomain(getActiveDisplay(), x2, y2); 
     107    double[] d4 = DisplayUtil.pixelToDomain(getActiveDisplay(), x1, y2); 
     108 
     109    float[] f1 = {(float) d1[0], (float) d1[1]}; 
     110    float[] f2 = {(float) d2[0], (float) d2[1]}; 
     111    float[] f3 = {(float) d3[0], (float) d3[1]}; 
     112    float[] f4 = {(float) d4[0], (float) d4[1]}; 
     113 
    89114    float[][] shadeSamples = null; 
    90115    float[][] outlineSamples = null; 
     
    94119    try { 
    95120      shadeSamples = new float[][] { 
    96         {x1, x2, x1, x2}, 
    97         {y1, y1, y2, y2} 
     121        {f1[0], f2[0], f4[0], f3[0]}, 
     122        {f1[1], f2[1], f4[1], f3[1]} 
    98123      }; 
    99124 
    100125      outlineSamples = new float[][] { 
    101         {x1, x1, x2, x2, x1}, 
    102         {y1, y2, y2, y1, y1} 
     126        {f1[0], f2[0], f3[0], f4[0], f1[0]}, 
     127        {f1[1], f2[1], f3[1], f4[1], f1[1]} 
    103128      }; 
    104129 
     
    141166      outField.setSamples(outlineRangeSamples); 
    142167 
     168      // go Mallards 
    143169      wholeTeam = new DataImpl[] {inField, outField}; 
    144170      ret = new Tuple (wholeTeam, false); 
     
    149175  } 
    150176 
    151   /** Gets X coordinate of the overlay's first endpoint. */ 
    152   public float getX1() { return x1; } 
    153  
    154   /** Gets X coordinate of the overlay's second endpoint. */ 
    155   public float getX2() { return x2; } 
    156  
    157   /** Gets Y coordinate of the overlay's second endpoint. */ 
    158   public float getY1() { return y1; } 
    159  
    160   /** Gets Y coordinate of the overlay's first endpoint. */ 
    161   public float getY2() { return y2; } 
     177 
     178  /**  
     179   * Gets domain coordinates of box corners  
     180   * Corners are returned as a double[4][2] 
     181   */ 
     182  public double[][] getCornersDomain() { 
     183    /* 
     184     * 0----1 
     185     * |    | 
     186     * |    | 
     187     * 3----2 
     188     */ 
     189 
     190    double[] p0 = DisplayUtil.pixelToDomain(getActiveDisplay(), x1, y1); 
     191    double[] p1 = DisplayUtil.pixelToDomain(getActiveDisplay(), x2, y1); 
     192    double[] p2 = DisplayUtil.pixelToDomain(getActiveDisplay(), x2, y2); 
     193    double[] p3 = DisplayUtil.pixelToDomain(getActiveDisplay(), x1, y2); 
     194 
     195    double[][] ret = {  {p0[0], p0[1]}, 
     196                        {p1[0], p1[1]}, 
     197                        {p2[0], p2[1]}, 
     198                        {p3[0], p3[1]}}; 
     199 
     200    return ret;  
     201  } 
     202   
     203  /** Gets X coordinate of the first endpoint. */ 
     204  public int getX1() { return x1; } 
     205 
     206  /** Gets X coordinate of the second endpoint. */ 
     207  public int getX2() { return x2; } 
     208 
     209  /** Gets Y coordinate of the first endpoint. */ 
     210  public int getY1() { return y1; } 
     211 
     212  /** Gets Y coordinate of the second endpoint. */ 
     213  public int getY2() { return y2; } 
    162214} 
Note: See TracChangeset for help on using the changeset viewer.