Geometry improvements

src/utilities/CMakeLists.txt

@@ -142,6 +142,8 @@ set(geometry_src
   geometry/Transformation.cpp
   geometry/Vector3d.hpp
   geometry/Vector3d.cpp
+  geometry/Polygon.hpp
+  geometry/Polygon.cpp
   ../polypartition/polypartition.cpp
 )
 

src/utilities/geometry/Geometry.i

@@ -13,6 +13,7 @@
   using namespace openstudio;
   #include <utilities/geometry/Vector3d.hpp>
   #include <utilities/geometry/Point3d.hpp>
+  #include <utilities/geometry/Polygon.hpp>
   #include <utilities/geometry/PointLatLon.hpp>
   #include <utilities/geometry/Plane.hpp>
   #include <utilities/geometry/EulerAngles.hpp>
@@ -51,6 +52,7 @@
 %template(OptionalThreeGeometry) boost::optional<openstudio::ThreeGeometry>;
 %template(OptionalFloorplanJS) boost::optional<openstudio::FloorplanJS>;
 %template(OptionalFloorplanObject) boost::optional<openstudio::FloorplanObject>;
+%template(OptionalPolygon3d) boost::optional<openstudio::Polygon3d>;
 
 // create an instantiation of the vector classes
 // Note JM 2019-04-16: No need to ignore std::vector<T>::vector/resize when you have a default constructor
@@ -100,6 +102,7 @@
 %include <utilities/geometry/Intersection.hpp>
 %include <utilities/geometry/ThreeJS.hpp>
 %include <utilities/geometry/FloorplanJS.hpp>
+%include <utilities/geometry/Polygon.hpp>
 
 %extend openstudio::Vector3d{
   std::string __str__() const {

src/utilities/geometry/Intersection.cpp

@@ -1054,4 +1054,184 @@ std::vector<Point3d> simplify(const std::vector<Point3d>& vertices, bool removeC
   return result;
 }
 
+/// <summary>
+/// Converts a Polygon to a BoostPolygon
+/// </summary>
+/// <param name="polygon"></param>
+/// <returns></returns>
+boost::optional<BoostPolygon> BoostPolygonFromPolygon(const Polygon3d& polygon) {
+  BoostPolygon boostPolygon;
+
+  for (const Point3d& vertex : polygon.getOuterPath()) {
+
+    // should all have zero z coordinate now
+    //double z = vertex.z();
+    //if (abs(z) > tol) {
+    //  LOG_FREE(Error, "utilities.geometry.boostPolygonFromVertices", "All points must be on z = 0 plane");
+    //  return boost::none;
+    //}
+    boost::geometry::append(boostPolygon, boost::make_tuple(vertex.x(), vertex.y()));
+  }
+
+  const Point3dVector& path = polygon.getOuterPath();
+  const Point3d& first = path.front();
+  boost::geometry::append(boostPolygon, boost::make_tuple(first.x(), first.y()));
+
+  return boostPolygon;
+}
+
+Polygon3d PolygonFromBoostPolygon(const BoostPolygon& boostPolygon) {
+  Polygon3d p;
+  BoostRing outer = boostPolygon.outer();
+  if (outer.empty()) {
+    return p;
+  }
+
+  Point3dVector points;
+  for (unsigned i = 0; i < outer.size() - 1; ++i) {
+    Point3d point3d(outer[i].x(), outer[i].y(), 0.0);
+    points.push_back(point3d);
+  }
+
+  points = removeCollinearLegacy(points);
+  for (auto point : points)
+    p.addPoint(point);
+
+  for (auto inner : boostPolygon.inners()) {
+    Point3dVector hole;
+    for (unsigned i = 0; i < inner.size() - 1; ++i) {
+      Point3d point3d(inner[i].x(), inner[i].y(), 0.0);
+      hole.push_back(point3d);
+    }
+    p.addHole(hole);
+  }
+
+  return p;
+}
+
+// Non class member stuff
+boost::optional<Polygon3d> join(const Polygon3d& polygon1, const Polygon3d& polygon2) {
+
+  // Convert polygons to boost polygon (not ring obvs)
+  boost::optional<BoostPolygon> boostPolygon1 = BoostPolygonFromPolygon(polygon1);
+  if (!boostPolygon1) {
+    return boost::none;
+  }
+
+  boost::optional<BoostPolygon> boostPolygon2 = BoostPolygonFromPolygon(polygon2);
+  if (!boostPolygon2) {
+    return boost::none;
+  }
+
+  std::vector<BoostPolygon> unionResult;
+  try {
+    boost::geometry::union_(*boostPolygon1, *boostPolygon2, unionResult);
+  } catch (const boost::geometry::overlay_invalid_input_exception&) {
+    LOG_FREE(Error, "utilities.geometry.join", "overlay_invalid_input_exception");
+    return boost::none;
+  }
+
+  // Smooth the result
+  unionResult = removeSpikes(unionResult);
+
+  //unionResult = removeSpikesEx(unionResult);    // This one will buffer -> and <- buffer when it is written
+
+  // Check the result - we do not have to bail for holes but we bail for > 1 poly
+  if (unionResult.empty()) {
+    return boost::none;
+  } else if (unionResult.size() > 1) {
+    return boost::none;
+  }
+
+  // Convert back to polygon
+  Polygon3d p = PolygonFromBoostPolygon(unionResult.front());
+  return p;
+}
+
+std::vector<Polygon3d> joinAllPolygons(const std::vector<std::vector<Point3d>>& polygons, double tol) {
+  std::vector<Polygon3d> inputPolygons;
+
+  // CReate Polygon3d from point3dvectors
+  for (auto polygon : polygons) {
+    Polygon3d inputPolygon;
+    for (auto point : polygon) {
+      inputPolygon.addPoint(point);
+    }
+    inputPolygons.push_back(polygon);
+  }
+
+  return joinAll(inputPolygons, tol);
+}
+
+std::vector<Polygon3d> joinAll(const std::vector<Polygon3d>& polygons, double tol) {
+
+  std::vector<Polygon3d> result;
+
+  size_t N = polygons.size();
+  if (N <= 1) {
+    return polygons;
+  }
+
+  std::vector<double> polygonAreas(N, 0.0);
+  for (unsigned i = 0; i < N; ++i) {
+    auto area = getArea(polygons[i].getOuterPath());
+    if (area) {
+      polygonAreas[i] = *area;
+    }
+  }
+
+  // compute adjacency matrix
+  Matrix A(N, N, 0.0);
+  for (unsigned i = 0; i < N; ++i) {
+    A(i, i) = 1.0;
+    for (unsigned j = i + 1; j < N; ++j) {
+      if (join(polygons[i], polygons[j] /*,tol*/)) {
+        A(i, j) = 1.0;
+        A(j, i) = 1.0;
+      }
+    }
+  }
+
+  std::vector<std::vector<unsigned>> connectedComponents = findConnectedComponents(A);
+  for (const std::vector<unsigned>& component : connectedComponents) {
+
+    std::vector<unsigned> orderedComponent(component);
+    std::sort(orderedComponent.begin(), orderedComponent.end(), [&polygonAreas](int ia, int ib) { return polygonAreas[ia] > polygonAreas[ib]; });
+
+    Polygon3d polygon;
+    std::set<unsigned> joinedComponents;
+    // try to join at most component.size() times
+    for (unsigned n = 0; n < component.size(); ++n) {
+
+      // loop over polygons to join in order
+      for (unsigned i : orderedComponent) {
+        if (polygon.getOuterPath().empty()) {
+          polygon = polygons[i];
+          joinedComponents.insert(i);
+        } else {
+          // if not already joined
+          if (joinedComponents.find(i) == joinedComponents.end()) {
+            boost::optional<Polygon3d> joined = join(polygon, polygons[i] /*, tol*/);
+            if (joined) {
+              polygon = *joined;
+              joinedComponents.insert(i);
+            }
+          }
+        }
+      }
+
+      // if all polygons have been joined then we are done
+      if (joinedComponents.size() == component.size()) {
+        break;
+      }
+    }
+
+    if (joinedComponents.size() != component.size()) {
+      LOG_FREE(Error, "utilities.geometry.joinAll", "Could not join all connected components");
+    }
+    result.push_back(polygon);
+  }
+
+  return result;
+}
 }  // namespace openstudio

src/utilities/geometry/Intersection.hpp

@@ -33,7 +33,7 @@
 #include "../UtilitiesAPI.hpp"
 
 #include "Point3d.hpp"
-
+#include "Polygon.hpp"
 #include <vector>
 #include <boost/optional.hpp>
 
@@ -80,9 +80,17 @@ UTILITIES_API bool pointInPolygon(const Point3d& point, const std::vector<Point3
 /// compute the union of two overlapping polygons, requires that all vertices are in clockwise order on the z = 0 plane (i.e. in face coordinates but reversed)
 UTILITIES_API boost::optional<std::vector<Point3d>> join(const std::vector<Point3d>& polygon1, const std::vector<Point3d>& polygon2, double tol);
 
+UTILITIES_API boost::optional<Polygon3d> join(const Polygon3d& polygon1, const Polygon3d& polygon2);
+
 /// compute the union of many polygons, requires that all vertices are in clockwise order on the z = 0 plane (i.e. in face coordinates but reversed)
 UTILITIES_API std::vector<std::vector<Point3d>> joinAll(const std::vector<std::vector<Point3d>>& polygons, double tol);
 
+/// compute the union of many polygons, requires that all vertices are in clockwise order on the z = 0 plane (i.e. in face coordinates but reversed)
+UTILITIES_API std::vector<Polygon3d> joinAll(const std::vector<Polygon3d>& polygons, double tol);
+
+/// compute the union of many polygons, requires that all vertices are in clockwise order on the z = 0 plane (i.e. in face coordinates but reversed)
+UTILITIES_API std::vector<Polygon3d> joinAllPolygons(const std::vector<std::vector<Point3d>>& polygons, double tol);
+
 /// intersect two polygons, requires that all vertices are in clockwise order on the z = 0 plane (i.e. in face coordinates but reversed)
 UTILITIES_API boost::optional<IntersectionResult> intersect(const std::vector<Point3d>& polygon1, const std::vector<Point3d>& polygon2, double tol);
 

src/utilities/geometry/Polygon.cpp

@@ -0,0 +1,147 @@
+/***********************************************************************************************************************
+*  OpenStudio(R), Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+*
+*  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+*  following conditions are met:
+*
+*  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+*  disclaimer.
+*
+*  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+*  disclaimer in the documentation and/or other materials provided with the distribution.
+*
+*  (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
+*  derived from this software without specific prior written permission from the respective party.
+*
+*  (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
+*  may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
+*  written permission from Alliance for Sustainable Energy, LLC.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+*  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
+*  STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+*  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+*  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+*  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+*  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+***********************************************************************************************************************/
+
+#include "Polygon.hpp"
+#include "Vector3d.hpp"
+#include "Geometry.hpp"
+
+namespace openstudio {
+
+Polygon3d::Polygon3d() {}
+
+Polygon3d::Polygon3d(Point3dVector outerPath) {
+  for (auto p : outerPath)
+    points.push_back(p);
+}
+
+/// <summary>
+/// Adds a point to the polygon perimeter
+/// </summary>
+/// <param name="point"></param>
+void Polygon3d::addPoint(Point3d& point) {
+  points.push_back(point);
+}
+
+/// <summary>
+/// Sets the perimeter of the polygonb
+/// </summary>
+/// <param name="perimeter"></param>
+void Polygon3d::setOuterPath(Point3dVector outerPath) {
+  points = outerPath;
+}
+
+Point3dVector Polygon3d::getOuterPath() const {
+  return points;
+}
+
+Point3dVectorVector Polygon3d::getInnerPaths() const {
+  return innerPaths;
+}
+
+/// <summary>
+/// Adds a hole to the polygon
+/// </summary>
+/// <param name="hole"></param>
+void Polygon3d::addHole(Point3dVector hole) {
+  innerPaths.push_back(hole);
+}
+
+Vector3d Polygon3d::newellVector() {
+  OptionalVector3d v = openstudio::getNewallVector(points);
+
+  if (v) {
+    return v.get();
+  }
+
+  return Vector3d();
+}
+
+Vector3d Polygon3d::outwardNormal() {
+  return openstudio::getOutwardNormal(points).get();
+}
+
+double Polygon3d::grossArea() {
+
+  boost::optional<double> area = openstudio::getArea(points);
+  if (area == boost::none)
+    return 0;
+  else
+    return area.get();
+  return 0;
+}
+
+double Polygon3d::netArea() {
+
+  double netArea = grossArea();
+  for (auto hole : innerPaths) {
+    boost::optional<double> area = openstudio::getArea(hole);
+    if (area != boost::none) netArea -= area.get();
+  }
+
+  return netArea;
+}
+
+double Polygon3d::getPerimeter() {
+
+  double perimeter = 0;
+  for (size_t i = 0; i < points.size(); i++) {
+    Point3d p1 = points[i];
+    Point3d p2 = points[(i + 1) % points.size()];
+    perimeter += openstudio::getDistance(p1, p2);
+  }
+
+  return perimeter;
+}
+
+bool Polygon3d::getIsClockwise() {
+  OptionalVector3d normal = getOutwardNormal(points);
+  if (normal == boost::none)
+    return true;
+  else
+    return normal.get().z() > 0;
+}
+
+Point3d Polygon3d::getCentroid() {
+  boost::optional p = openstudio::getCentroid(points);
+  if (p == boost::none)
+    return Point3d();
+  else
+    return p.get();
+}
+
+//bool Polygon3d::PointInPolygon(Point3d testPoint) {
+//  return true;
+//}
+
+//typedef boost::geometry::model::polygon<BoostPoint> BoostPolygon;
+//typedef boost::geometry::model::d2::point_xy<double> BoostPoint;
+
+// TODO: I want to inlude all the boolean joining etc code here
+
+}  // namespace openstudio