## org.opengis.geometry.coordinate
Interface ArcStringByBulge

All Superinterfaces:
  CurveSegment, GenericCurve

All Known Subinterfaces:
  ArcByBulge

    @UML(identifier="GM_ArcStringByBulge",
         specification=ISO_19107)
    public interface ArcStringByBulge

extends CurveSegment

A variant of the arc that stores the parameters of the second constructor of the component arcs and recalculates the other attributes of the standard arc. The control point sequence is similar to that in arc string, but the midPoint position is not needed since it is to be calculated. The control point sequence shall consist of the start and end points of each arc.

Since:
  GeoAPI 1.0
Version:
  ISO 19107
See Also:
  `GeometryFactory.createArcStringByBulge(java.util.List<org.opengis.geometry.coordinate.Position>, double[], java.util.List<double[]>)`

Method Summary
`ArcString` `asArcString()` Recast as a base arc string.
`double[]` `getBulges()` Returns the offset of each arc's midpoint.
`CurveInterpolation` `getInterpolation()` The interpolation for a `ArcStringByBulge` is "Circular arc by 2 points and bulge factor".
`List<double[]>` `getNormals()` Returns a vector normal (perpendicular) to the chord of the arc, the line joining the first and last point of the arc.
`int` `getNumArc()` Returns the number of circular arcs in the string.

Methods inherited from interface CurveSegment
`getBoundary, getCurve, getNumDerivativesAtEnd, getNumDerivativesAtStart, getNumDerivativesInterior, getSamplePoints, reverse`

Methods inherited from interface GenericCurve
`asLineString, forConstructiveParam, forParam, getEndConstructiveParam, getEndParam, getEndPoint, getParamForPoint, getStartConstructiveParam, getStartParam, getStartPoint, getTangent, length, length`

Method Detail

### getBulges

    @UML(identifier="bulge",
         obligation=MANDATORY,
         specification=ISO_19107)
    double[] getBulges()

  Returns the offset of each arc's midpoint. The attribute "bulge" is the real number multiplier for the normal that determines the offset direction of the midpoint of each arc. The length of the bulge sequence is exactly 1 less than the length of the control point array, since a bulge is needed for each pair of adjacent points in the control point array.

  The bulge is not given by a distance, since it is simply a multiplier for the normal, the unit of the offset distance is determined by the length function for vectors in the coordinate reference system. In the examples in this specification, the normal is often given as a Euclidean unit vector, which may or may not fix its length to one depending of the distance formulae used for the coordinate reference system.

  The midpoint of the resulting arc is given by:

  > `midPoint = ((`startPoint` + `endPoint`)/2.0) + bulge×`normal``

  Returns:
    The offset of each arc's midpoint.

### getNumArc

    @UML(identifier="numArc",
         obligation=MANDATORY,
         specification=ISO_19107)
    int getNumArc()

  Returns the number of circular arcs in the string. Since the interpolation method requires overlapping sets of 2 positions, the number of arcs determines the number of control points.

  >     numArc = controlPoints.length - 1

  Returns:
    The number of circular arcs.

### getNormals

    @UML(identifier="normal",
         obligation=MANDATORY,
         specification=ISO_19107)
    List<double[]> getNormals()

  Returns a vector normal (perpendicular) to the chord of the arc, the line joining the first and last point of the arc. In a 2D coordinate system, there are only two possible directions for the normal, and it is often given as a signed real, indicating its length, with a positive sign indicating a left turn angle from the chord line, and a negative sign indicating a right turn from the chord. In 3D, the normal determines the plane of the arc, along with the start and end point of the arc.

  The normal is usually a unit vector, but this is not absolutely necessary. If the normal is a zero vector, the geometric object becomes equivalent to the straight line between the two end points. The length of the normal sequence is exactly the same as for the bulge sequence, 1 less than the control point sequence length.

  Returns:
    The sequence of normal vectors.

### getInterpolation

    @UML(identifier="interpolation",
         obligation=MANDATORY,
         specification=ISO_19107)
    CurveInterpolation getInterpolation()

  The interpolation for a `ArcStringByBulge` is "Circular arc by 2 points and bulge factor".

  Specified by:
    `getInterpolation` in interface `CurveSegment`
  Returns:
    Always `CurveInterpolation.CIRCULAR_ARC_2_POINTS_WITH_BULGE`.

### asArcString

    @UML(identifier="asGM_ArcString",
         obligation=MANDATORY,
         specification=ISO_19107)
    ArcString asArcString()

  Recast as a base arc string.

  Returns:
    This arc string by bulge as a base arc string.

Copyright © 1994-2008 Open Geospatial Consortium. All Rights Reserved.