DPath (ZVTM-ZUIST 0.12.0 API)

java.lang.Object
- fr.inria.zvtm.glyphs.Glyph
- - fr.inria.zvtm.glyphs.DPath<T>

All Implemented Interfaces:

RectangularShape, Translucent, Cloneable
```
public class DPath<T>
extends Glyph
implements RectangularShape
```
Dynamic Path, made of an arbitrary number of segments, quadratic curves, cubic curves, and gaps. All of these can be dynamically modified and animated through AnimManager's createPathAnimation method. This class implements RectangularShape even though it is not, just to give easy access to the path's bounding box dimensions.

Author:

Emmanuel Pietriga, Boris Trofimov

See Also:

VSegment

Field Summary

Fields
Modifier and Type	Field and Description
`static short`	`DRAW_GENERAL_PATH` Draw the general path that gets compiled each time we make a change to the DPath (default).
`static short`	`DRAW_SUBPATHS` Iterate on the path's components (each line, quad curve, cubic curve) and draw them step by step.
`fr.inria.zvtm.glyphs.projection.ProjectedCoords[]`	`pc` For internal use.
`double`	`vh` Height in virtual space.
`double`	`vw` Width in virtual space.

Fields inherited from class fr.inria.zvtm.glyphs.Glyph
alphaC, coef, color, cursorInsideColor, ENTERED_GLYPH, EXITED_GLYPH, fColor, HSV, NO_CURSOR_EVENT, orient, sensit, size, stickedTo, stroke, visible, vx, vy, vz

Fields inherited from interface fr.inria.zvtm.glyphs.Translucent
acO

Constructor Summary

Constructors
Constructor and Description
`DPath()`
`DPath(double x, double y, int z, Color c)` Drawing method: DRAW_GENERAL_PATH.
`DPath(double x, double y, int z, Color c, float alpha)` Drawing method: DRAW_GENERAL_PATH.
`DPath(double x, double y, int z, Color c, float alpha, short m)`
`DPath(int z)` Drawing method: DRAW_GENERAL_PATH.
`DPath(PathIterator pi, int z, Color c)` Drawing method: DRAW_GENERAL_PATH.
`DPath(PathIterator pi, int z, Color c, float alpha)` Drawing method: DRAW_GENERAL_PATH.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addCamera(int verifIndex)` Create new projected coordinates.
`void`	`addCbCurve(double x, double y, double x1, double y1, double x2, double y2, boolean abs)` Add a new cubic curve to the path, from current point to point (x,y), controlled by (x1,y1)
`void`	`addQdCurve(double x, double y, double x1, double y1, boolean abs)` Add a new quadratic curve to the path, from current point to point (x,y), controlled by (x1,y1)
`void`	`addSegment(double x, double y, boolean abs)` Add a new segment to the path, from current point to point (x,y).
`Object`	`clone()` Not implemented yet.
`void`	`computeBounds()`
`boolean`	`containedInRegion(double wb, double nb, double eb, double sb, int i)` Method used internally to find out if it is necessary to project and draw the glyph through a lens for a given camera.
`boolean`	`coordInside(int jpx, int jpy, Camera c, double cvx, double cvy)` Not supported in DPath.
`boolean`	`coordInsideP(int jpx, int jpy, Camera c)` Not supported in DPath.
`boolean`	`coordInsideV(double cvx, double cvy, Camera c)` Not supported in DPath.
`boolean`	`coordsInsideBoundingBox(double x, double y)`
`void`	`draw(Graphics2D g, int vW, int vH, int i, Stroke stdS, AffineTransform stdT, int dx, int dy)` Draw this glyph.
`void`	`drawForLens(Graphics2D g, int vW, int vH, int i, Stroke stdS, AffineTransform stdT, int dx, int dy)` Draw this glyph through a lens.
`void`	`edit(Point2D.Double[] points, boolean abs)` Transform DPath by translating each of the points
`void`	`editElement(int index, double sx, double sy, double ex, double ey, Point2D.Double[] ctrlPoints, boolean abs)` Edit coordinates of start, end and control points of the element in DPath
`boolean`	`fillsView(double w, double h, int camIndex)` Find out if this glyph completely fills a view.
`Point2D.Double[]`	`getAllPointsCoordinates()` Get coordinates of each point in the path including control points.
`double[]`	`getBounds()` Get the bounding box of this Glyph in virtual space coordinates.
`short`	`getDrawingMethod()` The drawing method employed.
`Point2D.Double[]`	`getElementPointsCoordinates(int index)` Get coordinates of the start, end and control points of the element
`int`	`getElementsCount()` Get total number of elements in the path
`int`	`getElementType(int index)` Get element's type
`Point2D.Double`	`getEndPoint()`
`double`	`getEndPointX()`
`double`	`getEndPointY()`
`double`	`getEndTangentOrientation()` Get orientation of the tangent to the end of the path.
`static Point2D.Double[]`	`getFlattenedCoordinates(DPath path, Point2D.Double startPoint, Point2D.Double endPoint, boolean abs)` Calculates coordinates of all DPath's points (including control points) to display the DPath as a line.
`double`	`getHeight()` Get the vertical distance from northern-most point to the southern-most one.
`GeneralPath`	`getJava2DGeneralPath()` Get the Java2D GeneralPath representing this DPath in virtual space coordinates.
`PathIterator`	`getJava2DPathIterator()` Get the Java2D path iterator representing this DPath.
`Shape`	`getJava2DShape()` Get the Java2D Shape corresponding to this Glyph.
`int`	`getNumberOfPoints()`
`double`	`getOrient()` Get the glyph's orientation.
`double`	`getSize()` Get glyph's size (diameter of bounding circle).
`Point2D.Double`	`getStartPoint()`
`double`	`getStartPointX()`
`double`	`getStartPointY()`
`double`	`getStartTangentOrientation()` Get orientation of the tangent to the start of the path.
`PathIterator`	`getSVGPathIterator()` Get an SVG-compatible path iterator for this DPath.
`double`	`getWidth()` Get the horizontal distance from western-most point to the eastern-most one.
`void`	`highlight(boolean b, Color selectedColor)` Highlight this glyph to give visual feedback when the cursor is inside it.
`void`	`initCams(int nbCam)` Initialize projected coordinates.
`void`	`jump(double x, double y, boolean abs)` Add a new 'gap' to the path (move without drawing anything), from current point to point (x,y).
`void`	`move(double x, double y)` Translate the glyph by (x,y) - relative translation.
`void`	`moveTo(double x, double y)` Translate the glyph to (x,y) - absolute translation.
`void`	`orientTo(double angle)` No effect.
`void`	`project(Camera c, Dimension d)` Project glyph w.r.t a given camera's coordinate system, prior to actual painting.
`void`	`projectForLens(Camera c, int lensWidth, int lensHeight, float lensMag, double lensx, double lensy)` Project glyph w.r.t a given camera's coordinate system, prior to actual painting through a lens.
`void`	`removeCamera(int index)` Dispose of projected coordinates.
`void`	`reSize(double factor)` No effect.
`void`	`setDrawingMethod(short m)` Specify what drawing method to use to paint this path.
`void`	`setHeight(double h)` Not implemented yet.
`void`	`setPath(PathIterator pi)`
`void`	`setWidth(double w)` Not implemented yet.
`void`	`sizeTo(double s)` No effect.
`void`	`updateJava2DGeneralPath()` Update the Java2D GeneralPath representing this DPath.
`boolean`	`visibleInDisc(double dvx, double dvy, double dvr, Shape dvs, int camIndex, int jpx, int jpy, int dpr)` The disc is actually approximated to its bounding box here.
`boolean`	`visibleInRegion(double wb, double nb, double eb, double sb, int i)` Method used internally to find out if it is necessary to project and draw this glyph for a given camera.

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - DRAW_GENERAL_PATH
```
public static final short DRAW_GENERAL_PATH
```
    Draw the general path that gets compiled each time we make a change to the DPath (default). A side effect of this method is that the stroke set, if any, is sensitive to zooming.
    
    See Also:
    
    Constant Field Values
  - DRAW_SUBPATHS
```
public static final short DRAW_SUBPATHS
```
    Iterate on the path's components (each line, quad curve, cubic curve) and draw them step by step. A side effect of this method is that the stroke set, if any, is not sensitive to zooming.
    
    See Also:
    
    Constant Field Values
  - pc
```
public fr.inria.zvtm.glyphs.projection.ProjectedCoords[] pc
```
    For internal use. Dot not tamper with. Made public for outside package subclassing. Stores projected start point only.
  - vw
```
public double vw
```
    Width in virtual space. For internal use. Made public for easier outside package subclassing.
  - vh
```
public double vh
```
    Height in virtual space. For internal use. Made public for easier outside package subclassing.
- Constructor Detail
  - DPath
```
public DPath()
```
  - DPath
```
public DPath(int z)
```
    Drawing method: DRAW_GENERAL_PATH.
    
    Parameters:
    
    z - z-index (pass 0 if you do not use z-ordering)
  - DPath
```
public DPath(double x,
             double y,
             int z,
             Color c)
```
    Drawing method: DRAW_GENERAL_PATH.
    
    Parameters:
    
    x - start coordinate in virtual space
    
    y - start coordinate in virtual space
    
    z - z-index (pass 0 if you do not use z-ordering)
    
    c - color
  - DPath
```
public DPath(double x,
             double y,
             int z,
             Color c,
             float alpha)
```
    Drawing method: DRAW_GENERAL_PATH.
    
    Parameters:
    
    x - start coordinate in virtual space
    
    y - start coordinate in virtual space
    
    z - z-index (pass 0 if you do not use z-ordering)
    
    c - color
    
    alpha - alpha channel value in [0;1.0] 0 is fully transparent, 1 is opaque
  - DPath
```
public DPath(double x,
             double y,
             int z,
             Color c,
             float alpha,
             short m)
```
    Parameters:
    
    x - start coordinate in virtual space
    
    y - start coordinate in virtual space
    
    z - z-index (pass 0 if you do not use z-ordering)
    
    c - color
    
    alpha - alpha channel value in [0;1.0] 0 is fully transparent, 1 is opaque
    m - method to draw this glyph.
    
    DRAW_GENERAL_PATH will draw the general path that gets compiled each time we make a change to the DPath (default). A side effect of this method is that the stroke set, if any, is sensitive to zooming.
    
    DRAW_SUBPATHS will iterate on the path's components (each line, quad curve, cubic curve) and draw them step by step. A side effect of this method is that the stroke set, if any, is not sensitive to zooming.
  - DPath
```
public DPath(PathIterator pi,
             int z,
             Color c)
```
    Drawing method: DRAW_GENERAL_PATH.
    
    Parameters:
    
    pi - PathIterator describing this path (virtual space coordinates)
    
    z - z-index (pass 0 if you do not use z-ordering)
    
    c - color
  - DPath
```
public DPath(PathIterator pi,
             int z,
             Color c,
             float alpha)
```
    Drawing method: DRAW_GENERAL_PATH.
    
    Parameters:
    
    pi - PathIterator describing this path (virtual space coordinates)
    
    z - z-index (pass 0 if you do not use z-ordering)
    
    c - color
    
    alpha - alpha channel value in [0;1.0] 0 is fully transparent, 1 is opaque
- Method Detail
  - setPath
```
public void setPath(PathIterator pi)
```
  - addCbCurve
```
public void addCbCurve(double x,
                       double y,
                       double x1,
                       double y1,
                       double x2,
                       double y2,
                       boolean abs)
```
    Add a new cubic curve to the path, from current point to point (x,y), controlled by (x1,y1)
    
    Parameters:
    
    x - x coordinate of end point in virtual space
    
    y - y coordinate of end point in virtual space
    
    x1 - x coordinate of 1st control point in virtual space
    
    y1 - y coordinate of 1st control point in virtual space
    
    x2 - x coordinate of 2nd control point in virtual space
    
    y2 - y coordinate of 2nd control point in virtual space
    
    abs - true if coordinates should be interpreted as absolute coordinates, false if coordinates should be interpreted as relative coordinates (w.r.t last point)
  - addQdCurve
```
public void addQdCurve(double x,
                       double y,
                       double x1,
                       double y1,
                       boolean abs)
```
    Add a new quadratic curve to the path, from current point to point (x,y), controlled by (x1,y1)
    
    Parameters:
    
    x - x coordinate of end point in virtual space
    
    y - y coordinate of end point in virtual space
    
    x1 - x coordinate of control point in virtual space
    
    y1 - y coordinate of control point in virtual space
    
    abs - true if coordinates should be interpreted as absolute coordinates, false if coordinates should be interpreted as relative coordinates (w.r.t last point)
  - addSegment
```
public void addSegment(double x,
                       double y,
                       boolean abs)
```
    Add a new segment to the path, from current point to point (x,y).
    
    Parameters:
    
    x - x coordinate of end point in virtual space
    
    y - y coordinate of end point in virtual space
    
    abs - true if coordinates should be interpreted as absolute coordinates, false if coordinates should be interpreted as relative coordinates (w.r.t last point)
  - jump
```
public void jump(double x,
                 double y,
                 boolean abs)
```
    Add a new 'gap' to the path (move without drawing anything), from current point to point (x,y).
    
    Parameters:
    
    x - x coordinate of end point in virtual space
    
    y - y coordinate of end point in virtual space
    
    abs - true if coordinates should be interpreted as absolute coordinates, false if coordinates should be interpreted as relative coordinates (w.r.t last point)
  - getWidth
```
public double getWidth()
```
    Get the horizontal distance from western-most point to the eastern-most one.
    
    Specified by:
    
    getWidth in interface RectangularShape
  - getHeight
```
public double getHeight()
```
    Get the vertical distance from northern-most point to the southern-most one.
    
    Specified by:
    
    getHeight in interface RectangularShape
  - setWidth
```
public void setWidth(double w)
```
    Not implemented yet.
    
    Specified by:
    
    setWidth in interface RectangularShape
  - setHeight
```
public void setHeight(double h)
```
    Not implemented yet.
    
    Specified by:
    
    setHeight in interface RectangularShape
  - getStartPoint
```
public Point2D.Double getStartPoint()
```
  - getEndPoint
```
public Point2D.Double getEndPoint()
```
  - getStartPointX
```
public double getStartPointX()
```
  - getStartPointY
```
public double getStartPointY()
```
  - getEndPointX
```
public double getEndPointX()
```
  - getEndPointY
```
public double getEndPointY()
```
  - initCams
```
public void initCams(int nbCam)
```
    Description copied from class: Glyph
    
    Initialize projected coordinates. Called internally when glyph is created in order to create the initial set of projected coordinates w.r.t the number of cameras in the virtual space.
    
    Specified by:
    
    initCams in class Glyph
    
    Parameters:
    
    nbCam - current number of cameras in the virtual space
    
    See Also:
    
    Glyph.addCamera(int verifIndex), Glyph.removeCamera(int index)
  - addCamera
```
public void addCamera(int verifIndex)
```
    Description copied from class: Glyph
    
    Create new projected coordinates. Called internally to create new projected coordinates to use with the new camera.
    
    Specified by:
    
    addCamera in class Glyph
    
    Parameters:
    
    verifIndex - camera index, just to be sure that the number of projected coordinates is consistent with the number of cameras.
    
    See Also:
    
    Glyph.initCams(int nbCam), Glyph.removeCamera(int index)
  - removeCamera
```
public void removeCamera(int index)
```
    Description copied from class: Glyph
    
    Dispose of projected coordinates. If a camera is removed from the virtual space to which this glyphs belongs, the corresponding projected coordinates should be deleted. the array of projected coordinates should not be modified however, because other cameras' index remain the same. The corresponding index in the array should just be set to null.
    
    Specified by:
    
    removeCamera in class Glyph
    
    See Also:
    
    Glyph.initCams(int nbCam), Glyph.addCamera(int verifIndex)
  - sizeTo
```
public void sizeTo(double s)
```
    No effect.
    
    Specified by:
    
    sizeTo in class Glyph
    
    See Also:
    
    Glyph.reSize(double factor)
  - reSize
```
public void reSize(double factor)
```
    No effect.
    
    Specified by:
    
    reSize in class Glyph
    
    See Also:
    
    Glyph.sizeTo(double s)
  - move
```
public void move(double x,
                 double y)
```
    Translate the glyph by (x,y) - relative translation.
    
    Overrides:
    
    move in class Glyph
    
    See Also:
    
    moveTo(double x, double y)
  - moveTo
```
public void moveTo(double x,
                   double y)
```
    Translate the glyph to (x,y) - absolute translation.
    
    Overrides:
    
    moveTo in class Glyph
    
    See Also:
    
    move(double x, double y)
  - orientTo
```
public void orientTo(double angle)
```
    No effect.
    
    Specified by:
    
    orientTo in class Glyph
    
    Parameters:
    
    angle - in [0:2Pi[
  - getSize
```
public double getSize()
```
    Description copied from class: Glyph
    
    Get glyph's size (diameter of bounding circle).
    
    Specified by:
    
    getSize in class Glyph
  - computeBounds
```
public void computeBounds()
```
  - getBounds
```
public double[] getBounds()
```
    Get the bounding box of this Glyph in virtual space coordinates.
    
    Overrides:
    
    getBounds in class Glyph
    
    Returns:
    
    west, north, east and south bounds in virtual space.
  - coordsInsideBoundingBox
```
public boolean coordsInsideBoundingBox(double x,
                                       double y)
```
  - getOrient
```
public double getOrient()
```
    Description copied from class: Glyph
    
    Get the glyph's orientation.
    
    Specified by:
    
    getOrient in class Glyph
  - fillsView
```
public boolean fillsView(double w,
                         double h,
                         int camIndex)
```
    Description copied from class: Glyph
    
    Find out if this glyph completely fills a view. (In which case it is not necessary to repaint objects below it in the drawing stack). If implemented, this method should be very efficient, as it is used by an optional top-down clipping algorithm. Otherwise it might cost more time than it can potentially save. Until now it has only been implemented for non-reorientable rectangles and was activated only for treemap-like representations in which a lot of rectangles can potentially overlap each other.
    
    Specified by:
    
    fillsView in class Glyph
  - coordInside
```
public boolean coordInside(int jpx,
                           int jpy,
                           Camera c,
                           double cvx,
                           double cvy)
```
    Not supported in DPath.
    
    Specified by:
    
    coordInside in class Glyph
    
    Parameters:
    
    jpx - provide projected JPanel coordinates of the associated view, not virtual space coordinates
    
    jpy - provide projected JPanel coordinates of the associated view, not virtual space coordinates
    
    c - camera through which the glyph is observed (only a few types of Glyph actually require this information: SICircle, SIRectangle, VText)
    
    cvx - virtual space coordinates
    
    cvy - virtual space coordinates
    
    See Also:
    
    Glyph.coordInsideV(double cvx, double cvy, Camera c), Glyph.coordInsideP(int jpx, int jpy, Camera c)
  - coordInsideV
```
public boolean coordInsideV(double cvx,
                            double cvy,
                            Camera c)
```
    Not supported in DPath.
    
    Specified by:
    
    coordInsideV in class Glyph
    
    Parameters:
    
    cvx - virtual space coordinates
    
    cvy - virtual space coordinates
    
    c - camera through which the glyph is observed (only a few types of Glyph actually require this information: SICircle, SIRectangle, VText)
    
    See Also:
    
    Glyph.coordInside(int jpx, int jpy, Camera c, double cvx, double cvy), Glyph.coordInsideP(int jpx, int jpy, Camera c)
  - coordInsideP
```
public boolean coordInsideP(int jpx,
                            int jpy,
                            Camera c)
```
    Not supported in DPath.
    
    Specified by:
    
    coordInsideP in class Glyph
    
    Parameters:
    
    jpx - provide projected JPanel coordinates of the associated view, not virtual space coordinates
    
    jpy - provide projected JPanel coordinates of the associated view, not virtual space coordinates
    
    c - camera through which the glyph is observed
    
    See Also:
    
    Glyph.coordInsideV(double cvx, double cvy, Camera c), Glyph.coordInside(int jpx, int jpy, Camera c, double cvx, double cvy)
  - project
```
public void project(Camera c,
                    Dimension d)
```
    Description copied from class: Glyph
    
    Project glyph w.r.t a given camera's coordinate system, prior to actual painting. Called internally.
    
    Specified by:
    
    project in class Glyph
    
    Parameters:
    
    c - camera
    
    d - dimension of View using camera c
  - projectForLens
```
public void projectForLens(Camera c,
                           int lensWidth,
                           int lensHeight,
                           float lensMag,
                           double lensx,
                           double lensy)
```
    Description copied from class: Glyph
    
    Project glyph w.r.t a given camera's coordinate system, prior to actual painting through a lens. Called internally.
    
    Specified by:
    
    projectForLens in class Glyph
    
    Parameters:
    
    c - camera
    
    lensWidth - width of lens activated in View using this camera
    
    lensHeight - height of lens activated in View using this camera
    
    lensMag - magnification factor of lens activated in View using this camera
    
    lensx - horizontal coordinateof lens activated in View using this camera
    
    lensy - vertical coordinate of lens activated in View using this camera
  - setDrawingMethod
```
public void setDrawingMethod(short m)
```
    Specify what drawing method to use to paint this path.
    Parameters:
    m - method to draw this glyph.
    
    DRAW_GENERAL_PATH will draw the general path that gets compiled each time we make a change to the DPath (default). A side effect of this method is that the stroke set, if any, is sensitive to zooming.
    
    DRAW_SUBPATHS will iterate on the path's components (each line, quad curve, cubic curve) and draw them step by step. A side effect of this method is that the stroke set, if any, is not sensitive to zooming.
  - getDrawingMethod
```
public short getDrawingMethod()
```
    The drawing method employed.
    Returns:
    DRAW_GENERAL_PATH will draw the general path that gets compiled each time we make a change to the DPath (default). A side effect of this method is that the stroke set, if any, is sensitive to zooming.
    
    DRAW_SUBPATHS will iterate on the path's components (each line, quad curve, cubic curve) and draw them step by step. A side effect of this method is that the stroke set, if any, is not sensitive to zooming.
  - draw
```
public void draw(Graphics2D g,
                 int vW,
                 int vH,
                 int i,
                 Stroke stdS,
                 AffineTransform stdT,
                 int dx,
                 int dy)
```
    Description copied from class: Glyph
    
    Draw this glyph.
    
    Specified by:
    
    draw in class Glyph
    
    Parameters:
    
    g - graphics context in which the glyph should be drawn
    
    vW - associated View width (used by some closed shapes to determine if it is worth painting the glyph's border)
    
    vH - associated View height (used by some closed shapes to determine if it is worth painting the glyph's border)
    
    i - camera index in the virtual space containing the glyph
    
    stdS - default stroke
    
    stdT - identity transform
    
    dx - horizontal offset
    
    dy - vertical offset
  - drawForLens
```
public void drawForLens(Graphics2D g,
                        int vW,
                        int vH,
                        int i,
                        Stroke stdS,
                        AffineTransform stdT,
                        int dx,
                        int dy)
```
    Description copied from class: Glyph
    
    Draw this glyph through a lens.
    
    Specified by:
    
    drawForLens in class Glyph
    
    Parameters:
    
    g - graphics context in which the glyph should be drawn
    
    vW - associated View width (used by some closed shapes to determine if it is worth painting the glyph's border)
    
    vH - associated View height (used by some closed shapes to determine if it is worth painting the glyph's border)
    
    i - camera index in the virtual space containing the glyph
    
    stdS - default stroke
    
    stdT - identity transform
    
    dx - horizontal offset
    
    dy - vertical offset
  - visibleInRegion
```
public boolean visibleInRegion(double wb,
                               double nb,
                               double eb,
                               double sb,
                               int i)
```
    Description copied from class: Glyph
    
    Method used internally to find out if it is necessary to project and draw this glyph for a given camera.
    
    Overrides:
    
    visibleInRegion in class Glyph
    
    Parameters:
    
    wb - west region boundary (virtual space coordinates)
    
    nb - north region boundary (virtual space coordinates)
    
    eb - east region boundary (virtual space coordinates)
    
    sb - south region boundary (virtual space coordinates)
    
    i - camera index (useuful only for some glyph classes redefining this method)
    
    Returns:
    
    true if the glyph is currently visible in the region delimited by wb, nb, eb, sb, symbolising the region seen through a camera
  - containedInRegion
```
public boolean containedInRegion(double wb,
                                 double nb,
                                 double eb,
                                 double sb,
                                 int i)
```
    Description copied from class: Glyph
    
    Method used internally to find out if it is necessary to project and draw the glyph through a lens for a given camera.
    
    Overrides:
    
    containedInRegion in class Glyph
    
    Parameters:
    
    wb - west region boundary (virtual space coordinates)
    
    nb - north region boundary (virtual space coordinates)
    
    eb - east region boundary (virtual space coordinates)
    
    sb - south region boundary (virtual space coordinates)
    
    i - camera index (useuful only for some glyph classes redefining this method)
    
    Returns:
    
    true if the glyph intersects the region delimited by wb, nb, eb, sb
  - visibleInDisc
```
public boolean visibleInDisc(double dvx,
                             double dvy,
                             double dvr,
                             Shape dvs,
                             int camIndex,
                             int jpx,
                             int jpy,
                             int dpr)
```
    The disc is actually approximated to its bounding box here. Precise intersection computation would be too costly.
    
    Overrides:
    
    visibleInDisc in class Glyph
  - clone
```
public Object clone()
```
    Not implemented yet.
    
    Overrides:
    
    clone in class Glyph
  - highlight
```
public void highlight(boolean b,
                      Color selectedColor)
```
    Highlight this glyph to give visual feedback when the cursor is inside it.
    
    Specified by:
    
    highlight in class Glyph
  - editElement
```
public void editElement(int index,
                        double sx,
                        double sy,
                        double ex,
                        double ey,
                        Point2D.Double[] ctrlPoints,
                        boolean abs)
```
    Edit coordinates of start, end and control points of the element in DPath
    
    Parameters:
    
    index - index of the element in the DPath
    
    sx - x coordinate of the element's start point
    
    sy - y coordinate of the element's start point
    
    ex - x coordinate of the element's end point
    
    ey - y coordinate of the element's end point
    
    ctrlPoints - list of the points that contain coordinates of the control point(s) (in case of QD/CB curve)
    
    abs - indicates whether to use absolute coordinates or relative
  - edit
```
public void edit(Point2D.Double[] points,
                 boolean abs)
```
    Transform DPath by translating each of the points
    
    Parameters:
    
    points - List of new coordinates for each point. Example order could be: startPoint, controlPoint1, controlPoint2, endPoint, controlPoint1, endPoint, endPoint ...
    
    abs - whether to use absolute coordinates or relative
  - getElementsCount
```
public int getElementsCount()
```
    Get total number of elements in the path
  - getElementType
```
public int getElementType(int index)
```
    Get element's type
    
    Parameters:
    
    index - index of the element in the DPath
    
    Returns:
    
    -1 in case of incorrect parameters, otherwise returns one of the constants DPath.CBC, DPath.QDC, DPath.SEG, DPath.MOV
  - getElementPointsCoordinates
```
public Point2D.Double[] getElementPointsCoordinates(int index)
```
    Get coordinates of the start, end and control points of the element
    
    Parameters:
    
    index - index of the element in the DPath
    
    Returns:
    
    List of element's points ordered as startPoint, controlPoint1, controlPoint2, endPoint
  - getNumberOfPoints
```
public int getNumberOfPoints()
```
  - getAllPointsCoordinates
```
public Point2D.Double[] getAllPointsCoordinates()
```
    Get coordinates of each point in the path including control points.
    
    Returns:
    
    a copy of the list of points in following format: startPoint, controlPoint1, controlPoint2, endPoint ...
  - getFlattenedCoordinates
```
public static Point2D.Double[] getFlattenedCoordinates(DPath path,
                                                       Point2D.Double startPoint,
                                                       Point2D.Double endPoint,
                                                       boolean abs)
```
    Calculates coordinates of all DPath's points (including control points) to display the DPath as a line.
    
    Parameters:
    
    path - DPath to be flatten
    
    startPoint - Start point of desired line
    
    endPoint - End point of desired line
    
    abs - whether to use absolute values
    
    Returns:
    
    List of LongPoint absolute coordinates that can be passed to the edit(LongPoint[], boolean) method or to the AnimManager
  - getSVGPathIterator
```
public PathIterator getSVGPathIterator()
```
    Get an SVG-compatible path iterator for this DPath.
  - updateJava2DGeneralPath
```
public void updateJava2DGeneralPath()
```
    Update the Java2D GeneralPath representing this DPath.
  - getJava2DGeneralPath
```
public GeneralPath getJava2DGeneralPath()
```
    Get the Java2D GeneralPath representing this DPath in virtual space coordinates.
  - getJava2DShape
```
public Shape getJava2DShape()
```
    Description copied from class: Glyph
    
    Get the Java2D Shape corresponding to this Glyph. Virtual Space coordinates.
    
    Specified by:
    
    getJava2DShape in class Glyph
  - getJava2DPathIterator
```
public PathIterator getJava2DPathIterator()
```
    Get the Java2D path iterator representing this DPath.
  - getStartTangentOrientation
```
public double getStartTangentOrientation()
```
    Get orientation of the tangent to the start of the path.
    
    Returns:
    
    radians between 0..2*Pi
  - getEndTangentOrientation
```
public double getEndTangentOrientation()
```
    Get orientation of the tangent to the end of the path.
    
    Returns:
    
    radians between 0..2*Pi

Copyright © 2000-2002 Xerox Corporation. All Rights Reserved
Copyright © 2003 World Wide Web Consortium. All Rights Reserved
Copyright © 2004-2015 INRIA. All Rights Reserved
Licensed under the GNU LGPL. For full terms see the file COPYING.

Class DPath<T>

Field Summary

Fields inherited from class fr.inria.zvtm.glyphs.Glyph

Fields inherited from interface fr.inria.zvtm.glyphs.Translucent

Constructor Summary

Method Summary

Methods inherited from class fr.inria.zvtm.glyphs.Glyph

Methods inherited from class java.lang.Object

Field Detail

DRAW_GENERAL_PATH

DRAW_SUBPATHS

pc

vw

vh

Constructor Detail

DPath

DPath

DPath

DPath

DPath

DPath

DPath

Method Detail

setPath

addCbCurve

addQdCurve

addSegment

jump

getWidth

getHeight

setWidth

setHeight

getStartPoint

getEndPoint

getStartPointX

getStartPointY

getEndPointX

getEndPointY

initCams

addCamera

removeCamera

sizeTo

reSize

move

moveTo

orientTo

getSize

computeBounds

getBounds

coordsInsideBoundingBox

getOrient

fillsView

coordInside

coordInsideV

coordInsideP

project

projectForLens

setDrawingMethod

getDrawingMethod

draw

drawForLens

visibleInRegion

containedInRegion

visibleInDisc

clone

highlight

editElement

edit

getElementsCount

getElementType

getElementPointsCoordinates

getNumberOfPoints

getAllPointsCoordinates

getFlattenedCoordinates

getSVGPathIterator

updateJava2DGeneralPath

getJava2DGeneralPath

getJava2DShape

getJava2DPathIterator

getStartTangentOrientation