Method loop_to_function_item_upgrade_impl

src/ifcgeom/taxonomy.cpp:824–888

boost::optional<function_item::ptr> ifcopenshell::geometry::taxonomy::loop_to_function_item_upgrade_impl(ptr item) {
	boost::optional<function_item::ptr> function_item_;
	auto loop_ = dcast<loop>(item);
	if (loop_) {
        if (loop_->function_item.is_initialized()) {
            function_item_ = loop_->function_item;
		} else {
         // piecewise_function is a specialization of function_item - callers don't need to know this detail
			piecewise_function::spans_t spans;
			spans.reserve(loop_->children.size());
			for (auto& edge_ : loop_->children) {
				if (edge_->basis && edge_->basis->kind() == CIRCLE) {
					const circle::ptr circ = std::static_pointer_cast<circle>(edge_->basis);

					auto* s_pnt = boost::get<point3::ptr>(&edge_->start);
					auto* e_pnt = boost::get<point3::ptr>(&edge_->end);
					auto* s_param = boost::get<double>(&edge_->start);
					auto* e_param = boost::get<double>(&edge_->end);

					if (!s_pnt && !s_param) {
						return boost::none;
					}
					if (!e_pnt && !e_param) {
						return boost::none;
					}

					double s = s_pnt ? project_onto_curve(circ, **s_pnt) : *s_param;
					double e = e_pnt ? project_onto_curve(circ, **e_pnt) : *e_param;

					auto l = std::fabs(s - e) * circ->radius;
					std::function<Eigen::Matrix4d(double)> fn = [circ, s](double u) {
						point3 P;
						direction3 d;
						evaluate_curve(circ, u / circ->radius + s, P);
						evaluate_curve_d1(circ, u / circ->radius + s, d);
						return matrix4(P.ccomponents(), circ->matrix->ccomponents().col(2).head<3>(), d.ccomponents()).components();
					};
					spans.emplace_back(taxonomy::make<taxonomy::functor_item>(l, fn));
				} else if (edge_->start.which() == 1 && edge_->end.which() == 1) {
					if (edge_->basis && edge_->basis->kind() != LINE) {
						Logger::Message(Logger::Severity::LOG_WARNING, "Basis curve not supported - edge is treated as a straight line edge");
					}
					const auto& s = boost::get<point3::ptr>(edge_->start)->ccomponents();
					const auto& e = boost::get<point3::ptr>(edge_->end)->ccomponents();
					Eigen::Vector3d v = e - s;
					auto l = v.norm(); // the norm of a vector is a measure of its length
					v.normalize();     // normalize the vector so that it is a unit direction vector
					std::function<Eigen::Matrix4d(double)> fn = [s, v](double u) {
						Eigen::Vector3d o(s + u * v), axis(0, 0, 1), refDirection(v);
						auto Y = axis.cross(refDirection).normalized();
						axis = refDirection.cross(Y).normalized();
						return make<matrix4>(o, axis, refDirection)->components();
					};
					spans.emplace_back(taxonomy::make<taxonomy::functor_item>(l, fn));
				} else {
					Logger::Message(Logger::Severity::LOG_ERROR, "Basis curve not supported");
					return boost::none;
				}