Coverage Report - edu.uci.ics.jung.visualization.jai.PerspectiveShapeTransformer
 
Classes in this File Line Coverage Branch Coverage Complexity
PerspectiveShapeTransformer
0%
0/108
0%
0/36
4.25
 
 1   
 /*
 2   
  * Copyright (c) 2003, the JUNG Project and the Regents of the University of
 3   
  * California All rights reserved.
 4   
  *
 5   
  * This software is open-source under the BSD license; see either "license.txt"
 6   
  * or http://jung.sourceforge.net/license.txt for a description.
 7   
  *
 8   
  */
 9   
 package edu.uci.ics.jung.visualization.jai;
 10   
 
 11   
 import java.awt.Shape;
 12   
 import java.awt.geom.GeneralPath;
 13   
 import java.awt.geom.PathIterator;
 14   
 import java.awt.geom.Point2D;
 15   
 
 16   
 import javax.media.jai.PerspectiveTransform;
 17   
 
 18   
 import edu.uci.ics.jung.visualization.transform.MutableTransformer;
 19   
 import edu.uci.ics.jung.visualization.transform.shape.ShapeTransformer;
 20   
 
 21   
 /**
 22   
  * PerspectiveShapeTransformer extends PerspectiveTransformer and
 23   
  * adds implementations for methods in ShapeTransformer.
 24   
  * It modifies the shapes (Vertex, Edge, and Arrowheads) so that
 25   
  * they are distorted by the perspective transformation
 26   
  *
 27   
  * @author Tom Nelson
 28   
  *
 29   
  *
 30   
  */
 31   
 public class PerspectiveShapeTransformer extends PerspectiveTransformer
 32   
     implements ShapeTransformer {
 33   
 
 34   
     /**
 35   
      * Create an instance, setting values from the passed component
 36   
      * and registering to listen for size changes on the component.
 37   
      */
 38   
     public PerspectiveShapeTransformer(PerspectiveTransform perspectiveTransform) {
 39  0 
         this(perspectiveTransform, null);
 40  0 
     }
 41   
 
 42   
     /**
 43   
      * Create an instance
 44   
      */
 45   
     public PerspectiveShapeTransformer(PerspectiveTransform perspectiveTransform, MutableTransformer delegate) {
 46  0 
         super(perspectiveTransform, delegate);
 47  0 
    }
 48   
 
 49   
     /**
 50   
      * Transform the supplied shape with the overridden transform
 51   
      * method so that the shape is distorted by the perspective
 52   
      * transform.
 53   
      * @param shape a shape to transform
 54   
      * @return a GeneralPath for the transformed shape
 55   
      */
 56   
     @Override
 57   
     public Shape transform(Shape shape) {
 58  0 
         return transform(shape, 0);
 59   
     }
 60   
     public Shape transform(Shape shape, float flatness) {
 61  0 
         GeneralPath newPath = new GeneralPath();
 62  0 
         float[] coords = new float[6];
 63  0 
         PathIterator iterator = null;
 64  0 
         if(flatness == 0) {
 65  0 
             iterator = shape.getPathIterator(null);
 66   
         } else {
 67  0 
             iterator = shape.getPathIterator(null, flatness);
 68   
         }
 69   
         for( ;
 70  0 
             iterator.isDone() == false;
 71  0 
             iterator.next()) {
 72  0 
             int type = iterator.currentSegment(coords);
 73  0 
             switch(type) {
 74   
             case PathIterator.SEG_MOVETO:
 75  0 
                 Point2D p = transform(new Point2D.Float(coords[0], coords[1]));
 76  0 
                 newPath.moveTo((float)p.getX(), (float)p.getY());
 77  0 
                 break;
 78   
 
 79   
             case PathIterator.SEG_LINETO:
 80  0 
                 p = transform(new Point2D.Float(coords[0], coords[1]));
 81  0 
                 newPath.lineTo((float)p.getX(), (float) p.getY());
 82  0 
                 break;
 83   
 
 84   
             case PathIterator.SEG_QUADTO:
 85  0 
                 p = transform(new Point2D.Float(coords[0], coords[1]));
 86  0 
                 Point2D q = transform(new Point2D.Float(coords[2], coords[3]));
 87  0 
                 newPath.quadTo((float)p.getX(), (float)p.getY(), (float)q.getX(), (float)q.getY());
 88  0 
                 break;
 89   
 
 90   
             case PathIterator.SEG_CUBICTO:
 91  0 
                 p = transform(new Point2D.Float(coords[0], coords[1]));
 92  0 
                 q = transform(new Point2D.Float(coords[2], coords[3]));
 93  0 
                 Point2D r = transform(new Point2D.Float(coords[4], coords[5]));
 94  0 
                 newPath.curveTo((float)p.getX(), (float)p.getY(),
 95   
                         (float)q.getX(), (float)q.getY(),
 96   
                         (float)r.getX(), (float)r.getY());
 97  0 
                 break;
 98   
 
 99   
             case PathIterator.SEG_CLOSE:
 100  0 
                 newPath.closePath();
 101   
                 break;
 102   
 
 103   
             }
 104   
         }
 105  0 
         return newPath;
 106   
     }
 107   
 
 108   
     @Override
 109   
     public Shape inverseTransform(Shape shape) {
 110  0 
         GeneralPath newPath = new GeneralPath();
 111  0 
         float[] coords = new float[6];
 112  0 
         for(PathIterator iterator=shape.getPathIterator(null);
 113  0 
             iterator.isDone() == false;
 114  0 
             iterator.next()) {
 115  0 
             int type = iterator.currentSegment(coords);
 116  0 
             switch(type) {
 117   
             case PathIterator.SEG_MOVETO:
 118  0 
                 Point2D p = inverseTransform(new Point2D.Float(coords[0], coords[1]));
 119  0 
                 newPath.moveTo((float)p.getX(), (float)p.getY());
 120  0 
                 break;
 121   
 
 122   
             case PathIterator.SEG_LINETO:
 123  0 
                 p = inverseTransform(new Point2D.Float(coords[0], coords[1]));
 124  0 
                 newPath.lineTo((float)p.getX(), (float) p.getY());
 125  0 
                 break;
 126   
 
 127   
             case PathIterator.SEG_QUADTO:
 128  0 
                 p = inverseTransform(new Point2D.Float(coords[0], coords[1]));
 129  0 
                 Point2D q = inverseTransform(new Point2D.Float(coords[2], coords[3]));
 130  0 
                 newPath.quadTo((float)p.getX(), (float)p.getY(), (float)q.getX(), (float)q.getY());
 131  0 
                 break;
 132   
 
 133   
             case PathIterator.SEG_CUBICTO:
 134  0 
                 p = inverseTransform(new Point2D.Float(coords[0], coords[1]));
 135  0 
                 q = inverseTransform(new Point2D.Float(coords[2], coords[3]));
 136  0 
                 Point2D r = inverseTransform(new Point2D.Float(coords[4], coords[5]));
 137  0 
                 newPath.curveTo((float)p.getX(), (float)p.getY(),
 138   
                         (float)q.getX(), (float)q.getY(),
 139   
                         (float)r.getX(), (float)r.getY());
 140  0 
                 break;
 141   
 
 142   
             case PathIterator.SEG_CLOSE:
 143  0 
                 newPath.closePath();
 144   
                 break;
 145   
 
 146   
             }
 147   
         }
 148  0 
         return newPath;
 149   
     }
 150   
 
 151   
     public Shape perspectiveTransform(Shape shape) {
 152  0 
         return perspectiveTransform(shape, 0);
 153   
     }
 154   
 
 155   
     public Shape perspectiveTransform(Shape shape, float flatness) {
 156  0 
         GeneralPath newPath = new GeneralPath();
 157  0 
         float[] coords = new float[6];
 158  0 
         PathIterator iterator = null;
 159  0 
         if(flatness == 0) {
 160  0 
             iterator = shape.getPathIterator(null);
 161   
         } else {
 162  0 
             iterator = shape.getPathIterator(null, flatness);
 163   
         }
 164   
         for( ;
 165  0 
             iterator.isDone() == false;
 166  0 
             iterator.next()) {
 167  0 
             int type = iterator.currentSegment(coords);
 168  0 
             switch(type) {
 169   
             case PathIterator.SEG_MOVETO:
 170  0 
                 Point2D p = perspectiveTransform(new Point2D.Float(coords[0], coords[1]));
 171  0 
                 newPath.moveTo((float)p.getX(), (float)p.getY());
 172  0 
                 break;
 173   
 
 174   
             case PathIterator.SEG_LINETO:
 175  0 
                 p = perspectiveTransform(new Point2D.Float(coords[0], coords[1]));
 176  0 
                 newPath.lineTo((float)p.getX(), (float) p.getY());
 177  0 
                 break;
 178   
 
 179   
             case PathIterator.SEG_QUADTO:
 180  0 
                 p = perspectiveTransform(new Point2D.Float(coords[0], coords[1]));
 181  0 
                 Point2D q = perspectiveTransform(new Point2D.Float(coords[2], coords[3]));
 182  0 
                 newPath.quadTo((float)p.getX(), (float)p.getY(), (float)q.getX(), (float)q.getY());
 183  0 
                 break;
 184   
 
 185   
             case PathIterator.SEG_CUBICTO:
 186  0 
                 p = perspectiveTransform(new Point2D.Float(coords[0], coords[1]));
 187  0 
                 q = perspectiveTransform(new Point2D.Float(coords[2], coords[3]));
 188  0 
                 Point2D r = perspectiveTransform(new Point2D.Float(coords[4], coords[5]));
 189  0 
                 newPath.curveTo((float)p.getX(), (float)p.getY(),
 190   
                         (float)q.getX(), (float)q.getY(),
 191   
                         (float)r.getX(), (float)r.getY());
 192  0 
                 break;
 193   
 
 194   
             case PathIterator.SEG_CLOSE:
 195  0 
                 newPath.closePath();
 196   
                 break;
 197   
 
 198   
             }
 199   
         }
 200  0 
         return newPath;
 201   
     }
 202   
 
 203   
     public Shape inversePerspectiveTransform(Shape shape) {
 204  0 
         GeneralPath newPath = new GeneralPath();
 205  0 
         float[] coords = new float[6];
 206  0 
         for(PathIterator iterator=shape.getPathIterator(null);
 207  0 
             iterator.isDone() == false;
 208  0 
             iterator.next()) {
 209  0 
             int type = iterator.currentSegment(coords);
 210  0 
             switch(type) {
 211   
             case PathIterator.SEG_MOVETO:
 212  0 
                 Point2D p = inversePerspectiveTransform(new Point2D.Float(coords[0], coords[1]));
 213  0 
                 newPath.moveTo((float)p.getX(), (float)p.getY());
 214  0 
                 break;
 215   
 
 216   
             case PathIterator.SEG_LINETO:
 217  0 
                 p = inversePerspectiveTransform(new Point2D.Float(coords[0], coords[1]));
 218  0 
                 newPath.lineTo((float)p.getX(), (float) p.getY());
 219  0 
                 break;
 220   
 
 221   
             case PathIterator.SEG_QUADTO:
 222  0 
                 p = inversePerspectiveTransform(new Point2D.Float(coords[0], coords[1]));
 223  0 
                 Point2D q = inversePerspectiveTransform(new Point2D.Float(coords[2], coords[3]));
 224  0 
                 newPath.quadTo((float)p.getX(), (float)p.getY(), (float)q.getX(), (float)q.getY());
 225  0 
                 break;
 226   
 
 227   
             case PathIterator.SEG_CUBICTO:
 228  0 
                 p = inversePerspectiveTransform(new Point2D.Float(coords[0], coords[1]));
 229  0 
                 q = inversePerspectiveTransform(new Point2D.Float(coords[2], coords[3]));
 230  0 
                 Point2D r = inversePerspectiveTransform(new Point2D.Float(coords[4], coords[5]));
 231  0 
                 newPath.curveTo((float)p.getX(), (float)p.getY(),
 232   
                         (float)q.getX(), (float)q.getY(),
 233   
                         (float)r.getX(), (float)r.getY());
 234  0 
                 break;
 235   
 
 236   
             case PathIterator.SEG_CLOSE:
 237  0 
                 newPath.closePath();
 238   
                 break;
 239   
 
 240   
             }
 241   
         }
 242  0 
         return newPath;
 243   
     }
 244   
 
 245   
 }
Report generated by Cobertura 1.9.2 on 1/24/10 12:40 PM.