Method addOverhangByProjectionFactor

src/model/SubSurface.cpp:1050–1102

    }

    boost::optional<ShadingSurface> SubSurface_Impl::addOverhangByProjectionFactor(double projectionFactor, double offsetFraction) {
      std::string subSurfaceType = this->subSurfaceType();
      if (!(istringEqual("FixedWindow", subSurfaceType) || istringEqual("OperableWindow", subSurfaceType)
            || istringEqual("GlassDoor", subSurfaceType))) {
        return boost::none;
      }

      Model model = this->model();
      boost::optional<Space> space = this->space();
      boost::optional<ShadingSurface> shadingSurface;
      if (space) {

        Point3dVector vertices = this->vertices();
        Transformation transformation = Transformation::alignFace(vertices);
        Point3dVector faceVertices = transformation.inverse() * vertices;

        // new coordinate system has z' in direction of outward normal, y' is up
        double xmin = std::numeric_limits<double>::max();
        double xmax = std::numeric_limits<double>::min();
        double ymin = std::numeric_limits<double>::max();
        double ymax = std::numeric_limits<double>::min();
        for (const Point3d& faceVertex : faceVertices) {
          xmin = std::min(xmin, faceVertex.x());
          xmax = std::max(xmax, faceVertex.x());
          ymin = std::min(ymin, faceVertex.y());
          ymax = std::max(ymax, faceVertex.y());
        }
        if ((xmin > xmax) || (ymin > ymax)) {
          return boost::none;
        }

        double offset = offsetFraction * (ymax - ymin);
        double depth = projectionFactor * (offset + (ymax - ymin));

        Point3dVector overhangVertices{
          {xmax + offset, ymax + offset, 0},
          {xmin - offset, ymax + offset, 0},
          {xmin - offset, ymax + offset, depth},
          {xmax + offset, ymax + offset, depth},
        };

        ShadingSurfaceGroup shadingSurfaceGroup(model);
        shadingSurfaceGroup.setName(this->name().get() + " Shading Surfaces");
        shadingSurfaceGroup.setSpace(*space);

        shadingSurface = ShadingSurface(transformation * overhangVertices, model);
        shadingSurface->setShadingSurfaceGroup(shadingSurfaceGroup);

        shadingSurfaceGroup.setShadedSubSurface(getObject<SubSurface>());
      }

      return shadingSurface;
    }

    std::vector<ShadingSurfaceGroup> SubSurface_Impl::shadingSurfaceGroups() const {
      return getObject<ModelObject>().getModelObjectSources<ShadingSurfaceGroup>(ShadingSurfaceGroup::iddObjectType());