MultiSurface abstract class
A MultiSurface is a 2-dimensional GeometryCollection whose elements are Surfaces, all using coordinates from the same coordinate reference system.
abstract class MultiSurface extends GeometryCollection { MultiSurface(Iterable<Surface> surfaces):super(surfaces); /** * The mathematical centroid for this [Surface] as a [Point]. The result * is not guaranteed to be on this [Surface]. * */ @specification(name:"centroid()") Point get centroid; /** * A [Point] guaranteed to be on this [Surface]. */ @specification(name:"pointOnSurface()") Point get pointOnSurface; /** * The area of this [Surface], as measured in the spatial reference system * of this [Surface]. */ @specification(name:"area()") double get area; }
Extends
Geometry > Geometry_IterableMixin > Geometry_IterableMixin__GeometryContainerMixin > GeometryCollection > MultiSurface
Subclasses
Constructors
Properties
final String asText #
A WKT representation of the geometry
@specification(name:"asText()") String get asText { var buffer = new StringBuffer(); var writer = new _WKTWriter(buffer); _writeTaggedWKT(writer, withZ: is3D, withM: isMeasured); return buffer.toString(); }
final Geometry boundary #
Returns the closure of the combinatorial boundary of this geometric object
@specification(name:"boundary()") Geometry get boundary;
final int dimension #
The inherent dimension of this geometric object, which must be less than or equal to the coordinate dimension. In non-homogeneous collections, this will return the largest topological dimension of the contained objects.
@override int get dimension => fold(0, (prev, g) => max(prev, g.dimension));
final E first #
final String geometryType #
Returns the name of the instantiable subtype of Geometry of which this geometric object is an instantiable member. The name of the subtype of Geometry is returned as a string.
@override String get geometryType => "GeometryCollection";
final bool is3D #
A collection of geometries is considered 3D if every child geometry has a non-null z-component.
The value of this property is computed upon first access and then cached. Subsequent reads of the property efficiently reply the cached value.
@override bool get is3D { if (_is3D == null) _computeIs3D(); return _is3D; }
final bool isEmpty #
Returns 1 true if this geometric object is the empty Geometry.
bool get isEmpty => !iterator.moveNext();
final bool isMeasured #
A collection of geometries is considered measured if every child geometry has an m-component.
The value of this property is computed upon first access and then cached. Subsequent reads of the property efficiently reply the cached value.
@override bool get isMeasured { if (_isMeasured == null) _computeIsMeasured(); return _isMeasured; }
final bool isSimple #
A geometry collection is simple if all its child geometries are simple.
@override bool get isSimple => every((g) => g.isSimple);
final Iterator<Geometry> iterator #
the iterator to access the geometry objects
Iterator<Geometry> get iterator { if (_geometries == null) return [].iterator; else return _geometries.iterator; }
final E last #
final int length #
final int numGeometries #
Replies the number of geometries in this collection.
This getter is equivaled to the method getNumGeometries()
in the SFS, but see also length
.
@specification(name:"getNumGeometries") int get numGeometries => length;
final E single #
Returns the single element in this
.
If this
is empty or has more than one element throws a StateError
.
E get single { Iterator it = iterator; if (!it.moveNext()) throw new StateError("No elements"); E result = it.current; if (it.moveNext()) throw new StateError("More than one element"); return result; }
Operators
dynamic operator [](int n) #
Replies the <em>n</em>-th geometry in this collection.
This is the Dart'ish implemenation of getGeometryN()
using
operator overloading.
@specification(name:"getGeometryN") operator [](int n) => elementAt(n);
Methods
bool any(bool f(E element)) #
bool contains(E element) #
E elementAt(int index) #
Returns the indexth element.
If [this] [Iterable] has fewer than
index elements throws a
RangeError
.
Note: if this
does not have a deterministic iteration order then the
function may simply return any element without any iteration if there are
at least
index elements in this
.
E elementAt(int index) { if (index is! int || index < 0) throw new RangeError.value(index); int remaining = index; for (E element in this) { if (remaining == 0) return element; remaining--; } throw new RangeError.value(index); }
bool every(bool f(E element)) #
Iterable expand(Iterable f(E element)) #
Expand each element of this Iterable
into zero or more elements.
The resulting Iterable will run through the elements returned by f for each element of this, in order.
The returned Iterable
is lazy, and will call
f for each element
of this every time it's iterated.
Iterable expand(Iterable f(E element)) => new ExpandIterable<E, dynamic>(this, f);
E firstWhere(bool test(E value), {E orElse()}) #
Returns the first element that satisfies the given predicate f
.
If none matches, the result of invoking the
orElse function is
returned. By default, when
orElse is null
, a StateError
is
thrown.
E firstWhere(bool test(E value), { E orElse() }) { // TODO(floitsch): check that arguments are of correct type? for (E element in this) { if (test(element)) return element; } if (orElse != null) return orElse(); throw new StateError("No matching element"); }
dynamic fold(initialValue, combine(previousValue, E element)) #
Reduces a collection to a single value by iteratively combining each element of the collection with an existing value using the provided function.
Use initialValue as the initial value, and the function combine to create a new value from the previous one and an element.
Example of calculating the sum of an iterable:
iterable.fold(0, (prev, element) => prev + element);
dynamic fold(var initialValue, dynamic combine(var previousValue, E element)) { var value = initialValue; for (E element in this) value = combine(value, element); return value; }
void forEach(void f(E element)) #
Geometry getGeometryN(int n) #
Replies the <em>n</em>-th geometry in this collection.
@specification(name:"getGeometryN") Geometry getGeometryN(int n) => elementAt(n);
String join([String separator]) #
Converts each element to a String
and concatenates the strings.
Converts each element to a String
by calling Object.toString
on it.
Then concatenates the strings, optionally separated by the
separator
string.
String join([String separator]) { Iterator<E> iterator = this.iterator; if (!iterator.moveNext()) return ""; StringBuffer buffer = new StringBuffer(); if (separator == null || separator == "") { do { buffer.write("${iterator.current}"); } while (iterator.moveNext()); } else { buffer.write("${iterator.current}"); while (iterator.moveNext()) { buffer.write(separator); buffer.write("${iterator.current}"); } } return buffer.toString(); }
E lastWhere(bool test(E value), {E orElse()}) #
Returns the last element that satisfies the given predicate f
.
If none matches, the result of invoking the
orElse function is
returned. By default, when
orElse is null
, a StateError
is
thrown.
E lastWhere(bool test(E value), {E orElse()}) { // TODO(floitsch): check that arguments are of correct type? E result = null; bool foundMatching = false; for (E element in this) { if (test(element)) { result = element; foundMatching = true; } } if (foundMatching) return result; if (orElse != null) return orElse(); throw new StateError("No matching element"); }
Iterable map(f(E element)) #
Returns a lazy Iterable
where each element e
of this
is replaced
by the result of f(e)
.
This method returns a view of the mapped elements. As long as the
returned Iterable
is not iterated over, the supplied function
f will
not be invoked. The transformed elements will not be cached. Iterating
multiple times over the the returned Iterable
will invoke the supplied
function
f multiple times on the same element.
Iterable map(f(E element)) => new MappedIterable<E, dynamic>(this, f);
E reduce(E combine(E value, E element)) #
Reduces a collection to a single value by iteratively combining elements of the collection using the provided function.
Example of calculating the sum of an iterable:
iterable.reduce((value, element) => value + element);
E reduce(E combine(E value, E element)) { Iterator<E> iterator = this.iterator; if (!iterator.moveNext()) { throw new StateError("No elements"); } E value = iterator.current; while (iterator.moveNext()) { value = combine(value, iterator.current); } return value; }
E singleWhere(bool test(E value)) #
Returns the single element that satisfies f
. If no or more than one
element match then a StateError
is thrown.
E singleWhere(bool test(E value)) { // TODO(floitsch): check that argument is of correct type? E result = null; bool foundMatching = false; for (E element in this) { if (test(element)) { if (foundMatching) { throw new StateError("More than one matching element"); } result = element; foundMatching = true; } } if (foundMatching) return result; throw new StateError("No matching element"); }
Iterable<E> skip(int n) #
Iterable<E> skipWhile(bool test(E value)) #
Returns an Iterable
that skips elements while
test is satisfied.
The filtering happens lazily. Every new Iterator
of the returned
Iterable
will iterate over all elements of this
.
As long as the iterator's elements do not satisfy
test they are
discarded. Once an element satisfies the
test the iterator stops testing
and uses every element unconditionally.
Iterable<E> skipWhile(bool test(E value)) { return new SkipWhileIterable<E>(this, test); }
Iterable<E> take(int n) #
Iterable<E> takeWhile(bool test(E value)) #
Returns an Iterable
that stops once
test is not satisfied anymore.
The filtering happens lazily. Every new Iterator
of the returned
Iterable
will start iterating over the elements of this
.
When the iterator encounters an element e
that does not satisfy
test,
it discards e
and moves into the finished state. That is, it will not
ask or provide any more elements.
Iterable<E> takeWhile(bool test(E value)) { return new TakeWhileIterable<E>(this, test); }
List<E> toList({bool growable: true}) #
Set<E> toSet() #
Iterable<E> where(bool f(E element)) #
Returns a lazy Iterable
with all elements that satisfy the
predicate
f.
This method returns a view of the mapped elements. As long as the
returned Iterable
is not iterated over, the supplied function
f will
not be invoked. Iterating will not cache results, and thus iterating
multiple times over the the returned Iterable
will invoke the supplied
function
f multiple times on the same element.
Iterable<E> where(bool f(E element)) => new WhereIterable<E>(this, f);