anonymous_namespace{GLGizmoSVG.cpp} Namespace Reference

Classes
struct	Limits
struct	GuiCfg

Enumerations
enum class	IconType : unsigned {   reset_value , refresh , change_file , bake ,   save , exclamation , lock , unlock ,   reflection_x , reflection_y , _count }
enum class	IconState : unsigned { activable = 0 , hovered , disabled }

Functions
std::string	choose_svg_file ()
	Open file dialog with svg files.
double	get_tesselation_tolerance (double scale)
EmbossShape	select_shape (std::string_view filepath="", double tesselation_tolerance_in_mm=get_tesselation_tolerance(1.))
	Let user to choose file with (S)calable (V)ector (G)raphics - SVG. Than let select contour.
DataBasePtr	create_emboss_data_base (std::shared_ptr< std::atomic< bool > > &cancel, ModelVolumeType volume_type, std::string_view filepath="")
	Create new embos data.
std::string	get_file_name (const std::string &file_path)
	Separate file name from file path. String after last delimiter and before last point.
std::string	volume_name (const EmbossShape &shape)
	Create volume name from shape information.
CreateVolumeParams	create_input (GLCanvas3D &canvas, RaycastManager &raycaster, ModelVolumeType volume_type)
	Create input for volume creation.
const IconManager::Icon &	get_icon (const IconManager::VIcons &icons, IconType type, IconState state)
GuiCfg	create_gui_configuration ()
IconManager::VIcons	init_icons (IconManager &mng, const GuiCfg &cfg)
bool	draw_clickable (const IconManager::VIcons &icons, IconType type)
bool	reset_button (const IconManager::VIcons &icons)
void	wu_draw_line_side (Linef line, const std::function< void(int x, int y, float brightess)> &plot)
template<unsigned int N>
void	draw_side_outline (const ExPolygons &shape, const std::array< unsigned char, N > &color, std::vector< unsigned char > &data, size_t data_width, double scale)
template<unsigned int N>
void	draw_filled (const ExPolygons &shape, const std::array< unsigned char, N > &color, std::vector< unsigned char > &data, size_t data_width, double scale)
	Draw filled ExPolygon into data line by line inspired by: http://alienryderflex.com/polygon_fill/.
ExPolygons	union_ex (const ExPolygonsWithIds &shapes)
	Union shape defined by glyphs.
bool	init_texture (Texture &texture, const ExPolygonsWithIds &shapes_with_ids, unsigned max_size_px, const std::vector< std::string > &shape_warnings)
bool	is_closed (NSVGpath *path)
void	add_comma_separated (std::string &result, const std::string &add)
std::string	create_fill_warning (const NSVGshape &shape)
std::string	create_stroke_warning (const NSVGshape &shape)
std::vector< std::string >	create_shape_warnings (const EmbossShape &shape, float scale)
	Create warnings about shape.
void	delete_texture (Texture &texture)

Variables
const std::string	rotation_snapshot_name = L("SVG rotate")
const std::string	move_snapshot_name = L("SVG move")
const struct anonymous_namespace{GLGizmoSVG.cpp}::Limits	limits
wxString	last_used_directory = wxEmptyString
const float	warning_preccission = 1e-4f

---

Class Documentation

anonymous_namespace{GLGizmoSVG.cpp}::Limits

struct anonymous_namespace{GLGizmoSVG.cpp}::Limits

Collaboration diagram for anonymous_namespace{GLGizmoSVG.cpp}::Limits:

Class Members
MinMax< float >	angle {-180.f, 180.f}
MinMax< double >	depth {0.01, 1e4}
MinMax< double >	relative_scale_ratio {1e-5, 1e4}
MinMax< float >	size {0.01f, 1e4f}
MinMax< float >	ui_size {5.f, 100.f}
MinMax< float >	ui_size_in {.1f, 4.f}

anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg

struct anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg

Collaboration diagram for anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg:

Class Members
bool	dark_mode = false
float	icon_width = 0.f
float	input_offset = 0.f
float	input_width = 0.f
float	lock_offset = 0.f
float	max_tooltip_width = 0.f
double	screen_scale = -1.
unsigned	texture_max_size_px = 256
Translations	translations

Enumeration Type Documentation

IconState

enum class anonymous_namespace{GLGizmoSVG.cpp}::IconState : unsigned

strong

Enumerator
activable
hovered
disabled

: unsigned { activable = 0, hovered /*1*/, disabled /*2*/ };

IconType

enum class anonymous_namespace{GLGizmoSVG.cpp}::IconType : unsigned

strong

Enumerator
reset_value
refresh
change_file
bake
save
exclamation
lock
unlock
reflection_x
reflection_y
_count

                    : unsigned {
    reset_value,
    refresh,
    change_file,
    bake,
    save,
    exclamation,
    lock,
    unlock,
    reflection_x,
    reflection_y,
    // automatic calc of icon's count
    _count
};

Function Documentation

add_comma_separated()

void anonymous_namespace{GLGizmoSVG.cpp}::add_comma_separated	(	std::string &	result,
		const std::string &	add )

                                                                 {
    if (!result.empty())
        result += ", ";
    result += add;
}

References add_comma_separated().

Referenced by add_comma_separated(), create_fill_warning(), and create_stroke_warning().

Here is the call graph for this function:

Here is the caller graph for this function:

choose_svg_file()

std::string anonymous_namespace{GLGizmoSVG.cpp}::choose_svg_file

(

)

Open file dialog with svg files.

Returns

File path to svg

{
    wxWindow *parent = nullptr;
    wxString message = _L("Choose SVG file for emboss:");
    wxString selected_file = wxEmptyString;
    wxString wildcard = file_wildcards(FT_SVG);
    long style = wxFD_OPEN | wxFD_FILE_MUST_EXIST;
    wxFileDialog dialog(parent, message, last_used_directory, selected_file, wildcard, style);
    if (dialog.ShowModal() != wxID_OK) {
        BOOST_LOG_TRIVIAL(warning) << "SVG file for emboss was NOT selected.";
        return {};
    }
 
    wxArrayString input_files;
    dialog.GetPaths(input_files);
    if (input_files.IsEmpty()) {
        BOOST_LOG_TRIVIAL(warning) << "SVG file dialog result is empty.";
        return {};
    }
 
    if (input_files.size() != 1)
        BOOST_LOG_TRIVIAL(warning) << "SVG file dialog result contain multiple files but only first is used.";
 
    std::string path = into_u8(input_files.front());
    if (!boost::filesystem::exists(path)) {
        BOOST_LOG_TRIVIAL(warning) << "SVG file dialog return invalid path.";
        return {};
    }
 
    if (!boost::algorithm::iends_with(path, ".svg")) {
        BOOST_LOG_TRIVIAL(warning) << "SVG file dialog return path without '.svg' tail";
        return {};    
    }
 
    last_used_directory = dialog.GetDirectory();
    return path;
}

References _L, choose_svg_file(), Slic3r::GUI::file_wildcards(), Slic3r::GUI::FT_SVG, Slic3r::GUI::into_u8(), last_used_directory, and style.

Referenced by choose_svg_file(), and select_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

create_emboss_data_base()

DataBasePtr anonymous_namespace{GLGizmoSVG.cpp}::create_emboss_data_base	(	std::shared_ptr< std::atomic< bool > > &	cancel,
		ModelVolumeType	volume_type,
		std::string_view	filepath = "" )

Create new embos data.

Parameters

cancel	Cancel for previous job
volume_type	To distiquish whether it is outside of model
filepath	SVG file path

Returns

Base data for emboss SVG

{
    EmbossShape shape = select_shape(filepath);
 
    if (shape.shapes_with_ids.empty())
        // canceled selection of SVG file
        return nullptr;
 
    // Cancel previous Job, when it is in process
    // worker.cancel(); --> Use less in this case I want cancel only previous EmbossJob no other jobs
    // Cancel only EmbossUpdateJob no others
    if (cancel != nullptr)
        cancel->store(true);
    // create new shared ptr to cancel new job
    cancel = std::make_shared<std::atomic<bool>>(false);
 
    std::string name = volume_name(shape);
 
    auto result = std::make_unique<DataBase>(name, cancel /*copy*/, std::move(shape));
    result->is_outside = volume_type == ModelVolumeType::MODEL_PART;
    return result;
}

References create_emboss_data_base(), Slic3r::MODEL_PART, select_shape(), Slic3r::EmbossShape::shapes_with_ids, and volume_name().

Referenced by create_emboss_data_base().

Here is the call graph for this function:

Here is the caller graph for this function:

create_fill_warning()

std::string anonymous_namespace{GLGizmoSVG.cpp}::create_fill_warning

(

const NSVGshape &

shape

)

                                                      {
    if (!(shape.flags & NSVG_FLAGS_VISIBLE) || 
        shape.fill.type == NSVG_PAINT_NONE)
        return {}; // not visible
 
    std::string warning;
    if ((shape.opacity - 1.f + warning_preccission) <= 0.f)
        add_comma_separated(warning, GUI::format(_L("Opacity (%1%)"), shape.opacity));
 
    // if(shape->flags != NSVG_FLAGS_VISIBLE) add_warning(_u8L("Visibility flag"));
    bool is_fill_gradient = shape.fillGradient[0] != '\0';
    if (is_fill_gradient)
        add_comma_separated(warning, GUI::format(_L("Color gradient (%1%)"), shape.fillGradient));
 
    switch (shape.fill.type) {
    case NSVG_PAINT_UNDEF: add_comma_separated(warning, _u8L("Undefined fill type")); break;
    case NSVG_PAINT_LINEAR_GRADIENT:
        if (!is_fill_gradient)
            add_comma_separated(warning, _u8L("Linear gradient"));
        break;
    case NSVG_PAINT_RADIAL_GRADIENT:
        if (!is_fill_gradient)
            add_comma_separated(warning, _u8L("Radial gradient"));
        break;
    // case NSVG_PAINT_NONE:
    // case NSVG_PAINT_COLOR:
    // default: break;
    }
 
    // Unfilled is only line which could be opened
    if (shape.fill.type != NSVG_PAINT_NONE && !is_closed(shape.paths))
        add_comma_separated(warning, _u8L("Open filled path"));
    return warning;    
}

References _L, _u8L, add_comma_separated(), create_fill_warning(), Slic3r::GUI::format(), is_closed(), and warning_preccission.

Referenced by create_fill_warning(), and create_shape_warnings().

Here is the call graph for this function:

Here is the caller graph for this function:

create_gui_configuration()

GuiCfg anonymous_namespace{GLGizmoSVG.cpp}::create_gui_configuration

(

)

                                  {
    GuiCfg cfg; // initialize by default values;
 
    float line_height = ImGui::GetTextLineHeight();
    float line_height_with_spacing = ImGui::GetTextLineHeightWithSpacing();
 
    float space = line_height_with_spacing - line_height;
 
    cfg.icon_width = std::max(std::round(line_height/8)*8, 8.f);    
 
    GuiCfg::Translations &tr = cfg.translations;
 
    float lock_width = cfg.icon_width + 3 * space;
    // TRN - Input label. Be short as possible
    tr.depth       = _u8L("Depth");
    // TRN - Input label. Be short as possible
    tr.size        = _u8L("Size");
    // TRN - Input label. Be short as possible
    tr.use_surface = _u8L("Use surface");
    // TRN - Input label. Be short as possible
    tr.distance    = _u8L("From surface");
    // TRN - Input label. Be short as possible
    tr.rotation    = _u8L("Rotation");
    // TRN - Input label. Be short as possible
    tr.mirror      = _u8L("Mirror");
    float max_tr_width = std::max({
        ImGui::CalcTextSize(tr.depth.c_str()).x,
        ImGui::CalcTextSize(tr.size.c_str()).x + lock_width,
        ImGui::CalcTextSize(tr.use_surface.c_str()).x,
        ImGui::CalcTextSize(tr.distance.c_str()).x,
        ImGui::CalcTextSize(tr.rotation.c_str()).x + lock_width,
        ImGui::CalcTextSize(tr.mirror.c_str()).x,
    });
 
    const ImGuiStyle &style = ImGui::GetStyle();
    cfg.input_offset = style.WindowPadding.x + max_tr_width + space + cfg.icon_width;
    cfg.lock_offset = cfg.input_offset - (cfg.icon_width + 2 * space);
 
    ImVec2 letter_m_size = ImGui::CalcTextSize("M");
    const float count_letter_M_in_input = 12.f;
    cfg.input_width = letter_m_size.x * count_letter_M_in_input;
    cfg.texture_max_size_px = std::round((cfg.input_width + cfg.input_offset + cfg.icon_width + space)/8) * 8;
 
    cfg.max_tooltip_width = ImGui::GetFontSize() * 20.0f;
 
    return cfg;
}

References _u8L, create_gui_configuration(), anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::Translations::depth, anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::Translations::distance, anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::icon_width, anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::input_offset, anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::input_width, anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::lock_offset, anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::max_tooltip_width, anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::Translations::mirror, anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::Translations::rotation, anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::Translations::size, style, anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::texture_max_size_px, anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::translations, and anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::Translations::use_surface.

Referenced by create_gui_configuration().

Here is the call graph for this function:

Here is the caller graph for this function:

create_input()

CreateVolumeParams anonymous_namespace{GLGizmoSVG.cpp}::create_input	(	GLCanvas3D &	canvas,
		RaycastManager &	raycaster,
		ModelVolumeType	volume_type )

Create input for volume creation.

Parameters

canvas	parent of gizmo
raycaster	Keep scene
volume_type	Type of volume to be created

Returns

Params

{
    auto gizmo = static_cast<unsigned char>(GLGizmosManager::Svg);
    const GLVolume *gl_volume = get_first_hovered_gl_volume(canvas);
    Plater *plater = wxGetApp().plater();
    return CreateVolumeParams{canvas, plater->get_camera(), plater->build_volume(),
        plater->get_ui_job_worker(), volume_type, raycaster, gizmo, gl_volume};
}

References create_input(), Slic3r::GUI::get_first_hovered_gl_volume(), Slic3r::GUI::plater(), and Slic3r::GUI::GLGizmosManager::Svg.

Referenced by create_input().

Here is the call graph for this function:

Here is the caller graph for this function:

create_shape_warnings()

std::vector< std::string > anonymous_namespace{GLGizmoSVG.cpp}::create_shape_warnings	(	const EmbossShape &	shape,
		float	scale )

Create warnings about shape.

Parameters

image

Input svg loaded to shapes

Returns

Vector of warnings with same size as EmbossShape::shapes_with_ids or Empty when no warnings -> for fast checking that every thing is all right(more common case)

                                                                                 {
    const std::shared_ptr<NSVGimage>& image_ptr = shape.svg_file->image;
    assert(image_ptr != nullptr);
    if (image_ptr == nullptr)
        return {std::string{"Uninitialized SVG image"}};
 
    const NSVGimage &image = *image_ptr;
    std::vector<std::string> result;
    auto add_warning = [&result, &image](size_t index, const std::string &message) {
        if (result.empty())
            result = std::vector<std::string>(get_shapes_count(image) * 2);
        std::string &res = result[index];
        if (res.empty())
            res = message;
        else
            res += '\n' + message;
    };
 
    if (!shape.final_shape.is_healed) {
        for (const ExPolygonsWithId &i : shape.shapes_with_ids)
            if (!i.is_healed)
                add_warning(i.id, _u8L("Path can't be healed from self-intersection and multiple points."));
 
        // This waning is not connected to NSVGshape. It is about union of paths, but Zero index is shown first
        size_t index = 0;
        add_warning(index, _u8L("Final shape contains self-intersection or multiple points with same coordinate."));
    }
 
    size_t shape_index = 0;
    for (NSVGshape *shape = image.shapes; shape != NULL; shape = shape->next, ++shape_index) {
        if (!(shape->flags & NSVG_FLAGS_VISIBLE)){
            add_warning(shape_index * 2, GUI::format(_L("Shape is marked as invisible (%1%)."), shape->id));
            continue;
        }
 
        std::string fill_warning = create_fill_warning(*shape);
        if (!fill_warning.empty()) {
            // TRN: The first placeholder is shape identifier, the second is text describing the problem.
            add_warning(shape_index * 2, GUI::format(_L("Fill of shape (%1%) contains unsupported: %2%."), shape->id, fill_warning));
        }
        
        float minimal_width_in_mm = 1e-3f;
        if (shape->strokeWidth <= minimal_width_in_mm * scale) {
            add_warning(shape_index * 2, GUI::format(_L("Stroke of shape (%1%) is too thin (minimal width is %2% mm)."), shape->id, minimal_width_in_mm));
            continue;
        }
        std::string stroke_warning = create_stroke_warning(*shape);
        if (!stroke_warning.empty())
            add_warning(shape_index * 2 + 1, GUI::format(_L("Stroke of shape (%1%) contains unsupported: %2%."), shape->id, stroke_warning));
    }
    return result;
}

References _L, _u8L, create_fill_warning(), create_shape_warnings(), create_stroke_warning(), Slic3r::EmbossShape::final_shape, Slic3r::GUI::format(), Slic3r::get_shapes_count(), Slic3r::ExPolygonsWithId::id, Slic3r::ExPolygonsWithId::is_healed, Slic3r::HealedExPolygons::is_healed, scale(), Slic3r::EmbossShape::shapes_with_ids, and Slic3r::EmbossShape::svg_file.

Referenced by create_shape_warnings().

Here is the call graph for this function:

Here is the caller graph for this function:

create_stroke_warning()

std::string anonymous_namespace{GLGizmoSVG.cpp}::create_stroke_warning

(

const NSVGshape &

shape

)

                                                        {
 
    std::string warning;
    if (!(shape.flags & NSVG_FLAGS_VISIBLE) ||        
        shape.stroke.type == NSVG_PAINT_NONE ||
        shape.strokeWidth <= 1e-5f)
        return {}; // not visible
 
    if ((shape.opacity - 1.f + warning_preccission) <= 0.f)
        add_comma_separated(warning, GUI::format(_L("Opacity (%1%)"), shape.opacity));
 
    bool is_stroke_gradient = shape.strokeGradient[0] != '\0';
    if (is_stroke_gradient)
        add_comma_separated(warning, GUI::format(_L("Color gradient (%1%)"), shape.strokeGradient));
 
    switch (shape.stroke.type) {
    case NSVG_PAINT_UNDEF: add_comma_separated(warning, _u8L("Undefined stroke type")); break;
    case NSVG_PAINT_LINEAR_GRADIENT:
        if (!is_stroke_gradient)
            add_comma_separated(warning, _u8L("Linear gradient"));
        break;
    case NSVG_PAINT_RADIAL_GRADIENT:
        if (!is_stroke_gradient)
            add_comma_separated(warning, _u8L("Radial gradient"));
        break;
    // case NSVG_PAINT_COLOR:
    // case NSVG_PAINT_NONE:
    // default: break;
    }
 
    return warning;
}

References _L, _u8L, add_comma_separated(), create_stroke_warning(), Slic3r::GUI::format(), and warning_preccission.

Referenced by create_shape_warnings(), and create_stroke_warning().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_texture()

void anonymous_namespace{GLGizmoSVG.cpp}::delete_texture

(

Texture &

texture

)

                                     {
    if (texture.id != 0) {
        glsafe(::glDeleteTextures(1, &texture.id));
        texture.id = 0;
    }
}

References delete_texture(), glDeleteTextures, glsafe, and Slic3r::GUI::Texture::id.

Referenced by delete_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_clickable()

bool anonymous_namespace{GLGizmoSVG.cpp}::draw_clickable	(	const IconManager::VIcons &	icons,
		IconType	type )

{
    return clickable(get_icon(icons, type, IconState::activable), get_icon(icons, type, IconState::hovered));
}

References activable, Slic3r::GUI::clickable(), draw_clickable(), get_icon(), and hovered.

Referenced by draw_clickable().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_filled()

template<unsigned int N>

void anonymous_namespace{GLGizmoSVG.cpp}::draw_filled	(	const ExPolygons &	shape,
		const std::array< unsigned char, N > &	color,
		std::vector< unsigned char > &	data,
		size_t	data_width,
		double	scale )

Draw filled ExPolygon into data line by line inspired by: http://alienryderflex.com/polygon_fill/.

Template Parameters

N	Count channels for one pixel(RGBA = 4)

Parameters

shape	Shape to draw
color	Color of shape contain count of channels(N)
data	Image(2d) stored in 1d array
data_width	Count of pixel on one line(size in data = N x data_width)
scale	Shape scale for conversion to pixels

                                                                                                                                                   {
    assert(data.size() % N == 0);
    assert(data.size() % data_width == 0);
    assert((data.size() % (N*data_width)) == 0);
 
    BoundingBox bb_unscaled = get_extents(shape);
    
    Linesf lines = to_linesf(shape);
    BoundingBoxf bb(
        bb_unscaled.min.cast<double>(), 
        bb_unscaled.max.cast<double>());
 
    // scale lines to pixels
    if (!is_approx(scale, 1.)) {
        for (Linef &line : lines) {
            line.a *= scale;
            line.b *= scale;
        }
        bb.min *= scale;
        bb.max *= scale;
    }
 
    int count_lines = data.size() / (N * data_width);
    size_t data_line = N * data_width;
    auto get_offset = [count_lines, data_line](int x, int y) {
        // NOTE: y has opposit direction in texture
        return (count_lines - y - 1) * data_line + x * N;
    };
    auto set_color = [&data, &color, get_offset](int x, int y) {
        size_t offset = get_offset(x, y);
        if (data[offset + N - 1] != 0)
            return; // already setted by line
        for (unsigned i = 0; i < N; ++i)
            data[offset + i] = color[i];
    };
 
    // anti aliased drawing of lines
    auto draw = [&data, width = static_cast<int>(data_width), count_lines, get_offset, &color](int x, int y, float brightess) {
        if (x < 0 || y < 0 || x >= width || y >= count_lines)
            return; // out of image
        size_t offset = get_offset(x, y);
        unsigned char &alpha = data[offset + N - 1];
        if (alpha == 0){
            alpha = static_cast<unsigned char>(std::round(brightess * 255));
            for (size_t i = 0; i < N-1; ++i)
                data[offset + i] = color[i];
        } else if (alpha != 255){
            alpha = static_cast<unsigned char>(std::min(255, int(alpha) + static_cast<int>(std::round(brightess * 255))));
        }
    };
 
    for (const Linef& line: lines) 
        wu_draw_line_side(line, draw);
    
    auto tree = Slic3r::AABBTreeLines::build_aabb_tree_over_indexed_lines(lines);
 
    // range for intersection line
    double x1 = bb.min.x() - 1.f;
    double x2 = bb.max.x() + 1.f;
 
    int max_y = std::min(count_lines, static_cast<int>(std::round(bb.max.y())));
    for (int y = std::max(0, static_cast<int>(std::round(bb.min.y()))); y < max_y; ++y){
        double y_f = y + .5; // 0.5 ... intersection in center of pixel of pixel
        Linef line(Vec2d(x1, y_f), Vec2d(x2, y_f));
        using Intersection = std::pair<Vec2d, size_t>;
        using Intersections = std::vector<Intersection>;
        // sorted .. false
        // <false, Vec2d, Linef, decltype(tree)>
        Intersections intersections = Slic3r::AABBTreeLines::get_intersections_with_line<false, Vec2d, Linef>(lines, tree, line);
        if (intersections.empty())
            continue;
 
        assert((intersections.size() % 2) == 0);
 
        // sort intersections by x
        std::sort(intersections.begin(), intersections.end(), 
            [](const Intersection &i1, const Intersection &i2) { return i1.first.x() < i2.first.x(); });
 
        // draw lines
        for (size_t i = 0; i < intersections.size(); i+=2) {
            const Vec2d& p2 = intersections[i+1].first;
            if (p2.x() < 0)
                continue; // out of data
 
            const Vec2d& p1 = intersections[i].first;
            if (p1.x() > data_width)
                break; // out of data
 
            // clamp to data
            int max_x = std::min(static_cast<int>(data_width-1), static_cast<int>(std::round(p2.x())));
            for (int x = std::max(0, static_cast<int>(std::round(p1.x()))); x <= max_x; ++x)
                set_color(x, y);
        }
    }  
}

References Slic3r::Linef::a, Slic3r::Linef::b, Slic3r::AABBTreeLines::build_aabb_tree_over_indexed_lines(), Slic3r::GUI::draw(), draw_filled(), Slic3r::get_extents(), Slic3r::AABBTreeLines::get_intersections_with_line(), Slic3r::is_approx(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::GUI::N, Slic3r::offset(), scale(), Slic3r::to_linesf(), and wu_draw_line_side().

Referenced by draw_filled(), and init_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

draw_side_outline()

template<unsigned int N>

void anonymous_namespace{GLGizmoSVG.cpp}::draw_side_outline	(	const ExPolygons &	shape,
		const std::array< unsigned char, N > &	color,
		std::vector< unsigned char > &	data,
		size_t	data_width,
		double	scale )

{
    int count_lines = data.size() / (N * data_width);
    size_t data_line  = N * data_width;
    auto get_offset  = [count_lines, data_line](int x, int y) {
        // NOTE: y has opposit direction in texture
        return (count_lines - y - 1) * data_line + x * N;
    };
 
    // overlap color
    auto draw = [&data, data_width, count_lines, get_offset, &color](int x, int y, float brightess) {
        if (x < 0 || y < 0 || static_cast<size_t>(x) >= data_width || y >= count_lines)
            return; // out of image
        size_t offset = get_offset(x, y);
        bool change_color = false;
        for (size_t i = 0; i < N - 1; ++i) {
            if(data[offset + i] != color[i]){
                data[offset + i] = color[i];        
                change_color = true;
            }
        }
 
        unsigned char &alpha = data[offset + N - 1];
        if (alpha == 0 || change_color){
            alpha = static_cast<unsigned char>(std::round(brightess * 255));
        } else if (alpha != 255){
            alpha = static_cast<unsigned char>(std::min(255, int(alpha) + static_cast<int>(std::round(brightess * 255))));
        }
    };
 
    BoundingBox bb_unscaled = get_extents(shape);
    Linesf lines = to_linesf(shape);
    BoundingBoxf bb(bb_unscaled.min.cast<double>(), bb_unscaled.max.cast<double>());
 
    // scale lines to pixels
    if (!is_approx(scale, 1.)) {
        for (Linef &line : lines) {
            line.a *= scale;
            line.b *= scale;
        }
        bb.min *= scale;
        bb.max *= scale;
    }
 
    for (const Linef &line : lines)
        wu_draw_line_side(line, draw);
}

References Slic3r::Linef::a, Slic3r::Linef::b, Slic3r::GUI::draw(), draw_side_outline(), Slic3r::get_extents(), Slic3r::is_approx(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::GUI::N, Slic3r::offset(), scale(), Slic3r::to_linesf(), and wu_draw_line_side().

Referenced by draw_side_outline(), and init_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

get_file_name()

std::string anonymous_namespace{GLGizmoSVG.cpp}::get_file_name

(

const std::string &

file_path

)

Separate file name from file path. String after last delimiter and before last point.

Parameters

file_path

path return by file dialog

Returns

File name without directory path

{
    if (file_path.empty())
        return file_path;
 
    size_t pos_last_delimiter = file_path.find_last_of("/\\");
    if (pos_last_delimiter == std::string::npos) {
        // should not happend that in path is not delimiter
        assert(false);
        pos_last_delimiter = 0;
    }
 
    size_t pos_point = file_path.find_last_of('.');
    if (pos_point == std::string::npos || pos_point < pos_last_delimiter // last point is inside of directory path
    ) {
        // there is no extension
        assert(false);
        pos_point = file_path.size();
    }
 
    size_t offset = pos_last_delimiter + 1;             // result should not contain last delimiter ( +1 )
    size_t count  = pos_point - pos_last_delimiter - 1; // result should not contain extension point ( -1 )
    return file_path.substr(offset, count);
}

References count, get_file_name(), and Slic3r::offset().

Referenced by get_file_name(), and volume_name().

Here is the call graph for this function:

Here is the caller graph for this function:

get_icon()

const IconManager::Icon & anonymous_namespace{GLGizmoSVG.cpp}::get_icon	(	const IconManager::VIcons &	icons,
		IconType	type,
		IconState	state )

                                                                                                { 
    return *icons[(unsigned) type][(unsigned) state]; }

References get_icon().

Referenced by draw_clickable(), get_icon(), and reset_button().

Here is the call graph for this function:

Here is the caller graph for this function:

get_tesselation_tolerance()

double anonymous_namespace{GLGizmoSVG.cpp}::get_tesselation_tolerance

(

double

scale

)

                                              { 
    double tesselation_tolerance_in_mm = .1; //8e-2;
    double tesselation_tolerance_scaled = (tesselation_tolerance_in_mm*tesselation_tolerance_in_mm) / SCALING_FACTOR / SCALING_FACTOR;
    return tesselation_tolerance_scaled / scale / scale;
}

References get_tesselation_tolerance(), scale(), and SCALING_FACTOR.

Referenced by get_tesselation_tolerance().

Here is the call graph for this function:

Here is the caller graph for this function:

init_icons()

IconManager::VIcons anonymous_namespace{GLGizmoSVG.cpp}::init_icons	(	IconManager &	mng,
		const GuiCfg &	cfg )

{ 
    mng.release();
    
    ImVec2 size(cfg.icon_width, cfg.icon_width);
    // icon order has to match the enum IconType
    std::vector<std::string> filenames{
        "undo.svg",          // reset_value           
        "refresh.svg",       // refresh           
        "open.svg",          // changhe_file
        "burn.svg",          // bake
        "save.svg",          // save
        "obj_warning.svg",   // exclamation // ORCA: use obj_warning instead exclamation. exclamation is not compatible with low res
        "lock_closed.svg",   // lock
        "lock_open.svg",     // unlock
        "reflection_x.svg",  // reflection_x
        "reflection_y.svg",  // reflection_y
    };
 
    assert(filenames.size() == static_cast<size_t>(IconType::_count));
    std::string path = resources_dir() + "/images/";
    for (std::string &filename : filenames) filename = path + filename;
 
    auto type = IconManager::RasterType::color_wite_gray;
    return mng.init(filenames, size, type);
 
    //IconManager::VIcons vicons = mng.init(init_types);
    //
    //IconManager::Icons  icons;
    //icons.reserve(vicons.size());
    //for (IconManager::Icons &i : vicons)
    //    icons.push_back(i.front());
    //return icons;
}

References _count, Slic3r::GUI::IconManager::color_wite_gray, anonymous_namespace{GLGizmoSVG.cpp}::GuiCfg::icon_width, Slic3r::GUI::IconManager::init(), init_icons(), Slic3r::GUI::IconManager::release(), and Slic3r::resources_dir().

Referenced by init_icons().

Here is the call graph for this function:

Here is the caller graph for this function:

init_texture()

bool anonymous_namespace{GLGizmoSVG.cpp}::init_texture	(	Texture &	texture,
		const ExPolygonsWithIds &	shapes_with_ids,
		unsigned	max_size_px,
		const std::vector< std::string > &	shape_warnings )

                                                                                                                                               {
    BoundingBox bb = get_extents(shapes_with_ids);
    Point  bb_size   = bb.size();
    double bb_width  = bb_size.x(); // [in mm]
    double bb_height = bb_size.y(); // [in mm]
 
    bool is_widder = bb_size.x() > bb_size.y();
    double scale = 0.f;
    if (is_widder) {
        scale          = max_size_px / bb_width;
        texture.width  = max_size_px;
        texture.height = static_cast<unsigned>(std::ceil(bb_height * scale));
    } else {
        scale          = max_size_px / bb_height;
        texture.width  = static_cast<unsigned>(std::ceil(bb_width * scale));
        texture.height = max_size_px;
    }
    const int n_pixels = texture.width * texture.height;
    if (n_pixels <= 0)
        return false;
 
    constexpr int channels_count = 4;
    std::vector<unsigned char> data(n_pixels * channels_count, {0});
 
    // Union All shapes
    ExPolygons shape = union_ex(shapes_with_ids);
 
    // align to texture
    translate(shape, -bb.min);
    size_t texture_width = static_cast<size_t>(texture.width);
    unsigned char alpha = 255; // without transparency
    std::array<unsigned char, 4> color_shape{201, 201, 201, alpha}; // from degin by @JosefZachar
    std::array<unsigned char, 4> color_error{237, 28, 36, alpha}; // from icon: resources/icons/flag_red.svg
    std::array<unsigned char, 4> color_warning{237, 107, 33, alpha}; // icons orange
    // draw unhealedable shape
    for (const ExPolygonsWithId &shapes_with_id : shapes_with_ids)
        if (!shapes_with_id.is_healed) {
            ExPolygons bad_shape = shapes_with_id.expoly; // copy
            translate(bad_shape, -bb.min); // align to texture
            draw_side_outline<4>(bad_shape, color_error, data, texture_width, scale);
        }
    // Draw shape with warning
    if (!shape_warnings.empty()) {
        for (const ExPolygonsWithId &shapes_with_id : shapes_with_ids){
            assert(shapes_with_id.id < shape_warnings.size());
            if (shapes_with_id.id >= shape_warnings.size())
                continue;
            if (shape_warnings[shapes_with_id.id].empty())
                continue; // no warnings for shape
            ExPolygons warn_shape = shapes_with_id.expoly; // copy
            translate(warn_shape, -bb.min); // align to texture
            draw_side_outline<4>(warn_shape, color_warning, data, texture_width, scale);
        }
    }
 
    // Draw rest of shape
    draw_filled<4>(shape, color_shape, data, texture_width, scale);
 
    // sends data to gpu 
    glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
    if (texture.id != 0)
        glsafe(::glDeleteTextures(1, &texture.id));
    glsafe(::glGenTextures(1, &texture.id));
    glsafe(::glBindTexture(GL_TEXTURE_2D, texture.id));
    glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei) texture.width, (GLsizei) texture.height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                          (const void *) data.data()));
 
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
 
    GLuint NO_TEXTURE_ID = 0;
    glsafe(::glBindTexture(GL_TEXTURE_2D, NO_TEXTURE_ID));
    return true;
}

References draw_filled(), draw_side_outline(), Slic3r::get_extents(), GL_LINEAR, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_MIN_FILTER, GL_UNPACK_ALIGNMENT, GL_UNSIGNED_BYTE, glBindTexture, glDeleteTextures, glGenTextures, glPixelStorei, glsafe, glTexImage2D, glTexParameteri, Slic3r::GUI::Texture::height, Slic3r::GUI::Texture::id, init_texture(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, scale(), Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::translate(), Slic3r::union_ex(), and Slic3r::GUI::Texture::width.

Referenced by init_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

is_closed()

bool anonymous_namespace{GLGizmoSVG.cpp}::is_closed

(

NSVGpath *

path

)

                              {
    for (; path != NULL; path = path->next)
        if (path->next == NULL && path->closed)
            return true;    
    return false;
}

References is_closed().

Referenced by create_fill_warning(), and is_closed().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_button()

bool anonymous_namespace{GLGizmoSVG.cpp}::reset_button

(

const IconManager::VIcons &

icons

)

{
    float reset_offset = ImGui::GetStyle().WindowPadding.x;
    ImGui::SameLine(reset_offset);
 
    // from GLGizmoCut
    //std::string label_id = "neco";
    //std::string btn_label;
    //btn_label += ImGui::RevertButton;
    //return ImGui::Button((btn_label + "##" + label_id).c_str());
 
    auto icon = get_icon(icons, IconType::reset_value, IconState::hovered);
    return clickable(icon, icon); // ORCA use orange color for both states
}

References Slic3r::GUI::clickable(), get_icon(), hovered, reset_button(), and reset_value.

Referenced by reset_button().

Here is the call graph for this function:

Here is the caller graph for this function:

select_shape()

EmbossShape anonymous_namespace{GLGizmoSVG.cpp}::select_shape	(	std::string_view	filepath = "",
		double	tesselation_tolerance_in_mm = get_tesselation_tolerance(1.) )

Let user to choose file with (S)calable (V)ector (G)raphics - SVG. Than let select contour.

Parameters

filepath

SVG file path, when empty promt user to select one

Returns

EmbossShape to create

{
    EmbossShape shape;
    shape.projection.depth       = 10.;
    shape.projection.use_surface = false;
    
    EmbossShape::SvgFile svg;
    if (filepath.empty()) {
        // When empty open file dialog
        svg.path = choose_svg_file();
        if (svg.path.empty())            
            return {}; // file was not selected
    } else {
        svg.path = filepath; // copy
    }
    
 
    boost::filesystem::path path(svg.path);
    if (!boost::filesystem::exists(path)) {
        show_error(nullptr, GUI::format(_u8L("File does NOT exist (%1%)."), svg.path));
        return {};
    }
 
    if (!boost::algorithm::iends_with(svg.path, ".svg")) {
        show_error(nullptr, GUI::format(_u8L("Filename has to end with \".svg\" but you selected %1%"), svg.path));
        return {};
    }
 
    if(init_image(svg) == nullptr) {
        show_error(nullptr, GUI::format(_u8L("Nano SVG parser can't load from file (%1%)."), svg.path));
        return {};
    }
 
    // Set default and unchanging scale
    NSVGLineParams params{tesselation_tolerance};
    shape.shapes_with_ids = create_shape_with_ids(*svg.image, params);
 
    // Must contain some shapes !!!
    if (shape.shapes_with_ids.empty()) {
        show_error(nullptr, GUI::format(_u8L("SVG file does NOT contain a single path to be embossed (%1%)."), svg.path));
        return {};
    }
    shape.svg_file = std::move(svg);
    return shape;
}

References _u8L, choose_svg_file(), Slic3r::create_shape_with_ids(), Slic3r::EmbossProjection::depth, Slic3r::GUI::format(), Slic3r::EmbossShape::SvgFile::image, Slic3r::init_image(), Slic3r::EmbossShape::SvgFile::path, Slic3r::EmbossShape::projection, select_shape(), Slic3r::EmbossShape::shapes_with_ids, Slic3r::GUI::show_error(), Slic3r::EmbossShape::svg_file, and Slic3r::EmbossProjection::use_surface.

Referenced by create_emboss_data_base(), and select_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

union_ex()

ExPolygons anonymous_namespace{GLGizmoSVG.cpp}::union_ex

(

const ExPolygonsWithIds &

shapes

)

Union shape defined by glyphs.

{
    // unify to one expolygon
    ExPolygons result;
    for (const ExPolygonsWithId &shape : shapes) {
        if (shape.expoly.empty())
            continue;
        expolygons_append(result, shape.expoly);
    }
    return union_ex(result);
}

References Slic3r::expolygons_append(), and Slic3r::union_ex().

Here is the call graph for this function:

volume_name()

std::string anonymous_namespace{GLGizmoSVG.cpp}::volume_name

(

const EmbossShape &

shape

)

Create volume name from shape information.

Parameters

shape

File path

Returns

Name for volume

{
    std::string file_name = get_file_name(shape.svg_file->path);
    if (!file_name.empty())
        return file_name;
    return _u8L("SVG shape");
}

References _u8L, get_file_name(), Slic3r::EmbossShape::svg_file, and volume_name().

Referenced by create_emboss_data_base(), and volume_name().

Here is the call graph for this function:

Here is the caller graph for this function:

wu_draw_line_side()

void anonymous_namespace{GLGizmoSVG.cpp}::wu_draw_line_side	(	Linef	line,
		const std::function< void(int x, int y, float brightess)> &	plot )

                                                                              {
    auto ipart = [](float x) -> int {return static_cast<int>(std::floor(x));};
    auto round = [](float x) -> float {return std::round(x);};
    auto fpart = [](float x) -> float {return x - std::floor(x);};
    auto rfpart = [=](float x) -> float {return 1 - fpart(x);};
    
    Vec2d d = line.b - line.a;
    const bool steep = abs(d.y()) > abs(d.x());
    bool is_full; // identify full brightness pixel
    if (steep) {
        is_full = d.y() >= 0;
        std::swap(line.a.x(), line.a.y());
        std::swap(line.b.x(), line.b.y());
        std::swap(d.x(), d.y());
    }else
        is_full = d.x() < 0; // opposit direction of y
 
    if (line.a.x() > line.b.x()) {
        std::swap(line.a.x(), line.b.x());
        std::swap(line.a.y(), line.b.y());
        d *= -1;
    }
    const float gradient = (d.x() == 0) ? 1. : d.y() / d.x();
        
    int xpx11;
    float intery;
    {
        const float xend = round(line.a.x());
        const float yend = line.a.y() + gradient * (xend - line.a.x());
        const float xgap = rfpart(line.a.x() + 0.5f);
        xpx11 = int(xend);
        const int ypx11 = ipart(yend);
        if (steep) {
            plot(ypx11,     xpx11,  is_full? 1.f : (rfpart(yend) * xgap));
            plot(ypx11 + 1, xpx11, !is_full? 1.f : ( fpart(yend) * xgap));
        } else {
            plot(xpx11, ypx11,     is_full? 1.f : (rfpart(yend) * xgap));
            plot(xpx11, ypx11 + 1,!is_full? 1.f : ( fpart(yend) * xgap));
        }
        intery = yend + gradient;
    }
    
    int xpx12;
    {
        const float xend = round(line.b.x());
        const float yend = line.b.y() + gradient * (xend - line.b.x());
        const float xgap = rfpart(line.b.x() + 0.5f);
        xpx12 = int(xend);
        const int ypx12 = ipart(yend);
        if (steep) {
            plot(ypx12,     xpx12,  is_full? 1.f : (rfpart(yend) * xgap));
            plot(ypx12 + 1, xpx12, !is_full? 1.f : ( fpart(yend) * xgap));
        } else {
            plot(xpx12, ypx12,      is_full? 1.f : (rfpart(yend) * xgap));
            plot(xpx12, ypx12 + 1, !is_full? 1.f : ( fpart(yend) * xgap));
        }
    }
        
    if (steep) {
        if (is_full){
            for (int x = xpx11 + 1; x < xpx12; x++) {
                plot(ipart(intery),     x, 1.f);
                plot(ipart(intery) + 1, x, fpart(intery));
                intery += gradient;
            }
        } else {
            for (int x = xpx11 + 1; x < xpx12; x++) {
                plot(ipart(intery),     x, rfpart(intery));
                plot(ipart(intery) + 1, x, 1.f );
                intery += gradient;
            }
        }
    } else {
        if (is_full){
            for (int x = xpx11 + 1; x < xpx12; x++) {
                plot(x, ipart(intery),     1.f);
                plot(x, ipart(intery) + 1, fpart(intery));
                intery += gradient;
            }
        } else {
            for (int x = xpx11 + 1; x < xpx12; x++) {
                plot(x, ipart(intery),     rfpart(intery));
                plot(x, ipart(intery) + 1, 1.f);
                intery += gradient;
            }
        }
    }
}

References Slic3r::Linef::a, Slic3r::Linef::b, and wu_draw_line_side().

Referenced by draw_filled(), draw_side_outline(), and wu_draw_line_side().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

last_used_directory

wxString anonymous_namespace{GLGizmoSVG.cpp}::last_used_directory = wxEmptyString

Referenced by choose_svg_file().

limits

const struct anonymous_namespace{GLGizmoSVG.cpp}::Limits anonymous_namespace{GLGizmoSVG.cpp}::limits

move_snapshot_name

const std::string anonymous_namespace{GLGizmoSVG.cpp}::move_snapshot_name = L("SVG move")

rotation_snapshot_name

const std::string anonymous_namespace{GLGizmoSVG.cpp}::rotation_snapshot_name = L("SVG rotate")

warning_preccission

const float anonymous_namespace{GLGizmoSVG.cpp}::warning_preccission = 1e-4f

Referenced by create_fill_warning(), and create_stroke_warning().