Class RawCoordinateSequenceFactory

Factory for creating RawCoordinateSequence instances.

Inheritance

object

CoordinateSequenceFactory

RawCoordinateSequenceFactory

Inherited Members

CoordinateSequenceFactory.Ordinates

CoordinateSequenceFactory.Create(Coordinate[])

CoordinateSequenceFactory.Create(CoordinateSequence)

CoordinateSequenceFactory.Create(int, int)

CoordinateSequenceFactory.Create(int, Ordinates)

CoordinateSequenceFactory.GetCommonSequenceParameters(Coordinate[])

object.Equals(object)

object.Equals(object, object)

object.GetHashCode()

object.GetType()

object.ReferenceEquals(object, object)

object.ToString()

Namespace: NetTopologySuite.Geometries.Implementation

Assembly: NetTopologySuite.dll

Syntax

public sealed class RawCoordinateSequenceFactory : CoordinateSequenceFactory

Constructors

| Edit this page View Source

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

| Edit this page View Source

Create(int, int, int)

Creates a CoordinateSequence of the specified size and dimension with measure support. For this to be useful, the CoordinateSequence implementation must be mutable.

Declaration

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

Parameters

Type	Name	Description
int	size	The number of coordinates in the sequence
int	dimension	The dimension of the coordinates in the sequence (if user-specifiable, otherwise ignored)
int	measures	The number of measures of the coordinates in the sequence (if user-specifiable, otherwise ignored)

Returns

Type	Description
CoordinateSequence

Overrides

CoordinateSequenceFactory.Create(int, int, int)

Remarks

If the requested dimension or measures are larger than the CoordinateSequence implementation can provide, then a sequence of maximum possible dimension should be created. An error should not be thrown.

| Edit this page View Source

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.

| Edit this page View Source

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.

| Edit this page View Source

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

Exceptions

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

| Edit this page View Source

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.

| Edit this page View Source

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.

| Edit this page View Source

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

Exceptions

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

| Edit this page View Source

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

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.

| Edit this page View Source

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.

| Edit this page View Source

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

Exceptions

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

| Edit this page View Source

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

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.

| Edit this page View Source

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.