Luciad.Geometries.GeometryFactory Class Reference

Factory to create geometries defined within a coordinate reference. More...

Static Public Member Functions
static Luciad.Geometries.ArcBand	CreateArcBand (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate center, double minRadius, double maxRadius, Luciad.Cartesian.Angle startAngle, Luciad.Cartesian.Angle endAngle, Luciad.Cartesian.Angle.Direction angleDirection=Luciad.Cartesian.Angle.Direction.CounterClockwise)
	Factory method to create an arc band. More...
static Luciad.Geometries.Bounds	CreateBounds (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate location, double width, double height, double depth)
	Factory method to create a bounding box geometry. More...
static Luciad.Geometries.CircleBy3Points	CreateCircleBy3Points (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate startPoint, Luciad.Cartesian.Coordinate firstIntermediatePoint, Luciad.Cartesian.Coordinate secondIntermediatePoint)
	Factory method to create a circle, given three points. More...
static Luciad.Geometries.CircleByCenterPoint	CreateCircleByCenterPoint (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate center, double radius)
	Factory method to create a circle. More...
static Luciad.Geometries.CircularArcBy3Points	CreateCircularArcBy3Points (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate startPoint, Luciad.Cartesian.Coordinate intermediatePoint, Luciad.Cartesian.Coordinate endPoint)
	Factory method to create a circular arc, given three points. More...
static Luciad.Geometries.CircularArcByBulge	CreateCircularArcByBulge (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate startPoint, Luciad.Cartesian.Coordinate endPoint, double bulge)
	Factory method to create a circular arc, starting at the given start point and ending in the given end point. More...
static Luciad.Geometries.CircularArcByCenterPoint	CreateCircularArcByCenterPoint (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate center, double radius, Luciad.Cartesian.Angle startAngle, Luciad.Cartesian.Angle endAngle, Luciad.Cartesian.Angle.Direction angleDirection=Luciad.Cartesian.Angle.Direction.CounterClockwise)
	Factory method to create a circular arc. More...
static Luciad.Geometries.CompositeCurve	CreateCompositeCurve (System.Collections.Generic.IList< Luciad.Geometries.Curve > curveList)
	Factory to create a composite curve. More...
static Luciad.Geometries.CompositePatch	CreateCompositePatch (Luciad.Geometries.Patch exteriorPatch, System.Collections.Generic.IList< Luciad.Geometries.Patch > interiorPatches)
	Factory to create a composite patch. More...
static Luciad.Geometries.CompositeRing	CreateCompositeRing (System.Collections.Generic.IList< Luciad.Geometries.Curve > curveList)
	Factory to create a composite ring. More...
static Luciad.Geometries.BezierCurve	CreateCubicBezierCurve (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate controlPoint0, Luciad.Cartesian.Coordinate controlPoint1, Luciad.Cartesian.Coordinate controlPoint2, Luciad.Cartesian.Coordinate controlPoint3)
	Factory method to create a cubic Bézier curve transitioning smoothly between startPoint and endPoint. More...
static Luciad.Geometries.Ellipse	CreateEllipse (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate center, double a, double b, Luciad.Cartesian.Angle rotationAngle)
	Factory method to create an ellipse. More...
static Luciad.Geometries.EllipticalArc	CreateEllipticalArc (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate center, double a, double b, Luciad.Cartesian.Angle startAngle, Luciad.Cartesian.Angle endAngle, Luciad.Cartesian.Angle rotationAngle, Luciad.Cartesian.Angle.Direction angleDirection=Luciad.Cartesian.Angle.Direction.CounterClockwise)
	Factory method to create an elliptical arc. More...
static Luciad.Geometries.ExtrudedGeometry	CreateExtrudedGeometry (Luciad.Geodesy.CoordinateReference reference, Luciad.Geometries.Geometry baseGeometry, double minHeight, double maxHeight)
	Factory method to create an extruded geometry, based on a base geometry, minimum height and maximum height. More...
static Luciad.Geometries.Line	CreateLine (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate firstPoint, Luciad.Cartesian.Coordinate secondPoint, Luciad.Geodesy.LineInterpolationType curveInterpolationType)
	Factory method to create a line. More...
static Luciad.Geometries.MultiGeometry	CreateMultiGeometry (System.Collections.Generic.IList< Luciad.Geometries.Geometry > geometryList)
	Factory to create a multi-geometry. More...
static Luciad.Geometries.Patch	CreatePatch (Luciad.Geometries.Ring baseGeometry)
	Factory method to create a patch based on a Ring. More...
static Luciad.Geometries.Point	CreatePoint (Luciad.Geodesy.CoordinateReference reference, double x, double y, double z)
	Factory method to create a point. More...
static Luciad.Geometries.Point	CreatePoint (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate location)
	Factory method to create a point from a coordinate. More...
static Luciad.Geometries.Polygon	CreatePolygon (Luciad.Geometries.PolylineRing exteriorRing, System.Collections.Generic.IList< Luciad.Geometries.PolylineRing > interiorRings)
	Factory to create a polygon. More...
static Luciad.Geometries.Polyline	CreatePolyline (Luciad.Geodesy.CoordinateReference reference, System.Collections.Generic.IList< Luciad.Cartesian.Coordinate > points, Luciad.Geodesy.LineInterpolationType curveInterpolationType)
	Factory to create a polyline. More...
static Luciad.Geometries.PolylineRing	CreatePolylineRing (Luciad.Geodesy.CoordinateReference reference, System.Collections.Generic.IList< Luciad.Cartesian.Coordinate > points, Luciad.Geodesy.LineInterpolationType curveInterpolationType)
	Factory to create a polyline to be used as ring. More...
static Luciad.Geometries.BezierCurve	CreateQuadraticBezierCurve (Luciad.Geodesy.CoordinateReference reference, Luciad.Cartesian.Coordinate controlPoint0, Luciad.Cartesian.Coordinate controlPoint1, Luciad.Cartesian.Coordinate controlPoint2)
	Factory method to create a quadratic Bézier curve transitioning smoothly between startPoint and endPoint. More...
static Luciad.Geometries.CompositeCurve	CreateRoundedPolyline (Luciad.Geodesy.CoordinateReference reference, System.Collections.Generic.IList< Luciad.Cartesian.Coordinate > points, double cornerRoundness)
	Factory method to create a curve where pointy corners are replaced by Bezier Curves. More...
static Luciad.Geometries.CompositeRing	CreateRoundedPolylineRing (Luciad.Geodesy.CoordinateReference reference, System.Collections.Generic.IList< Luciad.Cartesian.Coordinate > points, double cornerRoundness)
	Factory method to create a ring where pointy corners are replaced by Bezier Curves. More...

Detailed Description

Factory to create geometries defined within a coordinate reference.

You can read more about the available geometries here.

Member Function Documentation

CreateArcBand()

static Luciad.Geometries.ArcBand Luciad.Geometries.GeometryFactory.CreateArcBand ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  center, double  minRadius, double  maxRadius, Luciad.Cartesian.Angle  startAngle, Luciad.Cartesian.Angle  endAngle, Luciad.Cartesian.Angle.Direction  angleDirection = Luciad.Cartesian.Angle.Direction.CounterClockwise  )

inlinestatic

Factory method to create an arc band.

Create the arc band you need

The angles for the arc band are expressed in degrees counterclockwise from the direction at 3 o'clock). By default, the arc band goes from the start angle to the end angle in the positive direction (counterclockwise). This can changed using the optional angleDirection parameter.

To create an arc band from 30° to 145° you can use the following code.

            string identifier = "EPSG:4326";
            CoordinateReference crs = CoordinateReferenceProvider.Create(identifier);
            Coordinate center = new Coordinate(3.5, 51.4, 123.0);
            double minRadius = 12000.0;
            double maxRadius = 15000.0;
            Angle startAngle = new Angle(30.0);
            Angle endAngle = new Angle(145.0);
            var arcBand = GeometryFactory.CreateArcBand(crs, center, minRadius, maxRadius, startAngle, endAngle);

Creation of an arc band is very similar to a circular arc. See GeometryFactory.CreateCircularArcByCenterPoint.

Interpretation based on the coordinate reference

When the passed coordinate reference is a geodetic reference the distance calculations to determine points on the arc band are done using geodesic calculations on the underlying ellipsoid of the coordinate reference.

For other coordinate references the distance calculations are done using cartesian calculations.

Parameters

reference	the coordinate reference in which the circular arc is defined.
center	the center point of the arc band.
minRadius	the minimal radius of the arc band.
maxRadius	the maximal radius of the arc band.
startAngle	the start angle of the arc band. (in degrees, counterclockwise from the direction at 3 o'clock).
endAngle	the end angle of the arc band. (in degrees, counterclockwise from the direction at 3 o'clock).
angleDirection	optional parameter defining the orientation of the arc, i.e. in which direction the arc extends from the start angle to the end angle. The default value is counterclockwise.

Returns

the arc band.

Exceptions

System.ArgumentException

if the arc band cannot be created.

CreateBounds()

static Luciad.Geometries.Bounds Luciad.Geometries.GeometryFactory.CreateBounds ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  location, double  width, double  height, double  depth  )

inlinestatic

Factory method to create a bounding box geometry.

Example to create a bounds geometry:

            string identifier = "EPSG:4326";
            CoordinateReference crs = CoordinateReferenceProvider.Create(identifier);
            Coordinate location = new Coordinate(3.5, 51.4, 123.0);
            double width = 5.5;
            double height = 6.6;
            double depth = 123.0;
            var bounds = GeometryFactory.CreateBounds(crs, location, width, height, depth);

Parameters

reference	the coordinate reference in which the point is defined.
location	the lower left location of the bounds.
width	the width of the bounds (positive value).
height	the height of the bounds (positive value).
depth	the depth of the bounds (positive value).

Returns

the point.

CreateCircleBy3Points()

static Luciad.Geometries.CircleBy3Points Luciad.Geometries.GeometryFactory.CreateCircleBy3Points ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  startPoint, Luciad.Cartesian.Coordinate  firstIntermediatePoint, Luciad.Cartesian.Coordinate  secondIntermediatePoint  )

inlinestatic

Factory method to create a circle, given three points.

The points are allowed to have a Z-value, but all Z-values are required to be equal. If this requirement is not met, an exception is thrown.

Example usage:

            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
            Coordinate startPoint = new Coordinate(3.5, 51.4, 123.0);
            Coordinate firstIntermediatePoint = new Coordinate(10, 50, 123.0);
            Coordinate secondIntermediatePoint = new Coordinate(8, 54, 123.0);
            var circleBy3Points = GeometryFactory.CreateCircleBy3Points(crs, startPoint, firstIntermediatePoint, secondIntermediatePoint);

A circle by-3-points where the three points coincide represents a circle with these points as its center and a radius of 0.

A circle by-3-points where 2 out of 3 points coincide represents a circle with its center located in the middle between the 2 coinciding points and the other point.

A circle by-3-points where the 3 points are co-linear results in System.ArgumentException exceptions when curve methods are called in case the coordinate reference is Cartesian .

When the passed coordinate reference is a geodetic reference, the distance calculations to determine points on the circle are done using geodesic calculations on the underlying ellipsoid of the coordinate reference.

For other coordinate references the distance calculations are done using cartesian calculations.

Parameters

reference	the coordinate reference in which the circle is defined.
startPoint	the start point of the circle.
firstIntermediatePoint	the first intermediate point of the circle.
secondIntermediatePoint	the second intermediate point of the circle.

Returns

the circle.

Exceptions

System.ArgumentException

if the input points do not have equal Z-values.

CreateCircleByCenterPoint()

static Luciad.Geometries.CircleByCenterPoint Luciad.Geometries.GeometryFactory.CreateCircleByCenterPoint ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  center, double  radius  )

inlinestatic

Factory method to create a circle.

Example usage:

            string identifier = "EPSG:3857";
            var crs = CoordinateReferenceProvider.Create(identifier);
            Coordinate center = new Coordinate(3.5, 51.4, 123.0);
            double radius = 12000.0;
            var circle = GeometryFactory.CreateCircleByCenterPoint(crs, center, radius);

When the passed coordinate reference is a geodetic reference, the distance calculations to determine points on the circle are done using geodesic calculations on the underlying ellipsoid of the coordinate reference.

Parameters

reference	the coordinate reference in which the circle is defined.
center	the center point of the circle.
radius	the radius of the circle. If the coordinate reference is a geodetic reference, this is expressed in meters. Otherwise the unit of the reference is used.

Returns

the circle.

Exceptions

System.ArgumentException

if the radius is smaller than 0.

CreateCircularArcBy3Points()

static Luciad.Geometries.CircularArcBy3Points Luciad.Geometries.GeometryFactory.CreateCircularArcBy3Points ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  startPoint, Luciad.Cartesian.Coordinate  intermediatePoint, Luciad.Cartesian.Coordinate  endPoint  )

inlinestatic

Factory method to create a circular arc, given three points.

The circular arc will start at the given start point, pass through the given intermediate point and end in the given end point. The points are allowed to have a Z-value, but all Z-values are required to be equal. If this requirement is not met, an exception is thrown.

Example usage:

            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
            Coordinate startPoint = new Coordinate(3.5, 51.4, 123.0);
            Coordinate intermediatePoint = new Coordinate(10, 50, 123.0);
            Coordinate endPoint = new Coordinate(8, 54, 123.0);
            var arc = GeometryFactory.CreateCircularArcBy3Points(crs, startPoint, intermediatePoint, endPoint);

A circular arc-by-3-points where the start, end and intermediate point coincide represents an arc on a circle with these points as its center and a radius of 0.

A circular arc-by-3-points where 2 out of 3 points coincide represents an arc on a circle with its center located in the middle between the 2 coinciding points and the other point. If the start and end point coincide, a full circle is drawn, otherwise, the arc is interpreted as half a circle in counterclockwise direction from start to end point.

When the passed coordinate reference is a geodetic reference, the distance calculations to determine points on the circular arc are done using geodesic calculations on the underlying ellipsoid of the coordinate reference.

For other coordinate references the distance calculations are done using cartesian calculations.

Parameters

reference	the coordinate reference in which the circular arc is defined.
startPoint	the start point of the circular arc.
intermediatePoint	an intermediate point of the circular arc.
endPoint	the end point of the circular arc.

Returns

the circular arc.

Exceptions

System.ArgumentException

if the input points do not have equal Z-values.

CreateCircularArcByBulge()

static Luciad.Geometries.CircularArcByBulge Luciad.Geometries.GeometryFactory.CreateCircularArcByBulge ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  startPoint, Luciad.Cartesian.Coordinate  endPoint, double  bulge  )

inlinestatic

Factory method to create a circular arc, starting at the given start point and ending in the given end point.

The points are allowed to have a Z-value, but both Z-values are required to be equal. If this requirement is not met, an exception is thrown.

Example usage:

            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
            Coordinate startPoint = new Coordinate(3.5, 51.4, 123.0);
            Coordinate endPoint = new Coordinate(8, 54, 123.0);
            double bulge = -0.7;
            var arc = GeometryFactory.CreateCircularArcByBulge(crs, startPoint, endPoint, bulge);

The bulge factor is the ratio of (1) the distance between the arc midpoint and the center of the arc's chord, and (2) half the length of the arc's chord. The sign of the bulge indicates whether the midpoint is on the left side (positive) or right side (negative) of the vector from start to end point. So a bulge factor with an absolute value of 1 means a half-circle, smaller than 1 means a less bulging arc and larger than 1 means an arc that bulges out in the start and end point.

A circular arc-by-bulge where the start and end point coincide represents an arc on a circle with these points as its center and a radius of 0. The bulge factor is ignored in this case.

When the passed coordinate reference is a geodetic reference, the distance calculations to determine points on the circular arc are done using geodesic calculations on the underlying ellipsoid of the coordinate reference.

For other coordinate references the distance calculations are done using cartesian calculations.

Parameters

reference	the coordinate reference in which the circular arc is defined.
startPoint	the start point of the circular arc.
endPoint	the end point of the circular arc.
bulge	the bulge factor of the circular arc.

Returns

the circular arc.

Exceptions

System.ArgumentException

if the input points do not have equal Z-values.

CreateCircularArcByCenterPoint()

static Luciad.Geometries.CircularArcByCenterPoint Luciad.Geometries.GeometryFactory.CreateCircularArcByCenterPoint ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  center, double  radius, Luciad.Cartesian.Angle  startAngle, Luciad.Cartesian.Angle  endAngle, Luciad.Cartesian.Angle.Direction  angleDirection = Luciad.Cartesian.Angle.Direction.CounterClockwise  )

inlinestatic

Factory method to create a circular arc.

Create the circular arc you need

The angles for the circular arc are expressed in degrees counterclockwise from the direction at 3 o'clock. The arc segment goes from the start angle to the end angle in the positive direction (counterclockwise).

To create a circular arc with an extent from 45° to 300° you can use the following code.

            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
            Coordinate center = new Coordinate(3.5, 51.4, 123.0);
            double radius = 12000.0;
            Angle startAngle = new Angle(45.0);
            Angle endAngle = new Angle(300.0);
            var arc = GeometryFactory.CreateCircularArcByCenterPoint(crs, center, radius, startAngle, endAngle);

Arc from 45° to 300°

To create a circular arc with an extent from 300° to 45° you can use the following code.

            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
            Coordinate center = new Coordinate(3.5, 51.4, 123.0);
            double radius = 12000.0;
            Angle startAngle = new Angle(300.0);
            Angle endAngle = new Angle(45.0);
            var arc = GeometryFactory.CreateCircularArcByCenterPoint(crs, center, radius, startAngle, endAngle);

Arc from 300° to 45°

Creation of a circular arc with the start and the end angle having the same value results in full circle.

Optional orientation of the arc

The default orientation for the circular arc is counterclockwise. The circular arc is a curve that is useful as a sub-curve building block for other geometries, e.g., an arc band. Therefore it also supports the specification of the orientation of the arc. When the orientation value is set to clock-wise the arc segment goes from the start angle to the end angle in counter clock wise direction (negative direction).

Interpretation based on the coordinate reference

When the passed coordinate reference is a geodetic reference, the distance calculations to determine points on the circular arc are done using geodesic calculations on the underlying ellipsoid of the coordinate reference.

For other coordinate references the distance calculations are done using cartesian calculations.

Parameters

reference	the coordinate reference in which the circular arc is defined.
center	the center point of the circular arc.
radius	the radius of the circular arc. If the coordinate reference is a geodetic reference, this is expressed in meters. Otherwise the unit of the reference is used.
startAngle	the start angle of the circular arc. (in degrees, counterclockwise from the direction at 3 o'clock).
endAngle	the end angle of the circular arc. (in degrees, counterclockwise from the direction at 3 o'clock).
angleDirection	optional parameter defining the orientation of the arc. The default value is counter clock-wise.

Returns

the circular arc.

CreateCompositeCurve()

static Luciad.Geometries.CompositeCurve Luciad.Geometries.GeometryFactory.CreateCompositeCurve ( System.Collections.Generic.IList< Luciad.Geometries.Curve >  curveList )

inlinestatic

Factory to create a composite curve.

The following requirements must be met for the curves:

1. the coordinate references must be the same
2. the end point of a curve must be same as the start point of the next curve

Parameters

curveList

the curves of which to make a composite curve.

Returns

the composite curve.

Exceptions

System.ArgumentException

if the requirements are not met.

CreateCompositePatch()

static Luciad.Geometries.CompositePatch Luciad.Geometries.GeometryFactory.CreateCompositePatch ( Luciad.Geometries.Patch  exteriorPatch, System.Collections.Generic.IList< Luciad.Geometries.Patch >  interiorPatches  )

inlinestatic

Factory to create a composite patch.

The composite patch represents a surface whose boundary is defined by an exterior patch and optionally a number of interior patches which represents holes within the surface.

The following requirements must be met for the exterior patch and the interior patches:

1. the coordinate references must be the same

Creation of composite patch with a hole:

            Patch exteriorPatch = GeometryFactory.CreatePatch(circleBy3Points);
            Patch interiorPatch = GeometryFactory.CreatePatch(ellipse);
 
            var interiorPatches = new List<Patch> { interiorPatch };
 
            var compositePatch = GeometryFactory.CreateCompositePatch(exteriorPatch, interiorPatches);

Parameters

exteriorPatch	the exterior patch of the composite patch surface.
interiorPatches	the interior patches of the composite patch surface. This can be an empty list.

Returns

the composite patch.

Exceptions

System.ArgumentException

if the requirements are not met.

CreateCompositeRing()

static Luciad.Geometries.CompositeRing Luciad.Geometries.GeometryFactory.CreateCompositeRing ( System.Collections.Generic.IList< Luciad.Geometries.Curve >  curveList )

inlinestatic

Factory to create a composite ring.

The following requirements must be met for the curves:

1. the coordinate references must be the same
2. the end point of a curve must be same as the start point of the next curve
3. the end point of the last curve must be the same as the start point of the first curve

Parameters

curveList

the curves of which to make a composite ring.

Returns

the composite ring.

Exceptions

System.ArgumentException

if the requirements are not met.

CreateCubicBezierCurve()

static Luciad.Geometries.BezierCurve Luciad.Geometries.GeometryFactory.CreateCubicBezierCurve ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  controlPoint0, Luciad.Cartesian.Coordinate  controlPoint1, Luciad.Cartesian.Coordinate  controlPoint2, Luciad.Cartesian.Coordinate  controlPoint3  )

inlinestatic

Factory method to create a cubic Bézier curve transitioning smoothly between startPoint and endPoint.

A cubic Bézier curve is defined by this equation:

F(t) = (1-t)^3*startPoint + 3(1-t)^2*t*controlPoint1 + 3(1-t)*t^2*controlPoint2 + t^3*endPoint

Cubic Bézier curves

At t=0 (at the start), F(t) evaluates to startPoint

At t=1 (at the end), F(t) evaluates to endPoint

For other values between 0 and 1, F(t) will evaluate to a curve tending to the two control points.

Parameters

reference	the coordinate reference in which the Bézier curve is defined.
controlPoint0	first control point of the cubic Bézier curve, start of the curve.
controlPoint1	second control point of the cubic Bézier curve.
controlPoint2	third control point of the cubic Bézier curve.
controlPoint3	fourth control point of the cubic Bézier curve, end of the curve.

Returns

the bezier curve geometry.

Since

2024.1

CreateEllipse()

static Luciad.Geometries.Ellipse Luciad.Geometries.GeometryFactory.CreateEllipse ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  center, double  a, double  b, Luciad.Cartesian.Angle  rotationAngle  )

inlinestatic

Factory method to create an ellipse.

Example usage:

            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
            Coordinate centerPoint = new Coordinate(3.5, 51.4, 123.0);
            double a = 12000;
            double b = 6000;
            Angle rotAngle = 45;
            var ellipse = GeometryFactory.CreateEllipse(crs, centerPoint, a, b, rotAngle);

When the passed coordinate reference is a geodetic reference, the distance calculations to determine points on the ellipse are done using geodesic calculations on the underlying ellipsoid of the coordinate reference.

For other coordinate references the distance calculations are done using cartesian calculations.

Parameters

reference	the coordinate reference in which the ellipse is defined.
center	the center point of the ellipse.
a	the length of the semi-major axis of the ellipse. If the coordinate reference is a geodetic reference, this is expressed in meters. Otherwise the unit of the reference is used.
b	the length of the semi-minor axis of the ellipse. If the coordinate reference is a geodetic reference, this is expressed in meters. Otherwise the unit of the reference is used.
rotationAngle	the rotation angle of the ellipse.

Returns

the ellipse.

Exceptions

System.ArgumentException

if a or b is smaller than 0.

CreateEllipticalArc()

static Luciad.Geometries.EllipticalArc Luciad.Geometries.GeometryFactory.CreateEllipticalArc ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  center, double  a, double  b, Luciad.Cartesian.Angle  startAngle, Luciad.Cartesian.Angle  endAngle, Luciad.Cartesian.Angle  rotationAngle, Luciad.Cartesian.Angle.Direction  angleDirection = Luciad.Cartesian.Angle.Direction.CounterClockwise  )

inlinestatic

Factory method to create an elliptical arc.

Example usage:

            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
            Coordinate centerPoint = new Coordinate(3.5, 51.4, 123.0);
            double a = 12000;
            double b = 6000;
            Angle startAngle = 30;
            Angle endAngle = 125;
            Angle rotAngle = 45;
            var arc = GeometryFactory.CreateEllipticalArc(crs, centerPoint, a, b, startAngle, endAngle, rotAngle);

Creation of an elliptical arc with the start and the end angle having the same value results in full ellipse.

When the passed coordinate reference is a geodetic reference, the distance calculations to determine points on the elliptical arc are done using geodesic calculations on the underlying ellipsoid of the coordinate reference.

For other coordinate references the distance calculations are done using cartesian calculations.

Parameters

reference	the coordinate reference in which the elliptical arc is defined.
center	the center point of the elliptical arc.
a	the length of the semi-major axis of the elliptical arc. If the coordinate reference is a geodetic reference, this is expressed in meters. Otherwise the unit of the reference is used.
b	the length of the semi-minor axis of the elliptical arc. If the coordinate reference is a geodetic reference, this is expressed in meters. Otherwise the unit of the reference is used.
startAngle	the start angle of the elliptical arc.
endAngle	the end angle of the elliptical arc.
rotationAngle	the rotation of the ellipse on which the arc is defined
angleDirection	optional parameter defining the orientation of the arc, i.e. in which direction the arc extends from the start angle to the end angle. The default value is counterclockwise.

Returns

the elliptical arc.

Exceptions

System.ArgumentException

if a or b is smaller than 0.

CreateExtrudedGeometry()

static Luciad.Geometries.ExtrudedGeometry Luciad.Geometries.GeometryFactory.CreateExtrudedGeometry ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Geometries.Geometry  baseGeometry, double  minHeight, double  maxHeight  )

inlinestatic

Factory method to create an extruded geometry, based on a base geometry, minimum height and maximum height.

If the base geometry has Z-values of its own, they are ignored. The maximum height cannot be smaller than the minimum height.

If the given geometry is not a supported base for an extruded geometry, an exception is thrown. Use ExtrudedGeometry.IsBaseGeometrySupported to check whether a geometry is supported or not. Currently, all Curve and Surface geometries are supported, as well as MultiGeometry instances that consist solely of such geometries.

Example Usage:

            var crs = CoordinateReferenceProvider.Create("EPSG:4326");
            Coordinate centerPoint = new Coordinate( 51, 4, 0 );
            double radius = 5000;
            var circle = GeometryFactory.CreateCircleByCenterPoint(crs, centerPoint, radius);
            double minHeight = 500;
            double maxHeight = 2000;
            var extrudedGeometry = GeometryFactory.CreateExtrudedGeometry(crs, circle, minHeight, maxHeight);

Parameters

reference	the coordinate reference in which the extruded geometry is defined. The horizontal component of this reference must be the same as the horizontal component of the base geometry's coordinate reference. The vertical reference is used to interpret the min and max height values.
baseGeometry	the geometry to use as a base for the extruded geometry.
minHeight	the minimum height of the extruded geometry. If the coordinate reference is a geodetic reference, this is expressed in meters. Otherwise the unit of the reference is used.
maxHeight	the maximum height of the extruded geometry.If the coordinate reference is a geodetic reference, this is expressed in meters. Otherwise the unit of the reference is used.

Returns

the extruded geometry.

Exceptions

System.ArgumentException

if the given geometry is not a supported base geometry for an extruded geometry, or if maxHeight < minHeight.

CreateLine()

static Luciad.Geometries.Line Luciad.Geometries.GeometryFactory.CreateLine ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  firstPoint, Luciad.Cartesian.Coordinate  secondPoint, Luciad.Geodesy.LineInterpolationType  curveInterpolationType  )

inlinestatic

Factory method to create a line.

Line objects can be created with the interpolation types:

• linear
• geodesic
• rhumb

The interpolation types geodesic and rhumb are only allowed for geodetic coordinate references.

Creation of geodesic line:

            Coordinate startPoint = new Coordinate(-10.0, 50.0, 123.0);
            Coordinate endPoint = new Coordinate(15.0, 50.0, 256.0);
            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
            var line = GeometryFactory.CreateLine(crs, startPoint, endPoint, LineInterpolationType.Geodesic);

Creation of rhumb line:

            Coordinate startPoint = new Coordinate(-10.0, 50.0, 123.0);
            Coordinate endPoint = new Coordinate(15.0, 50.0, 256.0);
            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
            var line = GeometryFactory.CreateLine(crs, startPoint, endPoint, LineInterpolationType.Rhumb);

Creation of linear line in a cartesian coordinate reference:

            Coordinate startPoint = new Coordinate(-10.0, 50.0, 123.0);
            Coordinate endPoint = new Coordinate(15.0, 50.0, 256.0);
            string identifier = "EPSG:3857";
            var crs = CoordinateReferenceProvider.Create(identifier);
            var line = GeometryFactory.CreateLine(crs, startPoint, endPoint, LineInterpolationType.Linear);

Parameters

reference	the coordinate reference in which the line is defined.
firstPoint	first point of the line.
secondPoint	second point of the line.
curveInterpolationType	the type of interpolation between the points, i.e., linear, geodesic, or rhumb.

Returns

the line geometry.

Exceptions

System.ArgumentException

if the line cannot be constructed. For example for an invalid combination of coordinate reference and interpolation type.

CreateMultiGeometry()

static Luciad.Geometries.MultiGeometry Luciad.Geometries.GeometryFactory.CreateMultiGeometry ( System.Collections.Generic.IList< Luciad.Geometries.Geometry >  geometryList )

inlinestatic

Factory to create a multi-geometry.

The following requirements must be met for the geometries:

1. the coordinate references must be the same

To create a multi-geometry from a list of geometries you can use the following code.

            var geometryList = new List<Geometry>();
            geometryList.Add(point);
            geometryList.Add(polyline);
            geometryList.Add(polygon);
            geometryList.Add(circularArcByCenterPoint);
            geometryList.Add(arcBand);
 
            var multiGeometry = GeometryFactory.CreateMultiGeometry(geometryList);

Parameters

geometryList

the geometries of which to make a multi-geometry; at least one geometry is required.

Returns

the multi-geometry.

Exceptions

System.ArgumentException

if the requirements are not met.

CreatePatch()

static Luciad.Geometries.Patch Luciad.Geometries.GeometryFactory.CreatePatch ( Luciad.Geometries.Ring  baseGeometry )

inlinestatic

Factory method to create a patch based on a Ring.

Example Usage:

            CircleByCenterPoint circleByCenterPoint = GeometryFactory.CreateCircleByCenterPoint(crs, centerPoint, radius);
            Patch circleByCenterPointPatch = GeometryFactory.CreatePatch(circleByCenterPoint);

            CircleBy3Points circleBy3Points = GeometryFactory.CreateCircleBy3Points(crs, startPoint, firstIntermediatePoint, secondIntermediatePoint);
            Patch circleBy3PointsPatch = GeometryFactory.CreatePatch(circleBy3Points);

            ArcBand arcBand = GeometryFactory.CreateArcBand(crs, center, minRadius, maxRadius, startAngle, endAngle);
            Patch arcBandPatch = GeometryFactory.CreatePatch(arcBand);

            Ellipse ellipse = GeometryFactory.CreateEllipse(crs, centerPoint, a, b, rotAngle);
            Patch ellipsePatch = GeometryFactory.CreatePatch(ellipse);

            PolylineRing polylineRing = GeometryFactory.CreatePolylineRing(crs, points, LineInterpolationType.Geodesic);
            Patch polylineRingPatch = GeometryFactory.CreatePatch(polylineRing);

Parameters

baseGeometry

the base geometry (Ring) for the patch.

Returns

the patch geometry.

Exceptions

System.ArgumentException

if the base ring geometry is not supported.

CreatePoint() [1/2]

static Luciad.Geometries.Point Luciad.Geometries.GeometryFactory.CreatePoint ( Luciad.Geodesy.CoordinateReference  reference, double  x, double  y, double  z  )

inlinestatic

Factory method to create a point.

Example to create a point geometry:

            string identifier = "EPSG:4326";
            CoordinateReference crs = CoordinateReferenceProvider.Create(identifier);
            var point = GeometryFactory.CreatePoint(crs, 3.5, 51.4, 123.0);

Parameters

reference	the coordinate reference in which the point is defined.
x	the x-value of the point.
y	the y-value of the point.
z	the z-value of the point.

Returns

the point.

CreatePoint() [2/2]

static Luciad.Geometries.Point Luciad.Geometries.GeometryFactory.CreatePoint ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  location  )

inlinestatic

Factory method to create a point from a coordinate.

Example to create a point geometry:

            string identifier = "EPSG:4326";
            CoordinateReference crs = CoordinateReferenceProvider.Create(identifier);
            Coordinate location = new Coordinate(3.5, 51.4, 123.0);
            var point = GeometryFactory.CreatePoint(crs, location);

Parameters

reference	the coordinate reference in which the point is defined.
location	the location of the point

Returns

the point.

Since

2022.1

CreatePolygon()

static Luciad.Geometries.Polygon Luciad.Geometries.GeometryFactory.CreatePolygon ( Luciad.Geometries.PolylineRing  exteriorRing, System.Collections.Generic.IList< Luciad.Geometries.PolylineRing >  interiorRings  )

inlinestatic

Factory to create a polygon.

The polygon represents a surface whose boundary is defined by an exterior (polyline) ring and optionally a number of interior (polyline) rings.

The following requirements must be met for the exterior ring and the interior rings:

1. the coordinate references must be the same
2. the interpolation type must be the same

Creation of polygon that only has an exterior ring:

            var points = new List<Coordinate> 
            {
                new Coordinate(-10.0, 50.0, 123.0),
                new Coordinate(15.0, 50.0, 256.0),
                new Coordinate(15.0, 40.0, 321.0),
            };
            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
            var exteriorRing = GeometryFactory.CreatePolylineRing(crs, points, LineInterpolationType.Geodesic);
            var interiorRings = new List<PolylineRing> { };
            var polygon = GeometryFactory.CreatePolygon(exteriorRing, interiorRings);

Creation of polygon that has a single hole:

            var pointsExterior = new List<Coordinate>
            {
                new Coordinate(-10.0, 50.0, 123.0),
                new Coordinate(15.0, 50.0, 123.0),
                new Coordinate(15.0, 40.0, 123.0),
            };
            var pointsInterior = new List<Coordinate>
            {
                new Coordinate(-0.0, 49.0, 123.0),
                new Coordinate(10.0, 49.0, 123.0),
                new Coordinate(10.0, 44.0, 123.0),
            };
            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
 
            var exteriorRing = GeometryFactory.CreatePolylineRing(crs, pointsExterior, LineInterpolationType.Geodesic);
            var interiorRing = GeometryFactory.CreatePolylineRing(crs, pointsInterior, LineInterpolationType.Geodesic);
            List<PolylineRing> interiorRings = new List<PolylineRing> { 
                interiorRing 
            };
            var polygon = GeometryFactory.CreatePolygon(exteriorRing, interiorRings);

Parameters

exteriorRing	the exterior ring of the polygon.
interiorRings	the interior rings of the polygon. This can be an empty list.

Returns

the polygon.

Exceptions

System.ArgumentException

if the requirements are not met.

CreatePolyline()

static Luciad.Geometries.Polyline Luciad.Geometries.GeometryFactory.CreatePolyline ( Luciad.Geodesy.CoordinateReference  reference, System.Collections.Generic.IList< Luciad.Cartesian.Coordinate >  points, Luciad.Geodesy.LineInterpolationType  curveInterpolationType  )

inlinestatic

Factory to create a polyline.

Polyline objects can be created with the interpolation types:

• linear
• geodesic
• rhumb

The interpolation types geodesic and rhumb are only allowed for geodetic coordinate references.

Creation of geodesic polyline:

            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);

Creation of rhumb polyline:

            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
            var polyline = GeometryFactory.CreatePolyline(crs, new List<Coordinate>
            {
                new Coordinate(-10.0, 50.0, 123.0),
                new Coordinate(15.0, 50.0, 256.0),
                new Coordinate(15.0, 40.0, 321.0),
                new Coordinate(-10.0, 50.0, 123.0),
            }, LineInterpolationType.Rhumb);

Creation of linear polyline in a cartesian coordinate reference:

            string identifier = "EPSG:3857";
            var crs = CoordinateReferenceProvider.Create(identifier);
            var polyline = GeometryFactory.CreatePolyline(crs, new List<Coordinate>
            {
                new Coordinate(-10.0, 50.0, 123.0),
                new Coordinate(15.0, 50.0, 256.0),
                new Coordinate(15.0, 40.0, 321.0),
                new Coordinate(-10.0, 50.0, 123.0),
            }, LineInterpolationType.Linear);

Parameters

reference	the coordinate reference in which the polyline is defined.
points	the points defining the polyline.
curveInterpolationType	the type of interpolation between the points, i.e., linear, geodesic, or rhumb.

Returns

the polyline

Exceptions

System.ArgumentException

if the polyline cannot be constructed. For example for an invalid combination of coordinate reference and interpolation type.

CreatePolylineRing()

static Luciad.Geometries.PolylineRing Luciad.Geometries.GeometryFactory.CreatePolylineRing ( Luciad.Geodesy.CoordinateReference  reference, System.Collections.Generic.IList< Luciad.Cartesian.Coordinate >  points, Luciad.Geodesy.LineInterpolationType  curveInterpolationType  )

inlinestatic

Factory to create a polyline to be used as ring.

The polyline represents a closed curve. The implementation does not require the list of points to be such that the first and the last point are the same. A line segment is automatically included between the last point and the first point.

Polyline objects can be created with the interpolation types:

• linear
• geodesic
• rhumb

The interpolation types geodesic and rhumb are only allowed for geodetic coordinate references.

Creation of a polyline as a ring:

            var points = new List<Coordinate>
            {
                new Coordinate(-10.0, 50.0, 123.0),
                new Coordinate(15.0, 50.0, 256.0),
                new Coordinate(15.0, 40.0, 321.0),
            };
            string identifier = "EPSG:4326";
            var crs = CoordinateReferenceProvider.Create(identifier);
            var polylineRing = GeometryFactory.CreatePolylineRing(crs, points, LineInterpolationType.Geodesic);

Parameters

reference	the coordinate reference in which the polyline is defined.
points	the points defining the polyline.
curveInterpolationType	the type of interpolation between the points, i.e., linear, geodesic, or rhumb.

Returns

the polyline, as a ring.

Exceptions

System.ArgumentException

if the polyline ring cannot be constructed. For example for an invalid combination of coordinate reference and interpolation type.

CreateQuadraticBezierCurve()

static Luciad.Geometries.BezierCurve Luciad.Geometries.GeometryFactory.CreateQuadraticBezierCurve ( Luciad.Geodesy.CoordinateReference  reference, Luciad.Cartesian.Coordinate  controlPoint0, Luciad.Cartesian.Coordinate  controlPoint1, Luciad.Cartesian.Coordinate  controlPoint2  )

inlinestatic

Factory method to create a quadratic Bézier curve transitioning smoothly between startPoint and endPoint.

A quadratic Bézier curve is defined by this equation:

F(t) = startPoint*(1-t)^2 + 2(1-t)*t*controlPoint + endPoint*t^2

Quadratic Bézier curves

At t=0 (at the start), F(t) evaluates to startPoint

At t=1 (at the end), F(t) evaluates to endPoint

For other values between 0 and 1, F(t) will evaluate to a quadratic curve tending to controlPoint.

Parameters

reference	the coordinate reference in which the Bézier curve is defined.
controlPoint0	first control point of the quadratic Bézier curve, start of the curve.
controlPoint1	second control point of the quadratic Bézier curve.
controlPoint2	third control point of the quadratic Bézier curve, end of the curve.

Returns

the bezier curve geometry.

Since

2024.1

CreateRoundedPolyline()

static Luciad.Geometries.CompositeCurve Luciad.Geometries.GeometryFactory.CreateRoundedPolyline ( Luciad.Geodesy.CoordinateReference  reference, System.Collections.Generic.IList< Luciad.Cartesian.Coordinate >  points, double  cornerRoundness  )

inlinestatic

Factory method to create a curve where pointy corners are replaced by Bezier Curves.

This method operates by assuming that the points originally define a Polyline. It retains the first and last point and replaces the geometry around vertex (corners) by a BezierCurve. The extent of BezierCurve depends on cornerRoundess. cornerRoundness decides the size of the Bezier Curve such that lower values will result in more pointy geometries.

This method requires at least 3 points to produce a rounded result. If only 2 points are provided, it will return a standard line. If less than 2 points are provided, this method will throw an Invalid Argument exception. If cornerRoundness is zero, a standard Polyline is created.

Corner roundness is expected to be between [0,1].

Rounded Line

Parameters

reference	The coordinate reference in which the curve is defined.
points	Series of points defining the curve. At least 2 points are required to produce a result.
cornerRoundness	The lower this value, the pointier the geometry will be. This value must be between [0, 1].

Returns

the rounded curve geometry.

Exceptions

System.ArgumentException

if the requirements are not met.

Since

2020.1

CreateRoundedPolylineRing()

static Luciad.Geometries.CompositeRing Luciad.Geometries.GeometryFactory.CreateRoundedPolylineRing ( Luciad.Geodesy.CoordinateReference  reference, System.Collections.Generic.IList< Luciad.Cartesian.Coordinate >  points, double  cornerRoundness  )

inlinestatic

Factory method to create a ring where pointy corners are replaced by Bezier Curves.

This method operates by assuming that the points define a PolylineRing and then replace each corner of the ring by a BezierCurve. The extent of BezierCurve depends on cornerRoundess. CornerRoundness decides the size of the Bezier Curve such that lower values will result in more pointy geometries.

This method requires at least 3 points to produce a result. If less than 3 points are provided, it will throw an Invalid Argument exception. If cornerRoundness is zero, a standard PolylineRing is created.

Corner roundness is expected to be between [0,1].

Roundness Factor

Parameters

reference	The coordinate reference in which the curve is defined.
points	Series of points defining the curve. At least 3 points are required to produce a result.
cornerRoundness	The lower this value, the pointier the geometry will be. This value must be between [0, 1].

Returns

the rounded ring geometry.

Exceptions

System.ArgumentException

if the requirements are not met.

Since

2020.1