src/share/classes/java/awt/geom/FlatteningPathIterator.java - toolchain/jdk/jdk9_jdk - Git at Google

 /*
  * Copyright (c) 1997, 1998, Oracle and/or its affiliates. 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.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package java.awt.geom;

 import java.util.*;

 /**
  * The <code>FlatteningPathIterator</code> class returns a flattened view of
  * another {@link PathIterator} object.  Other {@link java.awt.Shape Shape}
  * classes can use this class to provide flattening behavior for their paths
  * without having to perform the interpolation calculations themselves.
  *
  * @author Jim Graham
  */
 public class FlatteningPathIterator implements PathIterator {
     static final int GROW_SIZE = 24;    // Multiple of cubic & quad curve size

     PathIterator src;                   // The source iterator

     double squareflat;                  // Square of the flatness parameter
                                         // for testing against squared lengths

     int limit;                          // Maximum number of recursion levels

     double hold[] = new double[14];     // The cache of interpolated coords
                                         // Note that this must be long enough
                                         // to store a full cubic segment and
                                         // a relative cubic segment to avoid
                                         // aliasing when copying the coords
                                         // of a curve to the end of the array.
                                         // This is also serendipitously equal
                                         // to the size of a full quad segment
                                         // and 2 relative quad segments.

     double curx, cury;                  // The ending x,y of the last segment

     double movx, movy;                  // The x,y of the last move segment

     int holdType;                       // The type of the curve being held
                                         // for interpolation

     int holdEnd;                        // The index of the last curve segment
                                         // being held for interpolation

     int holdIndex;                      // The index of the curve segment
                                         // that was last interpolated.  This
                                         // is the curve segment ready to be
                                         // returned in the next call to
                                         // currentSegment().

     int levels[];                       // The recursion level at which
                                         // each curve being held in storage
                                         // was generated.

     int levelIndex;                     // The index of the entry in the
                                         // levels array of the curve segment
                                         // at the holdIndex

     boolean done;                       // True when iteration is done

     /**
      * Constructs a new <code>FlatteningPathIterator</code> object that
      * flattens a path as it iterates over it.  The iterator does not
      * subdivide any curve read from the source iterator to more than
      * 10 levels of subdivision which yields a maximum of 1024 line
      * segments per curve.
      * @param src the original unflattened path being iterated over
      * @param flatness the maximum allowable distance between the
      * control points and the flattened curve
      */
     public FlatteningPathIterator(PathIterator src, double flatness) {
         this(src, flatness, 10);
     }

     /**
      * Constructs a new <code>FlatteningPathIterator</code> object
      * that flattens a path as it iterates over it.
      * The <code>limit</code> parameter allows you to control the
      * maximum number of recursive subdivisions that the iterator
      * can make before it assumes that the curve is flat enough
      * without measuring against the <code>flatness</code> parameter.
      * The flattened iteration therefore never generates more than
      * a maximum of <code>(2^limit)</code> line segments per curve.
      * @param src the original unflattened path being iterated over
      * @param flatness the maximum allowable distance between the
      * control points and the flattened curve
      * @param limit the maximum number of recursive subdivisions
      * allowed for any curved segment
      * @exception <code>IllegalArgumentException</code> if
      *          <code>flatness</code> or <code>limit</code>
      *          is less than zero
      */
     public FlatteningPathIterator(PathIterator src, double flatness,
                                   int limit) {
         if (flatness < 0.0) {
             throw new IllegalArgumentException("flatness must be >= 0");
         }
         if (limit < 0) {
             throw new IllegalArgumentException("limit must be >= 0");
         }
         this.src = src;
         this.squareflat = flatness * flatness;
         this.limit = limit;
         this.levels = new int[limit + 1];
         // prime the first path segment
         next(false);
     }

     /**
      * Returns the flatness of this iterator.
      * @return the flatness of this <code>FlatteningPathIterator</code>.
      */
     public double getFlatness() {
         return Math.sqrt(squareflat);
     }

     /**
      * Returns the recursion limit of this iterator.
      * @return the recursion limit of this
      * <code>FlatteningPathIterator</code>.
      */
     public int getRecursionLimit() {
         return limit;
     }

     /**
      * Returns the winding rule for determining the interior of the
      * path.
      * @return the winding rule of the original unflattened path being
      * iterated over.
      * @see PathIterator#WIND_EVEN_ODD
      * @see PathIterator#WIND_NON_ZERO
      */
     public int getWindingRule() {
         return src.getWindingRule();
     }

     /**
      * Tests if the iteration is complete.
      * @return <code>true</code> if all the segments have
      * been read; <code>false</code> otherwise.
      */
     public boolean isDone() {
         return done;
     }

     /*
      * Ensures that the hold array can hold up to (want) more values.
      * It is currently holding (hold.length - holdIndex) values.
      */
     void ensureHoldCapacity(int want) {
         if (holdIndex - want < 0) {
             int have = hold.length - holdIndex;
             int newsize = hold.length + GROW_SIZE;
             double newhold[] = new double[newsize];
             System.arraycopy(hold, holdIndex,
                              newhold, holdIndex + GROW_SIZE,
                              have);
             hold = newhold;
             holdIndex += GROW_SIZE;
             holdEnd += GROW_SIZE;
         }
     }

     /**
      * Moves the iterator to the next segment of the path forwards
      * along the primary direction of traversal as long as there are
      * more points in that direction.
      */
     public void next() {
         next(true);
     }

     private void next(boolean doNext) {
         int level;

         if (holdIndex >= holdEnd) {
             if (doNext) {
                 src.next();
             }
             if (src.isDone()) {
                 done = true;
                 return;
             }
             holdType = src.currentSegment(hold);
             levelIndex = 0;
             levels[0] = 0;
         }

         switch (holdType) {
         case SEG_MOVETO:
         case SEG_LINETO:
             curx = hold[0];
             cury = hold[1];
             if (holdType == SEG_MOVETO) {
                 movx = curx;
                 movy = cury;
             }
             holdIndex = 0;
             holdEnd = 0;
             break;
         case SEG_CLOSE:
             curx = movx;
             cury = movy;
             holdIndex = 0;
             holdEnd = 0;
             break;
         case SEG_QUADTO:
             if (holdIndex >= holdEnd) {
                 // Move the coordinates to the end of the array.
                 holdIndex = hold.length - 6;
                 holdEnd = hold.length - 2;
                 hold[holdIndex + 0] = curx;
                 hold[holdIndex + 1] = cury;
                 hold[holdIndex + 2] = hold[0];
                 hold[holdIndex + 3] = hold[1];
                 hold[holdIndex + 4] = curx = hold[2];
                 hold[holdIndex + 5] = cury = hold[3];
             }

             level = levels[levelIndex];
             while (level < limit) {
                 if (QuadCurve2D.getFlatnessSq(hold, holdIndex) < squareflat) {
                     break;
                 }

                 ensureHoldCapacity(4);
                 QuadCurve2D.subdivide(hold, holdIndex,
                                       hold, holdIndex - 4,
                                       hold, holdIndex);
                 holdIndex -= 4;

                 // Now that we have subdivided, we have constructed
                 // two curves of one depth lower than the original
                 // curve.  One of those curves is in the place of
                 // the former curve and one of them is in the next
                 // set of held coordinate slots.  We now set both
                 // curves level values to the next higher level.
                 level++;
                 levels[levelIndex] = level;
                 levelIndex++;
                 levels[levelIndex] = level;
             }

             // This curve segment is flat enough, or it is too deep
             // in recursion levels to try to flatten any more.  The
             // two coordinates at holdIndex+4 and holdIndex+5 now
             // contain the endpoint of the curve which can be the
             // endpoint of an approximating line segment.
             holdIndex += 4;
             levelIndex--;
             break;
         case SEG_CUBICTO:
             if (holdIndex >= holdEnd) {
                 // Move the coordinates to the end of the array.
                 holdIndex = hold.length - 8;
                 holdEnd = hold.length - 2;
                 hold[holdIndex + 0] = curx;
                 hold[holdIndex + 1] = cury;
                 hold[holdIndex + 2] = hold[0];
                 hold[holdIndex + 3] = hold[1];
                 hold[holdIndex + 4] = hold[2];
                 hold[holdIndex + 5] = hold[3];
                 hold[holdIndex + 6] = curx = hold[4];
                 hold[holdIndex + 7] = cury = hold[5];
             }

             level = levels[levelIndex];
             while (level < limit) {
                 if (CubicCurve2D.getFlatnessSq(hold, holdIndex) < squareflat) {
                     break;
                 }

                 ensureHoldCapacity(6);
                 CubicCurve2D.subdivide(hold, holdIndex,
                                        hold, holdIndex - 6,
                                        hold, holdIndex);
                 holdIndex -= 6;

                 // Now that we have subdivided, we have constructed
                 // two curves of one depth lower than the original
                 // curve.  One of those curves is in the place of
                 // the former curve and one of them is in the next
                 // set of held coordinate slots.  We now set both
                 // curves level values to the next higher level.
                 level++;
                 levels[levelIndex] = level;
                 levelIndex++;
                 levels[levelIndex] = level;
             }

             // This curve segment is flat enough, or it is too deep
             // in recursion levels to try to flatten any more.  The
             // two coordinates at holdIndex+6 and holdIndex+7 now
             // contain the endpoint of the curve which can be the
             // endpoint of an approximating line segment.
             holdIndex += 6;
             levelIndex--;
             break;
         }
     }

     /**
      * Returns the coordinates and type of the current path segment in
      * the iteration.
      * The return value is the path segment type:
      * SEG_MOVETO, SEG_LINETO, or SEG_CLOSE.
      * A float array of length 6 must be passed in and can be used to
      * store the coordinates of the point(s).
      * Each point is stored as a pair of float x,y coordinates.
      * SEG_MOVETO and SEG_LINETO types return one point,
      * and SEG_CLOSE does not return any points.
      * @param coords an array that holds the data returned from
      * this method
      * @return the path segment type of the current path segment.
      * @exception <code>NoSuchElementException</code> if there
      *          are no more elements in the flattening path to be
      *          returned.
      * @see PathIterator#SEG_MOVETO
      * @see PathIterator#SEG_LINETO
      * @see PathIterator#SEG_CLOSE
      */
     public int currentSegment(float[] coords) {
         if (isDone()) {
             throw new NoSuchElementException("flattening iterator out of bounds");
         }
         int type = holdType;
         if (type != SEG_CLOSE) {
             coords[0] = (float) hold[holdIndex + 0];
             coords[1] = (float) hold[holdIndex + 1];
             if (type != SEG_MOVETO) {
                 type = SEG_LINETO;
             }
         }
         return type;
     }

     /**
      * Returns the coordinates and type of the current path segment in
      * the iteration.
      * The return value is the path segment type:
      * SEG_MOVETO, SEG_LINETO, or SEG_CLOSE.
      * A double array of length 6 must be passed in and can be used to
      * store the coordinates of the point(s).
      * Each point is stored as a pair of double x,y coordinates.
      * SEG_MOVETO and SEG_LINETO types return one point,
      * and SEG_CLOSE does not return any points.
      * @param coords an array that holds the data returned from
      * this method
      * @return the path segment type of the current path segment.
      * @exception <code>NoSuchElementException</code> if there
      *          are no more elements in the flattening path to be
      *          returned.
      * @see PathIterator#SEG_MOVETO
      * @see PathIterator#SEG_LINETO
      * @see PathIterator#SEG_CLOSE
      */
     public int currentSegment(double[] coords) {
         if (isDone()) {
             throw new NoSuchElementException("flattening iterator out of bounds");
         }
         int type = holdType;
         if (type != SEG_CLOSE) {
             coords[0] = hold[holdIndex + 0];
             coords[1] = hold[holdIndex + 1];
             if (type != SEG_MOVETO) {
                 type = SEG_LINETO;
             }
         }
         return type;
     }
 }
	/*
	* Copyright (c) 1997, 1998, Oracle and/or its affiliates. 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. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package java.awt.geom;

	import java.util.*;

	/**
	* The <code>FlatteningPathIterator</code> class returns a flattened view of
	* another {@link PathIterator} object. Other {@link java.awt.Shape Shape}
	* classes can use this class to provide flattening behavior for their paths
	* without having to perform the interpolation calculations themselves.
	*
	* @author Jim Graham
	*/
	public class FlatteningPathIterator implements PathIterator {
	static final int GROW_SIZE = 24; // Multiple of cubic & quad curve size

	PathIterator src; // The source iterator

	double squareflat; // Square of the flatness parameter
	// for testing against squared lengths

	int limit; // Maximum number of recursion levels

	double hold[] = new double[14]; // The cache of interpolated coords
	// Note that this must be long enough
	// to store a full cubic segment and
	// a relative cubic segment to avoid
	// aliasing when copying the coords
	// of a curve to the end of the array.
	// This is also serendipitously equal
	// to the size of a full quad segment
	// and 2 relative quad segments.

	double curx, cury; // The ending x,y of the last segment

	double movx, movy; // The x,y of the last move segment

	int holdType; // The type of the curve being held
	// for interpolation

	int holdEnd; // The index of the last curve segment
	// being held for interpolation

	int holdIndex; // The index of the curve segment
	// that was last interpolated. This
	// is the curve segment ready to be
	// returned in the next call to
	// currentSegment().

	int levels[]; // The recursion level at which
	// each curve being held in storage
	// was generated.

	int levelIndex; // The index of the entry in the
	// levels array of the curve segment
	// at the holdIndex

	boolean done; // True when iteration is done

	/**
	* Constructs a new <code>FlatteningPathIterator</code> object that
	* flattens a path as it iterates over it. The iterator does not
	* subdivide any curve read from the source iterator to more than
	* 10 levels of subdivision which yields a maximum of 1024 line
	* segments per curve.
	* @param src the original unflattened path being iterated over
	* @param flatness the maximum allowable distance between the
	* control points and the flattened curve
	*/
	public FlatteningPathIterator(PathIterator src, double flatness) {
	this(src, flatness, 10);
	}

	/**
	* Constructs a new <code>FlatteningPathIterator</code> object
	* that flattens a path as it iterates over it.
	* The <code>limit</code> parameter allows you to control the
	* maximum number of recursive subdivisions that the iterator
	* can make before it assumes that the curve is flat enough
	* without measuring against the <code>flatness</code> parameter.
	* The flattened iteration therefore never generates more than
	* a maximum of <code>(2^limit)</code> line segments per curve.
	* @param src the original unflattened path being iterated over
	* @param flatness the maximum allowable distance between the
	* control points and the flattened curve
	* @param limit the maximum number of recursive subdivisions
	* allowed for any curved segment
	* @exception <code>IllegalArgumentException</code> if
	* <code>flatness</code> or <code>limit</code>
	* is less than zero
	*/
	public FlatteningPathIterator(PathIterator src, double flatness,
	int limit) {
	if (flatness < 0.0) {
	throw new IllegalArgumentException("flatness must be >= 0");
	}
	if (limit < 0) {
	throw new IllegalArgumentException("limit must be >= 0");
	}
	this.src = src;
	this.squareflat = flatness * flatness;
	this.limit = limit;
	this.levels = new int[limit + 1];
	// prime the first path segment
	next(false);
	}

	/**
	* Returns the flatness of this iterator.
	* @return the flatness of this <code>FlatteningPathIterator</code>.
	*/
	public double getFlatness() {
	return Math.sqrt(squareflat);
	}

	/**
	* Returns the recursion limit of this iterator.
	* @return the recursion limit of this
	* <code>FlatteningPathIterator</code>.
	*/
	public int getRecursionLimit() {
	return limit;
	}

	/**
	* Returns the winding rule for determining the interior of the
	* path.
	* @return the winding rule of the original unflattened path being
	* iterated over.
	* @see PathIterator#WIND_EVEN_ODD
	* @see PathIterator#WIND_NON_ZERO
	*/
	public int getWindingRule() {
	return src.getWindingRule();
	}

	/**
	* Tests if the iteration is complete.
	* @return <code>true</code> if all the segments have
	* been read; <code>false</code> otherwise.
	*/
	public boolean isDone() {
	return done;
	}

	/*
	* Ensures that the hold array can hold up to (want) more values.
	* It is currently holding (hold.length - holdIndex) values.
	*/
	void ensureHoldCapacity(int want) {
	if (holdIndex - want < 0) {
	int have = hold.length - holdIndex;
	int newsize = hold.length + GROW_SIZE;
	double newhold[] = new double[newsize];
	System.arraycopy(hold, holdIndex,
	newhold, holdIndex + GROW_SIZE,
	have);
	hold = newhold;
	holdIndex += GROW_SIZE;
	holdEnd += GROW_SIZE;
	}
	}

	/**
	* Moves the iterator to the next segment of the path forwards
	* along the primary direction of traversal as long as there are
	* more points in that direction.
	*/
	public void next() {
	next(true);
	}

	private void next(boolean doNext) {
	int level;

	if (holdIndex >= holdEnd) {
	if (doNext) {
	src.next();
	}
	if (src.isDone()) {
	done = true;
	return;
	}
	holdType = src.currentSegment(hold);
	levelIndex = 0;
	levels[0] = 0;
	}

	switch (holdType) {
	case SEG_MOVETO:
	case SEG_LINETO:
	curx = hold[0];
	cury = hold[1];
	if (holdType == SEG_MOVETO) {
	movx = curx;
	movy = cury;
	}
	holdIndex = 0;
	holdEnd = 0;
	break;
	case SEG_CLOSE:
	curx = movx;
	cury = movy;
	holdIndex = 0;
	holdEnd = 0;
	break;
	case SEG_QUADTO:
	if (holdIndex >= holdEnd) {
	// Move the coordinates to the end of the array.
	holdIndex = hold.length - 6;
	holdEnd = hold.length - 2;
	hold[holdIndex + 0] = curx;
	hold[holdIndex + 1] = cury;
	hold[holdIndex + 2] = hold[0];
	hold[holdIndex + 3] = hold[1];
	hold[holdIndex + 4] = curx = hold[2];
	hold[holdIndex + 5] = cury = hold[3];
	}

	level = levels[levelIndex];
	while (level < limit) {
	if (QuadCurve2D.getFlatnessSq(hold, holdIndex) < squareflat) {
	break;
	}

	ensureHoldCapacity(4);
	QuadCurve2D.subdivide(hold, holdIndex,
	hold, holdIndex - 4,
	hold, holdIndex);
	holdIndex -= 4;

	// Now that we have subdivided, we have constructed
	// two curves of one depth lower than the original
	// curve. One of those curves is in the place of
	// the former curve and one of them is in the next
	// set of held coordinate slots. We now set both
	// curves level values to the next higher level.
	level++;
	levels[levelIndex] = level;
	levelIndex++;
	levels[levelIndex] = level;
	}

	// This curve segment is flat enough, or it is too deep
	// in recursion levels to try to flatten any more. The
	// two coordinates at holdIndex+4 and holdIndex+5 now
	// contain the endpoint of the curve which can be the
	// endpoint of an approximating line segment.
	holdIndex += 4;
	levelIndex--;
	break;
	case SEG_CUBICTO:
	if (holdIndex >= holdEnd) {
	// Move the coordinates to the end of the array.
	holdIndex = hold.length - 8;
	holdEnd = hold.length - 2;
	hold[holdIndex + 0] = curx;
	hold[holdIndex + 1] = cury;
	hold[holdIndex + 2] = hold[0];
	hold[holdIndex + 3] = hold[1];
	hold[holdIndex + 4] = hold[2];
	hold[holdIndex + 5] = hold[3];
	hold[holdIndex + 6] = curx = hold[4];
	hold[holdIndex + 7] = cury = hold[5];
	}

	level = levels[levelIndex];
	while (level < limit) {
	if (CubicCurve2D.getFlatnessSq(hold, holdIndex) < squareflat) {
	break;
	}

	ensureHoldCapacity(6);
	CubicCurve2D.subdivide(hold, holdIndex,
	hold, holdIndex - 6,
	hold, holdIndex);
	holdIndex -= 6;

	// Now that we have subdivided, we have constructed
	// two curves of one depth lower than the original
	// curve. One of those curves is in the place of
	// the former curve and one of them is in the next
	// set of held coordinate slots. We now set both
	// curves level values to the next higher level.
	level++;
	levels[levelIndex] = level;
	levelIndex++;
	levels[levelIndex] = level;
	}

	// This curve segment is flat enough, or it is too deep
	// in recursion levels to try to flatten any more. The
	// two coordinates at holdIndex+6 and holdIndex+7 now
	// contain the endpoint of the curve which can be the
	// endpoint of an approximating line segment.
	holdIndex += 6;
	levelIndex--;
	break;
	}
	}

	/**
	* Returns the coordinates and type of the current path segment in
	* the iteration.
	* The return value is the path segment type:
	* SEG_MOVETO, SEG_LINETO, or SEG_CLOSE.
	* A float array of length 6 must be passed in and can be used to
	* store the coordinates of the point(s).
	* Each point is stored as a pair of float x,y coordinates.
	* SEG_MOVETO and SEG_LINETO types return one point,
	* and SEG_CLOSE does not return any points.
	* @param coords an array that holds the data returned from
	* this method
	* @return the path segment type of the current path segment.
	* @exception <code>NoSuchElementException</code> if there
	* are no more elements in the flattening path to be
	* returned.
	* @see PathIterator#SEG_MOVETO
	* @see PathIterator#SEG_LINETO
	* @see PathIterator#SEG_CLOSE
	*/
	public int currentSegment(float[] coords) {
	if (isDone()) {
	throw new NoSuchElementException("flattening iterator out of bounds");
	}
	int type = holdType;
	if (type != SEG_CLOSE) {
	coords[0] = (float) hold[holdIndex + 0];
	coords[1] = (float) hold[holdIndex + 1];
	if (type != SEG_MOVETO) {
	type = SEG_LINETO;
	}
	}
	return type;
	}

	/**
	* Returns the coordinates and type of the current path segment in
	* the iteration.
	* The return value is the path segment type:
	* SEG_MOVETO, SEG_LINETO, or SEG_CLOSE.
	* A double array of length 6 must be passed in and can be used to
	* store the coordinates of the point(s).
	* Each point is stored as a pair of double x,y coordinates.
	* SEG_MOVETO and SEG_LINETO types return one point,
	* and SEG_CLOSE does not return any points.
	* @param coords an array that holds the data returned from
	* this method
	* @return the path segment type of the current path segment.
	* @exception <code>NoSuchElementException</code> if there
	* are no more elements in the flattening path to be
	* returned.
	* @see PathIterator#SEG_MOVETO
	* @see PathIterator#SEG_LINETO
	* @see PathIterator#SEG_CLOSE
	*/
	public int currentSegment(double[] coords) {
	if (isDone()) {
	throw new NoSuchElementException("flattening iterator out of bounds");
	}
	int type = holdType;
	if (type != SEG_CLOSE) {
	coords[0] = hold[holdIndex + 0];
	coords[1] = hold[holdIndex + 1];
	if (type != SEG_MOVETO) {
	type = SEG_LINETO;
	}
	}
	return type;
	}
	}