Package com.luciad.view.gxy

Class ALcdGXYPen

java.lang.Object
com.luciad.view.gxy.ALcdGXYPen
All Implemented Interfaces:
ILcdCloneable, ILcdGXYPen, Serializable, Cloneable
Direct Known Subclasses:
TLcdGeodeticPen, TLcdGridPen, TLcdGXYPen, TLcdProjectionPen
public abstract class ALcdGXYPen extends Object implements ILcdGXYPen, ILcdCloneable
Provides default implementations for some of the ILcdGXYPen methods. It also provides extra functionality which is described below.
See create(com.luciad.model.ILcdModelReference) for default factory methods.

An ALcdGXYPen allows to draw curves adaptively. Related methods are:

Extra line drawing methods are added as well:

An ALcdGXYPen provides additional methods to use and/or manipulate the internal path:

Three extra methods are added related to picking objects:

An ALcdGXYPen also provides additional methods to draw hot points:

Finally, several methods are provided which are only approximate but fast implementations of some of the methods of the ILcdGXYPen interface. This so-called "Cartesian mode" involves drawing straight lines, planar arcs, etc. Related methods are:

This class is subject to change.

See Also:

  • Field Details

    • fLastViewPoint

      protected transient TLcdXYPoint fLastViewPoint
      the view coordinates of the current position

    • fLastWorldPoint

      protected transient TLcdXYPoint fLastWorldPoint
      the world coordinates of the current position

    • fLastModelPoint

      protected transient TLcdXYZPoint fLastModelPoint
      the model coordinates of the current position

    • fValidMove

      protected transient boolean fValidMove
      Indicates whether the most recent attempt to move the current position was valid, that is to say whether the current position has valid model and world coordinates. This may or may not be the case when the current position is outside the valid area of the transformation between model and world coordinates.

    • fAccumulatedAWTPath

      protected transient ILcdAWTPath fAccumulatedAWTPath
      an ILcdAWTPath used to accumulate a path

    • fHotPointColor

      protected Color fHotPointColor
      the current color of hot points

    • fHotPointSize

      protected int fHotPointSize
      the current size of hot points in screen pixels

    • fHotPointShape

      protected int fHotPointShape
      the hot point shape type
      See Also:

    • END_ARROW_TYPE

      public static final int END_ARROW_TYPE
      constant representing an arrow at the end of the line
      See Also:

    • MIDDLE_TO_END_ARROW_TYPE

      public static final int MIDDLE_TO_END_ARROW_TYPE
      constant representing an arrow in the middle of the line pointing to the end of the line
      See Also:

    • MIDDLE_TO_BEGIN_ARROW_TYPE

      public static final int MIDDLE_TO_BEGIN_ARROW_TYPE
      constant representing an arrow in the middle of the line pointing to the start of the line
      See Also:

    • MIDDLE_BOTH_ARROW_TYPE

      public static final int MIDDLE_BOTH_ARROW_TYPE
      constant representing an arrow in the middle of the line pointing to both the start and the end of the line
      See Also:

    • BEGIN_ARROW_TYPE

      public static final int BEGIN_ARROW_TYPE
      constant representing an arrow at the start of the line
      See Also:

    • END_AND_BEGIN_ARROW_TYPE

      public static final int END_AND_BEGIN_ARROW_TYPE
      constant representing an arrow at both end points of the line
      See Also:

  • Constructor Details

    • ALcdGXYPen

      public ALcdGXYPen()
      Default constructor.

    • ALcdGXYPen

      public ALcdGXYPen(ALcdGXYPen aGXYPen)
      Copy constructor.
      Parameters:
      aGXYPen - the ALcdGXYPen to be copied

  • Method Details

    • create

      public static ALcdGXYPen create(ILcdModelReference aModelReference)
      Creates a pen that suits the given model reference and gives fast rendering results.
      Parameters:
      aModelReference - the model reference that the pen should work with. Never null.
      Since:
      2017.1
      See Also:

    • create

      public static ALcdGXYPen create(ILcdModelReference aModelReference, ALcdGXYPen.Quality aQuality)
      Creates a pen that suits the given model reference and using the given rendering quality.
      Parameters:
      aModelReference - the model reference that the pen should work with. Never null.
      aQuality - the rendering quality to use. Never null.
      Since:
      2017.1

    • getX

      public final int getX()
      Description copied from interface: ILcdGXYPen
      Gets the AWT x coordinate of the current position of this ILcdGXYPen.
      Specified by:
      getX in interface ILcdGXYPen
      Returns:
      the AWT x coordinate of the current position of this ILcdGXYPen

    • getY

      public final int getY()
      Description copied from interface: ILcdGXYPen
      Gets the AWT y coordinate of the current position of this ILcdGXYPen.
      Specified by:
      getY in interface ILcdGXYPen
      Returns:
      the AWT y coordinate of the current position of this ILcdGXYPen

    • getXAsDouble

      public final double getXAsDouble()
      Description copied from interface: ILcdGXYPen
      Gets the AWT x coordinate of the current position of this ILcdGXYPen.
      Specified by:
      getXAsDouble in interface ILcdGXYPen
      Returns:
      the AWT x coordinate of the current position of this ILcdGXYPen

    • getYAsDouble

      public final double getYAsDouble()
      Description copied from interface: ILcdGXYPen
      Gets the AWT y coordinate of the current position of this ILcdGXYPen.
      Specified by:
      getYAsDouble in interface ILcdGXYPen
      Returns:
      the AWT y coordinate of the current position of this ILcdGXYPen

    • moveTo

      public final void moveTo(ILcdPoint aPoint, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Moves the current position by setting its model coordinates to the given model point. The world and AWT coordinates of the current position are updated by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.

      Setting the current position is only required - and should therefore only be used - to define the start point of a line. This is necessary in combination with one of the drawLineTo, drawHorizontalLineTo, or drawVerticalLineTo methods or in case one adds a line to an empty (sub)path with one of the appendLineTo or accumulateLineTo methods.

      Note that this method does not create a line break.

      Specified by:
      moveTo in interface ILcdGXYPen
      Parameters:
      aPoint - the model point to which the current position is moved
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Throws:
      TLcdOutOfBoundsException - If the given point is outside the valid area of the given ILcdModelXYWorldTransformation.

    • moveTo

      public final void moveTo(ILcdPoint aPoint, ILcdModelXYWorldTransformation aModelXYWorldTransformation) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Moves the current position by setting its model coordinates to the given model point. The world coordinates of the current position are updated by means of the given ILcdModelXYWorldTransformation.

      Setting the current position is only required - and should therefore only be used - to define the start point of a line. This is necessary in combination with one of the drawLineTo, drawHorizontalLineTo, or drawVerticalLineTo methods or in case one adds a line to an empty (sub)path with one of the appendLineTo or accumulateLineTo methods.

      Note that this method does not create a line break.

      Specified by:
      moveTo in interface ILcdGXYPen
      Parameters:
      aPoint - the model point to which the current position is moved
      aModelXYWorldTransformation - the transformation between model and world coordinates
      Throws:
      TLcdOutOfBoundsException - If the given point is outside the valid area of the given ILcdModelXYWorldTransformation.

    • moveTo

      public final void moveTo(double aX, double aY, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Moves the current position by setting its AWT coordinates to the given AWT point. The world and model coordinates of the current position are updated by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.

      Setting the current position is only required - and should therefore only be used - to define the start point of a line. This is necessary in combination with one of the drawLineTo, drawHorizontalLineTo, or drawVerticalLineTo methods or in case one adds a line to an empty (sub)path with one of the appendLineTo or accumulateLineTo methods.

      Note that this method does not create a line break.

      Specified by:
      moveTo in interface ILcdGXYPen
      Parameters:
      aX - the x coordinate of the AWT point to which the current position is moved
      aY - the y coordinate of the AWT point to which the current position is moved
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Throws:
      TLcdOutOfBoundsException - If the given point is outside the valid area of the given ILcdModelXYWorldTransformation.

    • translateOf

      public void translateOf(double aDeltaX, double aDeltaY, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Translates the AWT coordinates of the current position. The world and model coordinates of the current position are updated by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.

      Setting the current position is only required - and should therefore only be used - to define the start point of a line. This is necessary in combination with one of the drawLineTo, drawHorizontalLineTo, or drawVerticalLineTo methods or in case one adds a line to an empty (sub)path with one of the appendLineTo or accumulateLineTo methods.

      Note that this method does not create a line break.

      Specified by:
      translateOf in interface ILcdGXYPen
      Parameters:
      aDeltaX - the amount by which the AWT x coordinate of the current position is translated
      aDeltaY - the amount by which the AWT y coordinate of the current position is translated
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Throws:
      TLcdOutOfBoundsException - If the translated point is outside the valid area of the given ILcdModelXYWorldTransformation

    • resetPosition

      public void resetPosition()
      Description copied from interface: ILcdGXYPen
      Makes the current position undefined so that it is not involved in the next drawing or append/accumulate operation.
      Specified by:
      resetPosition in interface ILcdGXYPen

    • getMinRecursionDepth

      public int getMinRecursionDepth()
      Returns the current minimum recursion depth value of the adaptive drawing algorithm.
      Returns:
      the current minimum recursion depth value of the adaptive drawing algorithm
      See Also:

    • setMinRecursionDepth

      public void setMinRecursionDepth(int aMinRecursionDepth)
      Sets the minimum recursion depth of the adaptive drawing algorithm. Its value should not be larger than the maximum recursion depth. The default is 0.
      Parameters:
      aMinRecursionDepth - the minimum recursion depth
      See Also:

    • getMaxRecursionDepth

      public int getMaxRecursionDepth()
      Returns the current maximum recursion depth value of the adaptive drawing algorithm.
      Returns:
      the current maximum recursion depth value of the adaptive drawing algorithm
      See Also:

    • setMaxRecursionDepth

      public void setMaxRecursionDepth(int aMaxRecursionDepth)
      Sets the maximum recursion depth of the adaptive drawing algorithm. Its value should not be smaller than the minimum recursion depth. The default is 7.
      Parameters:
      aMaxRecursionDepth - the maximum recursion depth
      See Also:

    • getViewDistanceThreshold

      public double getViewDistanceThreshold()
      Returns the current threshold on the distance between two consecutive points (view coordinates) of the polyline approximation. This threshold value is used as a stopcriterion by the adaptive drawing algorithm in case the polyline approximation is added to an ILcdAWTPath.
      Returns:
      the current threshold value on the distance between two consecutive points (view coordinates) of the polyline approximation.
      See Also:

    • setViewDistanceThreshold

      public void setViewDistanceThreshold(double aViewDistanceThreshold)
      Sets the threshold on the distance between two consecutive points (view coordinates) of the polyline approximation. This threshold value is used as a stopcriterion by the adaptive drawing algorithm in case the polyline approximation is added to an ILcdAWTPath. The default is 6 pixels.
      Parameters:
      aViewDistanceThreshold - the threshold on the distance to be used by the adaptive drawing algorithm
      See Also:

    • getWorldDistanceThreshold

      public double getWorldDistanceThreshold()
      Returns the current threshold on the distance between two consecutive points (in world coordinates) of the polyline approximation. This threshold value is used as a stopcriterion by the adaptive drawing algorithm in case the polyline approximation is added to an ILcdGeneralPath.
      Returns:
      the current threshold value on the distance between two consecutive points (world coordinates) of the polyline approximation.
      See Also:

    • setWorldDistanceThreshold

      public void setWorldDistanceThreshold(double aWorldDistanceThreshold)
      Sets the threshold on the distance between two consecutive points (in world coordinates) of the polyline approximation. This threshold value is used as a stopcriterion by the adaptive drawing algorithm in case the polyline approximation is added to an ILcdGeneralPath. The default is 1000.
      Parameters:
      aWorldDistanceThreshold - the threshold on the world distance to be used by the adaptive drawing algorithm
      See Also:

    • getAngleThreshold

      public double getAngleThreshold()
      Returns the current angle threshold. This threshold is used as a stopcriterion by the adaptive drawing algorithm in case the polyline approximation is added to an ILcdAWTPath or an ILcdGeneralPath. The angle corresponding to this threshold measures how much two consecutive line segments of the polyline approximation deviate from being parallel.
      Returns:
      the current angle threshold (expressed in degrees) used by the adaptive drawing algorithm
      See Also:

    • setAngleThreshold

      public void setAngleThreshold(double aAngleThreshold)
      Sets the angle threshold. This threshold value is used as a stopcriterion by the adaptive drawing algorithm in case the polyline approximation is added to an ILcdAWTPath or an ILcdGeneralPath. Its value should be between 0 and 90 degrees. The angle corresponding to this threshold measures how much two consecutive line segments of the polyline approximation deviate from being parallel. The default is 5 degrees.
      Parameters:
      aAngleThreshold - the threshold on the angle (expressed in degrees) to be used by the adaptive drawing algorithm
      Throws:
      IllegalArgumentException - If the given angle threshold is outside the valid range [0,90] degrees.
      See Also:

    • drawLineTo

      public void drawLineTo(ILcdPoint aPoint, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Draws a line from the current position to the given model point onto the given Graphics. The given model coordinates of the end point of the line are transformed to AWT coordinates by applying the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      drawLineTo in interface ILcdGXYPen
      Parameters:
      aPoint - the end point of the line (specified in model coordinates)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics onto which the line is drawn
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case the given end point of the line is outside the valid area of the transformation but this could be avoided by more advanced implementations.

    • drawHorizontalLineTo

      public void drawHorizontalLineTo(double aDeltaX, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Draws a horizontal line from the current position to the given model point onto the given Graphics. This model point is obtained by translating the model x coordinate of the current position by the given amount. The model coordinates of the end point of the line are transformed to AWT coordinates by applying the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      drawHorizontalLineTo in interface ILcdGXYPen
      Parameters:
      aDeltaX - the amount by which the model x coordinate of the current position is translated
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics on which the line is drawn
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case the given end point of the line is outside the valid area of the transformation but this could be avoided by more advanced implementations.

    • drawVerticalLineTo

      public void drawVerticalLineTo(double aDeltaY, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Draws a vertical line from the current position to the given model point onto the given Graphics. This model point is obtained by translating the model y coordinate of the current position by the given amount. The model coordinates of the end point of the line are transformed to AWT coordinates by applying the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      drawVerticalLineTo in interface ILcdGXYPen
      Parameters:
      aDeltaY - the amount by which the model y coordinate of the current position is translated
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics on which the line is drawn
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case the given end point of the line is outside the valid area of the transformation but this could be avoided by more advanced implementations.

    • drawLineTo

      public void drawLineTo(double aX, double aY, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Draws a line from the current position to the given AWT point onto the given Graphics. The given AWT coordinates of the end point of the line are transformed to model coordinates by applying the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      drawLineTo in interface ILcdGXYPen
      Parameters:
      aX - the AWT x coordinate of the point to which a line is drawn
      aY - the AWT y coordinate of the point to which a line is drawn
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics on which the line is drawn
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case the given end point of the line is outside the valid area of the transformation but this could be avoided by more advanced implementations.

    • drawLineTo

      public void drawLineTo(Point aPoint, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Draws a line from the current position to the given AWT point onto the given Graphics. The given AWT coordinates of the end point of the line are transformed to model coordinates by applying the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Parameters:
      aPoint - the point (expressed in AWT coordinates) to which a line is drawn
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics on which the line is drawn
      Throws:
      TLcdOutOfBoundsException - The current implementation does not throw a TLcdOutOfBoundsException if the end point of the line is outside the valid area of the transformation.

    • accumulateSplit

      public void accumulateSplit()
      Accumulates a line break to the internally stored path.

    • accumulateAWTPoint

      public void accumulateAWTPoint(double aX, double aY)
      Accumulates the given AWT point to the internally stored path.
      Parameters:
      aX - the x coordinate of the AWT point
      aY - the y coordinate of the AWT point

    • isAccumulatedPolylineTouched

      public boolean isAccumulatedPolylineTouched(double aX, double aY, int aSensitivity)
      Checks whether the given AWT point touches the internally stored path.
      Parameters:
      aX - the x coordinate of the AWT point
      aY - the y coordinate of the AWT point
      aSensitivity - the allowed tolerance expressed in pixels
      Returns:
      boolean indicating whether the given AWT point touches the internally stored path

    • calculateAccumulatedAWTBounds

      public void calculateAccumulatedAWTBounds(ILcd2DEditableBounds aBoundsSFCT) throws TLcdNoBoundsException
      Calculates the bounding box of the internally stored path. The size of the hot points is taken into account.
      Parameters:
      aBoundsSFCT - the bounding box of the internally stored path on completion of the method
      Throws:
      TLcdNoBoundsException - If the object does not have bounds.

    • emptyAccumulated

      public void emptyAccumulated()
      Description copied from interface: ILcdGXYPen
      Clears the accumulated internal path.
      Specified by:
      emptyAccumulated in interface ILcdGXYPen
      See Also:

    • accumulateLineTo

      public void accumulateLineTo(ILcdPoint aPoint, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Accumulates a line from the current position to the given model point to the internally stored path. The given model coordinates of the end point of the line are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.

      Note that nothing is painted yet.

      Specified by:
      accumulateLineTo in interface ILcdGXYPen
      Parameters:
      aPoint - the end point (specified in model coordinates) of the line
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case the given model point is outside the valid area of the transformation but this could be avoided by more advanced implementations.
      See Also:

    • accumulateHorizontalLineTo

      public void accumulateHorizontalLineTo(double aDeltaX, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Accumulates a horizontal line starting from the current position to the internally stored path. The model coordinates of the end point of this line are obtained by translating the model x coordinate of the current position by the given amount. The model coordinates of the end point of the line are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.

      Note that nothing is painted yet.

      Specified by:
      accumulateHorizontalLineTo in interface ILcdGXYPen
      Parameters:
      aDeltaX - the amount by which the model x coordinate of the current position is translated
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case the end point of the line is outside the valid area of the transformation but this could be avoided by more advanced implementations.

    • accumulateVerticalLineTo

      public void accumulateVerticalLineTo(double aDeltaY, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Accumulates a vertical line starting from the current position to the internally stored path. The model coordinates of the end point of this line are obtained by translating the model y coordinate of the current position by the given amount. The model coordinates of the end point of the line are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.

      Note that nothing is painted yet.

      Specified by:
      accumulateVerticalLineTo in interface ILcdGXYPen
      Parameters:
      aDeltaY - the amount by which the model y coordinate of the current position is translated
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case the end point of the line is outside the valid area of the transformation but this could be avoided by more advanced implementations.

    • accumulatePointList

      public void accumulatePointList(ILcdPointList aPointList, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Accumulates a polyline to the internally stored path. The polyline is given as an ILcdPointList of which the points are specified in model coordinates. These model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.

      Note that nothing is painted yet.

      Specified by:
      accumulatePointList in interface ILcdGXYPen
      Parameters:
      aPointList - the point list (specified in model coordinates)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case one of the points of the polyline is outside the valid area of the transformation but this could be avoided by more advanced implementations.
      See Also:

    • accumulateArc

      public void accumulateArc(ILcdPoint aCenter, double aA, double aB, double aRotAngle, double aStartAngle, double aArcAngle, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Accumulates a polyline approximation of the given arc to the internally stored path. The arc is specified as a segment of the circumference of an ellipse. The given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation are used to transform model coordinates to AWT coordinates.

      Note that nothing is painted yet.

      Specified by:
      accumulateArc in interface ILcdGXYPen
      Parameters:
      aCenter - the center of the ellipse (specified in model coordinates)
      aA - the semi-major axis of the ellipse
      aB - the semi-minor axis of the ellipse
      aRotAngle - the rotation angle of the major axis of the ellipse (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aStartAngle - the start angle of the arc (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aArcAngle - the span of the arc (expressed in degrees), increasing counterclockwise from the start angle
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case the center of the ellipse and/or one of the points of the polyline approximation to the arc are outside the valid area of the transformation but this could be avoided by more advanced implementations.
      See Also:

    • drawAccumulatedPolyline

      public void drawAccumulatedPolyline(Graphics aGraphics, boolean aEmptyAccumulated)
      Description copied from interface: ILcdGXYPen
      Draws the points stored in the internal path as a polyline. If aEmptyAccumulated is true, the internal path is cleared after the drawing operation.
      Specified by:
      drawAccumulatedPolyline in interface ILcdGXYPen
      Parameters:
      aGraphics - the Graphics onto which the polyline is drawn
      aEmptyAccumulated - boolean indicating whether the internal path should be cleared

    • drawAccumulatedPolygon

      public void drawAccumulatedPolygon(Graphics aGraphics, boolean aEmptyAccumulated)
      Description copied from interface: ILcdGXYPen
      Draws the points stored in the internal path as a polygon. If aEmptyAccumulated is true, the internal path is cleared after the drawing operation.
      Specified by:
      drawAccumulatedPolygon in interface ILcdGXYPen
      Parameters:
      aGraphics - the Graphics onto which the polyline is drawn
      aEmptyAccumulated - boolean indicating whether the internal path should be cleared

    • fillAccumulatedPolygon

      public void fillAccumulatedPolygon(Graphics aGraphics, boolean aEmptyAccumulated)
      Description copied from interface: ILcdGXYPen
      Draws the points stored in the internal path as a filled polygon. If aEmptyAccumulated is true, the internal path is cleared after the drawing operation.
      Specified by:
      fillAccumulatedPolygon in interface ILcdGXYPen
      Parameters:
      aGraphics - the Graphics onto which the polyline is drawn
      aEmptyAccumulated - boolean indicating whether the internal path should be cleared

    • appendGeneralPath

      public void appendGeneralPath(ILcdGeneralPath aGeneralPath, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, ILcdAWTPath aAWTPathSFCT)
      Description copied from interface: ILcdGXYPen
      Appends the given ILcdGeneralPath to the given ILcdAWTPath. The world coordinates of the points stored in the given ILcdGeneralPath are transformed to AWT coordinates by means of the given ILcdGXYViewXYWorldTransformation. If consecutive world points map to the same AWT point, the AWT path may be simplified in order to reduce memory requirements and improve the performance of further operations.
      Specified by:
      appendGeneralPath in interface ILcdGXYPen
      Parameters:
      aGeneralPath - the general path which is appended to the given AWT path
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aAWTPathSFCT - the AWT path to which the given general path is appended

    • drawLine

      @Deprecated public void drawLine(int aFromX, int aFromY, int aToX, int aToY, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Deprecated.
      This method is deprecated to support HiDPI displays, which requires additional coordinate precision to accurately apply dpi scaling. The recommendation is to use drawLine(ILcdPoint, ILcdPoint, ILcdModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation, Graphics), which relies on ILcdPoint with double-precision coordinates.
      Draws a line between the two given AWT view points onto the given Graphics. The AWT coordinates of the end points of the line are transformed to model coordinates by applying the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Parameters:
      aFromX - the AWT x-coordinate of the start point of the line
      aFromY - the AWT y-coordinate of the start point of the line
      aToX - the AWT x-coordinate of the end point of the line
      aToY - the AWT y-coordinate of the end point of the line
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics onto which the line is drawn
      Throws:
      TLcdOutOfBoundsException - The current implementation does not throw a TLcdOutOfBoundsException if one of the end points of the line is outside the valid area of the transformation.

    • drawLine

      public void drawLine(ILcdPoint aPoint1, ILcdPoint aPoint2, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Draws a line between the two given model points onto the given Graphics. The model coordinates of the end points of the line are transformed to AWT coordinates by applying the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      drawLine in interface ILcdGXYPen
      Parameters:
      aPoint1 - the start point of the line (specified in model coordinates)
      aPoint2 - the end point of the line (specified in model coordinates)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics onto which the line is drawn
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case one of the given end points of the line is outside the valid area of the transformation but this could be avoided by more advanced implementations.

    • drawLineWithArrow

      public void drawLineWithArrow(ILcdPoint aPoint1, ILcdPoint aPoint2, int aLength, double aAngle, int aArrowType, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Draws a line between the two given model points onto the given Graphics with arrows at either end or in the middle. The model coordinates of the end points of the line are transformed to AWT coordinates by applying the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Parameters:
      aPoint1 - the start point of the line, expressed in model coordinates
      aPoint2 - the end point of the line, expressed in model coordinates
      aLength - length of the arrowhead, expressed in pixels
      aAngle - angle of the arrowhead, expressed in degrees
      aArrowType - arrow type (END_ARROW_TYPE, MIDDLE_TO_END_ARROW_TYPE, MIDDLE_TO_BEGIN_ARROW_TYPE, MIDDLE_BOTH_ARROW_TYPE, BEGIN_ARROW_TYPE, END_AND_BEGIN_ARROW_TYPE)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics onto which the line is drawn
      Throws:
      TLcdOutOfBoundsException - The current implementation does not throw a TLcdOutOfBoundsException if one of the end points of the line is outside the valid area of the transformation.

    • drawPolyline

      public void drawPolyline(ILcdPointList aPointList, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Draws a polyline onto the given Graphics. The polyline is given as an ILcdPointList of which the points are specified in model coordinates. These model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      drawPolyline in interface ILcdGXYPen
      Parameters:
      aPointList - the point list (specified in model coordinates)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics onto which the polyline is drawn
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case one of the points of the polyline is outside the valid area of the transformation but this could be avoided by more advanced implementations.

    • drawPolygon

      public void drawPolygon(ILcdPointList aPointList, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Draws a polygon onto the given Graphics. The polygon is given as an ILcdPointList of which the points are specified in model coordinates. These model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      drawPolygon in interface ILcdGXYPen
      Parameters:
      aPointList - the point list (specified in model coordinates)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics onto which the polygon is drawn
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case one of the points of the polygon is outside the valid area of the transformation but this could be avoided by more advanced implementations.

    • fillPolygon

      public void fillPolygon(ILcdPointList aPointList, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Draws a filled polygon onto the given Graphics. The polygon is given as an ILcdPointList of which the points are specified in model coordinates. These model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      fillPolygon in interface ILcdGXYPen
      Parameters:
      aPointList - the point list (specified in model coordinates)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics onto which the polygon is drawn
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case one of the points of the polygon is outside the valid area of the transformation but this could be avoided by more advanced implementations.

    • drawArc

      public void drawArc(ILcdPoint aCenter, double aA, double aB, double aRotAngle, double aStartAngle, double aArcAngle, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Draws an arc onto the given Graphics. The arc is specified as a segment of the circumference of an ellipse. The given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation are used to transform model coordinates to AWT coordinates.
      Specified by:
      drawArc in interface ILcdGXYPen
      Parameters:
      aCenter - the center of the ellipse (specified in model coordinates)
      aA - the semi-major axis of the ellipse
      aB - the semi-minor axis of the ellipse
      aRotAngle - the rotation angle of the major axis of the ellipse (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aStartAngle - the start angle of the arc (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aArcAngle - the span of the arc (expressed in degrees), increasing counterclockwise from the start angle
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics onto which the arc is drawn
      Throws:
      TLcdOutOfBoundsException - Some implementations may throw an exception in case the center of the ellipse and/or one of the points of the arc is outside the valid area of the transformation but this could be avoided by more advanced implementations.
      See Also:

    • lineBoundsSFCT

      public void lineBoundsSFCT(ILcdPoint aPoint1, ILcdPoint aPoint2, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, ILcd2DEditableBounds aBoundsSFCT) throws TLcdNoBoundsException
      Description copied from interface: ILcdGXYPen
      Calculates the bounding box in AWT coordinates of the line between the two given model points. The model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      lineBoundsSFCT in interface ILcdGXYPen
      Parameters:
      aPoint1 - the start point of the line (specified in model coordinates)
      aPoint2 - the end point of the line (specified in model coordinates)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aBoundsSFCT - the bounding box in AWT coordinates of the given line on completion of the method
      Throws:
      TLcdNoBoundsException - If the line is outside the valid area of the given ILcdModelXYWorldTransformation.

    • polylineBoundsSFCT

      public void polylineBoundsSFCT(ILcdPointList aPointList, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, ILcd2DEditableBounds aBoundsSFCT) throws TLcdNoBoundsException
      Description copied from interface: ILcdGXYPen
      Calculates the bounding box in AWT coordinates of the given polyline. The polyline is given as an ILcdPointList of which the points are specified in model coordinates. These model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      polylineBoundsSFCT in interface ILcdGXYPen
      Parameters:
      aPointList - the point list (specified in model coordinates)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aBoundsSFCT - the bounding box in AWT coordinates of the given polyline on completion of the method
      Throws:
      TLcdNoBoundsException - If the polyline is outside the valid area of the given ILcdModelXYWorldTransformation.

    • arcBoundsSFCT

      public void arcBoundsSFCT(ILcdPoint aCenter, double aA, double aB, double aRotAngle, double aStartAngle, double aArcAngle, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, ILcd2DEditableBounds aBoundsSFCT) throws TLcdNoBoundsException
      Description copied from interface: ILcdGXYPen
      Calculates the bounding box in AWT coordinates of the given arc. The arc is specified as a segment of the circumference of an ellipse. The given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation are used to transform model coordinates to AWT coordinates.
      Specified by:
      arcBoundsSFCT in interface ILcdGXYPen
      Parameters:
      aCenter - the center of the ellipse (specified in model coordinates)
      aA - the semi-major axis of the ellipse
      aB - the semi-minor axis of the ellipse
      aRotAngle - the rotation angle of the major axis of the ellipse (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aStartAngle - the start angle of the arc (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aArcAngle - the span of the arc (expressed in degrees), increasing counterclockwise from the start angle
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aBoundsSFCT - the bounding box in AWT coordinates of the given arc on completion of the method
      Throws:
      TLcdNoBoundsException - If the given arc is outside the valid area of the given ILcdModelXYWorldTransformation
      See Also:

    • isTouched

      public boolean isTouched(ILcdPoint aPoint, double aX, double aY, int aSensitivity, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation)
      Description copied from interface: ILcdGXYPen
      Tests if the given model point is touched by clicking at the given AWT point. This is the case when the given AWT point is within a square of size aSensitivity centered on the AWT coordinates of the given model point. These AWT coordinates are obtained from the given model coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      isTouched in interface ILcdGXYPen
      Parameters:
      aPoint - the model point
      aX - the x-coordinate of the AWT point
      aY - the y-coordinate of the AWT point
      aSensitivity - the allowed tolerance (expressed in pixels)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Returns:
      a boolean indicating whether the given model point is touched by the given AWT point

    • isTouched

      public boolean isTouched(double aTargetX, double aTargetY, double aX, double aY, int aSensitivity)
      Tests if the given target AWT point is touched by clicking at the given AWT point. This is the case when the given AWT point is within a square with sides of length twice the aSensitivity and which is centered on the target AWT point.
      Parameters:
      aTargetX - the x-coordinate of the target AWT point
      aTargetY - the y-coordinate of the target AWT point
      aX - the x-coordinate of the AWT point
      aY - the y-coordinate of the AWT point
      aSensitivity - the allowed tolerance (expressed in pixels)
      Returns:
      If the given target AWT point is touched by clicking at the given AWT point.

    • isLineTouched

      public boolean isLineTouched(ILcdPoint aPoint1, ILcdPoint aPoint2, double aX, double aY, boolean aIncludeHotPoint, int aSensitivity, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation)
      Description copied from interface: ILcdGXYPen
      Tests if a given line is touched by clicking at the given AWT point. The line is specified by means of two given model points. Model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation. The user can specify the allowed tolerance (aSensitivity) and whether the test should include the hot points (aIncludeHotPoint).
      Specified by:
      isLineTouched in interface ILcdGXYPen
      Parameters:
      aPoint1 - the start point of the line (specified in model coordinates)
      aPoint2 - the end point of the line (specified in model coordinates)
      aX - the x-coordinate of the AWT point
      aY - the y-coordinate of the AWT point
      aIncludeHotPoint - boolean indicating whether to include the hot points
      aSensitivity - the allowed tolerance (expressed in pixels)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Returns:
      a boolean indicating whether the given line is touched by the given AWT point

    • isHorizontalLineTouched

      public boolean isHorizontalLineTouched(ILcdPoint aPoint, double aDeltaX, double aX, double aY, boolean aIncludeHotPoint, int aSensitivity, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation)
      Description copied from interface: ILcdGXYPen
      Tests if a given horizontal line is touched by clicking at the given AWT point. The horizontal line is specified by means of a start point (specified in model coordinates) and the amount by which the x coordinate of this point should be translated to obtain the end point. Model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation. The user can specify the allowed tolerance (aSensitivity) and whether the test should include the hot points (aIncludeHotPoint).
      Specified by:
      isHorizontalLineTouched in interface ILcdGXYPen
      Parameters:
      aPoint - the start point of the line (specified in model coordinates)
      aDeltaX - the amount by which the x coordinate of the start point is translated
      aX - the x-coordinate of the AWT point
      aY - the y-coordinate of the AWT point
      aIncludeHotPoint - boolean indicating whether to include the hot points
      aSensitivity - the allowed tolerance (expressed in pixels)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Returns:
      a boolean indicating whether the given line is touched by the given AWT point

    • isVerticalLineTouched

      public boolean isVerticalLineTouched(ILcdPoint aPoint, double aDeltaY, double aX, double aY, boolean aIncludeHotPoint, int aSensitivity, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation)
      Description copied from interface: ILcdGXYPen
      Tests if a given vertical line is touched by clicking at the given AWT point. The vertical line is specified by means of a start point (specified in model coordinates) and the amount by which the y coordinate of this point should be translated to obtain the end point. Model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation. The user can specify the allowed tolerance (aSensitivity) and whether the test should include the hot points (aIncludeHotPoint).
      Specified by:
      isVerticalLineTouched in interface ILcdGXYPen
      Parameters:
      aPoint - the start point of the line (specified in model coordinates)
      aDeltaY - the amount by which the y coordinate of the start point is translated
      aX - the x-coordinate of the AWT point
      aY - the y-coordinate of the AWT point
      aIncludeHotPoint - boolean indicating whether to include the hot points
      aSensitivity - the allowed tolerance (expressed in pixels)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Returns:
      a boolean indicating whether the given line is touched by the given AWT point

    • getTouchedSegment

      public int getTouchedSegment(ILcdPointList aPointList, boolean aAsPolygon, double aX, double aY, boolean aIncludeHotPoints, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation)
      Description copied from interface: ILcdGXYPen
      Gets the index of the line segment of the given ILcdPointList which is touched by the given AWT point. If aAsPolygon equals true, the segment from the last point to the first point (the index of which equals one less than the number of points in the ILcdPointList) is taken into account as well.
      Specified by:
      getTouchedSegment in interface ILcdGXYPen
      Parameters:
      aPointList - the point list defining the line segments
      aAsPolygon - boolean indicating whether the given point list should be considered as a polygon or not (in which case it is considered as a polyline)
      aX - the x-coordinate of the AWT point
      aY - the y-coordinate of the AWT point
      aIncludeHotPoints - boolean indicating whether to include the hot points
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Returns:
      the index of the touched line segment or -1 if no segment is touched

    • isArcTouched

      public boolean isArcTouched(ILcdPoint aCenter, double aA, double aB, double aRotAngle, double aStartAngle, double aArcAngle, double aX, double aY, int aSensitivity, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation)
      Description copied from interface: ILcdGXYPen
      Tests if the given arc is touched by clicking at the given AWT point taking into account the given tolerance. The arc is specified as a segment of the circumference of an ellipse. The given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation are used to transform model coordinates to AWT coordinates.
      Specified by:
      isArcTouched in interface ILcdGXYPen
      Parameters:
      aCenter - the center of the ellipse (specified in model coordinates)
      aA - the semi-major axis of the ellipse
      aB - the semi-minor axis of the ellipse
      aRotAngle - the rotation angle of the major axis of the ellipse (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aStartAngle - the start angle of the arc (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aArcAngle - the span of the arc (expressed in degrees), increasing counterclockwise from the start angle
      aX - the x-coordinate of the AWT point
      aY - the y-coordinate of the AWT point
      aSensitivity - the allowed tolerance (expressed in pixels)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Returns:
      a boolean indicating whether the given arc is touched by the given AWT point
      See Also:

    • contains

      public boolean contains(ILcdPointList aPointList, double aX, double aY, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation)
      Description copied from interface: ILcdGXYPen
      Checks whether the given polygon encloses the given AWT point. The polygon is given as an ILcdPointList containing points specified in model coordinates. Model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      contains in interface ILcdGXYPen
      Parameters:
      aPointList - the point list defining a polygon
      aX - the x-coordinate of the AWT point
      aY - the y-coordinate of the AWT point
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Returns:
      a boolean indicating whether the given polygon encloses the given AWT point

    • AWTPathContains

      protected boolean AWTPathContains(ILcdAWTPath aAWTPath, double aX, double aY)
      Checks whether the polygon, specified as an ILcdAWTPath, encloses the given AWT point.
      Parameters:
      aAWTPath - the AWT path defining a polygon
      aX - the x-coordinate of the AWT point
      aY - the y-coordinate of the AWT point
      Returns:
      a boolean indicating whether the polygon encloses the given AWT point.

    • getHotPointColor

      public Color getHotPointColor()
      Gets the hot point color currently used by this ILcdGXYPen.
      Returns:
      the hot point color currently used by this ILcdGXYPen.
      See Also:

    • setHotPointColor

      public void setHotPointColor(Color aHotPointColor)
      Sets the hot point color. Note that this value is not taken into account when a hot point icon is set.
      Parameters:
      aHotPointColor - the hot point color to be set
      See Also:

    • setHotPointShape

      public void setHotPointShape(int aHotPointShape)
      Sets the hot point shape. Note that this value is not taken into account when a hot point icon is set.
      Specified by:
      setHotPointShape in interface ILcdGXYPen
      Parameters:
      aHotPointShape - the hot point shape to be set (ILcdGXYPen#FILLED_SQUARE, ILcdGXYPen#VERTICAL_CROSS, ILcdGXYPen#HORIZONTAL_CROSS, ILcdGXYPen#CIRCLE, ILcdGXYPen#FILLED_CIRCLE)
      See Also:

    • getHotPointShape

      public int getHotPointShape()
      Description copied from interface: ILcdGXYPen
      Gets the hot point shape currently used by this ILcdGXYPen.
      Specified by:
      getHotPointShape in interface ILcdGXYPen
      Returns:
      the hot point shape currently used by this ILcdGXYPen
      See Also:

    • setHotPointSize

      public void setHotPointSize(int aHotPointSize)
      Sets the hot point size. This size is half the width of the square representing a hot point. Note that this value is not taken into account when a hot point icon is set.
      Specified by:
      setHotPointSize in interface ILcdGXYPen
      Parameters:
      aHotPointSize - the hot point size (expressed in pixels)
      See Also:

    • getHotPointSize

      public int getHotPointSize()
      Gets the size of the shape currently representing a hot point. This size equals half the width of the square representing a hot point unless a hot point icon has been set, in which case it equals half of the maximum of the icon's width and height.
      Specified by:
      getHotPointSize in interface ILcdGXYPen
      Returns:
      the size of the shape currently representing a hot point
      See Also:

    • setHotPointIcon

      public void setHotPointIcon(ILcdIcon aIcon)
      Sets the hot point icon. If equal to null, an icon according to the values in getHotPointShape(), getHotPointSize() and getHotPointColor() is rendered. The default value is null.
      Parameters:
      aIcon - the icon to be used to render hot points
      See Also:

    • getHotPointIcon

      public ILcdIcon getHotPointIcon()
      Gets the hot point icon currently used by this ILcdGXYPen. If equal to null, an icon according to the values in getHotPointShape(), getHotPointSize() and getHotPointColor() is rendered.
      Returns:
      the hot point icon
      See Also:

    • drawHotPoint

      public void drawHotPoint(ILcdPoint aPoint, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Description copied from interface: ILcdGXYPen
      Draws a hot point at the given model point. The model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Specified by:
      drawHotPoint in interface ILcdGXYPen
      Parameters:
      aPoint - the position at which the hot point is drawn (specified in model coordinates)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics onto which the hot point is drawn
      Throws:
      TLcdOutOfBoundsException - If the given model point is outside the valid area of the given ILcdModelXYWorldTransformation.

    • drawHotPoint

      public void drawHotPoint(ILcdPoint aPoint, String aReference, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Draws a hot point at the given model point and a string next to this point. The model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation.
      Parameters:
      aPoint - the position at which the hot point is drawn (expressed in model coordinates)
      aReference - the string which has to be drawn next to the given model point
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics onto which the hot point and the string are drawn
      Throws:
      TLcdOutOfBoundsException - If the given model point is outside the valid area of the given ILcdModelXYWorldTransformation.

    • drawHotPoint

      @Deprecated public void drawHotPoint(Point aPoint, Graphics aGraphics)
      Deprecated.
      This method is deprecated to support HiDPI displays, which requires additional coordinate precision to accurately apply dpi scaling. The recommendation is to use drawHotPoint(double, double, Graphics), which uses double-precision coordinates.
      Draws a hot point at the given AWT point. This implementation checks whether a hot point icon has been set. If so, it renders the icon. Otherwise, an icon according to the values in getHotPointShape(), getHotPointSize() and getHotPointColor() is rendered.
      Parameters:
      aPoint - the position at which the hot point is drawn (expressed in AWT coordinates)
      aGraphics - the Graphics onto which the hot point is drawn

    • drawHotPoint

      public void drawHotPoint(double aX, double aY, Graphics aGraphics)
      Draws a hot point at the given AWT point. This implementation checks whether a hot point icon has been set. If so, it renders the icon. Otherwise, an icon according to the values in getHotPointShape(), getHotPointSize() and getHotPointColor() is rendered.
      Specified by:
      drawHotPoint in interface ILcdGXYPen
      Parameters:
      aX - the AWT x coordinate of the position at which the hot point is drawn
      aY - the AWT y coordinate of the position at which the hot point is drawn
      aGraphics - the Graphics onto which the hot point is drawn

    • drawHotPoint

      public void drawHotPoint(double aX, double aY, String aReference, Graphics aGraphics)
      Draws a hot point at the given AWT point and a string next to it. This implementation checks whether a hot point icon has been set. If so, it renders the icon. Otherwise, an icon according to the values in getHotPointShape(), getHotPointSize() and getHotPointColor() is rendered.
      Parameters:
      aX - the AWT x coordinate of the position at which the hot point is drawn
      aY - the AWT y coordinate of the position at which the hot point is drawn
      aReference - the string which has to be drawn next to the hot point
      aGraphics - the Graphics onto which the hot point and the string are drawn

    • clone

      public Object clone()
      Description copied from interface: ILcdCloneable

      Makes Object.clone() public.

      When for example extending from java.lang.Object, it can be implemented like this: 
      
 public Object clone() {
   try {
     return super.clone();
   } catch ( CloneNotSupportedException e ) {
     // Cannot happen: extends from Object and implements Cloneable (see also Object.clone)
     throw new RuntimeException( e );
   }
 }
      Specified by:
      clone in interface ILcdCloneable
      Specified by:
      clone in interface ILcdGXYPen
      Overrides:
      clone in class Object
      See Also:

    • appendCartesianLineTo

      protected void appendCartesianLineTo(ILcdPoint aPoint, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, ILcdAWTPath aAWTPathSFCT)
      Appends a straight line between the AWT coordinates of the current position and the given model point to the given ILcdAWTPath. The given model coordinates of the end point of the line are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation. If this model point is outside the valid area of the given ILcdModelXYWorldTransformation or if the line crosses a border of the projection area, a line break is appended to the given ILcdAWTPath.
      Parameters:
      aPoint - the end point (expressed in model coordinates) of the line
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aAWTPathSFCT - the AWT path to which the line is appended on return of the method

    • appendCartesianPolyline

      protected void appendCartesianPolyline(ILcdPointList aPointList, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, ILcdAWTPath aAWTPathSFCT)
      Appends a polyline to the given ILcdAWTPath. A straight line is appended between the AWT coordinates of the points of the polyline. The polyline is given as an ILcdPointList of which the points are expressed in model coordinates. These model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation. If a model point is outside the valid area of the given ILcdModelXYWorldTransformation or a line segment crosses the border of the projection area, a line break is appended to the given ILcdAWTPath so that the polyline is split.
      Parameters:
      aPointList - the point list, expressed in model coordinates
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aAWTPathSFCT - the AWT path to which the given point list is appended on return of the method

    • appendCartesianArc

      protected void appendCartesianArc(ILcdPoint aCenter, double aA, double aB, double aRotAngle, double aStartAngle, double aArcAngle, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, ILcdAWTPath aAWTPathSFCT)
      Appends a polyline approximation of the given arc to the given ILcdAWTPath. The arc is specified as a segment of the circumference of an ellipse. The given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation are used to transform model coordinates to AWT coordinates. If a point is outside the valid area of the given ILcdModelXYWorldTransformation, a line break is appended to the given ILcdAWTPath so that the polyline is split.
      Parameters:
      aCenter - the center of the ellipse, expressed in model coordinates
      aA - the semi-major axis of the ellipse
      aB - the semi-minor axis of the ellipse
      aRotAngle - the rotation angle of the major axis of the ellipse, expressed in degrees. Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aStartAngle - the start angle of the arc (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aArcAngle - the span of the arc (expressed in degrees), increasing counterclockwise from the start angle
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aAWTPathSFCT - the AWT path to which the polyline approximation of the given arc is appended
      See Also:

    • appendCartesianLineTo

      protected void appendCartesianLineTo(ILcdPoint aPoint, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGeneralPath aGeneralPathSFCT)
      Appends a straight line between the world coordinates of the current position and the given model point to the given ILcdGeneralPath. The given model coordinates of the end point of the line are transformed to world coordinates by means of the given ILcdModelXYWorldTransformation. If this point is outside the valid area of the transformation or if the line crosses a border of the projection area, a line break is appended to the given ILcdGeneralPath.
      Parameters:
      aPoint - the end point of the line, expressed in model coordinates
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGeneralPathSFCT - the general path to which the line is appended

    • appendCartesianPolyline

      protected void appendCartesianPolyline(ILcdPointList aPointList, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGeneralPath aGeneralPathSFCT)
      Appends a polyline to the given ILcdGeneralPath. A straight line is appended between the world coordinates of the points of the polyline. The polyline is given as an ILcdPointList of which the points are expressed in model coordinates. These model coordinates are transformed to world coordinates by means of the given ILcdModelXYWorldTransformation. If a model point is outside the valid area of this transformation or a line segment crosses the border of the projection area, a line break is appended to the given ILcdGeneralPath so that the polyline is split.
      Parameters:
      aPointList - the point list, expressed in model coordinates
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGeneralPathSFCT - the general path to which the given point list is appended

    • appendCartesianArc

      protected void appendCartesianArc(ILcdPoint aCenter, double aA, double aB, double aRotAngle, double aStartAngle, double aArcAngle, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGeneralPath aGeneralPathSFCT)
      Appends a polyline approximation of the given arc to the given ILcdGeneralPath. The arc is specified as a segment of the circumference of an ellipse. The given ILcdModelXYWorldTransformation is used to transform model coordinates to world coordinates. If a point is outside the valid area of this transformation, a line break is appended to the given ILcdGeneralPath so that the polyline is split.
      Parameters:
      aCenter - the center of the ellipse, expressed in model coordinates
      aA - the semi-major axis of the ellipse
      aB - the semi-minor axis of the ellipse
      aRotAngle - the rotation angle of the major axis of the ellipse (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aStartAngle - the start angle of the arc (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aArcAngle - the span of the arc (expressed in degrees), increasing counterclockwise from the start angle
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGeneralPathSFCT - the general path to which the polyline approximation of the given arc is appended
      See Also:

    • drawCartesianArc

      protected void drawCartesianArc(double aCenterX, double aCenterY, double aStartX, double aStartY, double aArcAngle, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, Graphics aGraphics) throws TLcdOutOfBoundsException
      Draws a circular arc onto the given Graphics. The circular arc is specified by the center of the circle, a point on the circumference of the circle which denotes the start point of the arc and the angle spanned by the arc. The given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation are used to transform between model coordinates and AWT coordinates.
      Parameters:
      aCenterX - the AWT x coordinate of the center of the circle
      aCenterY - the AWT y coordinate of the center of the circle
      aStartX - the AWT x coordinate of the start point of the arc
      aStartY - the AWT y coordinate of the start point of the arc
      aArcAngle - the span of the arc (expressed in degrees), increasing counterclockwise from the start angle
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aGraphics - the Graphics onto which the arc is drawn
      Throws:
      TLcdOutOfBoundsException - The current implementation does not throw a TLcdOutOfBoundsException if one of the defining points of the circular arc or one of the points of the arc is outside the valid area of the transformation.

    • cartesianModelDistance

      protected double cartesianModelDistance(double aX1, double aY1, double aX2, double aY2, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation) throws TLcdOutOfBoundsException
      Calculates an approximation of the model distance between the two given points expressed in AWT coordinates. The distance is calculated after transforming the AWT coordinates to world coordinates assuming that this is a good approximation of the model distance.
      Parameters:
      aX1 - the x-coordinate of the first AWT point
      aY1 - the y-coordinate of the first AWT point
      aX2 - the x-coordinate of the second AWT point
      aY2 - the y-coordinate of the second AWT point
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Returns:
      an approximation of the distance between the two given points within the model coordinate system
      Throws:
      TLcdOutOfBoundsException - The current implementation does not throw a TLcdOutOfBoundsException.

    • isCartesianLineTouched

      protected boolean isCartesianLineTouched(ILcdPoint aPoint1, ILcdPoint aPoint2, double aXView, double aYView, boolean aIncludeHotPoint, int aSensitivity, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation)
      Tests if a given line is touched by clicking at the given AWT point. The line is specified by means of two given model points. Model coordinates are transformed to AWT coordinates by means of the given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation. The user can specify the allowed tolerance (aSensitivity) and whether the test should include the hot points (aIncludeHotPoint).
      Parameters:
      aPoint1 - the start point of the line, expressed in model coordinates
      aPoint2 - the end point of the line, expressed in model coordinates
      aXView - the x-coordinate of the AWT point
      aYView - the y-coordinate of the AWT point
      aIncludeHotPoint - boolean indicating whether to include the hot points
      aSensitivity - the allowed tolerance (expressed in pixels)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Returns:
      a boolean indicating whether the given line is touched by the given AWT point

    • isViewLineTouched

      public boolean isViewLineTouched(Point aPoint1, Point aPoint2, double aX, double aY, boolean aIncludeHotPoints, int aSensitivity)
      Tests if a given straight line is touched by clicking at the given AWT point. The straight line is defined by means of two points expressed in AWT coordinates. The user can specify the allowed tolerance (aSensitivity) and whether the test should include the hot points (aIncludeHotPoint).
      Parameters:
      aPoint1 - the start point of the line, expressed in AWT coordinates
      aPoint2 - the end point of the line, expressed in AWT coordinates
      aX - the x-coordinate of the AWT point
      aY - the y-coordinate of the AWT point
      aIncludeHotPoints - boolean indicating whether to include the hot points
      aSensitivity - the allowed tolerance (expressed in pixels)
      Returns:
      a boolean indicating whether the given line is touched by the given AWT point

    • isCartesianArcTouched

      protected boolean isCartesianArcTouched(ILcdPoint aCenter, double aA, double aB, double aRotAngle, double aStartAngle, double aArcAngle, int aViewX, int aViewY, int aSensitivity, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation)
      Tests if the given arc is touched by clicking at the given AWT point taking into account the given tolerance. The arc is specified as a segment of the circumference of an ellipse. The given ILcdModelXYWorldTransformation and ILcdGXYViewXYWorldTransformation are used to transform model coordinates to AWT coordinates.
      Parameters:
      aCenter - the center of the ellipse, expressed in model coordinates
      aA - the semi-major axis of the ellipse
      aB - the semi-minor axis of the ellipse
      aRotAngle - the rotation angle of the major axis of the ellipse (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aStartAngle - the start angle of the arc (expressed in degrees). Positive angles are measured counter-clockwise from the line at 3 o'clock.
      aArcAngle - the span of the arc (expressed in degrees), increasing counterclockwise from the start angle
      aViewX - the x-coordinate of the AWT point
      aViewY - the y-coordinate of the AWT point
      aSensitivity - the allowed tolerance (expressed in pixels)
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      Returns:
      a boolean indicating whether the given arc is touched by the given AWT point
      See Also:

    • appendCurve

      public void appendCurve(ILcdCurve aCurve, boolean aIncludingStartPoint, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, ILcdAWTPath aAWTPathSFCT)
      Appends a polyline approximation of a curve to the given ILcdAWTPath. The pen assumes C1 continuity of the curve (first derivatives are continuous).
      Parameters:
      aCurve - the curve which has to be approximated.
      aIncludingStartPoint - A boolean indicating whether the start point of the curve should be included.
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aAWTPathSFCT - an ILcdAWTPath to which the polyline approximation of the curve is added

    • appendCurve

      public void appendCurve(ILcdCurve aCurve, boolean aIncludingStartPoint, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGeneralPath aGeneralPathSFCT)
      Appends a polyline approximation of a curve to the given ILcdGeneralPath. The pen assumes C1 continuity of the curve (first derivatives are continuous).
      Parameters:
      aCurve - the curve which has to be approximated.
      aIncludingStartPoint - A boolean indicating whether the start point of the curve should be included.
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGeneralPathSFCT - an ILcdGeneralPath to which the polyline approximation of the curve is added

    • appendParameterizedPath

      public void appendParameterizedPath(ILcdParameterizedPath aParameterizedPath, boolean aIncludingStartPoint, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGXYViewXYWorldTransformation aGXYViewXYWorldTransformation, ILcdAWTPath aAWTPathSFCT)
      Appends a polyline approximation of a curve to the given ILcdAWTPath.
      Parameters:
      aParameterizedPath - An ILcdParameterizedPath describing the curve which has to be approximated.
      aIncludingStartPoint - A boolean indicating whether the start point of the curve should be included.
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGXYViewXYWorldTransformation - the transformation between world and view coordinates
      aAWTPathSFCT - an ILcdAWTPath to which the polyline approximation of the curve is added

    • appendParameterizedPath

      public void appendParameterizedPath(ILcdParameterizedPath aParameterizedPath, boolean aIncludingStartPoint, ILcdModelXYWorldTransformation aModelXYWorldTransformation, ILcdGeneralPath aGeneralPathSFCT)
      Appends a polyline approximation of a curve to the given ILcdGeneralPath.
      Parameters:
      aParameterizedPath - An ILcdParameterizedPath describing the curve which has to be approximated.
      aIncludingStartPoint - A boolean indicating whether the start point of the curve should be included.
      aModelXYWorldTransformation - the transformation between model and world coordinates
      aGeneralPathSFCT - an ILcdGeneralPath to which the polyline approximation of the curve is added