PrusaSlicer-NonPlainar/src/libslic3r/ShortestPath.hpp

#ifndef slic3r_ShortestPath_hpp_
#define slic3r_ShortestPath_hpp_

#include "libslic3r.h"
#include "ExtrusionEntity.hpp"
#include "Point.hpp"

#include <utility>
#include <vector>

namespace Slic3r {

std::vector<size_t> 				 chain_points(const Points &points, Point *start_near = nullptr);

std::vector<std::pair<size_t, bool>> chain_extrusion_entities(std::vector<ExtrusionEntity*> &entities, const Point *start_near = nullptr);
void                                 reorder_extrusion_entities(std::vector<ExtrusionEntity*> &entities, std::vector<std::pair<size_t, bool>> &chain);
void                                 chain_and_reorder_extrusion_entities(std::vector<ExtrusionEntity*> &entities, const Point *start_near = nullptr);

// Chain instances of print objects by an approximate shortest path.
// Returns pairs of PrintObject idx and instance of that PrintObject.
class Print;
std::vector<std::pair<size_t, size_t>> chain_print_object_instances(const Print &print);


} // namespace Slic3r

#endif /* slic3r_ShortestPath_hpp_ */
Introduction of a greedy Traveling Salesman Problem algorithm, producing better shortest path estimate than the "closest next neighbor" heuristics. The new greedy algorithm utilizes KD tree for closest end point search, and builds a graph to detect loops. PerimeterGenerator newly uses the optimized TSP algorithm. ExtrusionEntity has been refactored / simplified. 2019-09-26 07:44:38 +00:00			`#ifndef slic3r_ShortestPath_hpp_`
			`#define slic3r_ShortestPath_hpp_`

			`#include "libslic3r.h"`
			`#include "ExtrusionEntity.hpp"`
			`#include "Point.hpp"`

			`#include <utility>`
			`#include <vector>`

			`namespace Slic3r {`

Reworked Traveling Salesman Problem code for simplicity and robustness. The TSP algorithm is newly used for planning of the printing order of objects AND their instances. 2019-09-26 14:39:50 +00:00			`std::vector<size_t> chain_points(const Points &points, Point *start_near = nullptr);`

Introduction of a greedy Traveling Salesman Problem algorithm, producing better shortest path estimate than the "closest next neighbor" heuristics. The new greedy algorithm utilizes KD tree for closest end point search, and builds a graph to detect loops. PerimeterGenerator newly uses the optimized TSP algorithm. ExtrusionEntity has been refactored / simplified. 2019-09-26 07:44:38 +00:00			`std::vector<std::pair<size_t, bool>> chain_extrusion_entities(std::vector<ExtrusionEntity> &entities, const Point start_near = nullptr);`
Reworked Traveling Salesman Problem code for simplicity and robustness. The TSP algorithm is newly used for planning of the printing order of objects AND their instances. 2019-09-26 14:39:50 +00:00			`void reorder_extrusion_entities(std::vector<ExtrusionEntity*> &entities, std::vector<std::pair<size_t, bool>> &chain);`
			`void chain_and_reorder_extrusion_entities(std::vector<ExtrusionEntity> &entities, const Point start_near = nullptr);`

			`// Chain instances of print objects by an approximate shortest path.`
			`// Returns pairs of PrintObject idx and instance of that PrintObject.`
			`class Print;`
			`std::vector<std::pair<size_t, size_t>> chain_print_object_instances(const Print &print);`

Introduction of a greedy Traveling Salesman Problem algorithm, producing better shortest path estimate than the "closest next neighbor" heuristics. The new greedy algorithm utilizes KD tree for closest end point search, and builds a graph to detect loops. PerimeterGenerator newly uses the optimized TSP algorithm. ExtrusionEntity has been refactored / simplified. 2019-09-26 07:44:38 +00:00
			`} // namespace Slic3r`

			`#endif /* slic3r_ShortestPath_hpp_ */`