src/java.desktop/share/classes/sun/java2d/pipe/Region.java

Print this page




  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.java2d.pipe;
  27 
  28 import java.awt.Rectangle;
  29 import java.awt.Shape;
  30 import java.awt.geom.AffineTransform;
  31 import java.awt.geom.RectangularShape;
  32 


  33 /**
  34  * This class encapsulates a definition of a two dimensional region which
  35  * consists of a number of Y ranges each containing multiple X bands.
  36  * <p>
  37  * A rectangular Region is allowed to have a null band list in which
  38  * case the rectangular shape is defined by the bounding box parameters
  39  * (lox, loy, hix, hiy).
  40  * <p>
  41  * The band list, if present, consists of a list of rows in ascending Y
  42  * order, ending at endIndex which is the index beyond the end of the
  43  * last row.  Each row consists of at least 3 + 2n entries (n >= 1)
  44  * where the first 3 entries specify the Y range as start, end, and
  45  * the number of X ranges in that Y range.  These 3 entries are
  46  * followed by pairs of X coordinates in ascending order:
  47  * <pre>
  48  * bands[rowstart+0] = Y0;        // starting Y coordinate
  49  * bands[rowstart+1] = Y1;        // ending Y coordinate - endY > startY
  50  * bands[rowstart+2] = N;         // number of X bands - N >= 1
  51  *
  52  * bands[rowstart+3] = X10;       // starting X coordinate of first band


 143         if (sv == 1.0) {
 144             return v;
 145         }
 146         final double newv = v * sv;
 147         if (newv < Integer.MIN_VALUE) {
 148             return Integer.MIN_VALUE;
 149         }
 150         if (newv > Integer.MAX_VALUE) {
 151             return Integer.MAX_VALUE;
 152         }
 153         return (int) Math.round(newv);
 154     }
 155 
 156     protected Region(int lox, int loy, int hix, int hiy) {
 157         this.lox = lox;
 158         this.loy = loy;
 159         this.hix = hix;
 160         this.hiy = hiy;
 161     }
 162 









 163     /**
 164      * Returns a Region object covering the pixels which would be
 165      * touched by a fill or clip operation on a Graphics implementation
 166      * on the specified Shape object under the optionally specified
 167      * AffineTransform object.
 168      *
 169      * @param s a non-null Shape object specifying the geometry enclosing
 170      *          the pixels of interest
 171      * @param at an optional <code>AffineTransform</code> to be applied to the
 172      *          coordinates as they are returned in the iteration, or
 173      *          <code>null</code> if untransformed coordinates are desired
 174      */
 175     public static Region getInstance(Shape s, AffineTransform at) {
 176         return getInstance(WHOLE_REGION, false, s, at);
 177     }
 178 
 179     /**
 180      * Returns a Region object covering the pixels which would be
 181      * touched by a fill or clip operation on a Graphics implementation
 182      * on the specified Shape object under the optionally specified


 239                 ((RectangularShape)s).isEmpty())
 240         {
 241             return EMPTY_REGION;
 242         }
 243 
 244         int box[] = new int[4];
 245         ShapeSpanIterator sr = new ShapeSpanIterator(normalize);
 246         try {
 247             sr.setOutputArea(devBounds);
 248             sr.appendPath(s.getPathIterator(at));
 249             sr.getPathBox(box);
 250             Region r = Region.getInstance(box);
 251             r.appendSpans(sr);
 252             return r;
 253         } finally {
 254             sr.dispose();
 255         }
 256     }
 257 
 258     /**
































 259      * Returns a Region object with a rectangle of interest specified
 260      * by the indicated Rectangle object.
 261      * <p>
 262      * This method can also be used to create a simple rectangular
 263      * region.
 264      */
 265     public static Region getInstance(Rectangle r) {
 266         return Region.getInstanceXYWH(r.x, r.y, r.width, r.height);
 267     }
 268 
 269     /**
 270      * Returns a Region object with a rectangle of interest specified
 271      * by the indicated rectangular area in x, y, width, height format.
 272      * <p>
 273      * This method can also be used to create a simple rectangular
 274      * region.
 275      */
 276     public static Region getInstanceXYWH(int x, int y, int w, int h) {
 277         return Region.getInstanceXYXY(x, y, dimAdd(x, w), dimAdd(y, h));
 278     }




  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.java2d.pipe;
  27 
  28 import java.awt.Rectangle;
  29 import java.awt.Shape;
  30 import java.awt.geom.AffineTransform;
  31 import java.awt.geom.RectangularShape;
  32 
  33 import sun.java2d.loops.TransformHelper;
  34 
  35 /**
  36  * This class encapsulates a definition of a two dimensional region which
  37  * consists of a number of Y ranges each containing multiple X bands.
  38  * <p>
  39  * A rectangular Region is allowed to have a null band list in which
  40  * case the rectangular shape is defined by the bounding box parameters
  41  * (lox, loy, hix, hiy).
  42  * <p>
  43  * The band list, if present, consists of a list of rows in ascending Y
  44  * order, ending at endIndex which is the index beyond the end of the
  45  * last row.  Each row consists of at least 3 + 2n entries (n >= 1)
  46  * where the first 3 entries specify the Y range as start, end, and
  47  * the number of X ranges in that Y range.  These 3 entries are
  48  * followed by pairs of X coordinates in ascending order:
  49  * <pre>
  50  * bands[rowstart+0] = Y0;        // starting Y coordinate
  51  * bands[rowstart+1] = Y1;        // ending Y coordinate - endY > startY
  52  * bands[rowstart+2] = N;         // number of X bands - N >= 1
  53  *
  54  * bands[rowstart+3] = X10;       // starting X coordinate of first band


 145         if (sv == 1.0) {
 146             return v;
 147         }
 148         final double newv = v * sv;
 149         if (newv < Integer.MIN_VALUE) {
 150             return Integer.MIN_VALUE;
 151         }
 152         if (newv > Integer.MAX_VALUE) {
 153             return Integer.MAX_VALUE;
 154         }
 155         return (int) Math.round(newv);
 156     }
 157 
 158     protected Region(int lox, int loy, int hix, int hiy) {
 159         this.lox = lox;
 160         this.loy = loy;
 161         this.hix = hix;
 162         this.hiy = hiy;
 163     }
 164 
 165     private Region(int lox, int loy, int hix, int hiy, int[] bands, int end) {
 166         this.lox = lox;
 167         this.loy = loy;
 168         this.hix = hix;
 169         this.hiy = hiy;
 170         this.bands = bands;
 171         this.endIndex = end;
 172     }
 173 
 174     /**
 175      * Returns a Region object covering the pixels which would be
 176      * touched by a fill or clip operation on a Graphics implementation
 177      * on the specified Shape object under the optionally specified
 178      * AffineTransform object.
 179      *
 180      * @param s a non-null Shape object specifying the geometry enclosing
 181      *          the pixels of interest
 182      * @param at an optional <code>AffineTransform</code> to be applied to the
 183      *          coordinates as they are returned in the iteration, or
 184      *          <code>null</code> if untransformed coordinates are desired
 185      */
 186     public static Region getInstance(Shape s, AffineTransform at) {
 187         return getInstance(WHOLE_REGION, false, s, at);
 188     }
 189 
 190     /**
 191      * Returns a Region object covering the pixels which would be
 192      * touched by a fill or clip operation on a Graphics implementation
 193      * on the specified Shape object under the optionally specified


 250                 ((RectangularShape)s).isEmpty())
 251         {
 252             return EMPTY_REGION;
 253         }
 254 
 255         int box[] = new int[4];
 256         ShapeSpanIterator sr = new ShapeSpanIterator(normalize);
 257         try {
 258             sr.setOutputArea(devBounds);
 259             sr.appendPath(s.getPathIterator(at));
 260             sr.getPathBox(box);
 261             Region r = Region.getInstance(box);
 262             r.appendSpans(sr);
 263             return r;
 264         } finally {
 265             sr.dispose();
 266         }
 267     }
 268 
 269     /**
 270      * Returns a Region object with a rectangle of interest specified by the
 271      * indicated rectangular area in lox, loy, hix, hiy and edges array, which
 272      * is located relative to the rectangular area. Edges array - 0,1 are y
 273      * range, 2N,2N+1 are x ranges, 1 per y range.
 274      * <p>
 275      * Note that we trust to the edges array, which means that edges should be:
 276      * {@code edges + (lox, loy) < (hix, hiy)}, otherwise result is undefined
 277      *
 278      * @see TransformHelper
 279      */
 280     static Region getInstance(final int lox, final int loy, final int hix,
 281                               final int hiy, final int edges[]) {
 282         // rowsNum * (3 + 1 * 2), plus one byte for endIndex
 283         final int[] bands = new int[(edges[1] - edges[0]) * 5 + 1];
 284         int end = 0;
 285         int index = 2;
 286         for (int y = edges[0]; end < bands.length && y < edges[1]; ++y) {
 287             final int x1 = edges[index++];
 288             final int x2 = edges[index++];
 289             if (x1 < x2) {
 290                 bands[end++] = loy + y;     // spanloy
 291                 bands[end++] = loy + y + 1; // spanhiy
 292                 bands[end++] = 1;           // 1 span per row
 293                 bands[end++] = lox + x1;    // spanlox
 294                 bands[end++] = lox + x2;    // spanhix
 295             }
 296         }
 297         return end != 0 ? new Region(lox, loy, hix, hiy, bands, end)
 298                         : EMPTY_REGION;
 299     }
 300 
 301     /**
 302      * Returns a Region object with a rectangle of interest specified
 303      * by the indicated Rectangle object.
 304      * <p>
 305      * This method can also be used to create a simple rectangular
 306      * region.
 307      */
 308     public static Region getInstance(Rectangle r) {
 309         return Region.getInstanceXYWH(r.x, r.y, r.width, r.height);
 310     }
 311 
 312     /**
 313      * Returns a Region object with a rectangle of interest specified
 314      * by the indicated rectangular area in x, y, width, height format.
 315      * <p>
 316      * This method can also be used to create a simple rectangular
 317      * region.
 318      */
 319     public static Region getInstanceXYWH(int x, int y, int w, int h) {
 320         return Region.getInstanceXYXY(x, y, dimAdd(x, w), dimAdd(y, h));
 321     }