120 lines
3.8 KiB
C++
120 lines
3.8 KiB
C++
#ifndef MODELARRANGE_HPP
|
|
#define MODELARRANGE_HPP
|
|
|
|
//#include "Model.hpp"
|
|
#include "Polygon.hpp"
|
|
#include "BoundingBox.hpp"
|
|
|
|
namespace Slic3r {
|
|
|
|
class Model;
|
|
|
|
namespace arr {
|
|
|
|
class Circle {
|
|
Point center_;
|
|
double radius_;
|
|
public:
|
|
|
|
inline Circle(): center_(0, 0), radius_(std::nan("")) {}
|
|
inline Circle(const Point& c, double r): center_(c), radius_(r) {}
|
|
|
|
inline double radius() const { return radius_; }
|
|
inline const Point& center() const { return center_; }
|
|
inline operator bool() { return !std::isnan(radius_); }
|
|
};
|
|
|
|
enum class BedShapeType {
|
|
BOX,
|
|
CIRCLE,
|
|
IRREGULAR,
|
|
WHO_KNOWS
|
|
};
|
|
|
|
struct BedShapeHint {
|
|
BedShapeType type;
|
|
/*union*/ struct { // I know but who cares...
|
|
Circle circ;
|
|
BoundingBox box;
|
|
Polyline polygon;
|
|
} shape;
|
|
};
|
|
|
|
BedShapeHint bedShape(const Polyline& bed);
|
|
|
|
class ArrangeItem {
|
|
public:
|
|
|
|
virtual ~ArrangeItem() = default;
|
|
|
|
virtual void transform(Vec2d offset, double rotation_rads) = 0;
|
|
|
|
virtual Polygon silhouette() const = 0;
|
|
};
|
|
|
|
using ArrangeItems = std::vector<std::reference_wrapper<ArrangeItem>>;
|
|
|
|
//struct WipeTowerInfo {
|
|
// bool is_wipe_tower = false;
|
|
// Vec2d pos;
|
|
// Vec2d bb_size;
|
|
// double rotation;
|
|
//};
|
|
|
|
/**
|
|
* \brief Arranges the model objects on the screen.
|
|
*
|
|
* The arrangement considers multiple bins (aka. print beds) for placing all
|
|
* the items provided in the model argument. If the items don't fit on one
|
|
* print bed, the remaining will be placed onto newly created print beds.
|
|
* The first_bin_only parameter, if set to true, disables this behavior and
|
|
* makes sure that only one print bed is filled and the remaining items will be
|
|
* untouched. When set to false, the items which could not fit onto the
|
|
* print bed will be placed next to the print bed so the user should see a
|
|
* pile of items on the print bed and some other piles outside the print
|
|
* area that can be dragged later onto the print bed as a group.
|
|
*
|
|
* \param model The model object with the 3D content.
|
|
* \param dist The minimum distance which is allowed for any pair of items
|
|
* on the print bed in any direction.
|
|
* \param bb The bounding box of the print bed. It corresponds to the 'bin'
|
|
* for bin packing.
|
|
* \param first_bin_only This parameter controls whether to place the
|
|
* remaining items which do not fit onto the print area next to the print
|
|
* bed or leave them untouched (let the user arrange them by hand or remove
|
|
* them).
|
|
* \param progressind Progress indicator callback called when an object gets
|
|
* packed. The unsigned argument is the number of items remaining to pack.
|
|
* \param stopcondition A predicate returning true if abort is needed.
|
|
*/
|
|
//bool arrange(Model &model,
|
|
// WipeTowerInfo& wipe_tower_info,
|
|
// coord_t min_obj_distance,
|
|
// const Slic3r::Polyline& bed,
|
|
// BedShapeHint bedhint,
|
|
// bool first_bin_only,
|
|
// std::function<void(unsigned)> progressind,
|
|
// std::function<bool(void)> stopcondition);
|
|
|
|
bool arrange(ArrangeItems &items,
|
|
coord_t min_obj_distance,
|
|
BedShapeHint bedhint,
|
|
std::function<void(unsigned)> progressind,
|
|
std::function<bool(void)> stopcondition);
|
|
|
|
/// This will find a suitable position for a new object instance and leave the
|
|
/// old items untouched.
|
|
//void find_new_position(const Model& model,
|
|
// ModelInstancePtrs instances_to_add,
|
|
// coord_t min_obj_distance,
|
|
// const Slic3r::Polyline& bed,
|
|
// WipeTowerInfo& wti);
|
|
void find_new_position(ArrangeItems &items,
|
|
const ArrangeItems &instances_to_add,
|
|
coord_t min_obj_distance,
|
|
BedShapeHint bedhint);
|
|
|
|
|
|
} // arr
|
|
} // Slic3r
|
|
#endif // MODELARRANGE_HPP
|