/ - Diff - org.gvsig.jdk - gvSIG

Revision 36

     <?xml version="1.0" encoding="ISO-8859-1"?>
     <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     	<modelVersion>4.0.0</modelVersion>
     	<artifactId>org.gvsig.jdk.v1_6</artifactId>
     	<packaging>jar</packaging>
     	<name>org.gvsig.jdk.v1_6</name>
     	<description>Private classes of the OpenJDK v1.6</description>
     	<parent>
     		<groupId>org.gvsig</groupId>
     		<artifactId>org.gvsig.jdk</artifactId>
     		<version>1.0.2</version>
     	</parent>
     	<dependencies>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.tools.lib</artifactId>
     		</dependency>
     	</dependencies>
         <build>
             <plugins>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-compiler-plugin</artifactId>
                     <configuration>
                         <source>1.6</source>
                         <target>1.6</target>
                     </configuration>
                 </plugin>
             </plugins>
         </build>
     </project>

     <?xml version="1.0" encoding="UTF-8" ?>
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
     <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     <title>${artifactId} package documentation</title>
     </head>
     <body>
     	<p>TODO: Example library API overview.</p>
     	<p>See the <a href="http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/javadoc.html${symbol_pound}overviewcomment">Javadoc Tool documentation about the overview file</a></p>
     </body>
     </html>

     <?xml version="1.0" encoding="UTF-8" ?>
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
     <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     <title>${package} package documentation</title>
     </head>
     <body>
     	<p>TODO: Example library API description.</p>
     	<p>See the <a href="http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/javadoc.html${symbol_pound}packagecomment">Javadoc Tool documentation about the package file</a></p>
     </body>
     </html>

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (CIT)
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 2
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      */
     /*
      * AUTHORS (In addition to CIT):
      * 2009 {Iver T.I.}   {Task}
      */
     package org.gvsig.jdk;
     import java.awt.geom.PathIterator;
     import org.gvsig.jdk.sun.awt.geom.Crossings;
     import org.gvsig.jdk.sun.awt.geom.Curve;
     /**
      * This class contains some utility methods to access to some
      * private classes of the OpenJDK. These classes have been copied
      * to this package and their visibility has been reduced. It is not
      * possible to access them without using this class.
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public class GeomUtilities {
     	/**
     	 * Tests if the specified rectangular area is inside the boundary of
     	 * a <code>Shape</code>.
     	 * @param pi the path iterator of a shape
     	 * @param x,&nbsp;y the specified coordinates
     	 * @param w the width of the specified rectangular area
     	 * @param h the height of the specified rectangular area
     	 * @return <code>true</code> if this <code>Shape</code> contains
     	 * the specified rectangluar area; <code>false</code> otherwise.
     	 */
     	public static boolean contains(PathIterator pi, double x, double y, double w, double h) {
     		Crossings c = Crossings.findCrossings(pi,
     				x, y, x+w, y+h);
     		return (c != null && c.covers(y, y+h));
+    	}
     	/**
     	 * Tests if the interior of a <code>Shape</code> intersects the
     	 * interior of a specified set of rectangular coordinates.
     	 * @param pi the path iterator of a shape
     	 * @param x,&nbsp;y the specified coordinates
     	 * @param w the width of the specified rectangular coordinates
     	 * @param h the height of the specified rectangular coordinates
     	 * @return <code>true</code> if this <code>Shape</code> and the
     	 * interior of the specified set of rectangular coordinates intersect
     	 * each other; <code>false</code> otherwise.
     	 */
     	public static boolean intersects(PathIterator pi, double x, double y, double w, double h) {
     		Crossings c = Crossings.findCrossings(pi,
     				x, y, x+w, y+h);
     		return (c == null || !c.isEmpty());
+    	}
     	 /**
          * Calculates the number of times the given path
          * crosses the ray extending to the right from (px,py).
          * If the point lies on a part of the path,
          * then no crossings are counted for that intersection.
          * +1 is added for each crossing where the Y coordinate is increasing
          * -1 is added for each crossing where the Y coordinate is decreasing
          * The path must start with a SEG_MOVETO, otherwise an exception is
          * thrown.
          * The caller must check p[xy] for NaN values.
          * The caller may also reject infinite p[xy] values as well.
          * @param pi the path iterator of a shape
          * @param px the x coordinate
          * @param py the y coordinate
          * @return is the sum of all crossings for every segment in
          * the path
          */
     	public static int pointCrossingsForPath(PathIterator pi, double px, double py){
     		return Curve.pointCrossingsForPath(pi, px, py);
+    	}
+    }

     /*
      * Copyright 1998 Sun Microsystems, Inc.  All Rights Reserved.
      * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+     *
      * This code is free software; you can redistribute it and/or modify it
      * under the terms of the GNU General Public License version 2 only, as
      * published by the Free Software Foundation.  Sun designates this
      * particular file as subject to the "Classpath" exception as provided
      * by Sun in the LICENSE file that accompanied this code.
+     *
      * This code is distributed in the hope that it will be useful, but WITHOUT
      * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      * version 2 for more details (a copy is included in the LICENSE file that
      * accompanied this code).
+     *
      * You should have received a copy of the GNU General Public License version
      * 2 along with this work; if not, write to the Free Software Foundation,
      * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+     *
      * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
      * CA 95054 USA or visit www.sun.com if you need additional information or
      * have any questions.
      */
     package org.gvsig.jdk.sun.awt.geom;
     final class ChainEnd {
         CurveLink head;
         CurveLink tail;
         ChainEnd partner;
         int etag;
         ChainEnd(CurveLink first, ChainEnd partner) {
             this.head = first;
             this.tail = first;
             this.partner = partner;
             this.etag = first.getEdgeTag();
+        }
         public CurveLink getChain() {
             return head;
+        }
         public void setOtherEnd(ChainEnd partner) {
             this.partner = partner;
+        }
         public ChainEnd getPartner() {
             return partner;
+        }
         /*
          * Returns head of a complete chain to be added to subcurves
          * or null if the links did not complete such a chain.
          */
         public CurveLink linkTo(ChainEnd that) {
             if (etag == AreaOp.ETAG_IGNORE ||
                 that.etag == AreaOp.ETAG_IGNORE)
+            {
                 throw new InternalError("ChainEnd linked more than once!");
+            }
             if (etag == that.etag) {
                 throw new InternalError("Linking chains of the same type!");
+            }
             ChainEnd enter, exit;
             // assert(partner.etag != that.partner.etag);
             if (etag == AreaOp.ETAG_ENTER) {
                 enter = this;
                 exit = that;
             } else {
                 enter = that;
                 exit = this;
+            }
             // Now make sure these ChainEnds are not linked to any others...
             etag = AreaOp.ETAG_IGNORE;
             that.etag = AreaOp.ETAG_IGNORE;
             // Now link everything up...
             enter.tail.setNext(exit.head);
             enter.tail = exit.tail;
             if (partner == that) {
                 // Curve has closed on itself...
                 return enter.head;
+            }
             // Link this chain into one end of the chain formed by the partners
             ChainEnd otherenter = exit.partner;
             ChainEnd otherexit = enter.partner;
             otherenter.partner = otherexit;
             otherexit.partner = otherenter;
             if (enter.head.getYTop() < otherenter.head.getYTop()) {
                 enter.tail.setNext(otherenter.head);
                 otherenter.head = enter.head;
             } else {
                 otherexit.tail.setNext(enter.head);
                 otherexit.tail = enter.tail;
+            }
             return null;
+        }
         public void addLink(CurveLink newlink) {
             if (etag == AreaOp.ETAG_ENTER) {
                 tail.setNext(newlink);
                 tail = newlink;
             } else {
                 newlink.setNext(head);
                 head = newlink;
+            }
+        }
         public double getX() {
             if (etag == AreaOp.ETAG_ENTER) {
                 return tail.getXBot();
             } else {
                 return head.getXBot();
+            }
+        }
+    }

     /*
      * Copyright 1998-2003 Sun Microsystems, Inc.  All Rights Reserved.
      * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+     *
      * This code is free software; you can redistribute it and/or modify it
      * under the terms of the GNU General Public License version 2 only, as
      * published by the Free Software Foundation.  Sun designates this
      * particular file as subject to the "Classpath" exception as provided
      * by Sun in the LICENSE file that accompanied this code.
+     *
      * This code is distributed in the hope that it will be useful, but WITHOUT
      * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      * version 2 for more details (a copy is included in the LICENSE file that
      * accompanied this code).
+     *
      * You should have received a copy of the GNU General Public License version
      * 2 along with this work; if not, write to the Free Software Foundation,
      * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+     *
      * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
      * CA 95054 USA or visit www.sun.com if you need additional information or
      * have any questions.
      */
     package org.gvsig.jdk.sun.awt.geom;
     import java.awt.geom.PathIterator;
     import java.util.Enumeration;
     import java.util.Vector;
     public abstract class Crossings {
         public static final boolean debug = false;
         int limit = 0;
         double yranges[] = new double[10];
         double xlo, ylo, xhi, yhi;
         Crossings(double xlo, double ylo, double xhi, double yhi) {
             this.xlo = xlo;
             this.ylo = ylo;
             this.xhi = xhi;
             this.yhi = yhi;
+        }
         public final double getXLo() {
             return xlo;
+        }
         public final double getYLo() {
             return ylo;
+        }
         public final double getXHi() {
             return xhi;
+        }
         public final double getYHi() {
             return yhi;
+        }
         public abstract void record(double ystart, double yend, int direction);
         public void print() {
             System.out.println("Crossings [");
             System.out.println("  bounds = ["+ylo+", "+yhi+"]");
             for (int i = 0; i < limit; i += 2) {
                 System.out.println("  ["+yranges[i]+", "+yranges[i+1]+"]");
+            }
             System.out.println("]");
+        }
         public final boolean isEmpty() {
             return (limit == 0);
+        }
         public abstract boolean covers(double ystart, double yend);
         public static Crossings findCrossings(Vector curves,
                                               double xlo, double ylo,
                                               double xhi, double yhi)
+        {
             Crossings cross = new EvenOdd(xlo, ylo, xhi, yhi);
             Enumeration enum_ = curves.elements();
             while (enum_.hasMoreElements()) {
                 Curve c = (Curve) enum_.nextElement();
                 if (c.accumulateCrossings(cross)) {
                     return null;
+                }
+            }
             if (debug) {
                 cross.print();
+            }
             return cross;
+        }
         public static Crossings findCrossings(PathIterator pi,
                                               double xlo, double ylo,
                                               double xhi, double yhi)
+        {
             Crossings cross;
             if (pi.getWindingRule() == pi.WIND_EVEN_ODD) {
                 cross = new EvenOdd(xlo, ylo, xhi, yhi);
             } else {
                 cross = new NonZero(xlo, ylo, xhi, yhi);
+            }
             // coords array is big enough for holding:
             //     coordinates returned from currentSegment (6)
             //     OR
             //         two subdivided quadratic curves (2+4+4=10)
             //         AND
             //             0-1 horizontal splitting parameters
             //             OR
             //             2 parametric equation derivative coefficients
             //     OR
             //         three subdivided cubic curves (2+6+6+6=20)
             //         AND
             //             0-2 horizontal splitting parameters
             //             OR
             //             3 parametric equation derivative coefficients
             double coords[] = new double[23];
             double movx = 0;
             double movy = 0;
             double curx = 0;
             double cury = 0;
             double newx, newy;
             while (!pi.isDone()) {
                 int type = pi.currentSegment(coords);
                 switch (type) {
                 case PathIterator.SEG_MOVETO:
                     if (movy != cury &&
                         cross.accumulateLine(curx, cury, movx, movy))
+                    {
                         return null;
+                    }
                     movx = curx = coords[0];
                     movy = cury = coords[1];
                     break;
                 case PathIterator.SEG_LINETO:
                     newx = coords[0];
                     newy = coords[1];
                     if (cross.accumulateLine(curx, cury, newx, newy)) {
                         return null;
+                    }
                     curx = newx;
                     cury = newy;
                     break;
                 case PathIterator.SEG_QUADTO:
                     newx = coords[2];
                     newy = coords[3];
                     if (cross.accumulateQuad(curx, cury, coords)) {
                         return null;
+                    }
                     curx = newx;
                     cury = newy;
                     break;
                 case PathIterator.SEG_CUBICTO:
                     newx = coords[4];
                     newy = coords[5];
                     if (cross.accumulateCubic(curx, cury, coords)) {
                         return null;
+                    }
                     curx = newx;
                     cury = newy;
                     break;
                 case PathIterator.SEG_CLOSE:
                     if (movy != cury &&
                         cross.accumulateLine(curx, cury, movx, movy))
+                    {
                         return null;
+                    }
                     curx = movx;
                     cury = movy;
                     break;
+                }
                 pi.next();
+            }
             if (movy != cury) {
                 if (cross.accumulateLine(curx, cury, movx, movy)) {
                     return null;
+                }
+            }
             if (debug) {
                 cross.print();
+            }
             return cross;
+        }
         public boolean accumulateLine(double x0, double y0,
                                       double x1, double y1)
+        {
             if (y0 <= y1) {
                 return accumulateLine(x0, y0, x1, y1, 1);
             } else {
                 return accumulateLine(x1, y1, x0, y0, -1);
+            }
+        }
         public boolean accumulateLine(double x0, double y0,
                                       double x1, double y1,
                                       int direction)
+        {
             if (yhi <= y0 || ylo >= y1) {
                 return false;
+            }
             if (x0 >= xhi && x1 >= xhi) {
                 return false;
+            }
             if (y0 == y1) {
                 return (x0 >= xlo || x1 >= xlo);
+            }
             double xstart, ystart, xend, yend;
             double dx = (x1 - x0);
             double dy = (y1 - y0);
             if (y0 < ylo) {
                 xstart = x0 + (ylo - y0) * dx / dy;
                 ystart = ylo;
             } else {
                 xstart = x0;
                 ystart = y0;
+            }
             if (yhi < y1) {
                 xend = x0 + (yhi - y0) * dx / dy;
                 yend = yhi;
             } else {
                 xend = x1;
                 yend = y1;
+            }
             if (xstart >= xhi && xend >= xhi) {
                 return false;
+            }
             if (xstart > xlo || xend > xlo) {
                 return true;
+            }
             record(ystart, yend, direction);
             return false;
+        }
         private Vector tmp = new Vector();
         public boolean accumulateQuad(double x0, double y0, double coords[]) {
             if (y0 < ylo && coords[1] < ylo && coords[3] < ylo) {
                 return false;
+            }
             if (y0 > yhi && coords[1] > yhi && coords[3] > yhi) {
                 return false;
+            }
             if (x0 > xhi && coords[0] > xhi && coords[2] > xhi) {
                 return false;
+            }
             if (x0 < xlo && coords[0] < xlo && coords[2] < xlo) {
                 if (y0 < coords[3]) {
                     record(Math.max(y0, ylo), Math.min(coords[3], yhi), 1);
                 } else if (y0 > coords[3]) {
                     record(Math.max(coords[3], ylo), Math.min(y0, yhi), -1);
+                }
                 return false;
+            }
             Curve.insertQuad(tmp, x0, y0, coords);
             Enumeration enum_ = tmp.elements();
             while (enum_.hasMoreElements()) {
                 Curve c = (Curve) enum_.nextElement();
                 if (c.accumulateCrossings(this)) {
                     return true;
+                }
+            }
             tmp.clear();
             return false;
+        }
         public boolean accumulateCubic(double x0, double y0, double coords[]) {
             if (y0 < ylo && coords[1] < ylo &&
                 coords[3] < ylo && coords[5] < ylo)
+            {
                 return false;
+            }
             if (y0 > yhi && coords[1] > yhi &&
                 coords[3] > yhi && coords[5] > yhi)
+            {
                 return false;
+            }
             if (x0 > xhi && coords[0] > xhi &&
                 coords[2] > xhi && coords[4] > xhi)
+            {
                 return false;
+            }
             if (x0 < xlo && coords[0] < xlo &&
                 coords[2] < xlo && coords[4] < xlo)
+            {
                 if (y0 <= coords[5]) {
                     record(Math.max(y0, ylo), Math.min(coords[5], yhi), 1);
                 } else {
                     record(Math.max(coords[5], ylo), Math.min(y0, yhi), -1);
+                }
                 return false;
+            }
             Curve.insertCubic(tmp, x0, y0, coords);
             Enumeration enum_ = tmp.elements();
             while (enum_.hasMoreElements()) {
                 Curve c = (Curve) enum_.nextElement();
                 if (c.accumulateCrossings(this)) {
                     return true;
+                }
+            }
             tmp.clear();
             return false;
+        }
         final static class EvenOdd extends Crossings {
             public EvenOdd(double xlo, double ylo, double xhi, double yhi) {
                 super(xlo, ylo, xhi, yhi);
+            }
             public final boolean covers(double ystart, double yend) {
                 return (limit == 2 && yranges[0] <= ystart && yranges[1] >= yend);
+            }
             public void record(double ystart, double yend, int direction) {
                 if (ystart >= yend) {
                     return;
+                }
                 int from = 0;
                 // Quickly jump over all pairs that are completely "above"
                 while (from < limit && ystart > yranges[from+1]) {
                     from += 2;
+                }
                 int to = from;
                 while (from < limit) {
                     double yrlo = yranges[from++];
                     double yrhi = yranges[from++];
                     if (yend < yrlo) {
                         // Quickly handle insertion of the new range
                         yranges[to++] = ystart;
                         yranges[to++] = yend;
                         ystart = yrlo;
                         yend = yrhi;
                         continue;
+                    }
                     // The ranges overlap - sort, collapse, insert, iterate
                     double yll, ylh, yhl, yhh;
                     if (ystart < yrlo) {
                         yll = ystart;
                         ylh = yrlo;
                     } else {
                         yll = yrlo;
                         ylh = ystart;
+                    }
                     if (yend < yrhi) {
                         yhl = yend;
                         yhh = yrhi;
                     } else {
                         yhl = yrhi;
                         yhh = yend;
+                    }
                     if (ylh == yhl) {
                         ystart = yll;
                         yend = yhh;
                     } else {
                         if (ylh > yhl) {
                             ystart = yhl;
                             yhl = ylh;
                             ylh = ystart;
+                        }
                         if (yll != ylh) {
                             yranges[to++] = yll;
                             yranges[to++] = ylh;
+                        }
                         ystart = yhl;
                         yend = yhh;
+                    }
                     if (ystart >= yend) {
                         break;
+                    }
+                }
                 if (to < from && from < limit) {
                     System.arraycopy(yranges, from, yranges, to, limit-from);
+                }
                 to += (limit-from);
                 if (ystart < yend) {
                     if (to >= yranges.length) {
                         double newranges[] = new double[to+10];
                         System.arraycopy(yranges, 0, newranges, 0, to);
                         yranges = newranges;
+                    }
                     yranges[to++] = ystart;
                     yranges[to++] = yend;
+                }
                 limit = to;
+            }
+        }
         final static class NonZero extends Crossings {
             private int crosscounts[];
             public NonZero(double xlo, double ylo, double xhi, double yhi) {
                 super(xlo, ylo, xhi, yhi);
                 crosscounts = new int[yranges.length / 2];
+            }
             public final boolean covers(double ystart, double yend) {
                 int i = 0;
                 while (i < limit) {
                     double ylo = yranges[i++];
                     double yhi = yranges[i++];
                     if (ystart >= yhi) {
                         continue;
+                    }
                     if (ystart < ylo) {
                         return false;
+                    }
                     if (yend <= yhi) {
                         return true;
+                    }
                     ystart = yhi;
+                }
                 return (ystart >= yend);
+            }
             public void remove(int cur) {
                 limit -= 2;
                 int rem = limit - cur;
                 if (rem > 0) {
                     System.arraycopy(yranges, cur+2, yranges, cur, rem);
                     System.arraycopy(crosscounts, cur/2+1,
                                      crosscounts, cur/2,
                                      rem/2);
+                }
+            }
             public void insert(int cur, double lo, double hi, int dir) {
                 int rem = limit - cur;
                 double oldranges[] = yranges;
                 int oldcounts[] = crosscounts;
                 if (limit >= yranges.length) {
                     yranges = new double[limit+10];
                     System.arraycopy(oldranges, 0, yranges, 0, cur);
                     crosscounts = new int[(limit+10)/2];
                     System.arraycopy(oldcounts, 0, crosscounts, 0, cur/2);
+                }
                 if (rem > 0) {
                     System.arraycopy(oldranges, cur, yranges, cur+2, rem);
                     System.arraycopy(oldcounts, cur/2,
                                      crosscounts, cur/2+1,
                                      rem/2);
+                }
                 yranges[cur+0] = lo;
                 yranges[cur+1] = hi;
                 crosscounts[cur/2] = dir;
                 limit += 2;
+            }
             public void record(double ystart, double yend, int direction) {
                 if (ystart >= yend) {
                     return;
+                }
                 int cur = 0;
                 // Quickly jump over all pairs that are completely "above"
                 while (cur < limit && ystart > yranges[cur+1]) {
                     cur += 2;
+                }
                 if (cur < limit) {
                     int rdir = crosscounts[cur/2];
                     double yrlo = yranges[cur+0];
                     double yrhi = yranges[cur+1];
                     if (yrhi == ystart && rdir == direction) {
                         // Remove the range from the list and collapse it
                         // into the range being inserted.  Note that the
                         // new combined range may overlap the following range
                         // so we must not simply combine the ranges in place
                         // unless we are at the last range.
                         if (cur+2 == limit) {
                             yranges[cur+1] = yend;
                             return;
+                        }
                         remove(cur);
                         ystart = yrlo;
                         rdir = crosscounts[cur/2];
                         yrlo = yranges[cur+0];
                         yrhi = yranges[cur+1];
+                    }
                     if (yend < yrlo) {
                         // Just insert the new range at the current location
                         insert(cur, ystart, yend, direction);
                         return;
+                    }
                     if (yend == yrlo && rdir == direction) {
                         // Just prepend the new range to the current one
                         yranges[cur] = ystart;
                         return;
+                    }
                     // The ranges must overlap - (yend > yrlo && yrhi > ystart)
                     if (ystart < yrlo) {
                         insert(cur, ystart, yrlo, direction);
                         cur += 2;
                         ystart = yrlo;
                     } else if (yrlo < ystart) {
                         insert(cur, yrlo, ystart, rdir);
                         cur += 2;
                         yrlo = ystart;
+                    }
                     // assert(yrlo == ystart);
                     int newdir = rdir + direction;
                     double newend = Math.min(yend, yrhi);
                     if (newdir == 0) {
                         remove(cur);
                     } else {
                         crosscounts[cur/2] = newdir;
                         yranges[cur++] = ystart;
                         yranges[cur++] = newend;
+                    }
                     ystart = yrlo = newend;
                     if (yrlo < yrhi) {
                         insert(cur, yrlo, yrhi, rdir);
+                    }
+                }
                 if (ystart < yend) {
                     insert(cur, ystart, yend, direction);
+                }
+            }
+        }
+    }

     /*
      * Copyright 1998 Sun Microsystems, Inc.  All Rights Reserved.
      * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+     *
      * This code is free software; you can redistribute it and/or modify it
      * under the terms of the GNU General Public License version 2 only, as
      * published by the Free Software Foundation.  Sun designates this
      * particular file as subject to the "Classpath" exception as provided
      * by Sun in the LICENSE file that accompanied this code.
+     *
      * This code is distributed in the hope that it will be useful, but WITHOUT
      * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      * version 2 for more details (a copy is included in the LICENSE file that
      * accompanied this code).
+     *
      * You should have received a copy of the GNU General Public License version
      * 2 along with this work; if not, write to the Free Software Foundation,
      * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+     *
      * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
      * CA 95054 USA or visit www.sun.com if you need additional information or
      * have any questions.
      */
     package org.gvsig.jdk.sun.awt.geom;
     import java.awt.geom.PathIterator;
     import java.awt.geom.Rectangle2D;
     final class Order0 extends Curve {
         private double x;
         private double y;
         Order0(double x, double y) {
             super(INCREASING);
             this.x = x;
             this.y = y;
+        }
         public int getOrder() {
             return 0;
+        }
         public double getXTop() {
             return x;
+        }
         public double getYTop() {
             return y;
+        }
         public double getXBot() {
             return x;
+        }
         public double getYBot() {
             return y;
+        }
         public double getXMin() {
             return x;
+        }
         public double getXMax() {
             return x;
+        }
         public double getX0() {
             return x;
+        }
         public double getY0() {
             return y;
+        }
         public double getX1() {
             return x;
+        }
         public double getY1() {
             return y;
+        }
         public double XforY(double y) {
             return y;
+        }
         public double TforY(double y) {
             return 0;
+        }
         public double XforT(double t) {
             return x;
+        }
         public double YforT(double t) {
             return y;
+        }
         public double dXforT(double t, int deriv) {
             return 0;
+        }
         public double dYforT(double t, int deriv) {
             return 0;
+        }
         public double nextVertical(double t0, double t1) {
             return t1;
+        }
         public int crossingsFor(double x, double y) {
             return 0;
+        }
         public boolean accumulateCrossings(Crossings c) {
             return (x > c.getXLo() &&
                     x < c.getXHi() &&
                     y > c.getYLo() &&
                     y < c.getYHi());
+        }
         public void enlarge(Rectangle2D r) {
             r.add(x, y);
+        }
         public Curve getSubCurve(double ystart, double yend, int dir) {
             return this;
+        }
         public Curve getReversedCurve() {
             return this;
+        }
         public int getSegment(double coords[]) {
             coords[0] = x;
             coords[1] = y;
             return PathIterator.SEG_MOVETO;
+        }
+    }

     /*
      * Copyright 1998-2006 Sun Microsystems, Inc.  All Rights Reserved.
      * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+     *
      * This code is free software; you can redistribute it and/or modify it
      * under the terms of the GNU General Public License version 2 only, as
      * published by the Free Software Foundation.  Sun designates this
      * particular file as subject to the "Classpath" exception as provided
      * by Sun in the LICENSE file that accompanied this code.
+     *
      * This code is distributed in the hope that it will be useful, but WITHOUT
      * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      * version 2 for more details (a copy is included in the LICENSE file that
      * accompanied this code).
+     *
      * You should have received a copy of the GNU General Public License version
      * 2 along with this work; if not, write to the Free Software Foundation,
      * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+     *
      * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
      * CA 95054 USA or visit www.sun.com if you need additional information or
      * have any questions.
      */
     package org.gvsig.jdk.sun.awt.geom;
     import java.awt.geom.PathIterator;
     import java.awt.geom.Rectangle2D;
     final class Order1 extends Curve {
         private double x0;
         private double y0;
         private double x1;
         private double y1;
         private double xmin;
         private double xmax;
         Order1(double x0, double y0,
                       double x1, double y1,
                       int direction)
+        {
             super(direction);
             this.x0 = x0;
             this.y0 = y0;
             this.x1 = x1;
             this.y1 = y1;
             if (x0 < x1) {
                 this.xmin = x0;
                 this.xmax = x1;
             } else {
                 this.xmin = x1;
                 this.xmax = x0;
+            }
+        }
         public int getOrder() {
             return 1;
+        }
         public double getXTop() {
             return x0;
+        }
         public double getYTop() {
             return y0;
+        }
         public double getXBot() {
             return x1;
+        }
         public double getYBot() {
             return y1;
+        }
         public double getXMin() {
             return xmin;
+        }
         public double getXMax() {
             return xmax;
+        }
         public double getX0() {
             return (direction == INCREASING) ? x0 : x1;
+        }
         public double getY0() {
             return (direction == INCREASING) ? y0 : y1;
+        }
         public double getX1() {
             return (direction == DECREASING) ? x0 : x1;
+        }
         public double getY1() {
             return (direction == DECREASING) ? y0 : y1;
+        }
         public double XforY(double y) {
             if (x0 == x1 || y <= y0) {
                 return x0;
+            }
             if (y >= y1) {
                 return x1;
+            }
             // assert(y0 != y1); /* No horizontal lines... */
             return (x0 + (y - y0) * (x1 - x0) / (y1 - y0));
+        }
         public double TforY(double y) {
             if (y <= y0) {
                 return 0;
+            }
             if (y >= y1) {
                 return 1;
+            }
             return (y - y0) / (y1 - y0);
+        }
         public double XforT(double t) {
             return x0 + t * (x1 - x0);
+        }
         public double YforT(double t) {
             return y0 + t * (y1 - y0);
+        }
         public double dXforT(double t, int deriv) {
             switch (deriv) {
             case 0:
                 return x0 + t * (x1 - x0);
             case 1:
                 return (x1 - x0);
             default:
                 return 0;
+            }
+        }
         public double dYforT(double t, int deriv) {
             switch (deriv) {
             case 0:
                 return y0 + t * (y1 - y0);
             case 1:
                 return (y1 - y0);
             default:
                 return 0;
+            }
+        }
         public double nextVertical(double t0, double t1) {
             return t1;
+        }
         public boolean accumulateCrossings(Crossings c) {
             double xlo = c.getXLo();
             double ylo = c.getYLo();
             double xhi = c.getXHi();
             double yhi = c.getYHi();
             if (xmin >= xhi) {
                 return false;
+            }
             double xstart, ystart, xend, yend;
             if (y0 < ylo) {
                 if (y1 <= ylo) {
                     return false;
+                }
                 ystart = ylo;
                 xstart = XforY(ylo);
             } else {
                 if (y0 >= yhi) {
                     return false;
+                }
                 ystart = y0;
                 xstart = x0;
+            }
             if (y1 > yhi) {
                 yend = yhi;
                 xend = XforY(yhi);
             } else {
                 yend = y1;
                 xend = x1;
+            }
             if (xstart >= xhi && xend >= xhi) {
                 return false;
+            }
             if (xstart > xlo || xend > xlo) {
                 return true;
+            }
             c.record(ystart, yend, direction);
             return false;
+        }
         public void enlarge(Rectangle2D r) {
             r.add(x0, y0);
             r.add(x1, y1);
+        }
         public Curve getSubCurve(double ystart, double yend, int dir) {
             if (ystart == y0 && yend == y1) {
                 return getWithDirection(dir);
+            }
             if (x0 == x1) {
                 return new Order1(x0, ystart, x1, yend, dir);
+            }
             double num = x0 - x1;
             double denom = y0 - y1;
             double xstart = (x0 + (ystart - y0) * num / denom);
             double xend = (x0 + (yend - y0) * num / denom);
             return new Order1(xstart, ystart, xend, yend, dir);
+        }
         public Curve getReversedCurve() {
             return new Order1(x0, y0, x1, y1, -direction);
+        }
         public int compareTo(Curve other, double yrange[]) {
             if (!(other instanceof Order1)) {
                 return super.compareTo(other, yrange);
+            }
             Order1 c1 = (Order1) other;
             if (yrange[1] <= yrange[0]) {
                 throw new InternalError("yrange already screwed up...");
+            }
             yrange[1] = Math.min(Math.min(yrange[1], y1), c1.y1);
             if (yrange[1] <= yrange[0]) {
                 throw new InternalError("backstepping from "+yrange[0]+" to "+yrange[1]);
+            }
             if (xmax <= c1.xmin) {
                 return (xmin == c1.xmax) ? 0 : -1;
+            }
             if (xmin >= c1.xmax) {
                 return 1;
+            }
             /*
              * If "this" is curve A and "other" is curve B, then...
              * xA(y) = x0A + (y - y0A) (x1A - x0A) / (y1A - y0A)
              * xB(y) = x0B + (y - y0B) (x1B - x0B) / (y1B - y0B)
              * xA(y) == xB(y)
              * x0A + (y - y0A) (x1A - x0A) / (y1A - y0A)
              *    == x0B + (y - y0B) (x1B - x0B) / (y1B - y0B)
              * 0 == x0A (y1A - y0A) (y1B - y0B) + (y - y0A) (x1A - x0A) (y1B - y0B)
              *    - x0B (y1A - y0A) (y1B - y0B) - (y - y0B) (x1B - x0B) (y1A - y0A)
              * 0 == (x0A - x0B) (y1A - y0A) (y1B - y0B)
              *    + (y - y0A) (x1A - x0A) (y1B - y0B)
              *    - (y - y0B) (x1B - x0B) (y1A - y0A)
              * If (dxA == x1A - x0A), etc...
              * 0 == (x0A - x0B) * dyA * dyB
              *    + (y - y0A) * dxA * dyB
              *    - (y - y0B) * dxB * dyA
              * 0 == (x0A - x0B) * dyA * dyB
              *    + y * dxA * dyB - y0A * dxA * dyB
              *    - y * dxB * dyA + y0B * dxB * dyA
              * 0 == (x0A - x0B) * dyA * dyB
              *    + y * dxA * dyB - y * dxB * dyA
              *    - y0A * dxA * dyB + y0B * dxB * dyA
              * 0 == (x0A - x0B) * dyA * dyB
              *    + y * (dxA * dyB - dxB * dyA)
              *    - y0A * dxA * dyB + y0B * dxB * dyA
              * y == ((x0A - x0B) * dyA * dyB
              *       - y0A * dxA * dyB + y0B * dxB * dyA)
              *    / (-(dxA * dyB - dxB * dyA))
              * y == ((x0A - x0B) * dyA * dyB
              *       - y0A * dxA * dyB + y0B * dxB * dyA)
              *    / (dxB * dyA - dxA * dyB)
              */
             double dxa = x1 - x0;
             double dya = y1 - y0;
             double dxb = c1.x1 - c1.x0;
             double dyb = c1.y1 - c1.y0;
             double denom = dxb * dya - dxa * dyb;
             double y;
             if (denom != 0) {
                 double num = ((x0 - c1.x0) * dya * dyb
                               - y0 * dxa * dyb
                               + c1.y0 * dxb * dya);
                 y = num / denom;
                 if (y <= yrange[0]) {
                     // intersection is above us
                     // Use bottom-most common y for comparison
                     y = Math.min(y1, c1.y1);
                 } else {
                     // intersection is below the top of our range
                     if (y < yrange[1]) {
                         // If intersection is in our range, adjust valid range
                         yrange[1] = y;
+                    }
                     // Use top-most common y for comparison
                     y = Math.max(y0, c1.y0);
+                }
             } else {
                 // lines are parallel, choose any common y for comparison
                 // Note - prefer an endpoint for speed of calculating the X
                 // (see shortcuts in Order1.XforY())
                 y = Math.max(y0, c1.y0);
+            }
             return orderof(XforY(y), c1.XforY(y));
+        }
         public int getSegment(double coords[]) {
             if (direction == INCREASING) {
                 coords[0] = x1;
                 coords[1] = y1;
             } else {
                 coords[0] = x0;
                 coords[1] = y0;
+            }
             return PathIterator.SEG_LINETO;
+        }
+    }

     /*
      * Copyright 1998-2006 Sun Microsystems, Inc.  All Rights Reserved.
      * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+     *
      * This code is free software; you can redistribute it and/or modify it
      * under the terms of the GNU General Public License version 2 only, as
      * published by the Free Software Foundation.  Sun designates this
      * particular file as subject to the "Classpath" exception as provided
      * by Sun in the LICENSE file that accompanied this code.
+     *
      * This code is distributed in the hope that it will be useful, but WITHOUT
      * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      * version 2 for more details (a copy is included in the LICENSE file that
      * accompanied this code).
+     *
      * You should have received a copy of the GNU General Public License version
      * 2 along with this work; if not, write to the Free Software Foundation,
      * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+     *
      * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
      * CA 95054 USA or visit www.sun.com if you need additional information or
      * have any questions.
      */
     package org.gvsig.jdk.sun.awt.geom;
     import java.awt.geom.PathIterator;
     import java.awt.geom.Rectangle2D;
     import java.util.Vector;
     final class Order2 extends Curve {
         private double x0;
         private double y0;
         private double cx0;
         private double cy0;
         private double x1;
         private double y1;
         private double xmin;
         private double xmax;
         private double xcoeff0;
         private double xcoeff1;
         private double xcoeff2;
         private double ycoeff0;
         private double ycoeff1;
         private double ycoeff2;
         public static void insert(Vector curves, double tmp[],
                                   double x0, double y0,
                                   double cx0, double cy0,
                                   double x1, double y1,
                                   int direction)
+        {
             int numparams = getHorizontalParams(y0, cy0, y1, tmp);
             if (numparams == 0) {
                 // We are using addInstance here to avoid inserting horisontal
                 // segments
                 addInstance(curves, x0, y0, cx0, cy0, x1, y1, direction);
                 return;
+            }
             // assert(numparams == 1);
             double t = tmp[0];
             tmp[0] = x0;  tmp[1] = y0;
             tmp[2] = cx0; tmp[3] = cy0;
             tmp[4] = x1;  tmp[5] = y1;
             split(tmp, 0, t);
             int i0 = (direction == INCREASING)? 0 : 4;
             int i1 = 4 - i0;
             addInstance(curves, tmp[i0], tmp[i0 + 1], tmp[i0 + 2], tmp[i0 + 3],
                         tmp[i0 + 4], tmp[i0 + 5], direction);
             addInstance(curves, tmp[i1], tmp[i1 + 1], tmp[i1 + 2], tmp[i1 + 3],
                         tmp[i1 + 4], tmp[i1 + 5], direction);
+        }
         public static void addInstance(Vector curves,
                                        double x0, double y0,
                                        double cx0, double cy0,
                                        double x1, double y1,
                                        int direction) {
             if (y0 > y1) {
                 curves.add(new Order2(x1, y1, cx0, cy0, x0, y0, -direction));
             } else if (y1 > y0) {
                 curves.add(new Order2(x0, y0, cx0, cy0, x1, y1, direction));
+            }
+        }
         /*
          * Return the count of the number of horizontal sections of the
          * specified quadratic Bezier curve.  Put the parameters for the
          * horizontal sections into the specified <code>ret</code> array.
          * <p>
          * If we examine the parametric equation in t, we have:
          *     Py(t) = C0*(1-t)^2 + 2*CP*t*(1-t) + C1*t^2
          *           = C0 - 2*C0*t + C0*t^2 + 2*CP*t - 2*CP*t^2 + C1*t^2
          *           = C0 + (2*CP - 2*C0)*t + (C0 - 2*CP + C1)*t^2
          *     Py(t) = (C0 - 2*CP + C1)*t^2 + (2*CP - 2*C0)*t + (C0)
          * If we take the derivative, we get:
          *     Py(t) = At^2 + Bt + C
          *     dPy(t) = 2At + B = 0
          *     2*(C0 - 2*CP + C1)t + 2*(CP - C0) = 0
          *     2*(C0 - 2*CP + C1)t = 2*(C0 - CP)
          *     t = 2*(C0 - CP) / 2*(C0 - 2*CP + C1)
          *     t = (C0 - CP) / (C0 - CP + C1 - CP)
          * Note that this method will return 0 if the equation is a line,
          * which is either always horizontal or never horizontal.
          * Completely horizontal curves need to be eliminated by other
          * means outside of this method.
          */
         public static int getHorizontalParams(double c0, double cp, double c1,
                                               double ret[]) {
             if (c0 <= cp && cp <= c1) {
                 return 0;
+            }
             c0 -= cp;
             c1 -= cp;
             double denom = c0 + c1;
             // If denom == 0 then cp == (c0+c1)/2 and we have a line.
             if (denom == 0) {
                 return 0;
+            }
             double t = c0 / denom;
             // No splits at t==0 and t==1
             if (t <= 0 || t >= 1) {
                 return 0;
+            }
             ret[0] = t;
             return 1;
+        }
         /*
          * Split the quadratic Bezier stored at coords[pos...pos+5] representing
          * the paramtric range [0..1] into two subcurves representing the
          * parametric subranges [0..t] and [t..1].  Store the results back
          * into the array at coords[pos...pos+5] and coords[pos+4...pos+9].
          */
         public static void split(double coords[], int pos, double t) {
             double x0, y0, cx, cy, x1, y1;
             coords[pos+8] = x1 = coords[pos+4];
             coords[pos+9] = y1 = coords[pos+5];
             cx = coords[pos+2];
             cy = coords[pos+3];
             x1 = cx + (x1 - cx) * t;
             y1 = cy + (y1 - cy) * t;
             x0 = coords[pos+0];
             y0 = coords[pos+1];
             x0 = x0 + (cx - x0) * t;
             y0 = y0 + (cy - y0) * t;
             cx = x0 + (x1 - x0) * t;
             cy = y0 + (y1 - y0) * t;
             coords[pos+2] = x0;
             coords[pos+3] = y0;
             coords[pos+4] = cx;
             coords[pos+5] = cy;
             coords[pos+6] = x1;
             coords[pos+7] = y1;
+        }
         Order2(double x0, double y0,
                       double cx0, double cy0,
                       double x1, double y1,
                       int direction)
+        {
             super(direction);
             // REMIND: Better accuracy in the root finding methods would
             //  ensure that cy0 is in range.  As it stands, it is never
             //  more than "1 mantissa bit" out of range...
             if (cy0 < y0) {
                 cy0 = y0;
             } else if (cy0 > y1) {
                 cy0 = y1;
+            }
             this.x0 = x0;
             this.y0 = y0;
             this.cx0 = cx0;
             this.cy0 = cy0;
             this.x1 = x1;
             this.y1 = y1;
             xmin = Math.min(Math.min(x0, x1), cx0);
             xmax = Math.max(Math.max(x0, x1), cx0);
             xcoeff0 = x0;
             xcoeff1 = cx0 + cx0 - x0 - x0;
             xcoeff2 = x0 - cx0 - cx0 + x1;
             ycoeff0 = y0;
             ycoeff1 = cy0 + cy0 - y0 - y0;
             ycoeff2 = y0 - cy0 - cy0 + y1;
+        }
         public int getOrder() {
             return 2;
+        }
         public double getXTop() {
             return x0;
+        }

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

gvSIG external » org.gvsig.jdk

Revision 36