@sentryware/s2-node 0.0.6

package/third_party/s2geometry/src/s2/s2lax_polygon_shape_test.cc

@@ -0,0 +1,234 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/s2lax_polygon_shape.h"
+
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "s2/third_party/absl/memory/memory.h"
+#include "s2/mutable_s2shape_index.h"
+#include "s2/s2cap.h"
+#include "s2/s2contains_point_query.h"
+#include "s2/s2lax_loop_shape.h"
+#include "s2/s2polygon.h"
+#include "s2/s2shapeutil_contains_brute_force.h"
+#include "s2/s2testing.h"
+#include "s2/s2text_format.h"
+
+using absl::make_unique;
+using s2textformat::MakePolygonOrDie;
+using std::unique_ptr;
+using std::vector;
+
+TEST(S2LaxPolygonShape, EmptyPolygon) {
+  S2LaxPolygonShape shape((S2Polygon()));
+  EXPECT_EQ(0, shape.num_loops());
+  EXPECT_EQ(0, shape.num_vertices());
+  EXPECT_EQ(0, shape.num_edges());
+  EXPECT_EQ(0, shape.num_chains());
+  EXPECT_EQ(2, shape.dimension());
+  EXPECT_TRUE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  EXPECT_FALSE(shape.GetReferencePoint().contained);
+}
+
+TEST(S2LaxPolygonShape, FullPolygon) {
+  S2LaxPolygonShape shape(S2Polygon(s2textformat::MakeLoopOrDie("full")));
+  EXPECT_EQ(1, shape.num_loops());
+  EXPECT_EQ(0, shape.num_vertices());
+  EXPECT_EQ(0, shape.num_edges());
+  EXPECT_EQ(1, shape.num_chains());
+  EXPECT_EQ(2, shape.dimension());
+  EXPECT_FALSE(shape.is_empty());
+  EXPECT_TRUE(shape.is_full());
+  EXPECT_TRUE(shape.GetReferencePoint().contained);
+}
+
+TEST(S2LaxPolygonShape, SingleVertexPolygon) {
+  // S2Polygon doesn't support single-vertex loops, so we need to construct
+  // the S2LaxPolygonShape directly.
+  vector<vector<S2Point>> loops;
+  loops.push_back(s2textformat::ParsePoints("0:0"));
+  S2LaxPolygonShape shape(loops);
+  EXPECT_EQ(1, shape.num_loops());
+  EXPECT_EQ(1, shape.num_vertices());
+  EXPECT_EQ(1, shape.num_edges());
+  EXPECT_EQ(1, shape.num_chains());
+  EXPECT_EQ(0, shape.chain(0).start);
+  EXPECT_EQ(1, shape.chain(0).length);
+  auto edge = shape.edge(0);
+  EXPECT_EQ(loops[0][0], edge.v0);
+  EXPECT_EQ(loops[0][0], edge.v1);
+  EXPECT_TRUE(edge == shape.chain_edge(0, 0));
+  EXPECT_EQ(2, shape.dimension());
+  EXPECT_FALSE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  EXPECT_FALSE(shape.GetReferencePoint().contained);
+}
+
+TEST(S2LaxPolygonShape, SingleLoopPolygon) {
+  // Test S2Polygon constructor.
+  vector<S2Point> vertices = s2textformat::ParsePoints("0:0, 0:1, 1:1, 1:0");
+  S2LaxPolygonShape shape(S2Polygon(make_unique<S2Loop>(vertices)));
+  EXPECT_EQ(1, shape.num_loops());
+  EXPECT_EQ(vertices.size(), shape.num_vertices());
+  EXPECT_EQ(vertices.size(), shape.num_loop_vertices(0));
+  EXPECT_EQ(vertices.size(), shape.num_edges());
+  EXPECT_EQ(1, shape.num_chains());
+  EXPECT_EQ(0, shape.chain(0).start);
+  EXPECT_EQ(vertices.size(), shape.chain(0).length);
+  for (int i = 0; i < vertices.size(); ++i) {
+    EXPECT_EQ(vertices[i], shape.loop_vertex(0, i));
+    auto edge = shape.edge(i);
+    EXPECT_EQ(vertices[i], edge.v0);
+    EXPECT_EQ(vertices[(i + 1) % vertices.size()], edge.v1);
+    EXPECT_EQ(edge.v0, shape.chain_edge(0, i).v0);
+    EXPECT_EQ(edge.v1, shape.chain_edge(0, i).v1);
+  }
+  EXPECT_EQ(2, shape.dimension());
+  EXPECT_FALSE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  EXPECT_FALSE(s2shapeutil::ContainsBruteForce(shape, S2::Origin()));
+}
+
+TEST(S2LaxPolygonShape, MultiLoopPolygon) {
+  // Test vector<vector<S2Point>> constructor.  Make sure that the loops are
+  // oriented so that the interior of the polygon is always on the left.
+  vector<S2LaxPolygonShape::Loop> loops = {
+    s2textformat::ParsePoints("0:0, 0:3, 3:3"),  // CCW
+    s2textformat::ParsePoints("1:1, 2:2, 1:2")   // CW
+  };
+  S2LaxPolygonShape shape(loops);
+
+  EXPECT_EQ(loops.size(), shape.num_loops());
+  int num_vertices = 0;
+  EXPECT_EQ(loops.size(), shape.num_chains());
+  for (int i = 0; i < loops.size(); ++i) {
+    EXPECT_EQ(loops[i].size(), shape.num_loop_vertices(i));
+    EXPECT_EQ(num_vertices, shape.chain(i).start);
+    EXPECT_EQ(loops[i].size(), shape.chain(i).length);
+    for (int j = 0; j < loops[i].size(); ++j) {
+      EXPECT_EQ(loops[i][j], shape.loop_vertex(i, j));
+      auto edge = shape.edge(num_vertices + j);
+      EXPECT_EQ(loops[i][j], edge.v0);
+      EXPECT_EQ(loops[i][(j + 1) % loops[i].size()], edge.v1);
+    }
+    num_vertices += loops[i].size();
+  }
+  EXPECT_EQ(num_vertices, shape.num_vertices());
+  EXPECT_EQ(num_vertices, shape.num_edges());
+  EXPECT_EQ(2, shape.dimension());
+  EXPECT_FALSE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  EXPECT_FALSE(s2shapeutil::ContainsBruteForce(shape, S2::Origin()));
+}
+
+TEST(S2LaxPolygonShape, MultiLoopS2Polygon) {
+  // Verify that the orientation of loops representing holes is reversed when
+  // converting from an S2Polygon to an S2LaxPolygonShape.
+  auto polygon = MakePolygonOrDie("0:0, 0:3, 3:3; 1:1, 1:2, 2:2");
+  S2LaxPolygonShape shape(*polygon);
+  for (int i = 0; i < polygon->num_loops(); ++i) {
+    S2Loop* loop = polygon->loop(i);
+    for (int j = 0; j < loop->num_vertices(); ++j) {
+      EXPECT_EQ(loop->oriented_vertex(j),
+                shape.loop_vertex(i, j));
+    }
+  }
+}
+
+TEST(S2LaxPolygonShape, ManyLoopPolygon) {
+  // Test a polygon with enough loops so that cumulative_vertices_ is used.
+  vector<vector<S2Point>> loops;
+  for (int i = 0; i < 100; ++i) {
+    S2Point center(S2LatLng::FromDegrees(0, i));
+    loops.push_back(
+        S2Testing::MakeRegularPoints(center, S1Angle::Degrees(0.1),
+                                     S2Testing::rnd.Uniform(3)));
+  }
+  S2LaxPolygonShape shape(loops);
+
+  EXPECT_EQ(loops.size(), shape.num_loops());
+  int num_vertices = 0;
+  EXPECT_EQ(loops.size(), shape.num_chains());
+  for (int i = 0; i < loops.size(); ++i) {
+    EXPECT_EQ(loops[i].size(), shape.num_loop_vertices(i));
+    EXPECT_EQ(num_vertices, shape.chain(i).start);
+    EXPECT_EQ(loops[i].size(), shape.chain(i).length);
+    for (int j = 0; j < loops[i].size(); ++j) {
+      EXPECT_EQ(loops[i][j], shape.loop_vertex(i, j));
+      auto edge = shape.edge(num_vertices + j);
+      EXPECT_EQ(loops[i][j], edge.v0);
+      EXPECT_EQ(loops[i][(j + 1) % loops[i].size()], edge.v1);
+    }
+    num_vertices += loops[i].size();
+  }
+  EXPECT_EQ(num_vertices, shape.num_vertices());
+  EXPECT_EQ(num_vertices, shape.num_edges());
+}
+
+TEST(S2LaxPolygonShape, DegenerateLoops) {
+  vector<S2LaxPolygonShape::Loop> loops = {
+    s2textformat::ParsePoints("1:1, 1:2, 2:2, 1:2, 1:3, 1:2, 1:1"),
+    s2textformat::ParsePoints("0:0, 0:3, 0:6, 0:9, 0:6, 0:3, 0:0"),
+    s2textformat::ParsePoints("5:5, 6:6")
+  };
+  S2LaxPolygonShape shape(loops);
+  EXPECT_FALSE(shape.GetReferencePoint().contained);
+}
+
+TEST(S2LaxPolygonShape, InvertedLoops) {
+  vector<S2LaxPolygonShape::Loop> loops = {
+    s2textformat::ParsePoints("1:2, 1:1, 2:2"),
+    s2textformat::ParsePoints("3:4, 3:3, 4:4")
+  };
+  S2LaxPolygonShape shape(loops);
+  EXPECT_TRUE(s2shapeutil::ContainsBruteForce(shape, S2::Origin()));
+}
+
+void CompareS2LoopToShape(const S2Loop& loop, unique_ptr<S2Shape> shape) {
+  MutableS2ShapeIndex index;
+  index.Add(std::move(shape));
+  S2Cap cap = loop.GetCapBound();
+  auto query = MakeS2ContainsPointQuery(&index);
+  for (int iter = 0; iter < 100; ++iter) {
+    S2Point point = S2Testing::SamplePoint(cap);
+    EXPECT_EQ(loop.Contains(point),
+              query.ShapeContains(*index.shape(0), point));
+  }
+}
+
+TEST(S2LaxPolygonShape, CompareToS2Loop) {
+  for (int iter = 0; iter < 100; ++iter) {
+    S2Testing::Fractal fractal;
+    fractal.set_max_level(S2Testing::rnd.Uniform(5));
+    fractal.set_fractal_dimension(1 + S2Testing::rnd.RandDouble());
+    S2Point center = S2Testing::RandomPoint();
+    unique_ptr<S2Loop> loop(fractal.MakeLoop(
+        S2Testing::GetRandomFrameAt(center), S1Angle::Degrees(5)));
+
+    // Compare S2Loop to S2LaxLoopShape.
+    CompareS2LoopToShape(*loop, make_unique<S2LaxLoopShape>(*loop));
+
+    // Compare S2Loop to S2LaxPolygonShape.
+    vector<S2LaxPolygonShape::Loop> loops(
+        1, vector<S2Point>(&loop->vertex(0),
+                           &loop->vertex(0) + loop->num_vertices()));
+    CompareS2LoopToShape(*loop, make_unique<S2LaxPolygonShape>(loops));
+  }
+}

package/third_party/s2geometry/src/s2/s2lax_polyline_shape.cc

@@ -0,0 +1,118 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/s2lax_polyline_shape.h"
+
+#include <algorithm>
+#include "s2/base/logging.h"
+#include "s2/s2polyline.h"
+
+using absl::make_unique;
+using absl::MakeSpan;
+using std::vector;
+
+S2LaxPolylineShape::S2LaxPolylineShape(const vector<S2Point>& vertices) {
+  Init(vertices);
+}
+
+S2LaxPolylineShape::S2LaxPolylineShape(const S2Polyline& polyline) {
+  Init(polyline);
+}
+
+void S2LaxPolylineShape::Init(const vector<S2Point>& vertices) {
+  num_vertices_ = vertices.size();
+  S2_LOG_IF(WARNING, num_vertices_ == 1)
+      << "s2shapeutil::S2LaxPolylineShape with one vertex has no edges";
+  vertices_.reset(new S2Point[num_vertices_]);
+  std::copy(vertices.begin(), vertices.end(), vertices_.get());
+}
+
+void S2LaxPolylineShape::Init(const S2Polyline& polyline) {
+  num_vertices_ = polyline.num_vertices();
+  S2_LOG_IF(WARNING, num_vertices_ == 1)
+      << "s2shapeutil::S2LaxPolylineShape with one vertex has no edges";
+  vertices_.reset(new S2Point[num_vertices_]);
+  std::copy(&polyline.vertex(0), &polyline.vertex(0) + num_vertices_,
+            vertices_.get());
+}
+
+void S2LaxPolylineShape::Encode(Encoder* encoder,
+                                s2coding::CodingHint hint) const {
+  s2coding::EncodeS2PointVector(MakeSpan(vertices_.get(), num_vertices_),
+                                hint, encoder);
+}
+
+bool S2LaxPolylineShape::Init(Decoder* decoder) {
+  s2coding::EncodedS2PointVector vertices;
+  if (!vertices.Init(decoder)) return false;
+  num_vertices_ = vertices.size();
+  vertices_ = make_unique<S2Point[]>(vertices.size());
+  for (int i = 0; i < num_vertices_; ++i) {
+    vertices_[i] = vertices[i];
+  }
+  return true;
+}
+
+S2Shape::Edge S2LaxPolylineShape::edge(int e) const {
+  S2_DCHECK_LT(e, num_edges());
+  return Edge(vertex(e), vertex(e + 1));
+}
+
+int S2LaxPolylineShape::num_chains() const {
+  return std::min(1, S2LaxPolylineShape::num_edges());  // Avoid virtual call.
+}
+
+S2Shape::Chain S2LaxPolylineShape::chain(int i) const {
+  return Chain(0, S2LaxPolylineShape::num_edges());  // Avoid virtual call.
+}
+
+S2Shape::Edge S2LaxPolylineShape::chain_edge(int i, int j) const {
+  S2_DCHECK_EQ(i, 0);
+  S2_DCHECK_LT(j, num_edges());
+  return Edge(vertex(j), vertex(j + 1));
+}
+
+S2Shape::ChainPosition S2LaxPolylineShape::chain_position(int e) const {
+  return S2Shape::ChainPosition(0, e);
+}
+
+bool EncodedS2LaxPolylineShape::Init(Decoder* decoder) {
+  return vertices_.Init(decoder);
+}
+
+S2Shape::Edge EncodedS2LaxPolylineShape::edge(int e) const {
+  S2_DCHECK_LT(e, num_edges());
+  return Edge(vertex(e), vertex(e + 1));
+}
+
+int EncodedS2LaxPolylineShape::num_chains() const {
+  return std::min(1, EncodedS2LaxPolylineShape::num_edges());
+}
+
+S2Shape::Chain EncodedS2LaxPolylineShape::chain(int i) const {
+  return Chain(0, EncodedS2LaxPolylineShape::num_edges());
+}
+
+S2Shape::Edge EncodedS2LaxPolylineShape::chain_edge(int i, int j) const {
+  S2_DCHECK_EQ(i, 0);
+  S2_DCHECK_LT(j, num_edges());
+  return Edge(vertex(j), vertex(j + 1));
+}
+
+S2Shape::ChainPosition EncodedS2LaxPolylineShape::chain_position(int e) const {
+  return S2Shape::ChainPosition(0, e);
+}

package/third_party/s2geometry/src/s2/s2lax_polyline_shape.h

@@ -0,0 +1,124 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#ifndef S2_S2LAX_POLYLINE_SHAPE_H_
+#define S2_S2LAX_POLYLINE_SHAPE_H_
+
+#include <memory>
+#include <vector>
+#include "s2/encoded_s2point_vector.h"
+#include "s2/s2polyline.h"
+#include "s2/s2shape.h"
+
+// S2LaxPolylineShape represents a polyline.  It is similar to
+// S2Polyline::Shape except that duplicate vertices are allowed, and the
+// representation is slightly more compact.
+//
+// Polylines may have any number of vertices, but note that polylines with
+// fewer than 2 vertices do not define any edges.  (To create a polyline
+// consisting of a single degenerate edge, either repeat the same vertex twice
+// or use S2LaxClosedPolylineShape defined in s2_lax_loop_shape.h.)
+class S2LaxPolylineShape : public S2Shape {
+ public:
+  static constexpr TypeTag kTypeTag = 4;
+
+  // Constructs an empty polyline.
+  S2LaxPolylineShape() : num_vertices_(0) {}
+
+  // Constructs an S2LaxPolylineShape with the given vertices.
+  explicit S2LaxPolylineShape(const std::vector<S2Point>& vertices);
+
+  // Constructs an S2LaxPolylineShape from the given S2Polyline, by copying
+  // its data.
+  explicit S2LaxPolylineShape(const S2Polyline& polyline);
+
+  // Initializes an S2LaxPolylineShape with the given vertices.
+  void Init(const std::vector<S2Point>& vertices);
+
+  // Initializes an S2LaxPolylineShape from the given S2Polyline, by copying
+  // its data.
+  void Init(const S2Polyline& polyline);
+
+  int num_vertices() const { return num_vertices_; }
+  const S2Point& vertex(int i) const { return vertices_[i]; }
+
+  // Appends an encoded representation of the S2LaxPolylineShape to "encoder".
+  //
+  // REQUIRES: "encoder" uses the default constructor, so that its buffer
+  //           can be enlarged as necessary by calling Ensure(int).
+  void Encode(Encoder* encoder,
+              s2coding::CodingHint hint = s2coding::CodingHint::COMPACT) const;
+
+  // Decodes an S2LaxPolylineShape, returning true on success.  (The method
+  // name is chosen for compatibility with EncodedS2LaxPolylineShape below.)
+  bool Init(Decoder* decoder);
+
+  // S2Shape interface:
+  int num_edges() const final { return std::max(0, num_vertices() - 1); }
+  Edge edge(int e) const final;
+  int dimension() const final { return 1; }
+  ReferencePoint GetReferencePoint() const final {
+    return ReferencePoint::Contained(false);
+  }
+  int num_chains() const final;
+  Chain chain(int i) const final;
+  Edge chain_edge(int i, int j) const final;
+  ChainPosition chain_position(int e) const final;
+  TypeTag type_tag() const override { return kTypeTag; }
+
+ private:
+  // For clients that have many small polylines, we save some memory by
+  // representing the vertices as an array rather than using std::vector.
+  int32 num_vertices_;
+  std::unique_ptr<S2Point[]> vertices_;
+};
+
+// Exactly like S2LaxPolylineShape, except that the vertices are kept in an
+// encoded form and are decoded only as they are accessed.  This allows for
+// very fast initialization and no additional memory use beyond the encoded
+// data.  The encoded data is not owned by this class; typically it points
+// into a large contiguous buffer that contains other encoded data as well.
+class EncodedS2LaxPolylineShape : public S2Shape {
+ public:
+  // Constructs an uninitialized object; requires Init() to be called.
+  EncodedS2LaxPolylineShape() {}
+
+  // Initializes an EncodedS2LaxPolylineShape.
+  //
+  // REQUIRES: The Decoder data buffer must outlive this object.
+  bool Init(Decoder* decoder);
+
+  int num_vertices() const { return vertices_.size(); }
+  S2Point vertex(int i) const { return vertices_[i]; }
+
+  // S2Shape interface:
+  int num_edges() const final { return std::max(0, num_vertices() - 1); }
+  Edge edge(int e) const final;
+  int dimension() const final { return 1; }
+  ReferencePoint GetReferencePoint() const final {
+    return ReferencePoint::Contained(false);
+  }
+  int num_chains() const final;
+  Chain chain(int i) const final;
+  Edge chain_edge(int i, int j) const final;
+  ChainPosition chain_position(int e) const final;
+
+ private:
+  s2coding::EncodedS2PointVector vertices_;
+};
+
+#endif  // S2_S2LAX_POLYLINE_SHAPE_H_

package/third_party/s2geometry/src/s2/s2lax_polyline_shape_test.cc

@@ -0,0 +1,62 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/s2lax_polyline_shape.h"
+
+#include <gtest/gtest.h>
+#include "s2/s2text_format.h"
+
+using std::vector;
+
+TEST(S2LaxPolylineShape, NoVertices) {
+  vector<S2Point> vertices;
+  S2LaxPolylineShape shape(vertices);
+  EXPECT_EQ(0, shape.num_edges());
+  EXPECT_EQ(0, shape.num_chains());
+  EXPECT_EQ(1, shape.dimension());
+  EXPECT_TRUE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  EXPECT_FALSE(shape.GetReferencePoint().contained);
+}
+
+TEST(S2LaxPolylineShape, OneVertex) {
+  vector<S2Point> vertices = {S2Point(1, 0, 0)};
+  S2LaxPolylineShape shape(vertices);
+  EXPECT_EQ(0, shape.num_edges());
+  EXPECT_EQ(0, shape.num_chains());
+  EXPECT_EQ(1, shape.dimension());
+  EXPECT_TRUE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+}
+
+TEST(S2LaxPolylineShape, EdgeAccess) {
+  vector<S2Point> vertices = s2textformat::ParsePoints("0:0, 0:1, 1:1");
+  S2LaxPolylineShape shape(vertices);
+  EXPECT_EQ(2, shape.num_edges());
+  EXPECT_EQ(1, shape.num_chains());
+  EXPECT_EQ(0, shape.chain(0).start);
+  EXPECT_EQ(2, shape.chain(0).length);
+  EXPECT_EQ(1, shape.dimension());
+  EXPECT_FALSE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  auto edge0 = shape.edge(0);
+  EXPECT_EQ(vertices[0], edge0.v0);
+  EXPECT_EQ(vertices[1], edge0.v1);
+  auto edge1 = shape.edge(1);
+  EXPECT_EQ(vertices[1], edge1.v0);
+  EXPECT_EQ(vertices[2], edge1.v1);
+}