Class RawCoordinateSequenceFactory

Factory for creating RawCoordinateSequence instances.

Inheritance

Object

CoordinateSequenceFactory

RawCoordinateSequenceFactory

Inherited Members

CoordinateSequenceFactory.Ordinates

CoordinateSequenceFactory.Create(Coordinate[])

CoordinateSequenceFactory.Create(CoordinateSequence)

CoordinateSequenceFactory.Create(Int32, Int32)

CoordinateSequenceFactory.Create(Int32, Ordinates)

CoordinateSequenceFactory.GetCommonSequenceParameters(Coordinate[])

Object.Equals(Object)

Object.Equals(Object, Object)

Object.GetHashCode()

Object.GetType()

Object.MemberwiseClone()

Object.ReferenceEquals(Object, Object)

Object.ToString()

Namespace: NetTopologySuite.Geometries.Implementation

Assembly: NetTopologySuite.dll

Syntax

public sealed class RawCoordinateSequenceFactory : CoordinateSequenceFactory

Constructors

RawCoordinateSequenceFactory(IEnumerable<Ordinates>)

Initializes a new instance of the RawCoordinateSequenceFactory class.

Declaration

public RawCoordinateSequenceFactory(IEnumerable<Ordinates> ordinateGroups)

Parameters

Type	Name	Description
IEnumerable<Ordinates>	ordinateGroups	A sequence of zero or more Ordinates flags representing ordinate values that should be allocated together.

Remarks

Any flags not represented in ordinateGroups, and any spatial or measure dimensions beyond the 16th, will be allocated together, SoA-style.

Elements without any bits set will be silently ignored.

Exceptions

Type	Condition
ArgumentNullException	Thrown when ordinateGroups is null.
ArgumentException	Thrown when a given flag appears in more than one element of ordinateGroups.

Methods

Create(Int32, Int32, Int32)

Declaration

public override CoordinateSequence Create(int size, int dimension, int measures)

Parameters

Type	Name	Description
Int32	size
Int32	dimension
Int32	measures

Returns

Type	Description
CoordinateSequence

Overrides

CoordinateSequenceFactory.Create(Int32, Int32, Int32)

CreateXY(Memory<Double>)

Creates a new RawCoordinateSequence that uses the given array for reading and writing X and Y data ignoring the Ordinates flags that were passed into the constructor for this factory instance.

Declaration

public static RawCoordinateSequence CreateXY(Memory<double> xy)

Parameters

Type	Name	Description
Memory<Double>	xy	An array of X and Y values, laid out as [x0, y0, x1, y1, x2, y2, ..., xn, yn].

Returns

Type	Description
RawCoordinateSequence	A RawCoordinateSequence instance that's backed by the given array.

Remarks

The resulting instance is essentially a PackedDoubleCoordinateSequence with slightly more overhead, so the main reason to prefer this over that one would be if you really need to avoid copying the data to fit it into that format.

Exceptions

Type	Condition
ArgumentException	Thrown when the length of xy is not a multiple of 2.

CreateXY(Memory<Double>, Memory<Double>)

Creates a new RawCoordinateSequence that uses the given arrays for reading and writing X and Y data ignoring the Ordinates flags that were passed into the constructor for this factory instance.

Declaration

public static RawCoordinateSequence CreateXY(Memory<double> x, Memory<double> y)

Parameters

Type	Name	Description
Memory<Double>	x	An array of X values, laid out as [x0, x1, x2, ..., xn].
Memory<Double>	y	An array of Y values, laid out as [y0, y1, y2, ..., yn].

Returns

Type	Description
RawCoordinateSequence	A RawCoordinateSequence instance that's backed by the given arrays.

Exceptions

Type	Condition
ArgumentException	Thrown when the input arrays do not contain data for the same number of coordinates.

CreateXYM(Memory<Double>)

Creates a new RawCoordinateSequence that uses the given array for reading and writing X, Y, and M data ignoring the Ordinates flags that were passed into the constructor for this factory instance.

Declaration

public static RawCoordinateSequence CreateXYM(Memory<double> xym)

Parameters

Type	Name	Description
Memory<Double>	xym	An array of X, Y, and M values, laid out as [x0, y0, m0, x1, y1, m1, x2, y2, m2, ..., xn, yn, mn].

Returns

Type	Description
RawCoordinateSequence	A RawCoordinateSequence instance that's backed by the given array.

Remarks

The resulting instance is essentially a PackedDoubleCoordinateSequence with slightly more overhead, so the main reason to prefer this over that one would be if you really need to avoid copying the data to fit it into that format.

Exceptions

Type	Condition
ArgumentException	Thrown when the length of xym is not a multiple of 3.

CreateXYM(Memory<Double>, Memory<Double>)

Creates a new RawCoordinateSequence that uses the given array for reading and writing X, Y, and M data ignoring the Ordinates flags that were passed into the constructor for this factory instance.

Declaration

public static RawCoordinateSequence CreateXYM(Memory<double> xy, Memory<double> m)

Parameters

Type	Name	Description
Memory<Double>	xy	An array of X and Y values, laid out as [x0, y0, x1, y1, x2, y2, ..., xn, yn].
Memory<Double>	m	An array of M values, laid out as [m0, m1, m2, ..., mn].

Returns

Type	Description
RawCoordinateSequence	A RawCoordinateSequence instance that's backed by the given array.

Remarks

The resulting instance is essentially a DotSpatialAffineCoordinateSequence with slightly more overhead, so the main reason to prefer this over that one would be if you really need to avoid copying the data to fit it into that format.

Exceptions

Type	Condition
ArgumentException	Thrown when the length of xy is not a multiple of 2, or when the input arrays do not contain data for the same number of coordinates.

CreateXYM(Memory<Double>, Memory<Double>, Memory<Double>)

Creates a new RawCoordinateSequence that uses the given arrays for reading and writing X, Y, and M data ignoring the Ordinates flags that were passed into the constructor for this factory instance.

Declaration

public static RawCoordinateSequence CreateXYM(Memory<double> x, Memory<double> y, Memory<double> m)

Parameters

Type	Name	Description
Memory<Double>	x	An array of X values, laid out as [x0, x1, x2, ..., xn].
Memory<Double>	y	An array of Y values, laid out as [y0, y1, y2, ..., yn].
Memory<Double>	m	An array of M values, laid out as [m0, m1, m2, ..., mn].

Returns

Type	Description
RawCoordinateSequence	A RawCoordinateSequence instance that's backed by the given arrays.

Exceptions

Type	Condition
ArgumentException	Thrown when the input arrays do not contain data for the same number of coordinates.

CreateXYZ(Memory<Double>)

Creates a new RawCoordinateSequence that uses the given array for reading and writing X, Y, and Z data ignoring the Ordinates flags that were passed into the constructor for this factory instance.

Declaration

public static RawCoordinateSequence CreateXYZ(Memory<double> xyz)

Parameters

Type	Name	Description
Memory<Double>	xyz	An array of X, Y, and Z values, laid out as [x0, y0, z0, x1, y1, z1, x2, y2, z2, ..., xn, yn, zn].

Returns

Type	Description
RawCoordinateSequence	A RawCoordinateSequence instance that's backed by the given array.

Remarks

The resulting instance is essentially a PackedDoubleCoordinateSequence with slightly more overhead, so the main reason to prefer this over that one would be if you really need to avoid copying the data to fit it into that format.

Exceptions

Type	Condition
ArgumentException	Thrown when the length of xyz is not a multiple of 3.

CreateXYZ(Memory<Double>, Memory<Double>)

Creates a new RawCoordinateSequence that uses the given array for reading and writing X, Y, and Z data ignoring the Ordinates flags that were passed into the constructor for this factory instance.

Declaration

public static RawCoordinateSequence CreateXYZ(Memory<double> xy, Memory<double> z)

Parameters

Type	Name	Description
Memory<Double>	xy	An array of X and Y values, laid out as [x0, y0, x1, y1, x2, y2, ..., xn, yn].
Memory<Double>	z	An array of Z values, laid out as [z0, z1, z2, ..., zn].

Returns

Type	Description
RawCoordinateSequence	A RawCoordinateSequence instance that's backed by the given array.

Remarks

The resulting instance is essentially a DotSpatialAffineCoordinateSequence with slightly more overhead, so the main reason to prefer this over that one would be if you really need to avoid copying the data to fit it into that format.

Exceptions

Type	Condition
ArgumentException	Thrown when the length of xy is not a multiple of 2, or when the input arrays do not contain data for the same number of coordinates.

CreateXYZ(Memory<Double>, Memory<Double>, Memory<Double>)

Creates a new RawCoordinateSequence that uses the given arrays for reading and writing X, Y, and Z data ignoring the Ordinates flags that were passed into the constructor for this factory instance.

Declaration

public static RawCoordinateSequence CreateXYZ(Memory<double> x, Memory<double> y, Memory<double> z)

Parameters

Type	Name	Description
Memory<Double>	x	An array of X values, laid out as [x0, x1, x2, ..., xn].
Memory<Double>	y	An array of Y values, laid out as [y0, y1, y2, ..., yn].
Memory<Double>	z	An array of Z values, laid out as [z0, z1, z2, ..., zn].

Returns

Type	Description
RawCoordinateSequence	A RawCoordinateSequence instance that's backed by the given arrays.

Exceptions

Type	Condition
ArgumentException	Thrown when the input arrays do not contain data for the same number of coordinates.

CreateXYZM(Memory<Double>)

Creates a new RawCoordinateSequence that uses the given array for reading and writing X, Y, Z, and M data ignoring the Ordinates flags that were passed into the constructor for this factory instance.

Declaration

public static RawCoordinateSequence CreateXYZM(Memory<double> xyzm)

Parameters

Type	Name	Description
Memory<Double>	xyzm	An array of X, Y, Z, and M values, laid out as [x0, y0, z0, m0, x1, y1, z1, m1, x2, y2, z2, m2, ..., xn, yn, zn, mn].

Returns

Type	Description
RawCoordinateSequence	A RawCoordinateSequence instance that's backed by the given array.

Remarks

The resulting instance is essentially a PackedDoubleCoordinateSequence with slightly more overhead, so the main reason to prefer this over that one would be if you really need to avoid copying the data to fit it into that format.

Exceptions

Type	Condition
ArgumentException	Thrown when the length of xyzm is not a multiple of 4.

CreateXYZM(Memory<Double>, Memory<Double>, Memory<Double>)

Creates a new RawCoordinateSequence that uses the given array for reading and writing X, Y, Z, and M data ignoring the Ordinates flags that were passed into the constructor for this factory instance.

Declaration

public static RawCoordinateSequence CreateXYZM(Memory<double> xy, Memory<double> z, Memory<double> m)

Parameters

Type	Name	Description
Memory<Double>	xy	An array of X and Y values, laid out as [x0, y0, x1, y1, x2, y2, ..., xn, yn].
Memory<Double>	z	An array of Z values, laid out as [z0, z1, z2, ..., zn].
Memory<Double>	m	An array of M values, laid out as [m0, m1, m2, ..., mn].

Returns

Type	Description
RawCoordinateSequence	A RawCoordinateSequence instance that's backed by the given array.

Remarks

The resulting instance is essentially a DotSpatialAffineCoordinateSequence with slightly more overhead, so the main reason to prefer this over that one would be if you really need to avoid copying the data to fit it into that format.

Exceptions

Type	Condition
ArgumentException	Thrown when the length of xy is not a multiple of 2, or when the input arrays do not contain data for the same number of coordinates.

CreateXYZM(Memory<Double>, Memory<Double>, Memory<Double>, Memory<Double>)

Creates a new RawCoordinateSequence that uses the given arrays for reading and writing X, Y, Z, and M data ignoring the Ordinates flags that were passed into the constructor for this factory instance.

Declaration

public static RawCoordinateSequence CreateXYZM(Memory<double> x, Memory<double> y, Memory<double> z, Memory<double> m)

Parameters

Type	Name	Description
Memory<Double>	x	An array of X values, laid out as [x0, x1, x2, ..., xn].
Memory<Double>	y	An array of Y values, laid out as [y0, y1, y2, ..., yn].
Memory<Double>	z	An array of Z values, laid out as [z0, z1, z2, ..., zn].
Memory<Double>	m	An array of M values, laid out as [m0, m1, m2, ..., mn].

Returns

Type	Description
RawCoordinateSequence	A RawCoordinateSequence instance that's backed by the given arrays.

Exceptions

Type	Condition
ArgumentException	Thrown when the input arrays do not contain data for the same number of coordinates.