juli/OrcaSlicer
1
1
Fork 0
mirror of https://github.com/OrcaSlicer/OrcaSlicer.git synced 2026-10-05 23:01:17 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
51baa579fe8232c87ca0e364eaf15bc530389fb8
OrcaSlicer/src/libslic3r/Format/svg.cpp
T
HanifKoh 4895bc03b4 Remove Unused Project Includes and Forward-Declare Where a Type Is Only Referenced (#16099) 
* Remove Unused Project Includes and Forward-Declare Where a Type Is Only Referenced

Generated with include-what-you-use and applied conservatively. Only OrcaSlicer's own headers, the ones under src/ and tests/, are removed or forward-declared; standard-library and third-party includes are left alone. An include is removed only when both the Release and the Debug configuration leave it unused, never from inside a conditional block, and never from a file with platform-specific blocks, which only gain includes. Files whose only use of a header sits behind a feature or debug macro (libvgcode's OpenGL ES and marker code, the ARACHNE/TESTS_EXPORT_SVGS debug output) keep their includes.

clonable_ptr.hpp gains #pragma once; it had no include guard and was only safe while Config.hpp was its sole includer.

* Remove Unused Project Includes From Files With Platform-Specific Code

A Linux include-what-you-use run cannot see the code inside _WIN32, __APPLE__ or __linux__ blocks, so its verdict is only taken where nothing the removed header declares, directly or through what it includes, is named inside those blocks. Removals also have to hold in both the Release and Debug configuration and never touch a line inside a conditional block.

* Restore the libslic3r Precompiled Header and Direct Includes Lost in the Platform Pass

The platform-file pass treated pchheader.hpp as an ordinary header and
emptied it, and left GUI_Preview.hpp and 14 other files relying on
headers they no longer reached directly.

* Restore MainFrame.hpp in ParamsDialog.cpp for the Windows-Only Reparent Call

* Include Headers That Files Reached Through Ones the Cleanup Removed

* Drop Includes Duplicated by the Cleanup or by Main's Own Additions

* Leave PreciseSeam.cpp as Main Has It After the Precise Seam Rework
2026-10-05 16:47:17 +08:00

408 lines
15 KiB
C++
Raw Blame History

#include "libslic3r/Point.hpp"
#include "libslic3r/Format/STEP.hpp"
#include "libslic3r/ClipperUtils.hpp"
#include "../libslic3r.h"
#include "../Model.hpp"
#include "../TriangleMesh.hpp"
#include "svg.hpp"
#include "nanosvg/nanosvg.h"
#include <cstdlib>
#include <cstddef>
#include <TopAbs_ShapeEnum.hxx>
#include <TopLoc_Location.hxx>
#include <Standard_Handle.hxx>
#include <Poly_Triangulation.hxx>
#include <BRep_Tool.hxx>
#include <cstdint>
#include <Standard_TypeDef.hxx>
#include <gp_Trsf.hxx>
#include <TopAbs_Orientation.hxx>
#include <Poly_Triangle.hxx>
#include <string>
#include <boost/log/trivial.hpp>
#include <vector>
#include <utility>
#include "BRepBuilderAPI_MakeWire.hxx"
#include "BRepBuilderAPI_MakeEdge.hxx"
#include "BRepBuilderAPI_MakeFace.hxx"
#include "BRepPrimAPI_MakePrism.hxx"
#include "BRepBuilderAPI_Transform.hxx"
#include "BRepMesh_IncrementalMesh.hxx"
#include "TopoDS_Face.hxx"
#include "TopExp_Explorer.hxx"
#include "TopoDS.hxx"
#include "BRepExtrema_SelfIntersection.hxx"
#include "libslic3r/Polygon.hpp"
#include "libslic3r/Polyline.hpp"
namespace Slic3r {
const double STEP_TRANS_CHORD_ERROR = 0.005;
const double STEP_TRANS_ANGLE_RES = 1;
struct Element_Info
{
std::string name;
unsigned int color;
TopoDS_Shape shape;
};
bool is_same_points(gp_Pnt pt1, gp_Pnt pt2) {
return abs(pt1.X() - pt2.X()) < 0.001
&& abs(pt1.Y() - pt2.Y()) < 0.001
&& abs(pt1.Z() - pt2.Z()) < 0.001;
}
struct Point_2D
{
Point_2D(float in_x, float in_y) : x(in_x), y(in_y) {}
float x;
float y;
};
void interp_v2_v2v2(float r[2], const float a[2], const float b[2], const float t)
{
const float s = 1.0f - t;
r[0] = s * a[0] + t * b[0];
r[1] = s * a[1] + t * b[1];
}
void interp_v2_v2v2v2v2_cubic(float p[2], const float v1[2], const float v2[2], const float v3[2], const float v4[2], const float u)
{
float q0[2], q1[2], q2[2], r0[2], r1[2];
interp_v2_v2v2(q0, v1, v2, u);
interp_v2_v2v2(q1, v2, v3, u);
interp_v2_v2v2(q2, v3, v4, u);
interp_v2_v2v2(r0, q0, q1, u);
interp_v2_v2v2(r1, q1, q2, u);
interp_v2_v2v2(p, r0, r1, u);
}
bool is_two_lines_interaction(gp_Pnt pL1, gp_Pnt pL2, gp_Pnt pR1, gp_Pnt pR2) {
Vec3d point1(pL1.X(), pL1.Y(), 0);
Vec3d point2(pL2.X(), pL2.Y(), 0);
Vec3d point3(pR1.X(), pR1.Y(), 0);
Vec3d point4(pR2.X(), pR2.Y(), 0);
Vec3d line1 = point2 - point1;
Vec3d line2 = point4 - point3;
Vec3d line_pos1 = point1 - point3;
Vec3d line_pos2 = point2 - point3;
Vec3d line_pos3 = point3 - point1;
Vec3d line_pos4 = point4 - point1;
Vec3d cross_1 = line2.cross(line_pos1);
Vec3d cross_2 = line2.cross(line_pos2);
Vec3d cross_3 = line1.cross(line_pos3);
Vec3d cross_4 = line1.cross(line_pos4);
return (cross_1.dot(cross_2) < 0) && (cross_3.dot(cross_4) < 0);
}
bool is_profile_self_interaction(std::vector<std::pair<gp_Pnt, gp_Pnt>> profile_line_points)
{
for (int i = 0; i < profile_line_points.size(); ++i) {
for (int j = i + 2; j < profile_line_points.size(); ++j)
if (is_two_lines_interaction(profile_line_points[i].first, profile_line_points[i].second, profile_line_points[j].first, profile_line_points[j].second))
return true;
}
return false;
}
double get_profile_area(std::vector<std::pair<gp_Pnt, gp_Pnt>> profile_line_points)
{
double min_x = 0;
for (auto line_points : profile_line_points) {
if (line_points.first.X() < min_x) min_x = line_points.first.X();
}
double area = 0;
for (auto line_points : profile_line_points) {
bool flag = true;
if (line_points.second.Y() < line_points.first.Y()) flag = false;
area += (line_points.second.X() + line_points.first.X() - 2 * min_x) * (line_points.second.Y() - line_points.first.Y()) / 2;
}
return abs(area);
}
bool get_svg_profile(const char *path, std::vector<Element_Info> &element_infos, std::string& message)
{
NSVGimage *svg_data = nullptr;
svg_data = nsvgParseFromFile(path, "mm", 96.0f);
if (svg_data == nullptr) {
message = "import svg failed: could not open svg.";
return false;
}
if (svg_data->shapes == nullptr) {
message = "import svg failed: could not parse imported svg data.";
return false;
}
int name_index = 1;
for (NSVGshape *shape = svg_data->shapes; shape; shape = shape->next) {
char * id = shape->id;
int interpolation_precision = 10; // Number of interpolation points
float step = 1.0f / float(interpolation_precision - 1);
// get the path point
std::vector<std::vector<std::vector<Point_2D>>> all_path_points; // paths<profiles<curves<points>>>
for (NSVGpath *path = shape->paths; path; path = path->next) {
std::vector<std::vector<Point_2D>> profile_points;
int index = 0;
for (int i = 0; i < path->npts - 1; i += 3) {
float * p = &path->pts[i * 2];
float a = 0.0f;
std::vector<Point_2D> curve_points; // points on a curve
for (int v = 0; v < interpolation_precision; v++) {
float pt[2];
// get interpolation points of Bezier curve
interp_v2_v2v2v2v2_cubic(pt, &p[0], &p[2], &p[4], &p[6], a);
Point_2D point(pt[0], -pt[1]);
curve_points.push_back(point);
a += step;
}
profile_points.push_back(curve_points);
// keep the adjacent curves end-to-end
if (profile_points.size() > 1) {
profile_points[index - 1].back() = profile_points[index].front();
}
index++;
}
if (!profile_points.empty())
all_path_points.push_back(profile_points);
}
// remove duplicate points and ensure the profile is closed
std::vector<std::vector<std::pair<gp_Pnt, gp_Pnt>>> path_line_points;
for (auto profile_points : all_path_points) {
std::vector<std::pair<gp_Pnt, gp_Pnt>> profile_line_points;
for (int i = 0; i < profile_points.size(); ++i) {
for (int j = 0; j + 1 < profile_points[i].size(); j++) {
gp_Pnt pt1(profile_points[i][j].x, profile_points[i][j].y, 0);
gp_Pnt pt2(profile_points[i][j + 1].x, profile_points[i][j + 1].y, 0);
if (is_same_points(pt1, pt2))
continue;
profile_line_points.push_back({pt1, pt2});
}
}
if (profile_line_points.empty())
continue;
// keep the start and end points of profile connected
if (shape->fill.gradient != nullptr)
profile_line_points.back().second = profile_line_points[0].first;
if (is_profile_self_interaction(profile_line_points))
BOOST_LOG_TRIVIAL(warning) << "the profile is self interaction.";
path_line_points.push_back(profile_line_points);
}
if (shape->fill.gradient == nullptr) {
double scale_size = 1e6;
std::vector<std::vector<std::pair<gp_Pnt, gp_Pnt>>> new_path_line_points;
float stroke_width = shape->strokeWidth * scale_size;
Polygons polygons;
bool close_polygon = false;
for (int i = 0; i < path_line_points.size(); ++i) {
Polyline pt_path;
for (auto line_point : path_line_points[i]) {
pt_path.points.push_back(Point(line_point.first.X() * scale_size, line_point.first.Y() * scale_size));
}
pt_path.points.push_back(Point(path_line_points[i].back().second.X() * scale_size, path_line_points[i].back().second.Y() * scale_size));
close_polygon = pt_path.points.front() == pt_path.points.back();
if (stroke_width > 0)
append(polygons, offset(pt_path, stroke_width / 2, jtMiter, 2., close_polygon ? etClosedLine : etOpenSquare));
}
if (!close_polygon)
polygons = union_(polygons);
std::vector<std::pair<gp_Pnt, gp_Pnt>> profile_line_points;
for (auto polygon : polygons) {
profile_line_points.clear();
for (int i = 0; i < polygon.size() - 1; ++i) {
gp_Pnt pt1(double(polygon[i][0] / scale_size), double(polygon[i][1] / scale_size), 0);
gp_Pnt pt2(double(polygon[i + 1][0] / scale_size), double(polygon[i + 1][1] / scale_size), 0);
profile_line_points.push_back({pt1, pt2});
}
gp_Pnt pt1(double(polygon.back()[0] / scale_size), double(polygon.back()[1] / scale_size), 0);
gp_Pnt pt2(double(polygon.front()[0] / scale_size), double(polygon.front()[1] / scale_size), 0);
profile_line_points.push_back({pt1, pt2});
new_path_line_points.push_back(profile_line_points);
}
path_line_points = new_path_line_points;
}
// generate all profile curves
std::vector<TopoDS_Wire> wires;
int index = 0;
double max_area = 0;
for (int i = 0; i < path_line_points.size(); ++i) {
BRepBuilderAPI_MakeWire wire_build;
for (auto point_item : path_line_points[i]) {
TopoDS_Edge edge_build = BRepBuilderAPI_MakeEdge(point_item.first, point_item.second);
wire_build.Add(edge_build);
}
TopoDS_Wire wire = wire_build.Wire();
double profile_area = get_profile_area(path_line_points[i]);
if (profile_area > max_area) {
max_area = profile_area;
index = i;
}
wires.emplace_back(wire);
}
if (wires.empty())
continue;
gp_Vec dir(0, 0, 10);
BRepBuilderAPI_MakeFace face_make(wires[index]);
for (int i = 0; i < wires.size(); ++i) {
if (index == i)
continue;
face_make.Add(wires[i]);
}
TopoDS_Face face = face_make.Face();
TopoDS_Shape element_shape = BRepPrimAPI_MakePrism(face, dir, false, false).Shape();
Element_Info element_info;
element_info.name = "part_" + std::to_string(name_index);
element_info.color = shape->fill.color;
element_info.shape = element_shape;
element_infos.push_back(element_info);
name_index++;
}
nsvgDelete(svg_data);
return true;
}
bool load_svg(const char *path, Model *model, std::string &message)
{
std::vector<Element_Info> namedSolids;
if (!get_svg_profile(path, namedSolids, message))
return false;
std::vector<stl_file> stl;
stl.resize(namedSolids.size());
// todo: zhimin, Can be accelerated in parallel with tbb
for (size_t i = 0 ; i < namedSolids.size(); i++) {
BRepMesh_IncrementalMesh mesh(namedSolids[i].shape, STEP_TRANS_CHORD_ERROR, false, STEP_TRANS_ANGLE_RES, true);
// BBS: calculate total number of the nodes and triangles
int aNbNodes = 0;
int aNbTriangles = 0;
for (TopExp_Explorer anExpSF(namedSolids[i].shape, TopAbs_FACE); anExpSF.More(); anExpSF.Next()) {
TopLoc_Location aLoc;
Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation(TopoDS::Face(anExpSF.Current()), aLoc);
if (!aTriangulation.IsNull()) {
aNbNodes += aTriangulation->NbNodes();
aNbTriangles += aTriangulation->NbTriangles();
}
}
if (aNbTriangles == 0 || aNbNodes == 0)
// BBS: No triangulation on the shape.
continue;
stl[i].stats.type = inmemory;
stl[i].stats.number_of_facets = (uint32_t) aNbTriangles;
stl[i].stats.original_num_facets = stl[i].stats.number_of_facets;
stl_allocate(&stl[i]);
std::vector<Vec3f> points;
points.reserve(aNbNodes);
// BBS: count faces missing triangulation
int aNbFacesNoTri = 0;
// BBS: fill temporary triangulation
int aNodeOffset = 0;
int aTriangleOffet = 0;
for (TopExp_Explorer anExpSF(namedSolids[i].shape, TopAbs_FACE); anExpSF.More(); anExpSF.Next()) {
const TopoDS_Shape &aFace = anExpSF.Current();
TopLoc_Location aLoc;
Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation(TopoDS::Face(aFace), aLoc);
if (aTriangulation.IsNull()) {
++aNbFacesNoTri;
continue;
}
// BBS: copy nodes
gp_Trsf aTrsf = aLoc.Transformation();
for (int aNodeIter = 1; aNodeIter <= aTriangulation->NbNodes(); ++aNodeIter) {
gp_Pnt aPnt = aTriangulation->Node(aNodeIter);
aPnt.Transform(aTrsf);
points.emplace_back(Vec3f(aPnt.X(), aPnt.Y(), aPnt.Z()));
}
// BBS: copy triangles
const TopAbs_Orientation anOrientation = anExpSF.Current().Orientation();
int anId[3];
for (int aTriIter = 1; aTriIter <= aTriangulation->NbTriangles(); ++aTriIter) {
Poly_Triangle aTri = aTriangulation->Triangle(aTriIter);
aTri.Get(anId[0], anId[1], anId[2]);
if (anOrientation == TopAbs_REVERSED) std::swap(anId[1], anId[2]);
// BBS: save triangles facets
stl_facet facet;
facet.vertex[0] = points[anId[0] + aNodeOffset - 1].cast<float>();
facet.vertex[1] = points[anId[1] + aNodeOffset - 1].cast<float>();
facet.vertex[2] = points[anId[2] + aNodeOffset - 1].cast<float>();
facet.extra[0] = 0;
facet.extra[1] = 0;
stl_normal normal;
stl_calculate_normal(normal, &facet);
stl_normalize_vector(normal);
facet.normal = normal;
stl[i].facet_start[aTriangleOffet + aTriIter - 1] = facet;
}
aNodeOffset += aTriangulation->NbNodes();
aTriangleOffet += aTriangulation->NbTriangles();
}
}
ModelObject *new_object = model->add_object();
// new_object->name ?
new_object->input_file = path;
auto stage_unit3 = stl.size() / LOAD_STEP_STAGE_UNIT_NUM + 1;
for (size_t i = 0; i < stl.size(); i++) {
// BBS: maybe mesh is empty from step file. Don't add
if (stl[i].stats.number_of_facets > 0) {
TriangleMesh triangle_mesh;
triangle_mesh.from_stl(stl[i]);
ModelVolume *new_volume = new_object->add_volume(std::move(triangle_mesh));
new_volume->name = namedSolids[i].name;
new_volume->source.input_file = path;
new_volume->source.object_idx = (int) model->objects.size() - 1;
new_volume->source.volume_idx = (int) new_object->volumes.size() - 1;
}
}
return true;
}
} // namespace Slic3r
Reference in New Issue View Git Blame Copy Permalink