Method intersectSurfaces

src/model/Space.cpp:2714–2814

    }

    void Space_Impl::intersectSurfaces(Space& other) {
      if (this->handle() == other.handle()) {
        return;
      }

      std::string name = nameString();
      std::string otherName = other.nameString();
      LOG(Debug, "Intersecting space " << name << " with space " << otherName);

      std::vector<Surface> surfaces = this->surfaces();
      std::vector<Surface> otherSurfaces = other.surfaces();

      std::sort(surfaces.begin(), surfaces.end(), [](const Surface& a, const Surface& b) -> bool { return a.grossArea() > b.grossArea(); });
      std::sort(otherSurfaces.begin(), otherSurfaces.end(), [](const Surface& a, const Surface& b) -> bool { return a.grossArea() > b.grossArea(); });

      std::map<std::string, bool> hasSubSurfaceMap;
      std::map<std::string, bool> hasAdjacentSurfaceMap;
      std::set<std::string> completedIntersections;

      bool anyNewSurfaces = true;
      while (anyNewSurfaces) {

        anyNewSurfaces = false;
        std::vector<Surface> newSurfaces;
        std::vector<Surface> newOtherSurfaces;

        for (Surface& surface : surfaces) {
          std::string surfaceHandle = toString(surface.handle());

          if (hasSubSurfaceMap.find(surfaceHandle) == hasSubSurfaceMap.end()) {
            hasSubSurfaceMap[surfaceHandle] = !surface.subSurfaces().empty();
            hasAdjacentSurfaceMap[surfaceHandle] = surface.adjacentSurface().has_value();
          }

          if (hasSubSurfaceMap[surfaceHandle] || hasAdjacentSurfaceMap[surfaceHandle]) {
            continue;
          }

          for (Surface& otherSurface : otherSurfaces) {
            std::string otherSurfaceHandle = toString(otherSurface.handle());

            if (hasSubSurfaceMap.find(otherSurfaceHandle) == hasSubSurfaceMap.end()) {
              hasSubSurfaceMap[otherSurfaceHandle] = !otherSurface.subSurfaces().empty();
              hasAdjacentSurfaceMap[otherSurfaceHandle] = otherSurface.adjacentSurface().has_value();
            }

            if (hasSubSurfaceMap[otherSurfaceHandle] || hasAdjacentSurfaceMap[otherSurfaceHandle]) {
              continue;
            }

            // see if we have already tested these for intersection,
            // surfaces that previously did not intersect will not intersect if vertices change
            // surfaces that previously did intersect will intersect exactly
            std::string intersectionKey = surfaceHandle + otherSurfaceHandle;
            if (completedIntersections.find(intersectionKey) != completedIntersections.end()) {
              continue;
            }
            completedIntersections.insert(intersectionKey);