bundles/org.simantics.scenegraph/src/org/simantics/scenegraph/utils/TransformedRectangle.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
   3  * in Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.scenegraph.utils;
  13
  14 import java.awt.Rectangle;
  15 import java.awt.Shape;
  16 import java.awt.geom.AffineTransform;
  17 import java.awt.geom.Ellipse2D;
  18 import java.awt.geom.NoninvertibleTransformException;
  19 import java.awt.geom.PathIterator;
  20 import java.awt.geom.Point2D;
  21 import java.awt.geom.Rectangle2D;
  22 import java.io.Serializable;
  23
  24 /**
  25  * A rectangle that is transformed.
  26  *
  27  * @see {@link GeometryUtils} Geometry-related tests for Shapes
  28  * @author Toni Kalajainen
  29  */
  30 public class TransformedRectangle implements Shape, Serializable {
  31
  32     private static final long serialVersionUID = 5160199078645323706L;
  33
  34     Rectangle2D rect = new Rectangle2D.Double();
  35
  36     // T(rect) -> Canvas
  37     AffineTransform transform = new AffineTransform();
  38     // T(canvas) -> Rect
  39     AffineTransform inv = new AffineTransform();
  40     boolean isIdentity = true;
  41
  42     /**
  43      * Cache
  44      */
  45     transient Rectangle2D bounds = null;
  46
  47     public TransformedRectangle() {}
  48
  49     public TransformedRectangle(Rectangle2D rect) {
  50         if (rect!=null)
  51             setUntransformedRectangle(rect);
  52     }
  53
  54     public TransformedRectangle(Rectangle2D rect, AffineTransform transform) {
  55         if (rect!=null)
  56             setUntransformedRectangle(rect);
  57         if (transform!=null)
  58             setTransform(transform);
  59     }
  60
  61     public TransformedRectangle(TransformedRectangle src) {
  62         setUntransformedRectangle(src.rect);
  63         setTransform(src.transform);
  64     }
  65
  66     public Rectangle2D getUntransformedRectangle() {
  67         return rect;
  68     }
  69     public void setUntransformedRectangle(Rectangle2D rect) {
  70         this.rect.setFrame(rect);
  71         bounds = null;
  72     }
  73     public AffineTransform getTransform() {
  74         return transform;
  75     }
  76     /**
  77      * Set the transform of the rectangle.
  78      * Transform transforms rectangle coordinates to external coordinates.
  79      *
  80      *  T = Rect -> Canvas
  81      *
  82      * @param transform
  83      */
  84     public void setTransform(AffineTransform transform) {
  85         this.transform.setTransform(transform);
  86         bounds = null;
  87         isIdentity = transform.isIdentity();
  88         try {
  89             inv = transform.createInverse();
  90         } catch (NoninvertibleTransformException e) {
  91             throw new RuntimeException(e);
  92         }
  93     }
  94
  95     public void concatenate(AffineTransform transform) {
  96         this.transform.concatenate(transform);
  97         bounds = null;
  98         try {
  99             inv = transform.createInverse();
 100         } catch (NoninvertibleTransformException e) {
 101             throw new RuntimeException(e);
 102         }
 103     }
 104
 105     @Override
 106     public boolean contains(Point2D p) {
 107         if (isIdentity)
 108             return rect.contains(p);
 109
 110         Point2D newP = inv.transform(p, new Point2D.Double());
 111         return rect.contains(newP);
 112     }
 113     @Override
 114     public boolean contains(double x, double y) {
 115         if (isIdentity)
 116             return rect.contains(x, y);
 117
 118         Point2D p = new Point2D.Double(x, y);
 119         inv.transform(p, p);
 120         return rect.contains(p);
 121     }
 122     @Override
 123     public boolean contains(Rectangle2D r) {
 124         if (isIdentity)
 125             return rect.contains(r);
 126
 127         Point2D p1 = new Point2D.Double(r.getMinX(), r.getMinY());
 128         Point2D p2 = new Point2D.Double(r.getMaxX(), r.getMinY());
 129         Point2D p3 = new Point2D.Double(r.getMaxX(), r.getMaxY());
 130         Point2D p4 = new Point2D.Double(r.getMinX(), r.getMaxY());
 131
 132         inv.transform(p1, p1);
 133         inv.transform(p2, p2);
 134         inv.transform(p3, p3);
 135         inv.transform(p4, p4);
 136
 137         return rect.contains(p1) && rect.contains(p2) && rect.contains(p3) && rect.contains(p4);
 138     }
 139     public boolean contains(TransformedRectangle r) {
 140         if (isIdentity)
 141             return r.intersects(rect);
 142
 143         // Convert points of r to rect
 144         Point2D p1 = new Point2D.Double(r.rect.getMinX(), r.rect.getMinY());
 145         Point2D p2 = new Point2D.Double(r.rect.getMaxX(), r.rect.getMinY());
 146         Point2D p3 = new Point2D.Double(r.rect.getMaxX(), r.rect.getMaxY());
 147         Point2D p4 = new Point2D.Double(r.rect.getMinX(), r.rect.getMaxY());
 148
 149         r.transform.transform(p1, p1);
 150         r.transform.transform(p2, p2);
 151         r.transform.transform(p3, p3);
 152         r.transform.transform(p4, p4);
 153
 154         inv.transform(p1, p1);
 155         inv.transform(p2, p2);
 156         inv.transform(p3, p3);
 157         inv.transform(p4, p4);
 158
 159         return rect.contains(p1) && rect.contains(p2) && rect.contains(p3) && rect.contains(p4);
 160     }
 161     /**
 162      * Tests if the rectangle completely contains the specified shape.
 163      *
 164      * NOTE This test simplifies curves to straight edges.
 165      *
 166      * @param s
 167      * @return
 168      */
 169     public boolean contains(Shape s) {
 170         return contains(s, Double.MAX_VALUE);
 171     }
 172     public boolean contains(Shape s, double flatness) {
 173         if (s instanceof Rectangle2D)
 174             return contains((Rectangle2D)s);
 175         if (s instanceof TransformedRectangle)
 176             return contains( (TransformedRectangle) s);
 177
 178         // rectangle contains s if all points of s are in side rect
 179         PathIterator pi = s.getPathIterator(inv, flatness);
 180         double coords[] = new double[6];
 181         while (!pi.isDone()) {
 182             int type = pi.currentSegment(coords);
 183             if (type == PathIterator.SEG_MOVETO || type == PathIterator.SEG_LINETO)
 184             {
 185                 if (!rect.contains(coords[0], coords[1]))
 186                     return false;
 187             }
 188             assert(type != PathIterator.SEG_CUBICTO && type != PathIterator.SEG_QUADTO);
 189             pi.next();
 190         }
 191         return true;
 192     }
 193
 194     @Override
 195     public boolean contains(double x, double y, double w, double h) {
 196         if (isIdentity)
 197             return rect.contains(x, y, w, h);
 198
 199         return contains(new Rectangle2D.Double(x, y, w, h));
 200     }
 201
 202     /**
 203      *
 204      * NOTE This test simplifies curves to straight edges.
 205      *
 206      * @param s
 207      * @return
 208      */
 209     public boolean intersects(Shape s) {
 210         return intersects(s, Double.MAX_VALUE);
 211     }
 212
 213     public boolean intersects(Shape s, double flatness) {
 214         if (s instanceof Rectangle2D)
 215             return intersects((Rectangle2D)s);
 216         if (s instanceof TransformedRectangle)
 217             return intersects( (TransformedRectangle) s);
 218
 219         PathIterator pi = s.getPathIterator(inv, flatness);
 220         double pos[] = new double[2];
 221         double coords[] = new double[6];
 222         while (!pi.isDone()) {
 223             int type = pi.currentSegment(coords);
 224             if (type == PathIterator.SEG_MOVETO)
 225             {
 226                 pos[0] = coords[0];
 227                 pos[1] = coords[1];
 228             }
 229             else
 230                 if (type == PathIterator.SEG_LINETO)
 231                 {
 232
 233                 }
 234             assert(type != PathIterator.SEG_CUBICTO && type != PathIterator.SEG_QUADTO);
 235             pi.next();
 236         }
 237         return true;
 238     }
 239
 240     public boolean intersects(TransformedRectangle r) {
 241         if (isIdentity)
 242             return r.intersects(rect);
 243
 244         // Convert points of r to rect
 245         Point2D p1 = new Point2D.Double(rect.getMinX(), rect.getMinY());
 246         Point2D p2 = new Point2D.Double(rect.getMaxX(), rect.getMinY());
 247         Point2D p3 = new Point2D.Double(rect.getMaxX(), rect.getMaxY());
 248         Point2D p4 = new Point2D.Double(rect.getMinX(), rect.getMaxY());
 249
 250         AffineTransform at = new AffineTransform(transform);
 251         at.concatenate(r.inv);
 252
 253         at.transform(p1, p1);
 254         at.transform(p2, p2);
 255         at.transform(p3, p3);
 256         at.transform(p4, p4);
 257
 258         if (r.rect.contains(p1) && r.rect.contains(p2) && r.rect.contains(p3) && r.rect.contains(p4))
 259             return true;
 260
 261         if (r.rect.intersectsLine(p1.getX(), p1.getY(), p2.getX(), p2.getY()) ||
 262                 r.rect.intersectsLine(p2.getX(), p2.getY(), p3.getX(), p3.getY()) ||
 263                 r.rect.intersectsLine(p3.getX(), p3.getY(), p4.getX(), p4.getY()) ||
 264                 r.rect.intersectsLine(p4.getX(), p4.getY(), p1.getX(), p1.getY()))
 265             return true;
 266
 267         p1 = new Point2D.Double(r.rect.getMinX(), r.rect.getMinY());
 268         p2 = new Point2D.Double(r.rect.getMaxX(), r.rect.getMinY());
 269         p3 = new Point2D.Double(r.rect.getMaxX(), r.rect.getMaxY());
 270         p4 = new Point2D.Double(r.rect.getMinX(), r.rect.getMaxY());
 271
 272         at = new AffineTransform(r.transform);
 273         at.concatenate(inv);
 274
 275         at.transform(p1, p1);
 276         at.transform(p2, p2);
 277         at.transform(p3, p3);
 278         at.transform(p4, p4);
 279
 280         if (rect.contains(p1) && rect.contains(p2) && rect.contains(p3) && rect.contains(p4))
 281             return true;
 282
 283
 284         return false;
 285     }
 286     @Override
 287     public boolean intersects(Rectangle2D r) {
 288         if (isIdentity)
 289             return rect.intersects(r);
 290
 291         Point2D p1 = new Point2D.Double(r.getMinX(), r.getMinY());
 292         Point2D p2 = new Point2D.Double(r.getMaxX(), r.getMinY());
 293         Point2D p3 = new Point2D.Double(r.getMaxX(), r.getMaxY());
 294         Point2D p4 = new Point2D.Double(r.getMinX(), r.getMaxY());
 295
 296         inv.transform(p1, p1);
 297         inv.transform(p2, p2);
 298         inv.transform(p3, p3);
 299         inv.transform(p4, p4);
 300
 301         if (rect.contains(p1) || rect.contains(p2) || rect.contains(p3) || rect.contains(p4))
 302             return true;
 303
 304         if (rect.intersectsLine(p1.getX(), p1.getY(), p2.getX(), p2.getY()) ||
 305                 rect.intersectsLine(p2.getX(), p2.getY(), p3.getX(), p3.getY()) ||
 306                 rect.intersectsLine(p3.getX(), p3.getY(), p4.getX(), p4.getY()) ||
 307                 rect.intersectsLine(p4.getX(), p4.getY(), p1.getX(), p1.getY()))
 308             return true;
 309
 310         p1 = new Point2D.Double(rect.getMinX(), rect.getMinY());
 311         p2 = new Point2D.Double(rect.getMaxX(), rect.getMinY());
 312         p3 = new Point2D.Double(rect.getMaxX(), rect.getMaxY());
 313         p4 = new Point2D.Double(rect.getMinX(), rect.getMaxY());
 314
 315         transform.transform(p1, p1);
 316         transform.transform(p2, p2);
 317         transform.transform(p3, p3);
 318         transform.transform(p4, p4);
 319
 320         if (r.contains(p1) || r.contains(p2) || r.contains(p3) || r.contains(p4))
 321             return true;
 322
 323         return false;
 324     }
 325     @Override
 326     public boolean intersects(double x, double y, double w, double h) {
 327         if (isIdentity)
 328             return rect.intersects(x, y, w, h);
 329
 330         return intersects(new Rectangle2D.Double(x, y, w, h));
 331     }
 332
 333     @Override
 334     public Rectangle getBounds() {
 335         if (isIdentity)
 336             return rect.getBounds();
 337         Rectangle2D b = getOrCreateBounds();
 338         return new Rectangle(
 339                 (int) Math.floor(b.getMinX()),
 340                 (int) Math.floor(b.getMinY()),
 341                 (int) Math.ceil(b.getWidth()),
 342                 (int) Math.ceil(b.getHeight())
 343         );
 344     }
 345     @Override
 346     public Rectangle2D getBounds2D() {
 347         if (isIdentity) return rect;
 348         return getOrCreateBounds();
 349     }
 350     @Override
 351     public PathIterator getPathIterator(AffineTransform at) {
 352         if (isIdentity)
 353             return rect.getPathIterator(at);
 354         if (at == null || at.isIdentity())
 355             return rect.getPathIterator(transform);
 356         // Concatenate both iterators
 357         // IS THIS ORDER CORRECT?! UNTESTED
 358         AffineTransform con = new AffineTransform(transform);
 359         con.preConcatenate(at);
 360         return rect.getPathIterator(con);
 361     }
 362     @Override
 363     public PathIterator getPathIterator(AffineTransform at, double flatness) {
 364         if (isIdentity)
 365             return rect.getPathIterator(at, flatness);
 366         if (at == null || at.isIdentity())
 367             return rect.getPathIterator(transform, flatness);
 368         // Concatenate both iterators
 369         AffineTransform con = new AffineTransform(transform);
 370         con.concatenate(at);
 371         return rect.getPathIterator(con, flatness);
 372     }
 373
 374
 375     Rectangle2D getOrCreateBounds()
 376     {
 377         if (bounds==null)
 378             bounds = transformRectangle(transform, rect);
 379         return bounds;
 380     }
 381
 382     static Rectangle2D transformRectangle(AffineTransform transform, Rectangle2D rect) {
 383         double x0 = rect.getMinX();
 384         double y0 = rect.getMinY();
 385         double x1 = rect.getMaxX();
 386         double y1 = rect.getMaxY();
 387         double m00 = transform.getScaleX();
 388         double m10 = transform.getShearY();
 389         double m01 = transform.getShearX();
 390         double m11 = transform.getScaleY();
 391         double X0, Y0, X1, Y1;
 392         if(m00 > 0.0) {
 393             X0 = m00 * x0;
 394             X1 = m00 * x1;
 395         }
 396         else {
 397             X1 = m00 * x0;
 398             X0 = m00 * x1;
 399         }
 400         if(m01 > 0.0) {
 401             X0 += m01 * y0;
 402             X1 += m01 * y1;
 403         }
 404         else {
 405             X1 += m01 * y0;
 406             X0 += m01 * y1;
 407         }
 408         if(m10 > 0.0) {
 409             Y0 = m10 * x0;
 410             Y1 = m10 * x1;
 411         }
 412         else {
 413             Y1 = m10 * x0;
 414             Y0 = m10 * x1;
 415         }
 416         if(m11 > 0.0) {
 417             Y0 += m11 * y0;
 418             Y1 += m11 * y1;
 419         }
 420         else {
 421             Y1 += m11 * y0;
 422             Y0 += m11 * y1;
 423         }
 424         return new Rectangle2D.Double(X0+transform.getTranslateX(),
 425                 Y0+transform.getTranslateY(), X1-X0, Y1-Y0);
 426     }
 427
 428     @Override
 429     public String toString() {
 430         Point2D p1 = new Point2D.Double(rect.getMinX(), rect.getMinY());
 431         Point2D p2 = new Point2D.Double(rect.getMaxX(), rect.getMinY());
 432         Point2D p3 = new Point2D.Double(rect.getMaxX(), rect.getMaxY());
 433         Point2D p4 = new Point2D.Double(rect.getMinX(), rect.getMaxY());
 434
 435         transform.transform(p1, p1);
 436         transform.transform(p2, p2);
 437         transform.transform(p3, p3);
 438         transform.transform(p4, p4);
 439
 440         StringBuilder sb = new StringBuilder();
 441         sb.append(p1+"\n");
 442         sb.append(p2+"\n");
 443         sb.append(p3+"\n");
 444         sb.append(p4);
 445
 446         return sb.toString();
 447     }
 448
 449     // Test this class
 450     // Run with VM arg: -ea
 451     public static void main(String[] args) {
 452         Rectangle2D rect = new Rectangle2D.Double(0, 0, 10, 10);
 453         AffineTransform at = new AffineTransform();
 454         at.setToRotation(Math.PI/4);
 455         TransformedRectangle tr = new TransformedRectangle(rect, at);
 456
 457         Rectangle2D t1 = new Rectangle2D.Double(5, 5, 5, 5);
 458         Rectangle2D t2 = new Rectangle2D.Double(-2, 4, 3, 2);
 459         Rectangle2D t3 = new Rectangle2D.Double(9, 9, 5, 5);
 460         Rectangle2D t4 = new Rectangle2D.Double(-100, -100, 200, 200);
 461
 462         // Contains test
 463         assert(!tr.contains(t1));
 464         assert( tr.contains(t2));
 465         assert(!tr.contains(t3));
 466         assert(!tr.contains(t4));
 467
 468         // Intersects test
 469         assert( tr.intersects(t1));
 470         assert( tr.intersects(t2));
 471         assert(!tr.intersects(t3));
 472         assert( tr.intersects(t4));
 473
 474         Ellipse2D e = new Ellipse2D.Double(-5, 0, 10, 10);
 475         assert( tr.intersects(e) );
 476         assert(!tr.contains(e) );
 477
 478         TransformedRectangle tr1 = new TransformedRectangle(t4, at);
 479         TransformedRectangle tr2 = new TransformedRectangle(new Rectangle2D.Double(3, 3, 2, 2), at);
 480         TransformedRectangle tr3 = new TransformedRectangle(new Rectangle2D.Double(-20, 3, 40, 3), at);
 481         TransformedRectangle tr4 = new TransformedRectangle(new Rectangle2D.Double(8, -6, 4, 8), at);
 482         TransformedRectangle tr5 = new TransformedRectangle(new Rectangle2D.Double(2, 12, 7, 7), at);
 483
 484         assert(!tr.contains(tr1) );
 485         assert( tr.contains(tr2) );
 486         assert(!tr.contains(tr3) );
 487         assert(!tr.contains(tr4) );
 488         assert(!tr.contains(tr5) );
 489
 490         assert( tr1.contains(tr) );
 491         assert(!tr2.contains(tr) );
 492         assert(!tr3.contains(tr) );
 493         assert(!tr4.contains(tr) );
 494         assert(!tr5.contains(tr) );
 495
 496         assert( tr.intersects(tr1) );
 497         assert( tr.intersects(tr2) );
 498         assert( tr.intersects(tr3) );
 499         assert( tr.intersects(tr4) );
 500         assert(!tr.intersects(tr5) );
 501
 502         assert(false);
 503     }
 504
 505 }