OrcaSlicer/src/libslic3r/Orient.hpp

#ifndef ORIENT_HPP
#define ORIENT_HPP

#include "TriangleMesh.hpp"
#include "Point.hpp"
#include "PrintConfig.hpp"
#include "libslic3r/Model.hpp"
#include <string>
#include <functional>
#include <Eigen/Core>
#include <vector>

namespace Slic3r {

namespace orientation {


/// A logical bed representing an object not being orientd. Either the orient
/// has not yet successfully run on this OrientPolygon or it could not fit the
/// object due to overly large size or invalid geometry.
static const constexpr int UNORIENTD = -1;

/// Input/Output structure for the orient() function. The mesh field will not
/// be modified during orientment. Instead, the translation and rotation fields
/// will mark the needed transformation for the polygon to be in the orientd
/// position. These can also be set to an initial offset and rotation.
///
/// The bed_idx field will indicate the logical bed into which the
/// polygon belongs: UNORIENTD means no place for the polygon
/// (also the initial state before orient), 0..N means the index of the bed.
/// Zero is the physical bed, larger than zero means a virtual bed.
struct OrientMesh {
    TriangleMesh mesh;              /// The real mesh data
    double overhang_angle = 30;
    double angle{ 0 };
    double angle_vertical{ 0 };
    Vec3d axis{ 0,0,1 };
    Vec3d axis_vertical{ 0,0,1 };
    Vec3d orientation{ 0,0,1 };
    Vec3d orientation_vertical{ -1,0,0 };
    Matrix3d rotation_matrix = Matrix3d::Identity();
    Matrix3d rotation_matrix_vertical = Matrix3d::Identity();
    Vec3d euler_angles = {0, 0, 0};
    Vec3d euler_angles_vertical = {0, 0, 0};
    Vec3d cooling_direction = {0, 0, 0};
    bool has_cooling_fan{false};

    std::string name;

    /// Optional setter function which can store arbitrary data in its closure
    std::function<void(const OrientMesh&)> setter = nullptr;

    /// Helper function to call the setter with the orient data arguments
    void apply() const { if (setter) setter(*this); }

};

struct OrientParams {
    float TAR_A               { 0.01f };     // 0.128f;
    float TAR_B               { 0.177f };
    float RELATIVE_F          { 6.610621027964314f };
    float CONTOUR_F           { 0.23228623269775997f };
    float BOTTOM_F            { 1.167152017941474f };
    float BOTTOM_HULL_F       { 0.1f };
    float TAR_C               { 0.24308070476924726f };
    float TAR_D               { 0.6284515508160871f };
    float TAR_E               { 0};         // 0.032157292647062234;
    float FIRST_LAY_H         { 0.2f};      // 0.029;
    float VECTOR_TOL          { -0.0011163303070972383f };
    float NEGL_FACE_SIZE      { 0.1f };
    float ASCENT              { -0.5f };
    float PLAFOND_ADV         { 0.04079208948120519f };
    float CONTOUR_AMOUNT      { 0.0101472219892684f };
    float OV_H                { 1.0370178217794535f };
    float height_offset       { 2.7417608343142073f };
    float height_log          { 0.06442030687034085f };
    float height_log_k        { 0.3933594673063997f };
    float LAF_MAX             { 0.999f };    // cos(1.4\degree) for low angle face //0.9997f;
    float LAF_MIN             { 0.9703f };   // cos(14\degree) 0.9703f;
    float TAR_LAF             { 0.01f };     // 0.1f
    float TAR_PROJ_AREA       { 0.1f };
    float BOTTOM_MIN          { 0.1f };      // min bottom area. If lower than it the objects may be unstable
    float BOTTOM_MAX          { 2000 };      // 400
    float height_to_bottom_hull_ratio_MIN { 1 };
    float BOTTOM_HULL_MAX     { 2000 };      // max bottom hull area to clip //600
    float APPERANCE_FACE_SUPP { 3 };         // penalty of generating supports on appearance face

    float overhang_angle     { 60.f };
    bool  use_low_angle_face { true };
    bool  min_volume         { false };
    Eigen::Vector3f fun_dir  {};

    /// Allow parallel execution.
    bool parallel { false };

    /// Progress indicator callback called when an object gets packed.
    /// The unsigned argument is the number of items remaining to pack.
    std::function<void(unsigned, std::string)> progressind {};

    /// A predicate returning true if abort is needed.
    std::function<bool(void)> stopcondition {};

    OrientParams() = default;
};

using OrientMeshs = std::vector<OrientMesh>;

/**
 * \brief Orients the input polygons.

 * \param items Input vector of OrientMeshs. The transformation, rotation
 * and bin_idx fields will be changed after the call finished and can be used
 * to apply the result on the input polygon.
 */
void orient(OrientMeshs &items, const OrientMeshs &excludes, const OrientParams &params = {});

// this function should be deleted, since rotating objects are so complicated that its inherited transformation may be a trouble
void orient(ModelObject* obj);

void orient(ModelInstance* instance);

// rotate z axis for cooling
void orient_for_cooling(TriangleMesh& mesh, const FanDirection& fan_dir);

}} // namespace Slic3r::orientment

#endif // MODELORIENT_HPP