Slic3r::GUI::ToolpathsObjExporter Class Reference

Collaboration diagram for Slic3r::GUI::ToolpathsObjExporter:

Classes
struct	SegmentLocalAxes
struct	Vertex
struct	CrossSection

Public Member Functions
	ToolpathsObjExporter (const libvgcode::Viewer &viewer)
void	export_to (const std::string &filename)

Private Types
enum	CornerType : unsigned char { RightTurn , LeftTurn , Straight }

Private Member Functions
SegmentLocalAxes	segment_local_axes (const Vec3f &v1, const Vec3f &v2)
CrossSection	cross_section (const Vec3f &v, const Vec3f &right, const Vec3f &up, float width, float height)
CrossSection	normal_cross_section (const Vec3f &v, const SegmentLocalAxes &axes, float width, float height)
CrossSection	corner_cross_section (const Vec3f &v, const SegmentLocalAxes &axes1, const SegmentLocalAxes &axes2, float width, float height, CornerType &corner_type)
void	export_segment (FILE &f, unsigned char flags, size_t v1_id, const libvgcode::PathVertex &v1, const libvgcode::PathVertex &v2, const libvgcode::PathVertex &v3)
size_t	vertex_id (int id)
void	export_vertex (FILE &f, const Vertex &v)
void	export_material (FILE &f, size_t material_id)
void	export_triangle (FILE &f, size_t v1, size_t v2, size_t v3)
void	export_materials (FILE &f)
size_t	color_id (size_t vertex_id)

Private Attributes
const libvgcode::Viewer &	m_viewer
size_t	m_vertices_count { 0 }
std::vector< libvgcode::Color >	m_colors

Static Private Attributes
static const unsigned char	Flag_First = 0x01
static const unsigned char	Flag_Last = 0x02
static const unsigned char	Flag_Internal = 0x04
static const float	Cap_Rounding_Factor = 0.25f

Detailed Description

---

Class Documentation

Slic3r::GUI::ToolpathsObjExporter::SegmentLocalAxes

struct Slic3r::GUI::ToolpathsObjExporter::SegmentLocalAxes

Class Members
Vec3f	forward
Vec3f	right
Vec3f	up

Slic3r::GUI::ToolpathsObjExporter::Vertex

struct Slic3r::GUI::ToolpathsObjExporter::Vertex

Class Members
Vec3f	normal
Vec3f	position

Slic3r::GUI::ToolpathsObjExporter::CrossSection

struct Slic3r::GUI::ToolpathsObjExporter::CrossSection

Collaboration diagram for Slic3r::GUI::ToolpathsObjExporter::CrossSection:

Class Members
Vertex	bottom
Vertex	left
Vertex	right
Vertex	top

Member Enumeration Documentation

CornerType

enum Slic3r::GUI::ToolpathsObjExporter::CornerType : unsigned char

private

Enumerator
RightTurn
LeftTurn
Straight

    {
        RightTurn,
        LeftTurn,
        Straight
    };

Constructor & Destructor Documentation

ToolpathsObjExporter()

Slic3r::GUI::ToolpathsObjExporter::ToolpathsObjExporter ( const libvgcode::Viewer & viewer )

inlineexplicit

    : m_viewer(viewer) {
    }

References m_viewer.

Member Function Documentation

color_id()

size_t Slic3r::GUI::ToolpathsObjExporter::color_id ( size_t vertex_id )

inlineprivate

                                      {
        const libvgcode::PathVertex& v = m_viewer.get_vertex_at(vertex_id);
        const size_t top_layer_id = m_viewer.is_top_layer_only_view_range() ? m_viewer.get_layers_view_range()[1] : 0;
        const bool color_top_layer_only = m_viewer.get_view_full_range()[1] != m_viewer.get_view_visible_range()[1];
        const libvgcode::Color color = (color_top_layer_only && v.layer_id < top_layer_id &&
              (!m_viewer.is_spiral_vase_mode() || vertex_id != m_viewer.get_view_enabled_range()[0])) ?
              libvgcode::DUMMY_COLOR : m_viewer.get_vertex_color(v);
        auto color_it = std::find_if(m_colors.begin(), m_colors.end(), [&color](const libvgcode::Color& m) { return m == color; });
        if (color_it == m_colors.end()) {
            m_colors.emplace_back(color);
            color_it = std::prev(m_colors.end());
        }
        return std::distance(m_colors.begin(), color_it);
    }

References libvgcode::DUMMY_COLOR, libvgcode::PathVertex::layer_id, m_colors, m_viewer, and vertex_id().

Referenced by export_segment().

Here is the call graph for this function:

Here is the caller graph for this function:

corner_cross_section()

CrossSection Slic3r::GUI::ToolpathsObjExporter::corner_cross_section ( const Vec3f & v, const SegmentLocalAxes & axes1, const SegmentLocalAxes & axes2, float width, float height, CornerType & corner_type )

inlineprivate

                                                            {
        if (std::abs(std::abs(axes1.forward.dot(axes2.forward)) - 1.0f) < EPSILON)
            corner_type = CornerType::Straight;
        else if (axes1.up.dot(axes1.forward.cross(axes2.forward)) < 0.0f)
            corner_type = CornerType::RightTurn;
        else
            corner_type = CornerType::LeftTurn;
        const Vec3f right = (0.5f * (axes1.right + axes2.right)).normalized();
        return cross_section(v, right, axes1.up, width, height);
    }

References cross_section(), EPSILON, Slic3r::GUI::ToolpathsObjExporter::SegmentLocalAxes::forward, LeftTurn, Slic3r::GUI::ToolpathsObjExporter::SegmentLocalAxes::right, RightTurn, Straight, and Slic3r::GUI::ToolpathsObjExporter::SegmentLocalAxes::up.

Referenced by export_segment().

Here is the call graph for this function:

Here is the caller graph for this function:

cross_section()

CrossSection Slic3r::GUI::ToolpathsObjExporter::cross_section ( const Vec3f & v, const Vec3f & right, const Vec3f & up, float width, float height )

inlineprivate

                                                                                                               {
        CrossSection ret;
        const Vec3f w_shift = 0.5f * width * right;
        const Vec3f h_shift = 0.5f * height * up;
        ret.right.position  = v + w_shift;
        ret.right.normal    = right;
        ret.top.position    = v + h_shift;
        ret.top.normal      = up;
        ret.left.position   = v - w_shift;
        ret.left.normal     = -right;
        ret.bottom.position = v - h_shift;
        ret.bottom.normal   = -up;
        return ret;
    }

References Slic3r::GUI::ToolpathsObjExporter::CrossSection::bottom, Slic3r::GUI::ToolpathsObjExporter::CrossSection::left, Slic3r::GUI::ToolpathsObjExporter::Vertex::normal, Slic3r::GUI::ToolpathsObjExporter::Vertex::position, Slic3r::GUI::ToolpathsObjExporter::CrossSection::right, and Slic3r::GUI::ToolpathsObjExporter::CrossSection::top.

Referenced by corner_cross_section(), and normal_cross_section().

Here is the caller graph for this function:

export_material()

void Slic3r::GUI::ToolpathsObjExporter::export_material ( FILE & f, size_t material_id )

inlineprivate

                                                      {
        fprintf(&f, "\nusemtl material_%zu\n", material_id + 1);
    }

References Slic3r::f().

Referenced by export_segment().

Here is the call graph for this function:

Here is the caller graph for this function:

export_materials()

void Slic3r::GUI::ToolpathsObjExporter::export_materials ( FILE & f )

inlineprivate

                                   {
        static const float inv_255 = 1.0f / 255.0f;
        size_t materials_counter = 0;
        for (const auto& color : m_colors) {
            fprintf(&f, "\nnewmtl material_%zu\n", ++materials_counter);
            fprintf(&f, "Ka 1 1 1\n");
            fprintf(&f, "Kd %g %g %g\n", static_cast<float>(color[0]) * inv_255,
                                         static_cast<float>(color[1]) * inv_255,
                                         static_cast<float>(color[2]) * inv_255);
            fprintf(&f, "Ks 0 0 0\n");
        }
    }

References Slic3r::f(), and m_colors.

Referenced by export_to().

Here is the call graph for this function:

Here is the caller graph for this function:

export_segment()

void Slic3r::GUI::ToolpathsObjExporter::export_segment ( FILE & f, unsigned char flags, size_t v1_id, const libvgcode::PathVertex & v1, const libvgcode::PathVertex & v2, const libvgcode::PathVertex & v3 )

inlineprivate

                                                                                                                                                                 {
        const Vec3f v1_pos = libvgcode::convert(v1.position);
        const Vec3f v2_pos = libvgcode::convert(v2.position);
        const Vec3f v3_pos = libvgcode::convert(v3.position);
        const SegmentLocalAxes v1_v2 = segment_local_axes(v1_pos, v2_pos);
        const SegmentLocalAxes v2_v3 = segment_local_axes(v2_pos, v3_pos);
 
        // starting cap
        if ((flags & Flag_First) > 0) {
            const Vertex v0 = { v1_pos - Cap_Rounding_Factor * v1.width * v1_v2.forward, -v1_v2.forward };
            const CrossSection ncs = normal_cross_section(v1_pos, v1_v2, v1.width, v1.height);
            export_vertex(f, v0);         // 0
            export_vertex(f, ncs.right);  // 1
            export_vertex(f, ncs.top);    // 2
            export_vertex(f, ncs.left);   // 3
            export_vertex(f, ncs.bottom); // 4
            export_material(f, color_id(v1_id));
            export_triangle(f, vertex_id(0), vertex_id(1), vertex_id(2));
            export_triangle(f, vertex_id(0), vertex_id(2), vertex_id(3));
            export_triangle(f, vertex_id(0), vertex_id(3), vertex_id(4));
            export_triangle(f, vertex_id(0), vertex_id(4), vertex_id(1));
            m_vertices_count += 5;
        }
        // segment body + ending cap
        if ((flags & Flag_Last) > 0) {
            const Vertex v0 = { v2_pos + Cap_Rounding_Factor * v2.width * v1_v2.forward, v1_v2.forward };
            const CrossSection ncs = normal_cross_section(v2_pos, v1_v2, v2.width, v2.height);
            export_vertex(f, v0);         // 0
            export_vertex(f, ncs.right);  // 1
            export_vertex(f, ncs.top);    // 2
            export_vertex(f, ncs.left);   // 3
            export_vertex(f, ncs.bottom); // 4
            export_material(f, color_id(v1_id + 1));
            // segment body
            export_triangle(f, vertex_id(-4), vertex_id(1), vertex_id(2));
            export_triangle(f, vertex_id(-4), vertex_id(2), vertex_id(-3));
            export_triangle(f, vertex_id(-3), vertex_id(2), vertex_id(3));
            export_triangle(f, vertex_id(-3), vertex_id(3), vertex_id(-2));
            export_triangle(f, vertex_id(-2), vertex_id(3), vertex_id(4));
            export_triangle(f, vertex_id(-2), vertex_id(4), vertex_id(-1));
            export_triangle(f, vertex_id(-1), vertex_id(4), vertex_id(1));
            export_triangle(f, vertex_id(-1), vertex_id(1), vertex_id(-4));
            // ending cap
            export_triangle(f, vertex_id(0), vertex_id(3), vertex_id(2));
            export_triangle(f, vertex_id(0), vertex_id(2), vertex_id(1));
            export_triangle(f, vertex_id(0), vertex_id(1), vertex_id(4));
            export_triangle(f, vertex_id(0), vertex_id(4), vertex_id(3));
            m_vertices_count += 5;
        }
        else {
            CornerType corner_type;
            const CrossSection ccs   = corner_cross_section(v2_pos, v1_v2, v2_v3, v2.width, v2.height, corner_type);
            const CrossSection ncs12 = normal_cross_section(v2_pos, v1_v2, v2.width, v2.height);
            const CrossSection ncs23 = normal_cross_section(v2_pos, v2_v3, v2.width, v2.height);
            if (corner_type == CornerType::Straight) {
                export_vertex(f, ncs12.right);  // 0
                export_vertex(f, ncs12.top);    // 1
                export_vertex(f, ncs12.left);   // 2
                export_vertex(f, ncs12.bottom); // 3
                export_material(f, color_id(v1_id + 1));
                // segment body
                export_triangle(f, vertex_id(-4), vertex_id(0), vertex_id(1));
                export_triangle(f, vertex_id(-4), vertex_id(1), vertex_id(-3));
                export_triangle(f, vertex_id(-3), vertex_id(1), vertex_id(2));
                export_triangle(f, vertex_id(-3), vertex_id(2), vertex_id(-2));
                export_triangle(f, vertex_id(-2), vertex_id(2), vertex_id(3));
                export_triangle(f, vertex_id(-2), vertex_id(3), vertex_id(-1));
                export_triangle(f, vertex_id(-1), vertex_id(3), vertex_id(0));
                export_triangle(f, vertex_id(-1), vertex_id(0), vertex_id(-4));
                m_vertices_count += 4;
            }
            else if (corner_type == CornerType::RightTurn) {
                export_vertex(f, ncs12.left);   // 0
                export_vertex(f, ccs.left);     // 1
                export_vertex(f, ccs.right);    // 2
                export_vertex(f, ncs12.top);    // 3
                export_vertex(f, ncs23.left);   // 4
                export_vertex(f, ncs12.bottom); // 5
                export_material(f, color_id(v1_id + 1));
                // segment body
                export_triangle(f, vertex_id(-4), vertex_id(2), vertex_id(3));
                export_triangle(f, vertex_id(-4), vertex_id(3), vertex_id(-3));
                export_triangle(f, vertex_id(-3), vertex_id(3), vertex_id(0));
                export_triangle(f, vertex_id(-3), vertex_id(0), vertex_id(-2));
                export_triangle(f, vertex_id(-2), vertex_id(0), vertex_id(5));
                export_triangle(f, vertex_id(-2), vertex_id(5), vertex_id(-1));
                export_triangle(f, vertex_id(-1), vertex_id(5), vertex_id(2));
                export_triangle(f, vertex_id(-1), vertex_id(2), vertex_id(-4));
                // corner
                export_triangle(f, vertex_id(1), vertex_id(0), vertex_id(3));
                export_triangle(f, vertex_id(1), vertex_id(3), vertex_id(4));
                export_triangle(f, vertex_id(1), vertex_id(4), vertex_id(5));
                export_triangle(f, vertex_id(1), vertex_id(5), vertex_id(0));
                m_vertices_count += 6;
            }
            else {
                export_vertex(f, ncs12.right);  // 0
                export_vertex(f, ccs.right);    // 1
                export_vertex(f, ncs23.right);  // 2
                export_vertex(f, ncs12.top);    // 3
                export_vertex(f, ccs.left);     // 4
                export_vertex(f, ncs12.bottom); // 5
                export_material(f, color_id(v1_id + 1));
                // segment body
                export_triangle(f, vertex_id(-4), vertex_id(0), vertex_id(3));
                export_triangle(f, vertex_id(-4), vertex_id(3), vertex_id(-3));
                export_triangle(f, vertex_id(-3), vertex_id(3), vertex_id(4));
                export_triangle(f, vertex_id(-3), vertex_id(4), vertex_id(-2));
                export_triangle(f, vertex_id(-2), vertex_id(4), vertex_id(5));
                export_triangle(f, vertex_id(-2), vertex_id(5), vertex_id(-1));
                export_triangle(f, vertex_id(-1), vertex_id(5), vertex_id(0));
                export_triangle(f, vertex_id(-1), vertex_id(0), vertex_id(-4));
                // corner
                export_triangle(f, vertex_id(1), vertex_id(2), vertex_id(3));
                export_triangle(f, vertex_id(1), vertex_id(3), vertex_id(0));
                export_triangle(f, vertex_id(1), vertex_id(0), vertex_id(5));
                export_triangle(f, vertex_id(1), vertex_id(5), vertex_id(2));
                m_vertices_count += 6;
            }
        }
    }

References Slic3r::GUI::ToolpathsObjExporter::CrossSection::bottom, Cap_Rounding_Factor, color_id(), libvgcode::convert(), corner_cross_section(), export_material(), export_triangle(), export_vertex(), Slic3r::f(), Flag_First, Flag_Last, Slic3r::GUI::ToolpathsObjExporter::SegmentLocalAxes::forward, libvgcode::PathVertex::height, Slic3r::GUI::ToolpathsObjExporter::CrossSection::left, m_vertices_count, normal_cross_section(), libvgcode::PathVertex::position, Slic3r::GUI::ToolpathsObjExporter::CrossSection::right, RightTurn, segment_local_axes(), Straight, Slic3r::GUI::ToolpathsObjExporter::CrossSection::top, vertex_id(), and libvgcode::PathVertex::width.

Referenced by export_to().

Here is the call graph for this function:

Here is the caller graph for this function:

export_to()

void Slic3r::GUI::ToolpathsObjExporter::export_to ( const std::string & filename )

inline

                                              {
        CNumericLocalesSetter locales_setter;
 
        // open geometry file
        FilePtr f_geo = boost::nowide::fopen(filename.c_str(), "w");
        if (f_geo.f == nullptr) {
            BOOST_LOG_TRIVIAL(error) << "ToolpathsObjExporter: Couldn't open " << filename << " for writing";
            return;
        }
 
        boost::filesystem::path materials_filename(filename);
        materials_filename.replace_extension("mtl");
 
        // write header to geometry file
        fprintf(f_geo.f, "# G-Code Toolpaths\n");
        fprintf(f_geo.f, "# Generated by %s-%s based on Slic3r\n", SLIC3R_APP_NAME, SoftFever_VERSION);
        fprintf(f_geo.f, "\nmtllib ./%s\n", materials_filename.filename().string().c_str());
 
        // open material file
        FilePtr f_mat = boost::nowide::fopen(materials_filename.string().c_str(), "w");
        if (f_mat.f == nullptr) {
            BOOST_LOG_TRIVIAL(error) << "ToolpathsObjExporter: Couldn't open " << materials_filename.string() << " for writing";
            return;
        }
 
        // write header to material file
        fprintf(f_mat.f, "# G-Code Toolpaths Materials\n");
        fprintf(f_mat.f, "# Generated by %s-%s based on Slic3r\n", SLIC3R_APP_NAME, SoftFever_VERSION);
 
        libvgcode::Interval visible_range = m_viewer.get_view_visible_range();
        if (m_viewer.is_top_layer_only_view_range())
            visible_range[0] = m_viewer.get_view_full_range()[0];
        for (size_t i = visible_range[0]; i <= visible_range[1]; ++i) {
            const libvgcode::PathVertex& curr = m_viewer.get_vertex_at(i);
            const libvgcode::PathVertex& next = m_viewer.get_vertex_at(i + 1);
            if (!curr.is_extrusion() || !next.is_extrusion())
                continue;
 
            const libvgcode::PathVertex& nextnext = m_viewer.get_vertex_at(i + 2);
            unsigned char flags = 0;
            if (curr.gcode_id == next.gcode_id)
                flags |= Flag_First;
            if (i + 1 == visible_range[1] || !nextnext.is_extrusion())
                flags |= Flag_Last;
            else
                flags |= Flag_Internal;
            export_segment(*f_geo.f, flags, i, curr, next, nextnext);
        }
        export_materials(*f_mat.f);
    }

References export_materials(), export_segment(), Slic3r::FilePtr::f, Flag_First, Flag_Internal, Flag_Last, libvgcode::PathVertex::gcode_id, libvgcode::PathVertex::is_extrusion(), and m_viewer.

Referenced by Slic3r::GUI::GCodeViewer::export_toolpaths_to_obj().

Here is the call graph for this function:

Here is the caller graph for this function:

export_triangle()

void Slic3r::GUI::ToolpathsObjExporter::export_triangle ( FILE & f, size_t v1, size_t v2, size_t v3 )

inlineprivate

                                                                   {
        fprintf(&f, "f %zu//%zu %zu//%zu %zu//%zu\n", v1, v1, v2, v2, v3, v3);
    }

References Slic3r::f().

Referenced by export_segment().

Here is the call graph for this function:

Here is the caller graph for this function:

export_vertex()

void Slic3r::GUI::ToolpathsObjExporter::export_vertex ( FILE & f, const Vertex & v )

inlineprivate

                                                 {
        fprintf(&f, "v %g %g %g\n", v.position.x(), v.position.y(), v.position.z());
        fprintf(&f, "vn %g %g %g\n", v.normal.x(), v.normal.y(), v.normal.z());
    }

References Slic3r::f(), Slic3r::GUI::ToolpathsObjExporter::Vertex::normal, and Slic3r::GUI::ToolpathsObjExporter::Vertex::position.

Referenced by export_segment().

Here is the call graph for this function:

Here is the caller graph for this function:

normal_cross_section()

CrossSection Slic3r::GUI::ToolpathsObjExporter::normal_cross_section ( const Vec3f & v, const SegmentLocalAxes & axes, float width, float height )

inlineprivate

                                                                                                               {
        return cross_section(v, axes.right, axes.up, width, height);
    }

References cross_section(), Slic3r::GUI::ToolpathsObjExporter::SegmentLocalAxes::right, and Slic3r::GUI::ToolpathsObjExporter::SegmentLocalAxes::up.

Referenced by export_segment().

Here is the call graph for this function:

Here is the caller graph for this function:

segment_local_axes()

SegmentLocalAxes Slic3r::GUI::ToolpathsObjExporter::segment_local_axes ( const Vec3f & v1, const Vec3f & v2 )

inlineprivate

                                                                          {
        SegmentLocalAxes ret;
        ret.forward = (v2 - v1).normalized();
        ret.right   = ret.forward.cross(Vec3f::UnitZ()).normalized();
        ret.up      = ret.right.cross(ret.forward);
        return ret;
    }

References Slic3r::GUI::ToolpathsObjExporter::SegmentLocalAxes::forward, Slic3r::GUI::ToolpathsObjExporter::SegmentLocalAxes::right, and Slic3r::GUI::ToolpathsObjExporter::SegmentLocalAxes::up.

Referenced by export_segment().

Here is the caller graph for this function:

vertex_id()

size_t Slic3r::GUI::ToolpathsObjExporter::vertex_id ( int id )

inlineprivate

{ return static_cast<size_t>(1 + static_cast<int>(m_vertices_count) + id); }

References m_vertices_count.

Referenced by color_id(), and export_segment().

Here is the caller graph for this function:

Member Data Documentation

Cap_Rounding_Factor

const float Slic3r::GUI::ToolpathsObjExporter::Cap_Rounding_Factor = 0.25f

staticprivate

Referenced by export_segment().

Flag_First

const unsigned char Slic3r::GUI::ToolpathsObjExporter::Flag_First = 0x01

staticprivate

Referenced by export_segment(), and export_to().

Flag_Internal

const unsigned char Slic3r::GUI::ToolpathsObjExporter::Flag_Internal = 0x04

staticprivate

Referenced by export_to().

Flag_Last

const unsigned char Slic3r::GUI::ToolpathsObjExporter::Flag_Last = 0x02

staticprivate

Referenced by export_segment(), and export_to().

m_colors

std::vector<libvgcode::Color> Slic3r::GUI::ToolpathsObjExporter::m_colors

private

Referenced by color_id(), and export_materials().

m_vertices_count

size_t Slic3r::GUI::ToolpathsObjExporter::m_vertices_count { 0 }

private

{ 0 };

Referenced by export_segment(), and vertex_id().

m_viewer

const libvgcode::Viewer& Slic3r::GUI::ToolpathsObjExporter::m_viewer

private

Referenced by ToolpathsObjExporter(), color_id(), and export_to().

---

The documentation for this class was generated from the following file:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/GCodeViewer.cpp