processing.opengl

Class LinePath

Object

LinePath

public class LinePath
extends Object

The LinePath class allows to represent polygonal paths, potentially composed by several disjoint polygonal segments. It can be iterated by the LinePath.PathIterator class including all of its segment types and winding rules

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	LinePath.PathIterator

Field Summary

Fields

Modifier and Type	Field and Description
static int	CAP_BUTT Ends unclosed subpaths and dash segments with no added decoration.
static int	CAP_ROUND Ends unclosed subpaths and dash segments with a round decoration that has a radius equal to half of the width of the pen.
static int	CAP_SQUARE Ends unclosed subpaths and dash segments with a square projection that extends beyond the end of the segment to a distance equal to half of the line width.
static int	JOIN_BEVEL Joins path segments by connecting the outer corners of their wide outlines with a straight segment.
static int	JOIN_MITER Joins path segments by extending their outside edges until they meet.
static int	JOIN_ROUND Joins path segments by rounding off the corner at a radius of half the line width.
static byte	SEG_CLOSE Closes segment at current position.
static byte	SEG_LINETO Extends segment by adding a line to a given position.
static byte	SEG_MOVETO Starts segment at a given position.
static int	WIND_EVEN_ODD The winding rule constant for specifying an even-odd rule for determining the interior of a path.
static int	WIND_NON_ZERO The winding rule constant for specifying a non-zero rule for determining the interior of a path.

Constructor Summary

Constructors

Constructor and Description
LinePath() Constructs a new empty single precision LinePath object with a default winding rule of WIND_NON_ZERO.
LinePath(int rule) Constructs a new empty single precision LinePath object with the specified winding rule to control operations that require the interior of the path to be defined.
LinePath(int rule, int initialCapacity) Constructs a new LinePath object from the given specified initial values.

Method Summary

Modifier and Type	Method and Description
void	closePath() Closes the current subpath by drawing a straight line back to the coordinates of the last moveTo.
static byte[]	copyOf(byte[] source, int length)
static float[]	copyOf(float[] source, int length)
static int[]	copyOf(int[] source, int length)
static LinePath	createStrokedPath(LinePath src, float weight, int caps, int join)
static LinePath	createStrokedPath(LinePath src, float weight, int caps, int join, float miterlimit)
static LinePath	createStrokedPath(LinePath src, float weight, int caps, int join, float miterlimit, PMatrix2D transform) Constructs a solid LinePath with the specified attributes.
LinePath.PathIterator	getPathIterator() The iterator for this class is not multi-threaded safe, which means that the LinePath class does not guarantee that modifications to the geometry of this LinePath object do not affect any iterations of that geometry that are already in process.
int	getWindingRule() Returns the fill style winding rule.
static double	hypot(double x, double y)
static int	hypot(int x, int y)
static long	hypot(long x, long y)
static int	isqrt(int x)
void	lineTo(float x, float y, int c) Adds a point to the path by drawing a straight line from the current coordinates to the new specified coordinates specified in float precision.
static long	lsqrt(long x)
void	moveTo(float x, float y, int c) Adds a point to the path by moving to the specified coordinates specified in float precision.
void	reset() Resets the path to empty.
void	setWindingRule(int rule) Sets the winding rule for this path to the specified value.

Methods inherited from class Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

WIND_EVEN_ODD

public static final int WIND_EVEN_ODD

The winding rule constant for specifying an even-odd rule for determining the interior of a path. The even-odd rule specifies that a point lies inside the path if a ray drawn in any direction from that point to infinity is crossed by path segments an odd number of times.

See Also:

Constant Field Values

WIND_NON_ZERO

public static final int WIND_NON_ZERO

The winding rule constant for specifying a non-zero rule for determining the interior of a path. The non-zero rule specifies that a point lies inside the path if a ray drawn in any direction from that point to infinity is crossed by path segments a different number of times in the counter-clockwise direction than the clockwise direction.

See Also:

Constant Field Values

SEG_MOVETO

public static final byte SEG_MOVETO

Starts segment at a given position.

See Also:

Constant Field Values

SEG_LINETO

public static final byte SEG_LINETO

Extends segment by adding a line to a given position.

See Also:

Constant Field Values

SEG_CLOSE

public static final byte SEG_CLOSE

Closes segment at current position.

See Also:

Constant Field Values

JOIN_MITER

public static final int JOIN_MITER

Joins path segments by extending their outside edges until they meet.

See Also:

Constant Field Values

JOIN_ROUND

public static final int JOIN_ROUND

Joins path segments by rounding off the corner at a radius of half the line width.

See Also:

Constant Field Values

JOIN_BEVEL

public static final int JOIN_BEVEL

Joins path segments by connecting the outer corners of their wide outlines with a straight segment.

See Also:

Constant Field Values

CAP_BUTT

public static final int CAP_BUTT

Ends unclosed subpaths and dash segments with no added decoration.

See Also:

Constant Field Values

CAP_ROUND

public static final int CAP_ROUND

Ends unclosed subpaths and dash segments with a round decoration that has a radius equal to half of the width of the pen.

See Also:

Constant Field Values

CAP_SQUARE

public static final int CAP_SQUARE

Ends unclosed subpaths and dash segments with a square projection that extends beyond the end of the segment to a distance equal to half of the line width.

See Also:

Constant Field Values

Constructor Detail

LinePath

public LinePath()

Constructs a new empty single precision LinePath object with a default winding rule of WIND_NON_ZERO.

LinePath

public LinePath(int rule)

Constructs a new empty single precision LinePath object with the specified winding rule to control operations that require the interior of the path to be defined.

Parameters:

rule - the winding rule

See Also:

WIND_EVEN_ODD, WIND_NON_ZERO

LinePath

public LinePath(int rule,
                int initialCapacity)

Constructs a new LinePath object from the given specified initial values. This method is only intended for internal use and should not be made public if the other constructors for this class are ever exposed.

Parameters:

rule - the winding rule

initialCapacity - the size to make the initial array to store the path segment types

Method Detail

moveTo

public final void moveTo(float x,
                         float y,
                         int c)

Adds a point to the path by moving to the specified coordinates specified in float precision.

This method provides a single precision variant of the double precision moveTo() method on the base LinePath class.

Parameters:

x - the specified X coordinate

y - the specified Y coordinate

See Also:

moveTo(float, float, int)

lineTo

public final void lineTo(float x,
                         float y,
                         int c)

Adds a point to the path by drawing a straight line from the current coordinates to the new specified coordinates specified in float precision.

This method provides a single precision variant of the double precision lineTo() method on the base LinePath class.

Parameters:

x - the specified X coordinate

y - the specified Y coordinate

See Also:

lineTo(float, float, int)

getPathIterator

public LinePath.PathIterator getPathIterator()

The iterator for this class is not multi-threaded safe, which means that the LinePath class does not guarantee that modifications to the geometry of this LinePath object do not affect any iterations of that geometry that are already in process.

closePath

public final void closePath()

Closes the current subpath by drawing a straight line back to the coordinates of the last moveTo. If the path is already closed then this method has no effect.

getWindingRule

public final int getWindingRule()

Returns the fill style winding rule.

Returns:

an integer representing the current winding rule.

See Also:

WIND_EVEN_ODD, WIND_NON_ZERO, setWindingRule(int)

setWindingRule

public final void setWindingRule(int rule)

Sets the winding rule for this path to the specified value.

Parameters:

rule - an integer representing the specified winding rule

Throws:

IllegalArgumentException - if rule is not either WIND_EVEN_ODD or WIND_NON_ZERO

See Also:

getWindingRule()

reset

public final void reset()

Resets the path to empty. The append position is set back to the beginning of the path and all coordinates and point types are forgotten.

createStrokedPath

public static LinePath createStrokedPath(LinePath src,
                                         float weight,
                                         int caps,
                                         int join)

createStrokedPath

public static LinePath createStrokedPath(LinePath src,
                                         float weight,
                                         int caps,
                                         int join,
                                         float miterlimit)

createStrokedPath

public static LinePath createStrokedPath(LinePath src,
                                         float weight,
                                         int caps,
                                         int join,
                                         float miterlimit,
                                         PMatrix2D transform)

Constructs a solid LinePath with the specified attributes.

Parameters:

src - the original path to be stroked

weight - the weight of the stroked path

caps - the decoration of the ends of the segments in the path

join - the decoration applied where path segments meet

miterlimit -

transform -

copyOf

public static float[] copyOf(float[] source,
                             int length)

copyOf

public static byte[] copyOf(byte[] source,
                            int length)

copyOf

public static int[] copyOf(int[] source,
                           int length)

isqrt

public static int isqrt(int x)

lsqrt

public static long lsqrt(long x)

hypot

public static double hypot(double x,
                           double y)

hypot

public static int hypot(int x,
                        int y)

hypot

public static long hypot(long x,
                         long y)