Slic3r::anonymous_namespace{TextureDisplacement.cpp} Namespace Reference

Classes
struct	DecodedTextureCache
struct	SmoothedTextureCache
struct	AdjustedTextureCache
struct	TextureDetailCache
struct	UnionFind
struct	UnwrapCache
struct	ChartEdge
struct	NetGrid
struct	UVTransform
struct	LscmLookup
struct	PatchRegion
struct	PreparedLayer
struct	Crossing
struct	Edge
struct	StepScan

Typedefs
using	Tri2 = std::array<Vec2f, 3>

Functions
void	smooth_height_pixels_box (std::vector< uint8_t > &pixels, int width, int height, int radius)
void	smooth_height_pixels (std::vector< uint8_t > &pixels, int width, int height, float radius)
float	unsharp_radius (int width, int height)
float	apply_brightness (float v, float b)
float	apply_contrast (float v, float c)
void	adjust_channel_spatial (std::vector< uint8_t > &channel, int width, int height, float blur, float sharpness)
float	box_face_sign (float n)
Vec2f	box_plane_yz (const Vec3f &p, float nx)
Vec2f	box_plane_xz (const Vec3f &p, float ny)
Vec2f	box_plane_xy (const Vec3f &p, float nz)
Vec2f	project_cylindrical (const Vec3f &position, const Vec3f &patch_center, const Vec3f &patch_axis)
Vec2f	project_spherical (const Vec3f &position, const Vec3f &patch_center)
indexed_triangle_set	compact_patch_with_map (const indexed_triangle_set &patch, std::vector< int > &original_to_compact)
uint64_t	undirected_edge_key (int a, int b)
Vec3f	face_normal (const indexed_triangle_set &mesh, const stl_triangle_vertex_indices &tri)
bool	chart_is_flattenable (const indexed_triangle_set &mesh, const std::vector< Vec3f > &normals, const std::vector< int > &faces)
std::vector< char >	split_chart_sides (const indexed_triangle_set &mesh, const std::vector< Vec3f > &normals, const std::vector< int > &faces)
std::vector< int >	segment_into_charts (const indexed_triangle_set &mesh, const std::vector< Vec3f > &normals, float seam_angle_deg, const std::unordered_set< uint64_t > &seam_keys, int &chart_count)
std::vector< Vec2f >	project_to_tangent_plane (const indexed_triangle_set &chart, const Vec3f &normal)
float	area_3d (const indexed_triangle_set &mesh)
float	area_2d (const std::vector< Vec2f > &uvs, const std::vector< stl_triangle_vertex_indices > &indices)
uint64_t	unwrap_cache_key (const indexed_triangle_set &patch, float seam_angle_deg, float padding_mm, const std::vector< std::pair< int, int > > &seam_edges)
std::map< std::pair< int, int >, std::vector< ChartEdge > >	build_shared_edges (const PatchUnwrap &u)
TextureIsland	solve_edge_alignment (const Vec2f &rc0, const Vec2f &rc1, const Vec2f &pp0, const Vec2f &pp1, const Vec2f &cen)
bool	triangles_overlap (const Tri2 &a, const Tri2 &b, float eps)
Vec3f	triplanar_weights (const Vec3f &normal)
std::vector< float >	patch_boundary_distance (const indexed_triangle_set &patch, const std::vector< bool > &is_boundary)
void	despeckle_triangle_colors (const indexed_triangle_set &mesh, std::vector< int > &color, int passes)
indexed_triangle_set	build_texture_displacement_v2 (const indexed_triangle_set &mesh, const std::vector< TextureDisplacementLayer > &layers, const TextureDisplacementFacetsData &facets_data, const TextureDisplacementOptions &options, const DisplacementProgressFn &progress, const TextureColorRequest *color, bool flip_normals, BakeStageRecorder *debug, TextureBakeStats *stats, const std::vector< Vec2f > *model_uv, float resting_drop)
std::shared_ptr< std::vector< PreparedLayer > >	prepare_sampleable_layers (const indexed_triangle_set &base_mesh, const std::vector< TextureDisplacementLayer > &layers, const TextureDisplacementFacetsData &facets_data, bool need_color, const std::vector< Vec2f > *model_uv)
void	ear_clip (const std::vector< Vec2f > &pts, std::vector< int > poly, const std::function< void(int, int, int)> &emit)
void	simplify_polyline (const std::vector< Vec2f > &in, float tol, std::vector< Vec2f > &out)
uint64_t	step_edge_key (int a, int b)
StepScan	scan_steps (const indexed_triangle_set &mesh, const std::vector< uint8_t > &region, const HeightFieldSampler &sampler, float step_width_mm, float seam_gap_mm, float min_feature_mm, bool nudge)
nlohmann::json	vec2_to_json (const Vec2f &v)
nlohmann::json	vec3_to_json (const Vec3f &v)
Vec2f	vec2_from_json (const nlohmann::json &j, const Vec2f &fallback)
Vec3f	vec3_from_json (const nlohmann::json &j, const Vec3f &fallback)
template<class T>
void	read (const nlohmann::json &j, const char *k, T &out)
void	read_enum (const nlohmann::json &j, const char *k, int &out)

Variables
DecodedTextureCache	g_decoded_texture_cache
SmoothedTextureCache	g_smoothed_texture_cache
AdjustedTextureCache	g_adjusted_texture_cache
constexpr float	SOURCE_BLUR_SPAN = 0.05f
constexpr float	SOURCE_BLUR_MAX_PX = 48.f
TextureDetailCache	g_texture_detail_cache
UnwrapCache	g_unwrap_cache
const size_t	UNWRAP_CACHE_MAX_ENTRIES = 8

---

Class Documentation

Slic3r::anonymous_namespace{TextureDisplacement.cpp}::DecodedTextureCache

struct Slic3r::anonymous_namespace{TextureDisplacement.cpp}::DecodedTextureCache

Collaboration diagram for Slic3r::anonymous_namespace{TextureDisplacement.cpp}::DecodedTextureCache:

Class Members
unordered_map< const void *, pair< weak_ptr< const vector< unsigned char > >, DecodedHeightTexture > >	entries
mutex	mutex

Slic3r::anonymous_namespace{TextureDisplacement.cpp}::SmoothedTextureCache

struct Slic3r::anonymous_namespace{TextureDisplacement.cpp}::SmoothedTextureCache

Collaboration diagram for Slic3r::anonymous_namespace{TextureDisplacement.cpp}::SmoothedTextureCache:

Class Members
unordered_map< const void *, Entry >	entries
mutex	mutex

Slic3r::anonymous_namespace{TextureDisplacement.cpp}::AdjustedTextureCache

struct Slic3r::anonymous_namespace{TextureDisplacement.cpp}::AdjustedTextureCache

Collaboration diagram for Slic3r::anonymous_namespace{TextureDisplacement.cpp}::AdjustedTextureCache:

Class Members
unordered_map< const void *, Entry >	entries
mutex	mutex

Slic3r::anonymous_namespace{TextureDisplacement.cpp}::TextureDetailCache

struct Slic3r::anonymous_namespace{TextureDisplacement.cpp}::TextureDetailCache

Collaboration diagram for Slic3r::anonymous_namespace{TextureDisplacement.cpp}::TextureDetailCache:

Class Members
unordered_map< const void *, pair< weak_ptr< const vector< unsigned char > >, TextureDetail > >	entries
mutex	mutex

Slic3r::anonymous_namespace{TextureDisplacement.cpp}::UnwrapCache

struct Slic3r::anonymous_namespace{TextureDisplacement.cpp}::UnwrapCache

Collaboration diagram for Slic3r::anonymous_namespace{TextureDisplacement.cpp}::UnwrapCache:

Class Members
unordered_map< uint64_t, PatchUnwrap >	entries
mutex	mutex

Slic3r::anonymous_namespace{TextureDisplacement.cpp}::ChartEdge

struct Slic3r::anonymous_namespace{TextureDisplacement.cpp}::ChartEdge

Class Members
int	chart = -1
int	uv_hi = -1
int	uv_lo = -1

Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Crossing

struct Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Crossing

Class Members
int	a = -1
int	b = -1
float	dt_max = std::numeric_limits<float>::max()
int	hi = -1
int	lo = -1
Vec3f	n
int	near_a = -1
int	near_b = -1
bool	no_seam = false
Vec3f	p
bool	sharp = false
float	sin_min = 1.f
int	single = -1
float	t
float	thick = 0.f
bool	used = false

Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Edge

struct Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Edge

Collaboration diagram for Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Edge:

Class Members
vector< Crossing >	xs

Typedef Documentation

Tri2

using Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Tri2 = std::array<Vec2f, 3>

Function Documentation

adjust_channel_spatial()

void Slic3r::anonymous_namespace{TextureDisplacement.cpp}::adjust_channel_spatial	(	std::vector< uint8_t > &	channel,
		int	width,
		int	height,
		float	blur,
		float	sharpness )

{
    if (blur > 0.f)
        smooth_height_pixels(channel, width, height, adjustment_blur_radius(blur, width, height));
 
    if (sharpness <= 0.f)
        return;
 
    // Unsharp mask: push each texel away from its local average by `amount` times the difference. The
    // blurred reference is a copy, so the sharpen reads the un-sharpened neighbourhood everywhere rather
    // than its own partly-written output.
    std::vector<uint8_t> base = channel;
    smooth_height_pixels(base, width, height, unsharp_radius(width, height));
    const float amount = 1.5f * std::clamp(sharpness, 0.f, 1.f);
    tbb::parallel_for(tbb::blocked_range<size_t>(0, channel.size()), [&](const tbb::blocked_range<size_t> &r) {
        for (size_t i = r.begin(); i < r.end(); ++i) {
            const float v = float(channel[i]) + amount * (float(channel[i]) - float(base[i]));
            channel[i]    = uint8_t(std::lround(std::clamp(v, 0.f, 255.f)));
        }
    });
}

References adjust_channel_spatial(), Slic3r::adjustment_blur_radius(), smooth_height_pixels(), and unsharp_radius().

Referenced by adjust_channel_spatial().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_brightness()

float Slic3r::anonymous_namespace{TextureDisplacement.cpp}::apply_brightness	(	float	v,
		float	b )

{
    return b >= 0.f ? v + b * (1.f - v) : v * (1.f + b);
}

References apply_brightness().

Referenced by apply_brightness().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_contrast()

float Slic3r::anonymous_namespace{TextureDisplacement.cpp}::apply_contrast	(	float	v,
		float	c )

{
    const float gain = c >= 0.f ? 1.f / std::max(1e-3f, 1.f - c) : 1.f + c;
    return (v - 0.5f) * gain + 0.5f;
}

References apply_contrast().

Referenced by apply_contrast().

Here is the call graph for this function:

Here is the caller graph for this function:

area_2d()

float Slic3r::anonymous_namespace{TextureDisplacement.cpp}::area_2d	(	const std::vector< Vec2f > &	uvs,
		const std::vector< stl_triangle_vertex_indices > &	indices )

{
    float area = 0.f;
    for (const stl_triangle_vertex_indices &t : indices) {
        const Vec2f e0 = uvs[size_t(t[1])] - uvs[size_t(t[0])];
        const Vec2f e1 = uvs[size_t(t[2])] - uvs[size_t(t[0])];
        area += 0.5f * std::abs(e0.x() * e1.y() - e0.y() * e1.x());
    }
    return area;
}

References Slic3r::area(), and area_2d().

Referenced by area_2d().

Here is the call graph for this function:

Here is the caller graph for this function:

area_3d()

float Slic3r::anonymous_namespace{TextureDisplacement.cpp}::area_3d

(

const indexed_triangle_set &

mesh

)

{
    float area = 0.f;
    for (const stl_triangle_vertex_indices &t : mesh.indices)
        area += 0.5f * (mesh.vertices[t[1]] - mesh.vertices[t[0]]).cross(mesh.vertices[t[2]] - mesh.vertices[t[0]]).norm();
    return area;
}

References Slic3r::area(), area_3d(), and Slic3r::cross().

Referenced by area_3d(), and prepare_sampleable_layers().

Here is the call graph for this function:

Here is the caller graph for this function:

box_face_sign()

float Slic3r::anonymous_namespace{TextureDisplacement.cpp}::box_face_sign ( float n )

inline

{ return n >= 0.f ? 1.f : -1.f; }

References box_face_sign().

Referenced by box_face_sign(), box_plane_xy(), box_plane_xz(), and box_plane_yz().

Here is the call graph for this function:

Here is the caller graph for this function:

box_plane_xy()

Vec2f Slic3r::anonymous_namespace{TextureDisplacement.cpp}::box_plane_xy ( const Vec3f & p, float nz )

inline

{ return Vec2f(box_face_sign(nz) * p.x(), -p.y()); }

References box_face_sign(), and box_plane_xy().

Referenced by box_plane_xy().

Here is the call graph for this function:

Here is the caller graph for this function:

box_plane_xz()

Vec2f Slic3r::anonymous_namespace{TextureDisplacement.cpp}::box_plane_xz ( const Vec3f & p, float ny )

inline

{ return Vec2f(-box_face_sign(ny) * p.x(), -p.z()); }

References box_face_sign(), and box_plane_xz().

Referenced by box_plane_xz().

Here is the call graph for this function:

Here is the caller graph for this function:

box_plane_yz()

Vec2f Slic3r::anonymous_namespace{TextureDisplacement.cpp}::box_plane_yz ( const Vec3f & p, float nx )

inline

{ return Vec2f(box_face_sign(nx) * p.y(), -p.z()); }

References box_face_sign(), and box_plane_yz().

Referenced by box_plane_yz().

Here is the call graph for this function:

Here is the caller graph for this function:

build_shared_edges()

std::map< std::pair< int, int >, std::vector< ChartEdge > > Slic3r::anonymous_namespace{TextureDisplacement.cpp}::build_shared_edges

(

const PatchUnwrap &

u

)

{
    std::map<std::pair<int, int>, std::vector<ChartEdge>> edges;
    for (const auto &[ua, ub] : u.boundary_edges) {
        if (ua < 0 || ub < 0 || size_t(ua) >= u.source_vertex.size() || size_t(ub) >= u.source_vertex.size())
            continue;
        const int ba = u.source_vertex[size_t(ua)], bb = u.source_vertex[size_t(ub)];
        if (ba < 0 || bb < 0 || ba == bb)
            continue;
        const int chart = (size_t(ua) < u.vertex_chart.size()) ? u.vertex_chart[size_t(ua)] : -1;
        if (chart < 0)
            continue;
        const std::pair<int, int> key{ std::min(ba, bb), std::max(ba, bb) };
        // Order the uv endpoints to match the base-vertex order in the key.
        ChartEdge e{ chart, ua, ub };
        if (u.source_vertex[size_t(ua)] != key.first)
            std::swap(e.uv_lo, e.uv_hi);
        edges[key].push_back(e);
    }
    return edges;
}

References Slic3r::PatchUnwrap::boundary_edges, build_shared_edges(), Slic3r::PatchUnwrap::source_vertex, Slic3r::anonymous_namespace{TextureDisplacement.cpp}::ChartEdge::uv_hi, Slic3r::anonymous_namespace{TextureDisplacement.cpp}::ChartEdge::uv_lo, and Slic3r::PatchUnwrap::vertex_chart.

Referenced by build_shared_edges().

Here is the call graph for this function:

Here is the caller graph for this function:

build_texture_displacement_v2()

indexed_triangle_set Slic3r::anonymous_namespace{TextureDisplacement.cpp}::build_texture_displacement_v2	(	const indexed_triangle_set &	mesh,
		const std::vector< TextureDisplacementLayer > &	layers,
		const TextureDisplacementFacetsData &	facets_data,
		const TextureDisplacementOptions &	options,
		const DisplacementProgressFn &	progress,
		const TextureColorRequest *	color,
		bool	flip_normals,
		BakeStageRecorder *	debug,
		TextureBakeStats *	stats,
		const std::vector< Vec2f > *	model_uv,
		float	resting_drop )

{
    HeightFieldSampler combined = make_combined_displacement_sampler(mesh, layers, facets_data, model_uv);
    if (!combined)
        return mesh; // nothing decodable to displace with
 
    // Unpainted triangles are excluded, keeping them out of refinement and pinned thereafter. The
    // paint is finer than that, though: a brush stroke splits a source triangle into pieces, and only
    // some of them are painted. `painted_pieces` keeps every layer's painted pieces (they lie in the
    // source surface) so the refined faces can be tested against the paint itself, not against the
    // source triangle they came from.
    std::vector<uint8_t> excluded(mesh.indices.size(), 1);
    indexed_triangle_set painted_pieces;
    {
        const TriangleMesh selector_mesh(mesh);
        TriangleSelector   selector(selector_mesh);
        bool               dirty = false;
        for (const TriangleSelector::TriangleSplittingData &data : facets_data) {
            if (data.triangles_to_split.empty())
                continue;
            selector.deserialize(data, dirty);
            dirty = true;
            std::vector<int> piece_src;
            const indexed_triangle_set patch =
                selector.get_facets_strict(EnforcerBlockerType::ENFORCER, &piece_src);
            for (const int src : piece_src)
                if (src >= 0 && size_t(src) < excluded.size())
                    excluded[size_t(src)] = 0;
            // `patch` carries the whole mesh's vertex array (see compact_patch_with_map()); append
            // only what its pieces reference.
            std::vector<int>           unused;
            const indexed_triangle_set compact = compact_patch_with_map(patch, unused);
            const int                  offset  = int(painted_pieces.vertices.size());
            painted_pieces.vertices.insert(painted_pieces.vertices.end(), compact.vertices.begin(), compact.vertices.end());
            for (const stl_triangle_vertex_indices &t : compact.indices)
                painted_pieces.indices.emplace_back(t[0] + offset, t[1] + offset, t[2] + offset);
        }
    }
    if (std::all_of(excluded.begin(), excluded.end(), [](uint8_t e) { return e != 0; }) || painted_pieces.indices.empty())
        return mesh; // nothing painted
 
    // Distance to the nearest painted piece. Built once here; the tree is read-only afterwards, so
    // the parallel stages below share it freely.
    const AABBTreeIndirect::Tree3f painted_tree =
        AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(painted_pieces.vertices, painted_pieces.indices);
    // `foot`/`normal`, when asked for, are the closest point on the painted pieces and that piece's
    // normal. The pieces lie in the *undisplaced* surface, so for a displaced point those two are the
    // base position and normal underneath it - the frame colour has to be projected in (see below).
    const auto painted_closest = [&painted_pieces, &painted_tree](const Vec3f &p, Vec3f *foot, Vec3f *normal) {
        size_t      hit = 0;
        Vec3f       hit_point;
        const float d2 = AABBTreeIndirect::squared_distance_to_indexed_triangle_set(
            painted_pieces.vertices, painted_pieces.indices, painted_tree, p, hit, hit_point);
        if (foot != nullptr)
            *foot = hit_point;
        if (normal != nullptr && hit < painted_pieces.indices.size()) {
            const stl_triangle_vertex_indices &t = painted_pieces.indices[hit];
            const Vec3f &a = painted_pieces.vertices[size_t(t[0])], &b = painted_pieces.vertices[size_t(t[1])],
                        &c = painted_pieces.vertices[size_t(t[2])];
            Vec3f       n = (b - a).cross(c - a);
            const float l = n.norm();
            *normal = (l > 0.f) ? Vec3f(n / l) : Vec3f::UnitZ();
        }
        return d2;
    };
    const auto painted_dist2 = [&painted_closest](const Vec3f &p) { return painted_closest(p, nullptr, nullptr); };
    // Before displacement the queried centroids lie in the same surface as the pieces, so anything
    // beyond a hair is genuinely outside the paint.
    constexpr float paint_tol = 0.05f;
    const auto      painted_at = [&painted_dist2](const Vec3f &p) { return painted_dist2(p) < paint_tol * paint_tol; };
 
    // "Auto" resolution and budget (0 and -1) resolve here, from the texture and the model - the mesh
    // is already in world mm at this point, so no transform is needed.
    const bool         auto_edge = options.v2_refine_mm <= 0.f, auto_budget = options.v2_max_triangles_k < 0;
    const V2Resolution rec = (auto_edge || auto_budget) ? recommend_v2_resolution(mesh, layers) : V2Resolution{};
    TextureBake::PipelineSettings settings;
    settings.refine_length = auto_edge ? std::max(0.05, double(rec.edge_mm)) : std::max(0.01f, options.v2_refine_mm);
    settings.regularize    = options.v2_regularize;
    settings.max_triangles = size_t(auto_budget ? std::max(0, rec.budget_k) : options.v2_max_triangles_k) * 1000;
    BOOST_LOG_TRIVIAL(info) << "TextureBake resolution: " << settings.refine_length << " mm"
                            << (auto_edge ? " (auto)" : "") << ", budget " << settings.max_triangles / 1000 << " k"
                            << (auto_budget ? " (auto)" : "");
    // How far a flat-face harvest may move the surface, tied to the resolution: what a bake refined to
    // 1.4 mm edges can merge flat is not what one refined to 0.1 mm may touch. A thirty-second of the
    // edge is well under a layer either way - at the default resolution it sheds about 5% of the
    // triangles on a relief that covers the whole surface, and far more of one with flat ground in it -
    // and the floor keeps a very fine resolution from spending the pass for nothing.
    settings.harvest_tol = std::clamp(settings.refine_length / 32.0, 0.005, 0.05);
    settings.preserve_untextured = true;
    // Always on: relief driven under the plate is unprintable whichever pipeline produced it, so this
    // is no longer a choice the user has to make. Only geometry that ends up below the model's own
    // bottom is moved - downward relief that stays clear of the plate is untouched.
    settings.clamp_below_plate   = true;
    settings.relocate            = options.v2_relocate;
    settings.flip_edges          = options.v2_flip_edges;
    // The sampler already returns millimetres, so the displacement stage must not scale it again.
    settings.displace.amplitude = 1.f;
    settings.displace.symmetric = false;
    // The paint decides what moves here, so the angle limits stay off.
    settings.displace.bottom_angle_limit = 0.f;
    settings.displace.top_angle_limit    = 0.f;
    // The sampler's normal only picks the projection blend (triplanar weights); the displacement
    // direction is the pipeline's own smooth normal. Handing it the Laplacian-smoothed blend normal
    // spreads a crease's 50/50 blend over a band of rows instead of one: on a cube edge the single row
    // of vertices that samples both faces' patterns half and half otherwise comes out as a row of
    // notches, since it matches neither face.
    settings.displace.blend_normal_smoothing = 32;
    // Refined faces are asked against the paint itself, so a stroke narrower than a source triangle
    // moves only what it covers.
    // Only when some included source triangle is painted in part: the pieces then cover less area
    // than the triangles they came from. Whole-triangle paint (the usual case, and every bench) has
    // nothing to gain from a query per refined face.
    {
        const auto area_of = [](const indexed_triangle_set &its) {
            double a = 0.0;
            for (const stl_triangle_vertex_indices &t : its.indices)
                a += 0.5 * double((its.vertices[size_t(t[1])] - its.vertices[size_t(t[0])])
                                      .cross(its.vertices[size_t(t[2])] - its.vertices[size_t(t[0])]).norm());
            return a;
        };
        double included_area = 0.0;
        for (size_t t = 0; t < mesh.indices.size(); ++t)
            if (excluded[t] == 0) {
                const stl_triangle_vertex_indices &f = mesh.indices[t];
                included_area += 0.5 * double((mesh.vertices[size_t(f[1])] - mesh.vertices[size_t(f[0])])
                                                  .cross(mesh.vertices[size_t(f[2])] - mesh.vertices[size_t(f[0])]).norm());
            }
        const double pieces_area = area_of(painted_pieces);
        if (pieces_area < included_area * (1.0 - 1e-4))
            settings.painted = painted_at;
    }
    // Graded wherever some of the surface is unpainted. A yes/no to a radius, not a distance: most
    // queries are far from the paint, and those the tree turns down at its root.
    const bool all_painted = std::none_of(excluded.begin(), excluded.end(), [](uint8_t e) { return e != 0; });
    if (settings.painted || !all_painted)
        settings.paint_within = [&painted_pieces, &painted_tree](const Vec3d &p, double radius) {
            float r2 = float(radius * radius);
            return AABBTreeIndirect::is_any_triangle_in_radius(painted_pieces.vertices, painted_pieces.indices,
                                                               painted_tree, Vec3f(p.cast<float>()), r2);
        };
 
    TextureBake::DisplaceBounds bounds;
    bounds.min = bounds.max = mesh.vertices.empty() ? Vec3f::Zero() : mesh.vertices.front();
    for (const Vec3f &v : mesh.vertices) {
        bounds.min = bounds.min.cwiseMin(v);
        bounds.max = bounds.max.cwiseMax(v);
    }
    // The bottom the pipeline clamps and snaps to is the plane the whole object rests on, not this
    // part's own: a part held off the plate by another keeps the relief on its underside.
    bounds.min.z() -= resting_drop;
 
    const auto sample = [&combined](const Vec3f &pos, const Vec3f &, const Vec3f &blend_normal) {
        // The blend normal chooses the projection; the move itself is along the smooth normal, which
        // the pipeline applies on its own.
        return combined(pos, blend_normal);
    };
 
    // The pipeline takes its displacement direction from the soup's winding, so a mirrored placement
    // would drive the whole relief inwards. The paint masks were read off `mesh` above, against its
    // own vertex order, so the winding can only be turned round after that - here, on the copy that
    // becomes the soup - and has to be turned back on the way out, since the caller undoes the same
    // mirror when it maps the result back into the volume's coordinates.
    indexed_triangle_set oriented = mesh;
    if (flip_normals)
        for (stl_triangle_vertex_indices &t : oriented.indices)
            std::swap(t[1], t[2]);
 
    // 0 means no simplification, i.e. Bake mode.
    const TextureBake::PipelineMode mode = settings.max_triangles > 0 ? TextureBake::PipelineMode::Export
                                                                      : TextureBake::PipelineMode::Bake;
    // Colour, when asked for. The sampler is built now so the simplification can see the colour
    // boundaries: a simplified triangle must not span two colours, or its one colour is wrong over
    // part of it (half a tile in the neighbour's colour, a tile edge that wanders).
    const bool              want_color = color != nullptr && color->out_triangle != nullptr && bool(color->quantize);
    const ColorFieldSampler color_sampler =
        want_color ? make_combined_color_sampler(mesh, layers, facets_data, color->quantize, color->quantize_pure, model_uv) :
                     ColorFieldSampler{};
    //
    // The *palette* index, not the printed filament. The decimation treats any edge whose two faces
    // differ as a crease (TextureBakeDecimate.cpp), so it must only ever see where the **perceived**
    // colour changes. A mix is one perceived colour however its components are laid down, which is why
    // it has to be the palette index here: back when this was handed a per-triangle interleave instead,
    // every band boundary read as a crease, the collapse ran along those lines and left a stack of
    // horizontal slivers, and the triangle budget went on drawing a pattern the eye is meant to blend
    // away. Faces the paint excludes are skipped by the pipeline itself.
    const TextureBake::ColorSampleFn color_sample =
        color_sampler ? TextureBake::ColorSampleFn([&color_sampler](const Vec3f &p, const Vec3f &n) {
                            return color_sampler(p, n);
                        })
                      : TextureBake::ColorSampleFn{};
    // The pipeline works on `oriented`, whose winding was reversed above for a mirrored placement, so
    // the stages it records are wound the same way. Note where they start and turn the whole range
    // back afterwards, exactly as the result itself is turned back below.
    const size_t                debug_mark = (debug != nullptr) ? debug->mark() : 0;
    TextureBake::PipelineResult result     = TextureBake::run_pipeline(
        TextureBake::to_soup(oriented, excluded), sample, settings, bounds, mode, excluded,
        [&progress](const char *, double f) {
            return !progress || progress(std::clamp(int(f * 100.0), 0, 99));
        },
        debug, color_sample);
    if (debug != nullptr && flip_normals)
        debug->rebase(debug_mark, nullptr, /* flip_winding */ true);
    if (result.canceled || result.geometry.empty())
        return {};
 
    if (stats != nullptr) {
        stats->triangles_refined = result.triangles_refined;
        stats->triangles_budget  = result.triangles_budget;
        stats->budget_limited    = result.budget_limited;
    }
    indexed_triangle_set out = TextureBake::to_indexed_triangle_set(result.geometry, &result.face_color);
    if (out.indices.empty())
        return mesh;
    if (flip_normals)
        for (stl_triangle_vertex_indices &t : out.indices)
            std::swap(t[1], t[2]);
 
    // Colour, per output triangle. The topology is new, so unlike the classic path there is no base
    // triangle to inherit a colour from: each output triangle samples the colour stack at its own
    // centroid, and takes colour only where the paint is - measured against the painted pieces, which
    // an output centroid is never further from than the relief depth. Then the same despeckle and
    // filament resolution as the classic path.
    if (want_color) {
        std::vector<uint8_t>     out_color(out.indices.size(), 0);
        const ColorFieldSampler &sampler = color_sampler;
        if (sampler) {
            float max_depth = 0.f;
            for (const TextureDisplacementLayer &layer : layers)
                max_depth = std::max(max_depth, std::abs(layer.depth_mm));
            const float relief_tol = max_depth + paint_tol;
            std::vector<int> palette(out.indices.size(), -1);
            const std::vector<int> &face_mask      = result.face_color;
            const bool              have_face_mask = face_mask.size() == out.indices.size();
            tbb::parallel_for(tbb::blocked_range<size_t>(0, out.indices.size()), [&](const tbb::blocked_range<size_t> &r) {
                for (size_t i = r.begin(); i < r.end(); ++i) {
                    const stl_triangle_vertex_indices &t = out.indices[i];
                    const Vec3f &a = out.vertices[size_t(t[0])], &b = out.vertices[size_t(t[1])], &c = out.vertices[size_t(t[2])];
                    const Vec3f  centroid = (a + b + c) / 3.f;
                    // Sample on the *base* surface under this face, not on the relief. The projection
                    // is a function of position and normal, and the displacement has moved both: the
                    // triplanar blend weights three axis planes by |n|^4, so a face tilted ~45 degrees
                    // away from its base normal reads the image half through an unrelated plane. The
                    // patch border is a ring of exactly such faces - the relief ramps to zero there -
                    // which is the coloured fringe around the border, and the steep interior slopes
                    // streak for the same reason. The classic path samples the base patch for this very
                    // reason; this path was the inconsistent one.
                    Vec3f       foot = centroid, base_n = Vec3f::UnitZ();
                    const float d2   = painted_closest(centroid, &foot, &base_n);
                    // Which faces may be coloured comes from the pipeline, which recorded it on the
                    // refined mesh where the paint mask is exact, and carried it through the collapse,
                    // the T-junction repair and the weld. Proximity cannot answer this: a displaced face
                    // is no longer where its base was, so on a part thinner than the relief depth the
                    // nearest painted surface to the *opposite* face is the painted one, and the texture
                    // appeared there too. Only the position to sample at still comes from the base
                    // surface, for the projection reason above.
                    if (have_face_mask) {
                        if (face_mask[i] == TextureBake::FACE_UNPAINTED)
                            continue;
                    } else if (!all_painted && d2 >= relief_tol * relief_tol) {
                        continue;
                    }
                    palette[i] = sampler(foot, base_n);
                }
            });
            // The despeckle filter is for a fine, uniform mesh, where one facet flipping colour is
            // noise. A simplified mesh is neither: its triangles are as large as the colour regions
            // themselves and already end on the colour boundaries, so a majority vote among three
            // neighbours would repaint whole features. Bake mode (no simplification) keeps it.
            // Not "did a collapse run": a flat-face harvest leaves the mesh as fine as it was, and
            // reading it as simplified switched the despeckle off for every bake that harvested.
            const bool simplified = result.simplified;
            despeckle_triangle_colors(out, palette, simplified ? 0 : color->despeckle_passes);
            merge_small_color_regions(out, palette, color->min_color_region_mm2);
            for (size_t i = 0; i < out.indices.size(); ++i) {
                if (palette[i] < 0)
                    continue;
                const stl_triangle_vertex_indices &t = out.indices[i];
                const Vec3f &a = out.vertices[size_t(t[0])], &b = out.vertices[size_t(t[1])], &c = out.vertices[size_t(t[2])];
                const Vec3f  centroid = (a + b + c) / 3.f;
                Vec3f        normal   = (b - a).cross(c - a);
                const float  nl       = normal.norm();
                normal                = (nl > 0.f) ? Vec3f(normal / nl) : Vec3f::UnitZ();
                const int filament = palette[i];
                if (filament >= 0)
                    out_color[i] = uint8_t(std::min(filament + 1, 255));
            }
        }
        *color->out_triangle = std::move(out_color);
    }
    return out;
}

References Slic3r::TextureBake::DisplaceSettings::amplitude, Slic3r::TextureBake::Bake, Slic3r::TextureBake::DisplaceSettings::blend_normal_smoothing, Slic3r::TextureBake::DisplaceSettings::bottom_angle_limit, Slic3r::bounds(), Slic3r::V2Resolution::budget_k, Slic3r::TextureBake::PipelineResult::budget_limited, Slic3r::TextureBakeStats::budget_limited, Slic3r::AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(), build_texture_displacement_v2(), Slic3r::TextureBake::PipelineResult::canceled, Slic3r::TextureBake::PipelineSettings::clamp_below_plate, compact_patch_with_map(), Slic3r::cross(), Slic3r::TriangleSelector::deserialize(), Slic3r::TextureColorRequest::despeckle_passes, despeckle_triangle_colors(), Slic3r::TextureBake::PipelineSettings::displace, Slic3r::V2Resolution::edge_mm, Slic3r::TextureBake::TriSoup::empty(), Slic3r::ENFORCER, Slic3r::TextureBake::Export, Slic3r::f(), Slic3r::TextureBake::PipelineResult::face_color, Slic3r::TextureBake::PipelineSettings::flip_edges, Slic3r::TextureBake::PipelineResult::geometry, Slic3r::TriangleSelector::get_facets_strict(), Slic3r::TextureBake::PipelineSettings::harvest_tol, Slic3r::AABBTreeIndirect::is_any_triangle_in_radius(), Slic3r::make_combined_color_sampler(), Slic3r::make_combined_displacement_sampler(), Slic3r::BakeStageRecorder::mark(), Slic3r::TextureBake::PipelineSettings::max_triangles, Slic3r::merge_small_color_regions(), Slic3r::TextureColorRequest::min_color_region_mm2, Slic3r::normal(), Slic3r::offset(), Slic3r::TextureColorRequest::out_triangle, Slic3r::TextureBake::PipelineSettings::paint_within, Slic3r::TextureBake::PipelineSettings::painted, Slic3r::TextureBake::PipelineSettings::preserve_untextured, Slic3r::TextureColorRequest::quantize, Slic3r::TextureColorRequest::quantize_pure, Slic3r::BakeStageRecorder::rebase(), Slic3r::recommend_v2_resolution(), Slic3r::TextureBake::PipelineSettings::refine_length, Slic3r::TextureBake::PipelineSettings::regularize, Slic3r::TextureBake::PipelineSettings::relocate, Slic3r::TextureBake::run_pipeline(), Slic3r::TextureBake::PipelineResult::simplified, Slic3r::AABBTreeIndirect::squared_distance_to_indexed_triangle_set(), Slic3r::TextureBake::DisplaceSettings::symmetric, Slic3r::TextureBake::to_indexed_triangle_set(), Slic3r::TextureBake::to_soup(), Slic3r::TextureBake::DisplaceSettings::top_angle_limit, Slic3r::TextureBake::PipelineResult::triangles_budget, Slic3r::TextureBakeStats::triangles_budget, Slic3r::TextureBake::PipelineResult::triangles_refined, Slic3r::TextureBakeStats::triangles_refined, Slic3r::TextureDisplacementOptions::v2_flip_edges, Slic3r::TextureDisplacementOptions::v2_max_triangles_k, Slic3r::TextureDisplacementOptions::v2_refine_mm, Slic3r::TextureDisplacementOptions::v2_regularize, and Slic3r::TextureDisplacementOptions::v2_relocate.

Referenced by build_texture_displacement_v2().

Here is the call graph for this function:

Here is the caller graph for this function:

chart_is_flattenable()

bool Slic3r::anonymous_namespace{TextureDisplacement.cpp}::chart_is_flattenable	(	const indexed_triangle_set &	mesh,
		const std::vector< Vec3f > &	normals,
		const std::vector< int > &	faces )

{
    constexpr float MIN_NORMAL_COS = -0.17f; // cos(100 deg)
 
    std::unordered_map<uint64_t, int> edge_use;
    std::unordered_map<int, int>      local_vertex;
    edge_use.reserve(faces.size() * 2);
    local_vertex.reserve(faces.size());
    Vec3f normal_sum = Vec3f::Zero();
    for (const int f : faces) {
        const stl_triangle_vertex_indices &tri = mesh.indices[size_t(f)];
        for (int i = 0; i < 3; ++i) {
            ++edge_use[undirected_edge_key(tri[i], tri[(i + 1) % 3])];
            local_vertex.emplace(tri[i], int(local_vertex.size()));
        }
        normal_sum += normals[size_t(f)];
    }
    if (int(local_vertex.size()) - int(edge_use.size()) + int(faces.size()) != 1)
        return false;
 
    UnionFind loops(local_vertex.size());
    int       boundary_seed = -1;
    for (const auto &[key, uses] : edge_use) {
        if (uses > 2)
            return false; // non-manifold
        if (uses == 1) {
            const int a = local_vertex[int(key >> 32)], b = local_vertex[int(uint32_t(key))];
            loops.unite(a, b);
            boundary_seed = a;
        }
    }
    if (boundary_seed < 0)
        return false; // closed
    const int loop = loops.find(boundary_seed);
    for (const auto &[key, uses] : edge_use)
        if (uses == 1 && loops.find(local_vertex[int(key >> 32)]) != loop)
            return false; // a second boundary loop: a ring, or a disk with a hole
 
    const float len = normal_sum.norm();
    if (len < 1e-6f)
        return false;
    const Vec3f mean = normal_sum / len;
    for (const int f : faces) {
        const stl_triangle_vertex_indices &tri = mesh.indices[size_t(f)];
        const bool degenerate = (mesh.vertices[tri[1]] - mesh.vertices[tri[0]]).cross(mesh.vertices[tri[2]] - mesh.vertices[tri[0]])
                                    .squaredNorm() < 1e-20f;
        if (!degenerate && normals[size_t(f)].dot(mean) < MIN_NORMAL_COS)
            return false;
    }
    return true;
}

References chart_is_flattenable(), Slic3r::cross(), Slic3r::dot(), Slic3r::f(), Slic3r::anonymous_namespace{TextureDisplacement.cpp}::UnionFind::find(), undirected_edge_key(), and Slic3r::anonymous_namespace{TextureDisplacement.cpp}::UnionFind::unite().

Referenced by chart_is_flattenable(), and segment_into_charts().

Here is the call graph for this function:

Here is the caller graph for this function:

compact_patch_with_map()

indexed_triangle_set Slic3r::anonymous_namespace{TextureDisplacement.cpp}::compact_patch_with_map	(	const indexed_triangle_set &	patch,
		std::vector< int > &	original_to_compact )

{
    original_to_compact.assign(patch.vertices.size(), -1);
    indexed_triangle_set compact;
    compact.vertices.reserve(patch.vertices.size());
    compact.indices.reserve(patch.indices.size());
    for (const stl_triangle_vertex_indices &tri : patch.indices) {
        stl_triangle_vertex_indices new_tri;
        for (int i = 0; i < 3; ++i) {
            const int vi = tri[i];
            if (original_to_compact[vi] < 0) {
                original_to_compact[vi] = int(compact.vertices.size());
                compact.vertices.push_back(patch.vertices[vi]);
            }
            new_tri[i] = original_to_compact[vi];
        }
        compact.indices.push_back(new_tri);
    }
    return compact;
}

References compact_patch_with_map().

Referenced by build_texture_displacement_v2(), and compact_patch_with_map().

Here is the call graph for this function:

Here is the caller graph for this function:

despeckle_triangle_colors()

void Slic3r::anonymous_namespace{TextureDisplacement.cpp}::despeckle_triangle_colors	(	const indexed_triangle_set &	mesh,
		std::vector< int > &	color,
		int	passes )

{
    if (passes <= 0 || color.size() != mesh.indices.size())
        return;
    const std::vector<Vec3i32> neighbors = its_face_neighbors(mesh);
    if (neighbors.size() != mesh.indices.size())
        return;
 
    std::vector<int> prev;
    for (int pass = 0; pass < passes; ++pass) {
        prev = color;
        tbb::parallel_for(tbb::blocked_range<size_t>(0, color.size()),
                          [&](const tbb::blocked_range<size_t> &range) {
            for (size_t i = range.begin(); i < range.end(); ++i) {
                if (prev[i] < 0)
                    continue;
                // At most four candidates (self plus three neighbours), so counting by a linear scan
                // is cheaper than any map.
                int  cand[4]  = { prev[i], -1, -1, -1 };
                int  count[4] = { 1, 0, 0, 0 };
                int  n        = 1;
                for (int e = 0; e < 3; ++e) {
                    const int nb = neighbors[i][e];
                    if (nb < 0 || size_t(nb) >= prev.size() || prev[size_t(nb)] < 0)
                        continue;
                    const int c = prev[size_t(nb)];
                    int       k = 0;
                    for (; k < n; ++k)
                        if (cand[k] == c) {
                            ++count[k];
                            break;
                        }
                    if (k == n && n < 4) {
                        cand[n]  = c;
                        count[n] = 1;
                        ++n;
                    }
                }
                // Strictly greater, so a tie leaves the triangle alone.
                int best = 0;
                for (int k = 1; k < n; ++k)
                    if (count[k] > count[best])
                        best = k;
                if (count[best] > count[0])
                    color[i] = cand[best];
            }
        });
    }
}

References despeckle_triangle_colors(), Slic3r::its_face_neighbors(), and Slic3r::range().

Referenced by build_texture_displacement_v2(), and despeckle_triangle_colors().

Here is the call graph for this function:

Here is the caller graph for this function:

ear_clip()

void Slic3r::anonymous_namespace{TextureDisplacement.cpp}::ear_clip	(	const std::vector< Vec2f > &	pts,
		std::vector< int >	poly,
		const std::function< void(int, int, int)> &	emit )

{
    auto cross2 = [](const Vec2f &o, const Vec2f &a, const Vec2f &b) {
        return (a.x() - o.x()) * (b.y() - o.y()) - (a.y() - o.y()) * (b.x() - o.x());
    };
    // A corner flatter than this is collinear: several vertices along one edge of the triangle. Such
    // a corner is never an ear - the zero-area triangle would lie on the edge, where the neighbour,
    // seeing the same points from its side, may emit the same one.
    float flat = 0.f;
    {
        Vec2f lo = pts[size_t(poly[0])], hi = lo;
        for (int id : poly) { lo = lo.cwiseMin(pts[size_t(id)]); hi = hi.cwiseMax(pts[size_t(id)]); }
        flat = 1e-5f * (hi - lo).squaredNorm();
    }
    while (poly.size() > 3) {
        const size_t n     = poly.size();
        bool         found = false;
        for (size_t i = 0; i < n && !found; ++i) {
            const int    ia = poly[(i + n - 1) % n], ib = poly[i], ic = poly[(i + 1) % n];
            const Vec2f &a = pts[size_t(ia)], &b = pts[size_t(ib)], &c = pts[size_t(ic)];
            const float  area2 = cross2(a, b, c);
            if (area2 <= flat)
                continue; // reflex or flat corner
            const float eps   = 1e-6f * area2;
            bool        clean = true;
            size_t      on_base = 0;
            for (size_t j = 0; j < n && clean; ++j) {
                const int ij = poly[j];
                if (ij == ia || ij == ib || ij == ic)
                    continue;
                const Vec2f &p = pts[size_t(ij)];
                clean = !(cross2(a, b, p) > eps && cross2(b, c, p) > eps && cross2(c, a, p) > eps);
                // On the ear's base, between its ends: a run of vertices along the base, as when
                // several sit on one edge of the triangle.
                if (std::abs(cross2(c, a, p)) <= flat && (p - c).dot(a - c) > 0.f && (p - a).dot(c - a) > 0.f)
                    ++on_base;
            }
            if (!clean)
                continue;
            if (on_base > 0) {
                // The base carries other vertices. When those are all that is left of the polygon,
                // in order from c round to a, fan them from b and finish; otherwise the ear is not
                // clear of the rest of the polygon.
                if (on_base + 3 != n)
                    continue;
                for (size_t j = 0; j + 1 < n - 1; ++j) {
                    const int u = poly[(i + 1 + j) % n], v = poly[(i + 2 + j) % n];
                    emit(ib, u, v);
                }
                poly.clear();
                return;
            }
            emit(ia, ib, ic);
            poly.erase(poly.begin() + long(i));
            found = true;
        }
        if (!found) {
            // Clip the smallest convex corner anyway, or failing that the flattest: a thin triangle
            // keeps every edge accounted for, and a convex one at least stays on the polygon's side.
            size_t pick = 0;
            float  best = std::numeric_limits<float>::max();
            bool   convex_found = false;
            for (size_t i = 0; i < n; ++i) {
                const Vec2f &a = pts[size_t(poly[(i + n - 1) % n])], &b = pts[size_t(poly[i])], &c = pts[size_t(poly[(i + 1) % n])];
                const float  m = cross2(a, b, c);
                if (m > flat && (!convex_found || m < best)) { best = m; pick = i; convex_found = true; }
                else if (!convex_found && std::abs(m) < best) { best = std::abs(m); pick = i; }
            }
            emit(poly[(pick + n - 1) % n], poly[pick], poly[(pick + 1) % n]);
            poly.erase(poly.begin() + long(pick));
        }
    }
    if (poly.size() == 3)
        emit(poly[0], poly[1], poly[2]);
}

References Slic3r::cross2(), Slic3r::dot(), and ear_clip().

Referenced by ear_clip().

Here is the call graph for this function:

Here is the caller graph for this function:

face_normal()

Vec3f Slic3r::anonymous_namespace{TextureDisplacement.cpp}::face_normal	(	const indexed_triangle_set &	mesh,
		const stl_triangle_vertex_indices &	tri )

{
    const Vec3f n   = (mesh.vertices[tri[1]] - mesh.vertices[tri[0]]).cross(mesh.vertices[tri[2]] - mesh.vertices[tri[0]]);
    const float len = n.norm();
    return (len > 1e-12f) ? Vec3f(n / len) : Vec3f::UnitZ();
}

References Slic3r::cross(), and face_normal().

Referenced by face_normal().

Here is the call graph for this function:

Here is the caller graph for this function:

patch_boundary_distance()

std::vector< float > Slic3r::anonymous_namespace{TextureDisplacement.cpp}::patch_boundary_distance	(	const indexed_triangle_set &	patch,
		const std::vector< bool > &	is_boundary )

{
    const size_t n = patch.vertices.size();
    std::vector<std::vector<std::pair<int, float>>> adj(n);
    for (const stl_triangle_vertex_indices &tri : patch.indices)
        for (int i = 0; i < 3; ++i) {
            const int a = tri[i], b = tri[(i + 1) % 3];
            if (a < 0 || b < 0 || size_t(a) >= n || size_t(b) >= n)
                continue;
            const float w = (patch.vertices[size_t(a)] - patch.vertices[size_t(b)]).norm();
            adj[size_t(a)].push_back({ b, w });
            adj[size_t(b)].push_back({ a, w });
        }
 
    std::vector<float> dist(n, std::numeric_limits<float>::infinity());
    using QN = std::pair<float, int>;
    std::priority_queue<QN, std::vector<QN>, std::greater<QN>> pq;
    for (size_t v = 0; v < n; ++v)
        if (v < is_boundary.size() && is_boundary[v]) {
            dist[v] = 0.f;
            pq.push({ 0.f, int(v) });
        }
    while (!pq.empty()) {
        const auto [d, u] = pq.top();
        pq.pop();
        if (d > dist[size_t(u)])
            continue;
        for (const auto &[w, ew] : adj[size_t(u)]) {
            const float nd = d + ew;
            if (nd < dist[size_t(w)]) {
                dist[size_t(w)] = nd;
                pq.push({ nd, w });
            }
        }
    }
    return dist;
}

References Slic3r::Geometry::dist(), and patch_boundary_distance().

Referenced by patch_boundary_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_sampleable_layers()

std::shared_ptr< std::vector< PreparedLayer > > Slic3r::anonymous_namespace{TextureDisplacement.cpp}::prepare_sampleable_layers	(	const indexed_triangle_set &	base_mesh,
		const std::vector< TextureDisplacementLayer > &	layers,
		const TextureDisplacementFacetsData &	facets_data,
		bool	need_color,
		const std::vector< Vec2f > *	model_uv )

{
    auto prepared = std::make_shared<std::vector<PreparedLayer>>();
 
    if (base_mesh.indices.empty())
        return prepared;
 
    std::vector<const TextureDisplacementLayer *> ordered;
    for (const TextureDisplacementLayer &l : layers)
        if (l.slot >= 0 && l.slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS))
            ordered.push_back(&l);
    std::sort(ordered.begin(), ordered.end(),
              [](const TextureDisplacementLayer *a, const TextureDisplacementLayer *b) { return a->slot < b->slot; });
 
    const std::vector<Vec3f> vertex_normals = texture_displacement_vertex_normals(base_mesh);
    const TriangleMesh       selector_mesh(base_mesh);
    const float              mesh_area = area_3d(base_mesh);
 
    for (const TextureDisplacementLayer *layer : ordered) {
        // Unwrap layers used to be skipped here ("no per-point UV"). That made the default pipeline
        // bake an unwrap layer as nothing at all - and since the job then clears the baked layers'
        // paint, the painted region simply vanished. They get an LscmLookup below instead.
        if (need_color && !layer->color_enabled)
            continue;
        const TriangleSelector::TriangleSplittingData &data = facets_data[size_t(layer->slot)];
        if (data.triangles_to_split.empty())
            continue;
        const DecodedHeightTexture tex = decode_height_texture(*layer);
        if (tex.empty() || (need_color && !tex.has_color()))
            continue;
 
        const bool model_uv_layer = layer->projection_method == TextureProjectionMethod::ModelUV &&
                                    model_uv != nullptr && model_uv->size() == base_mesh.indices.size() * 3;
 
        TriangleSelector selector(selector_mesh);
        selector.deserialize(data, false);
        std::vector<int>           patch_source; // only the model's own channel needs it; see the classic path
        const indexed_triangle_set patch =
            selector.get_facets_strict(EnforcerBlockerType::ENFORCER, model_uv_layer ? &patch_source : nullptr);
        if (patch.indices.empty())
            continue;
 
        // Patch centroid + cylinder axis, shared with build_texture_displacement() so a
        // Cylindrical/Spherical layer's detach criterion matches the geometry the bake will produce.
        Vec3f centroid, axis, average_normal;
        texture_displacement_patch_frame(patch, vertex_normals, centroid, axis, average_normal);
 
        std::shared_ptr<const LscmLookup> lscm;
        if (model_uv_layer || layer->projection_method == TextureProjectionMethod::LSCM) {
            // Solved on the very patch the classic path and the GUI solve it on (same geometry, seam
            // angle and edges), so it hits the unwrap cache and lands exactly where the UV editor
            // shows it, hand-placed islands and UV edits included. A ModelUV layer needs no solve at
            // all - its corners are read straight out of the volume's channel - but it is looked up
            // through the same per-triangle machinery, for the same reason: there is no formula from a
            // point to its uv.
            auto l    = std::make_shared<LscmLookup>();
            l->corner = model_uv_layer ? compute_model_corner_uvs(base_mesh, *model_uv, patch, patch_source) :
                                          compute_lscm_corner_uvs(patch, *layer);
            if (l->corner.size() == patch.indices.size() * 3) {
                l->patch = patch;
                l->tree  = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(l->patch.vertices, l->patch.indices);
                lscm     = std::move(l);
            }
        }
 
        std::shared_ptr<const PatchRegion> region;
        if (!lscm && area_3d(patch) < 0.9999f * mesh_area) {
            auto r   = std::make_shared<PatchRegion>();
            r->patch = patch;
            r->tree  = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(r->patch.vertices, r->patch.indices);
            region   = std::move(r);
        }
 
        prepared->push_back({ tex, *layer, centroid, axis, std::move(lscm), std::move(region) });
    }
    return prepared;
}

References area_3d(), Slic3r::AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(), Slic3r::compute_lscm_corner_uvs(), Slic3r::compute_model_corner_uvs(), Slic3r::decode_height_texture(), Slic3r::TriangleSelector::deserialize(), Slic3r::DecodedHeightTexture::empty(), Slic3r::ENFORCER, Slic3r::TriangleSelector::get_facets_strict(), Slic3r::DecodedHeightTexture::has_color(), Slic3r::LSCM, Slic3r::ModelUV, prepare_sampleable_layers(), Slic3r::TEXTURE_DISPLACEMENT_MAX_LAYERS, Slic3r::texture_displacement_patch_frame(), Slic3r::texture_displacement_vertex_normals(), and Slic3r::TriangleSelector::TriangleSplittingData::triangles_to_split.

Referenced by prepare_sampleable_layers().

Here is the call graph for this function:

Here is the caller graph for this function:

project_cylindrical()

Vec2f Slic3r::anonymous_namespace{TextureDisplacement.cpp}::project_cylindrical	(	const Vec3f &	position,
		const Vec3f &	patch_center,
		const Vec3f &	patch_axis )

{
    Vec3f up = patch_axis;
    up       = (up.norm() > 1e-8f) ? Vec3f(up.normalized()) : Vec3f::UnitZ();
    const Vec3f arbitrary = (std::abs(up.dot(Vec3f::UnitZ())) < 0.9f) ? Vec3f::UnitZ() : Vec3f::UnitX();
    const Vec3f right     = Vec3f(up.cross(arbitrary).normalized());
    // up x right, not right x up: that makes (right, fwd, up) right-handed, so the angle below grows
    // anticlockwise about the axis - which, seen from outside the cylinder, is to the viewer's right.
    // The other way round the texture wraps on mirrored, as if seen through the model from behind.
    const Vec3f fwd       = Vec3f(up.cross(right).normalized());
 
    const Vec3f rel        = position - patch_center;
    const float along_axis = rel.dot(up);
    const float x          = rel.dot(right);
    const float y          = rel.dot(fwd);
    const float radius     = std::sqrt(x * x + y * y);
    const float angle      = std::atan2(y, x);
 
    // Negated, like every other projection's v: v = 0 is the texture's top row, so v has to grow
    // *down* the axis for the top of the image to sit at the top of the model.
    return Vec2f(angle * radius, -along_axis);
}

References Slic3r::angle(), and project_cylindrical().

Referenced by project_cylindrical().

Here is the call graph for this function:

Here is the caller graph for this function:

project_spherical()

Vec2f Slic3r::anonymous_namespace{TextureDisplacement.cpp}::project_spherical	(	const Vec3f &	position,
		const Vec3f &	patch_center )

{
    const Vec3f rel    = position - patch_center;
    const float radius = rel.norm();
    if (radius < 1e-8f)
        return Vec2f::Zero();
 
    const Vec3f dir       = rel / radius;
    const float longitude = std::atan2(dir.y(), dir.x());
    const float latitude  = std::asin(std::clamp(dir.z(), -1.f, 1.f));
    // Longitude already grows to the right as seen from outside; latitude grows toward the north
    // pole, so it is negated to put the image's top row (v = 0) at the top of the model.
    return Vec2f(longitude, -latitude) * radius;
}

References project_spherical().

Referenced by project_spherical().

Here is the call graph for this function:

Here is the caller graph for this function:

project_to_tangent_plane()

std::vector< Vec2f > Slic3r::anonymous_namespace{TextureDisplacement.cpp}::project_to_tangent_plane	(	const indexed_triangle_set &	chart,
		const Vec3f &	normal )

{
    // Oriented like the box projection (see box_projection_axes()), so a chart reads the right way up
    // and unmirrored instead of being flattened to whichever basis a cross product happened to give.
    // For a chart whose normal *is* a world axis - a cube face, which is the common case once the
    // seam angle has cut the patch along its sharp edges - this is exactly the box basis, so such a
    // face unwraps to the same orientation Triplanar would have given it.
    Vec3f u, v;
    box_projection_axes(normal, u, v);
    // The box axes lie in the tangent plane already when the normal is a world axis; for any other
    // normal, u is squared up against it and v follows. u x v == -normal keeps the chart the way
    // round a viewer outside the model sees it (a plain normal x u would mirror it).
    u = u - normal * normal.dot(u);
    if (u.norm() <= 1e-6f) {
        // Out of reach for a unit normal - the box basis puts u perpendicular to the normal's own
        // dominant axis, so the two can never be within 45 degrees of each other - but a caller
        // handing over an unnormalized normal should still get a usable basis rather than a NaN.
        const Vec3f seed = (std::abs(normal.z()) < 0.9f) ? Vec3f::UnitZ() : Vec3f::UnitX();
        u = seed.cross(normal);
    }
    u = Vec3f(u.normalized());
    v = Vec3f(u.cross(normal).normalized());
 
    std::vector<Vec2f> uvs(chart.vertices.size());
    for (size_t i = 0; i < chart.vertices.size(); ++i)
        uvs[i] = Vec2f(chart.vertices[i].dot(u), chart.vertices[i].dot(v));
    return uvs;
}

References Slic3r::box_projection_axes(), Slic3r::normal(), and project_to_tangent_plane().

Referenced by project_to_tangent_plane().

Here is the call graph for this function:

Here is the caller graph for this function:

read()

template<class T>

void Slic3r::anonymous_namespace{TextureDisplacement.cpp}::read	(	const nlohmann::json &	j,
		const char *	k,
		T &	out )

{
    const auto it = j.find(k);
    if (it == j.end())
        return;
    try {
        out = it->get<T>();
    } catch (...) {
    }
}

References read().

Referenced by read().

Here is the call graph for this function:

Here is the caller graph for this function:

read_enum()

void Slic3r::anonymous_namespace{TextureDisplacement.cpp}::read_enum	(	const nlohmann::json &	j,
		const char *	k,
		int &	out )

{
    const auto it = j.find(k);
    if (it != j.end() && it->is_number_integer())
        out = it->get<int>();
}

References read_enum().

Referenced by read_enum().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_steps()

StepScan Slic3r::anonymous_namespace{TextureDisplacement.cpp}::scan_steps	(	const indexed_triangle_set &	mesh,
		const std::vector< uint8_t > &	region,
		const HeightFieldSampler &	sampler,
		float	step_width_mm,
		float	seam_gap_mm,
		float	min_feature_mm,
		bool	nudge )

{
    StepScan     scan;
    const size_t nv = mesh.vertices.size(), nt = mesh.indices.size();
    if (!sampler || region.size() != nt || step_width_mm <= 0.f)
        return scan;
 
    // 1. Heights at the vertices of the cuttable triangles, along the same normals the bake will use.
    // Vertex positions are worked on in `pos`: a vertex that happens to sit within a texel of a step
    // is nudged off it below, and everything from the edge march to the output uses the nudged place.
    std::vector<Vec3f>       &pos    = scan.pos;
    std::vector<Vec3f>       &vnormal = scan.vnormal;
    pos     = mesh.vertices;
    vnormal = texture_displacement_vertex_normals(mesh);
    std::vector<uint8_t>     wanted(nv, 0);
    for (size_t t = 0; t < nt; ++t)
        if (region[t] != 0)
            for (int k = 0; k < 3; ++k)
                wanted[size_t(mesh.indices[t][k])] = 1;
    std::vector<float> &vh = scan.vh;
    vh.assign(nv, 0.f);
    tbb::parallel_for(tbb::blocked_range<size_t>(0, nv), [&](const tbb::blocked_range<size_t> &r) {
        for (size_t v = r.begin(); v < r.end(); ++v)
            if (wanted[v])
                vh[v] = sampler(pos[v], vnormal[v]);
    });
    float hmin = std::numeric_limits<float>::max(), hmax = -hmin;
    for (size_t v = 0; v < nv; ++v)
        if (wanted[v]) { hmin = std::min(hmin, vh[v]); hmax = std::max(hmax, vh[v]); }
    const float range = scan.range = hmax - hmin;
    if (!(range > 1e-6f))
        return scan;
    const float iso = scan.iso = 0.5f * (hmin + hmax);
    // Only a texture that is mostly steps is cut: one whose heights sit at two levels with little in
    // between (a grid, a knurl, a logo). On a smooth or noisy relief the mid-level contour runs through
    // every triangle without being a step anywhere, and cutting along it would only multiply the
    // triangles; the chord-based refinement is the right tool there. Judged from the vertex heights,
    // which sample the whole painted surface.
    {
        size_t near_level = 0, total = 0;
        for (size_t v = 0; v < nv; ++v)
            if (wanted[v]) { ++total; near_level += std::abs(vh[v] - iso) > 0.35f * range; }
        if (total == 0 || double(near_level) < 0.6 * double(total))
            return scan;
    }
 
    // 1b. A vertex inside the blend of a sharp step - the texture's bilinear ramp is a texel wide - would
    // be displaced to a height between the two sides, and every triangle at it would ramp. Such a vertex
    // is nudged along the surface away from the step, down its own side's slope, until it samples a
    // pure value; a step's width or so. Only where the surface is flat around it: a vertex on a crease
    // of the model (a box edge) stays where it is. Skipped by a probe, which only wants the verdict.
    if (nudge) {
        std::vector<uint8_t> creased(nv, 0);
        std::vector<Vec3f>   first_normal(nv, Vec3f::Zero());
        std::vector<float>   shortest(nv, std::numeric_limits<float>::max()); // shortest edge at the vertex
        for (size_t t = 0; t < nt; ++t) {
            const auto  &tri = mesh.indices[t];
            const Vec3f &a = pos[size_t(tri[0])];
            Vec3f        fn = (pos[size_t(tri[1])] - a).cross(pos[size_t(tri[2])] - a);
            const float  fl = fn.norm();
            if (fl < 1e-12f) continue;
            fn /= fl;
            for (int k = 0; k < 3; ++k) {
                Vec3f &f0 = first_normal[size_t(tri[k])];
                if (f0.isZero()) f0 = fn;
                else if (f0.dot(fn) < 0.985f) creased[size_t(tri[k])] = 1; // ~10 degrees
                const float el = (pos[size_t(tri[(k + 1) % 3])] - pos[size_t(tri[k])]).norm();
                shortest[size_t(tri[k])]           = std::min(shortest[size_t(tri[k])], el);
                shortest[size_t(tri[(k + 1) % 3])] = std::min(shortest[size_t(tri[(k + 1) % 3])], el);
            }
        }
        tbb::parallel_for(tbb::blocked_range<size_t>(0, nv), [&](const tbb::blocked_range<size_t> &r) {
            for (size_t v = r.begin(); v < r.end(); ++v) {
                if (!wanted[v] || creased[v] || std::abs(vh[v] - iso) > 0.47f * range)
                    continue;
                const Vec3f &n  = vnormal[v];
                const Vec3f  ax = (std::abs(n.x()) < 0.9f) ? Vec3f::UnitX() : Vec3f::UnitY();
                const Vec3f  t1 = n.cross(ax).normalized(), t2 = n.cross(t1).normalized();
                const float  d  = step_width_mm;
                const float  gx = sampler(pos[v] + t1 * d, n) - sampler(pos[v] - t1 * d, n);
                const float  gy = sampler(pos[v] + t2 * d, n) - sampler(pos[v] - t2 * d, n);
                Vec3f        g  = t1 * gx + t2 * gy;
                const float  gl = g.norm();
                if (gl < 0.25f * range)
                    continue; // not at a step: a slope, which the chord test handles
                g /= gl;
                // Down the slope for a low vertex, up it for a high one, in steps of half a texel, and
                // never by more than a fraction of the shortest edge at the vertex: on a finely refined
                // mesh a texel-sized move would fold the triangles around it.
                const Vec3f dir   = (vh[v] > iso) ? g : Vec3f(-g);
                Vec3f       best  = pos[v];
                float       bh    = vh[v];
                const float limit = std::min(2.f * step_width_mm, 0.3f * shortest[v]);
                for (int i = 1; i <= 8; ++i) {
                    const float dist = 0.25f * step_width_mm * float(i);
                    if (dist > limit)
                        break;
                    const Vec3f q = pos[v] + dir * dist;
                    const float h = sampler(q, n);
                    if ((h > iso) != (vh[v] > iso))
                        break; // crossed the step: the nudge would change the vertex's side
                    best = q; bh = h;
                    if (std::abs(h - iso) > 0.48f * range)
                        break;
                }
                if (std::abs(bh - iso) > std::abs(vh[v] - iso)) { pos[v] = best; vh[v] = bh; }
            }
        });
    }
 
    const auto sample_between = [&scan](int a, int b, float t) { return scan.sample_between(a, b, t); };
    const auto side_of        = [&scan](float h) { return scan.side_of(h); };
 
    // 2. Crossings on the edges, found on the field itself - on a 1 mm edge over a texture with 30 um
    // texels, interpolating the endpoint heights could put a step anywhere along the edge. Both
    // triangles on an edge see the same crossings, which is what keeps the cut conformal.
    auto &edges = scan.edges;
    edges.reserve(nt);
 
    const auto find_crossings = [&](int a, int b, Edge &edge) {
        if (a > b) std::swap(a, b);
        const float len   = (pos[size_t(b)] - pos[size_t(a)]).norm();
        const int   steps = std::clamp(int(std::ceil(len / (0.5f * step_width_mm))), 4, 128);
        float       t0 = 0.f, h0 = vh[size_t(a)] - iso;
        for (int i = 1; i <= steps; ++i) {
            const float ti = float(i) / float(steps);
            const auto [pp, nn] = sample_between(a, b, ti);
            const float hi_ = sampler(pp, nn) - iso;
            if (h0 * hi_ < 0.f || (hi_ == 0.f && h0 != 0.f)) {
                float lo_t = t0, hi_t = ti, lo_h = h0;
                for (int k = 0; k < 10; ++k) {
                    const float tm = 0.5f * (lo_t + hi_t);
                    const auto [pm, nm] = sample_between(a, b, tm);
                    if (lo_h * (sampler(pm, nm) - iso) <= 0.f) hi_t = tm; else { lo_t = tm; }
                }
                Crossing c;
                c.a = a; c.b = b;
                // Never exactly on a vertex: that would make a zero-area triangle of the split.
                c.t = std::clamp(0.5f * (lo_t + hi_t), 1e-3f, 1.f - 1e-3f);
                std::tie(c.p, c.n) = sample_between(a, b, c.t);
                // Sharp means the field changes by at least half its range across `step_width_mm` in
                // the steepest tangent direction - a step, not a slope that merely passes mid-level.
                const Vec3f ax  = (std::abs(c.n.x()) < 0.9f) ? Vec3f::UnitX() : Vec3f::UnitY();
                const Vec3f t1v = c.n.cross(ax).normalized(), t2v = c.n.cross(t1v).normalized();
                const float d   = 0.5f * step_width_mm;
                const float gx  = sampler(c.p + t1v * d, c.n) - sampler(c.p - t1v * d, c.n);
                const float gy  = sampler(c.p + t2v * d, c.n) - sampler(c.p - t2v * d, c.n);
                const float gl  = std::sqrt(gx * gx + gy * gy);
                c.sharp = gl >= 0.5f * range;
                // How wide the feature is on either side of the step, along the gradient: the
                // distance until the field returns to mid-level, in steps of half the step width, up
                // to `thick_max`. A texture whose features are only a few texels wide has no pure
                // interior for a seam copy to land in and is left to refinement (see the gate below).
                {
                    const float thick_max = 4.f * step_width_mm;
                    c.thick = thick_max;
                    if (gl > 1e-12f) {
                        const Vec3f g = (t1v * gx + t2v * gy) / gl;
                        for (int sgn = -1; sgn <= 1; sgn += 2) {
                            const bool high = sgn > 0; // uphill along the gradient
                            for (int i = 1; i <= 8; ++i) {
                                const float dist = 0.5f * step_width_mm * float(i);
                                if (dist >= c.thick)
                                    break;
                                if (side_of(sampler(c.p + g * (float(sgn) * dist), c.n)) != high) {
                                    c.thick = std::min(c.thick, dist);
                                    break;
                                }
                            }
                        }
                    }
                }
                edge.xs.push_back(c);
            }
            t0 = ti; h0 = hi_;
        }
        // A pair of crossings closer than the smallest feature the mesh is meant to carry is a feature
        // too thin to print, and one closer than the seam gap has no room for two seams: dropping both
        // leaves the surface flat there, at the side around it.
        const float thinnest = std::max(min_feature_mm, seam_gap_mm);
        for (size_t i = 0; i + 1 < edge.xs.size();) {
            if ((edge.xs[i + 1].t - edge.xs[i].t) * len < thinnest)
                edge.xs.erase(edge.xs.begin() + long(i), edge.xs.begin() + long(i) + 2);
            else
                ++i;
        }
        // Parity: the endpoints' sides say whether the count must be odd or even; the march starts and
        // ends on the vertex heights themselves, so a mismatch is a numerical accident. Drop the lot
        // then - a triangle split on a wrong count is worse than a ramp there.
        const bool odd_expected = side_of(vh[size_t(a)]) != side_of(vh[size_t(b)]);
        if ((edge.xs.size() % 2 == 1) != odd_expected)
            edge.xs.clear();
    };
 
    // Edges to examine, in a fixed order so the crossings can be found in parallel.
    std::vector<uint64_t> edge_keys;
    for (size_t t = 0; t < nt; ++t) {
        if (region[t] == 0)
            continue;
        const auto &tri = mesh.indices[t];
        for (int e = 0; e < 3; ++e)
            edge_keys.push_back(step_edge_key(tri[e], tri[(e + 1) % 3]));
    }
    std::sort(edge_keys.begin(), edge_keys.end());
    edge_keys.erase(std::unique(edge_keys.begin(), edge_keys.end()), edge_keys.end());
    std::vector<Edge> found(edge_keys.size());
    tbb::parallel_for(tbb::blocked_range<size_t>(0, edge_keys.size()), [&](const tbb::blocked_range<size_t> &r) {
        for (size_t i = r.begin(); i < r.end(); ++i)
            find_crossings(int(edge_keys[i] >> 32), int(uint32_t(edge_keys[i])), found[i]);
    });
    size_t crossings = 0, sharp = 0;
    double thick_sum = 0.;
    for (size_t i = 0; i < edge_keys.size(); ++i) {
        for (const Crossing &c : found[i].xs) { ++crossings; sharp += c.sharp; thick_sum += c.thick; }
        edges.emplace(edge_keys[i], std::move(found[i]));
    }
    // The mid-level contour has to be a step nearly everywhere it is crossed, or this is not a step
    // texture: a noisy relief that happens to sit at two levels is crossed all over, mostly gently.
    if (crossings == 0 || double(sharp) < 0.8 * double(crossings))
        return scan;
    // And the features have to be wider than the step itself. A texture whose blobs are only a few
    // texels across (noise, a fine grain) is bimodal and sharp at every crossing, yet has no pure
    // interior for the seam copies to land in, and its contour runs through every triangle: cutting it
    // doubles the triangle count for walls the same size as the interpolation blur. Judged from the
    // mean feature thickness at the crossings, measured in step widths (2.25 = four to five texels).
    if (thick_sum < 2.25 * double(step_width_mm) * double(crossings))
        return scan;
 
    scan.ok = true;
    return scan;
 
}

References Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Crossing::a, Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Crossing::b, Slic3r::cross(), Slic3r::Geometry::dist(), Slic3r::anonymous_namespace{TextureDisplacement.cpp}::StepScan::edges, Slic3r::anonymous_namespace{TextureDisplacement.cpp}::StepScan::iso, Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Crossing::n, Slic3r::anonymous_namespace{TextureDisplacement.cpp}::StepScan::ok, Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Crossing::p, Slic3r::anonymous_namespace{TextureDisplacement.cpp}::StepScan::pos, Slic3r::anonymous_namespace{TextureDisplacement.cpp}::StepScan::range, Slic3r::range(), Slic3r::anonymous_namespace{TextureDisplacement.cpp}::StepScan::sample_between(), scan_steps(), Slic3r::sgn(), Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Crossing::sharp, Slic3r::anonymous_namespace{TextureDisplacement.cpp}::StepScan::side_of(), step_edge_key(), Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Crossing::t, Slic3r::texture_displacement_vertex_normals(), Slic3r::anonymous_namespace{TextureDisplacement.cpp}::Crossing::thick, Slic3r::anonymous_namespace{TextureDisplacement.cpp}::StepScan::vh, and Slic3r::anonymous_namespace{TextureDisplacement.cpp}::StepScan::vnormal.

Referenced by scan_steps().

Here is the call graph for this function:

Here is the caller graph for this function:

segment_into_charts()

std::vector< int > Slic3r::anonymous_namespace{TextureDisplacement.cpp}::segment_into_charts	(	const indexed_triangle_set &	mesh,
		const std::vector< Vec3f > &	normals,
		float	seam_angle_deg,
		const std::unordered_set< uint64_t > &	seam_keys,
		int &	chart_count )

{
    constexpr int MAX_SPLIT_DEPTH = 8;
    const int     n_faces         = int(mesh.indices.size());
    const float   cos_threshold   = std::cos(std::clamp(seam_angle_deg, 0.f, 180.f) * float(M_PI) / 180.f);
 
    // Each shared edge, with the (up to two) faces on it.
    std::unordered_map<uint64_t, std::pair<int, int>> edge_faces;
    edge_faces.reserve(size_t(n_faces) * 3);
    for (int f = 0; f < n_faces; ++f) {
        const stl_triangle_vertex_indices &tri = mesh.indices[size_t(f)];
        for (int i = 0; i < 3; ++i) {
            const uint64_t key        = undirected_edge_key(tri[i], tri[(i + 1) % 3]);
            const auto [it, inserted] = edge_faces.emplace(key, std::make_pair(f, -1));
            if (!inserted)
                it->second.second = f;
        }
    }
 
    // Faces joined across each edge that does not cut. A face has three edges, so at most three such neighbours.
    std::vector<std::array<int, 3>> adjacent(static_cast<size_t>(n_faces), { -1, -1, -1 });
    const auto link = [&adjacent](int f, int nb) {
        for (int &slot : adjacent[size_t(f)])
            if (slot < 0) {
                slot = nb;
                return;
            }
    };
    for (const auto &[key, fp] : edge_faces) {
        if (fp.second < 0 || fp.first == fp.second)
            continue; // a boundary edge of the patch, nothing on the far side to join
        // A manually/auto marked seam always cuts, whatever the dihedral angle - that is exactly
        // what lets "mark seam" / "cut island" split a chart that is otherwise flat enough to merge.
        if (!seam_keys.empty() && seam_keys.count(key))
            continue;
        if (normals[size_t(fp.first)].dot(normals[size_t(fp.second)]) >= cos_threshold) {
            link(fp.first, fp.second);
            link(fp.second, fp.first);
        }
    }
 
    // Connected pieces of `faces` over `adjacent`, staying within each face's current `group`.
    std::vector<int> group(static_cast<size_t>(n_faces), 0), visited(static_cast<size_t>(n_faces), -1);
    int              visit_pass = 0;
    const auto connected_pieces = [&](const std::vector<int> &faces, std::vector<std::vector<int>> &out) {
        const int        pass = visit_pass++;
        std::vector<int> stack;
        for (const int seed : faces) {
            if (visited[size_t(seed)] == pass)
                continue;
            visited[size_t(seed)] = pass;
            std::vector<int> piece{ seed };
            stack.assign(1, seed);
            while (!stack.empty()) {
                const int f = stack.back();
                stack.pop_back();
                for (const int nb : adjacent[size_t(f)])
                    if (nb >= 0 && visited[size_t(nb)] != pass && group[size_t(nb)] == group[size_t(f)]) {
                        visited[size_t(nb)] = pass;
                        piece.push_back(nb);
                        stack.push_back(nb);
                    }
            }
            out.push_back(std::move(piece));
        }
    };
 
    std::vector<int> all_faces(static_cast<size_t>(n_faces));
    std::iota(all_faces.begin(), all_faces.end(), 0);
    std::vector<std::vector<int>> pieces;
    connected_pieces(all_faces, pieces);
    std::vector<std::pair<std::vector<int>, int>> pending; // a piece, and how many cuts produced it
    for (std::vector<int> &piece : pieces)
        pending.emplace_back(std::move(piece), 0);
 
    std::vector<std::vector<int>> charts;
    int                           next_group = 1;
    while (!pending.empty()) {
        std::vector<int> faces = std::move(pending.back().first);
        const int        depth = pending.back().second;
        pending.pop_back();
        if (faces.size() < 2 || depth >= MAX_SPLIT_DEPTH || chart_is_flattenable(mesh, normals, faces)) {
            charts.push_back(std::move(faces));
            continue;
        }
        const std::vector<char> side = split_chart_sides(mesh, normals, faces);
        std::vector<int>        halves[2];
        for (size_t i = 0; i < faces.size(); ++i)
            halves[side[i] ? 1 : 0].push_back(faces[i]);
        if (halves[0].empty() || halves[1].empty()) {
            charts.push_back(std::move(faces));
            continue;
        }
        for (std::vector<int> &half : halves) {
            for (const int f : half)
                group[size_t(f)] = next_group;
            ++next_group;
            pieces.clear();
            connected_pieces(half, pieces);
            for (std::vector<int> &piece : pieces)
                pending.emplace_back(std::move(piece), depth + 1);
        }
    }
 
    // Chart ids in first-encountered-triangle order, which TextureIsland indexing documents.
    std::vector<std::pair<int, size_t>> first_face(charts.size());
    for (size_t c = 0; c < charts.size(); ++c)
        first_face[c] = { *std::min_element(charts[c].begin(), charts[c].end()), c };
    std::sort(first_face.begin(), first_face.end());
 
    std::vector<int> chart_of(static_cast<size_t>(n_faces), -1);
    for (size_t id = 0; id < first_face.size(); ++id)
        for (const int f : charts[first_face[id].second])
            chart_of[size_t(f)] = int(id);
    chart_count = int(charts.size());
    return chart_of;
}

References chart_is_flattenable(), Slic3r::empty(), Slic3r::f(), M_PI, segment_into_charts(), split_chart_sides(), and undirected_edge_key().

Referenced by segment_into_charts().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_polyline()

void Slic3r::anonymous_namespace{TextureDisplacement.cpp}::simplify_polyline	(	const std::vector< Vec2f > &	in,
		float	tol,
		std::vector< Vec2f > &	out )

{
    out.clear();
    if (in.size() < 3) { out = in; return; }
    std::vector<uint8_t> keep(in.size(), 0);
    keep.front() = keep.back() = 1;
    std::vector<std::pair<size_t, size_t>> stack = { { 0, in.size() - 1 } };
    while (!stack.empty()) {
        const auto [i0, i1] = stack.back();
        stack.pop_back();
        if (i1 <= i0 + 1)
            continue;
        const Vec2f d   = in[i1] - in[i0];
        const float len = d.norm();
        float       best = -1.f;
        size_t      bi   = i0;
        for (size_t i = i0 + 1; i < i1; ++i) {
            const Vec2f r    = in[i] - in[i0];
            const float dist = (len > 1e-12f) ? std::abs(d.x() * r.y() - d.y() * r.x()) / len : r.norm();
            if (dist > best) { best = dist; bi = i; }
        }
        if (best > tol) {
            keep[bi] = 1;
            stack.push_back({ i0, bi });
            stack.push_back({ bi, i1 });
        }
    }
    for (size_t i = 0; i < in.size(); ++i)
        if (keep[i]) out.push_back(in[i]);
}

References Slic3r::Geometry::dist(), and simplify_polyline().

Referenced by simplify_polyline().

Here is the call graph for this function:

Here is the caller graph for this function:

smooth_height_pixels()

void Slic3r::anonymous_namespace{TextureDisplacement.cpp}::smooth_height_pixels	(	std::vector< uint8_t > &	pixels,
		int	width,
		int	height,
		float	radius )

{
    if (radius <= 0.f || width <= 0 || height <= 0 || pixels.size() != size_t(width) * size_t(height))
        return;
 
    const int   whole = std::max(1, int(std::ceil(radius)));
    const float mix   = std::clamp(radius / float(whole), 0.f, 1.f);
    const std::vector<uint8_t> raw = (mix < 0.999f) ? pixels : std::vector<uint8_t>{};
    smooth_height_pixels_box(pixels, width, height, whole);
    if (!raw.empty())
        for (size_t i = 0; i < pixels.size(); ++i)
            pixels[i] = uint8_t(std::lround(float(raw[i]) + (float(pixels[i]) - float(raw[i])) * mix));
}

References smooth_height_pixels(), and smooth_height_pixels_box().

Referenced by adjust_channel_spatial(), and smooth_height_pixels().

Here is the call graph for this function:

Here is the caller graph for this function:

smooth_height_pixels_box()

void Slic3r::anonymous_namespace{TextureDisplacement.cpp}::smooth_height_pixels_box	(	std::vector< uint8_t > &	pixels,
		int	width,
		int	height,
		int	radius )

{
    if (radius <= 0 || width <= 0 || height <= 0 || pixels.size() != size_t(width) * size_t(height))
        return;
 
    const int   window = 2 * radius + 1;
    const float inv    = 1.f / float(window);
    const auto  wrap   = [](int i, int n) { return (i % n + n) % n; };
    std::vector<uint8_t> tmp(pixels.size());
 
    for (int pass = 0; pass < 2; ++pass) { // two passes -> smoother than a single box
        // Horizontal: a running sum per row.
        tbb::parallel_for(tbb::blocked_range<int>(0, height), [&](const tbb::blocked_range<int> &r) {
            for (int y = r.begin(); y < r.end(); ++y) {
                const uint8_t *src = pixels.data() + size_t(y) * size_t(width);
                uint8_t       *dst = tmp.data() + size_t(y) * size_t(width);
                uint32_t       sum = 0;
                for (int k = -radius; k <= radius; ++k)
                    sum += src[wrap(k, width)];
                for (int x = 0; x < width; ++x) {
                    dst[x] = uint8_t(std::lround(float(sum) * inv));
                    sum += src[wrap(x + radius + 1, width)];
                    sum -= src[wrap(x - radius, width)];
                }
            }
        });
        // Vertical: one running sum per column, advanced row by row so the reads stay row-major.
        tbb::parallel_for(tbb::blocked_range<int>(0, width, 256), [&](const tbb::blocked_range<int> &r) {
            std::vector<uint32_t> sum(size_t(r.size()), 0);
            for (int k = -radius; k <= radius; ++k) {
                const uint8_t *row = tmp.data() + size_t(wrap(k, height)) * size_t(width);
                for (int x = r.begin(); x < r.end(); ++x)
                    sum[size_t(x - r.begin())] += row[x];
            }
            for (int y = 0; y < height; ++y) {
                uint8_t       *dst = pixels.data() + size_t(y) * size_t(width);
                const uint8_t *add = tmp.data() + size_t(wrap(y + radius + 1, height)) * size_t(width);
                const uint8_t *sub = tmp.data() + size_t(wrap(y - radius, height)) * size_t(width);
                for (int x = r.begin(); x < r.end(); ++x) {
                    uint32_t &sx = sum[size_t(x - r.begin())];
                    dst[x] = uint8_t(std::lround(float(sx) * inv));
                    sx += add[x];
                    sx -= sub[x];
                }
            }
        });
    }
}

References smooth_height_pixels_box().

Referenced by smooth_height_pixels(), and smooth_height_pixels_box().

Here is the call graph for this function:

Here is the caller graph for this function:

solve_edge_alignment()

TextureIsland Slic3r::anonymous_namespace{TextureDisplacement.cpp}::solve_edge_alignment	(	const Vec2f &	rc0,
		const Vec2f &	rc1,
		const Vec2f &	pp0,
		const Vec2f &	pp1,
		const Vec2f &	cen )

{
    const Vec2f dP = pp1 - pp0, dC = rc1 - rc0;
    const float rho = std::atan2(dP.y(), dP.x()) - std::atan2(dC.y(), dC.x());
    const float cs = std::cos(rho), sn = std::sin(rho);
    const auto  rot = [&](const Vec2f &v) { return Vec2f(v.x() * cs - v.y() * sn, v.x() * sn + v.y() * cs); };
 
    TextureIsland island;
    island.scale        = 1.f;
    island.rotation_deg = rho * 180.f / float(M_PI);
    island.offset       = pp0 - (rot(rc0 - cen) + cen); // island_transform_matrix places rc0 exactly here
    return island;
}

References M_PI, Slic3r::TextureIsland::offset, Slic3r::TextureIsland::rotation_deg, Slic3r::TextureIsland::scale, and solve_edge_alignment().

Referenced by solve_edge_alignment().

Here is the call graph for this function:

Here is the caller graph for this function:

split_chart_sides()

std::vector< char > Slic3r::anonymous_namespace{TextureDisplacement.cpp}::split_chart_sides	(	const indexed_triangle_set &	mesh,
		const std::vector< Vec3f > &	normals,
		const std::vector< int > &	faces )

{
    const auto principal_axis = [](const std::vector<Vec3f> &samples, Vec3f &mean, Vec3f &axis) {
        mean = Vec3f::Zero();
        for (const Vec3f &s : samples)
            mean += s;
        mean /= float(samples.size());
        Eigen::Matrix3f covariance = Eigen::Matrix3f::Zero();
        for (const Vec3f &s : samples) {
            const Vec3f d = s - mean;
            covariance += d * d.transpose();
        }
        const Eigen::SelfAdjointEigenSolver<Eigen::Matrix3f> solver(covariance);
        axis = solver.eigenvectors().col(2); // eigenvalues come sorted ascending
        return solver.eigenvalues()(2) / float(samples.size());
    };
 
    std::vector<Vec3f> samples(faces.size());
    for (size_t i = 0; i < faces.size(); ++i)
        samples[i] = normals[size_t(faces[i])];
    Vec3f mean, axis;
    if (principal_axis(samples, mean, axis) < 1e-3f) {
        for (size_t i = 0; i < faces.size(); ++i) {
            const stl_triangle_vertex_indices &tri = mesh.indices[size_t(faces[i])];
            samples[i] = (mesh.vertices[tri[0]] + mesh.vertices[tri[1]] + mesh.vertices[tri[2]]) / 3.f;
        }
        principal_axis(samples, mean, axis);
    }
    std::vector<char> side(faces.size());
    for (size_t i = 0; i < faces.size(); ++i)
        side[i] = (samples[i] - mean).dot(axis) > 0.f;
    return side;
}

References split_chart_sides().

Referenced by segment_into_charts(), and split_chart_sides().

Here is the call graph for this function:

Here is the caller graph for this function:

step_edge_key()

uint64_t Slic3r::anonymous_namespace{TextureDisplacement.cpp}::step_edge_key ( int a, int b )

inline

{
    if (a > b) std::swap(a, b);
    return (uint64_t(uint32_t(a)) << 32) | uint32_t(b);
}

References step_edge_key().

Referenced by scan_steps(), and step_edge_key().

Here is the call graph for this function:

Here is the caller graph for this function:

triangles_overlap()

bool Slic3r::anonymous_namespace{TextureDisplacement.cpp}::triangles_overlap	(	const Tri2 &	a,
		const Tri2 &	b,
		float	eps )

{
    for (const Tri2 *t : { &a, &b })
        for (int i = 0; i < 3; ++i) {
            const Vec2f edge = (*t)[(i + 1) % 3] - (*t)[i];
            const float len  = edge.norm();
            if (len < 1e-12f)
                continue;
            const Vec2f axis(-edge.y() / len, edge.x() / len);
            float       a_min = std::numeric_limits<float>::max(), a_max = std::numeric_limits<float>::lowest();
            float       b_min = a_min, b_max = a_max;
            for (int k = 0; k < 3; ++k) {
                const float pa = axis.dot(a[k]), pb = axis.dot(b[k]);
                a_min = std::min(a_min, pa);
                a_max = std::max(a_max, pa);
                b_min = std::min(b_min, pb);
                b_max = std::max(b_max, pb);
            }
            if (a_max <= b_min + eps || b_max <= a_min + eps)
                return false;
        }
    return true;
}

References triangles_overlap().

Referenced by Slic3r::anonymous_namespace{TextureDisplacement.cpp}::NetGrid::hits(), and triangles_overlap().

Here is the call graph for this function:

Here is the caller graph for this function:

triplanar_weights()

Vec3f Slic3r::anonymous_namespace{TextureDisplacement.cpp}::triplanar_weights ( const Vec3f & normal )

inline

{
    Vec3f w = normal.cwiseAbs();
    w       = w.cwiseProduct(w);
    return w.cwiseProduct(w);
}

References Slic3r::normal(), and triplanar_weights().

Referenced by triplanar_weights().

Here is the call graph for this function:

Here is the caller graph for this function:

undirected_edge_key()

uint64_t Slic3r::anonymous_namespace{TextureDisplacement.cpp}::undirected_edge_key	(	int	a,
		int	b )

{
    if (a > b)
        std::swap(a, b);
    return (uint64_t(uint32_t(a)) << 32) | uint32_t(b);
}

References undirected_edge_key().

Referenced by chart_is_flattenable(), segment_into_charts(), and undirected_edge_key().

Here is the call graph for this function:

Here is the caller graph for this function:

unsharp_radius()

float Slic3r::anonymous_namespace{TextureDisplacement.cpp}::unsharp_radius	(	int	width,
		int	height )

{
    return std::max(1.f, 0.002f * float(std::min(width, height)));
}

References unsharp_radius().

Referenced by adjust_channel_spatial(), and unsharp_radius().

Here is the call graph for this function:

Here is the caller graph for this function:

unwrap_cache_key()

uint64_t Slic3r::anonymous_namespace{TextureDisplacement.cpp}::unwrap_cache_key	(	const indexed_triangle_set &	patch,
		float	seam_angle_deg,
		float	padding_mm,
		const std::vector< std::pair< int, int > > &	seam_edges )

{
    uint64_t   h   = 1469598103934665603ull;
    const auto mix = [&h](const void *data, size_t bytes) {
        const unsigned char *p = static_cast<const unsigned char *>(data);
        for (size_t i = 0; i < bytes; ++i) {
            h ^= p[i];
            h *= 1099511628211ull;
        }
    };
    mix(patch.vertices.data(), patch.vertices.size() * sizeof(Vec3f));
    mix(patch.indices.data(), patch.indices.size() * sizeof(stl_triangle_vertex_indices));
    mix(&seam_angle_deg, sizeof(seam_angle_deg));
    mix(&padding_mm, sizeof(padding_mm));
    mix(seam_edges.data(), seam_edges.size() * sizeof(std::pair<int, int>));
    return h;
}

References unwrap_cache_key().

Referenced by unwrap_cache_key().

Here is the call graph for this function:

Here is the caller graph for this function:

vec2_from_json()

Vec2f Slic3r::anonymous_namespace{TextureDisplacement.cpp}::vec2_from_json	(	const nlohmann::json &	j,
		const Vec2f &	fallback )

{
    if (!j.is_array() || j.size() != 2)
        return fallback;
    return Vec2f(j[0].get<float>(), j[1].get<float>());
}

References vec2_from_json().

Referenced by vec2_from_json().

Here is the call graph for this function:

Here is the caller graph for this function:

vec2_to_json()

nlohmann::json Slic3r::anonymous_namespace{TextureDisplacement.cpp}::vec2_to_json

(

const Vec2f &

v

)

{ return nlohmann::json::array({ v.x(), v.y() }); }

References vec2_to_json().

Referenced by vec2_to_json().

Here is the call graph for this function:

Here is the caller graph for this function:

vec3_from_json()

Vec3f Slic3r::anonymous_namespace{TextureDisplacement.cpp}::vec3_from_json	(	const nlohmann::json &	j,
		const Vec3f &	fallback )

{
    if (!j.is_array() || j.size() != 3)
        return fallback;
    return Vec3f(j[0].get<float>(), j[1].get<float>(), j[2].get<float>());
}

References vec3_from_json().

Referenced by vec3_from_json().

Here is the call graph for this function:

Here is the caller graph for this function:

vec3_to_json()

nlohmann::json Slic3r::anonymous_namespace{TextureDisplacement.cpp}::vec3_to_json

(

const Vec3f &

v

)

{ return nlohmann::json::array({ v.x(), v.y(), v.z() }); }

References vec3_to_json().

Referenced by vec3_to_json().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

g_adjusted_texture_cache

AdjustedTextureCache Slic3r::anonymous_namespace{TextureDisplacement.cpp}::g_adjusted_texture_cache

g_decoded_texture_cache

DecodedTextureCache Slic3r::anonymous_namespace{TextureDisplacement.cpp}::g_decoded_texture_cache

g_smoothed_texture_cache

SmoothedTextureCache Slic3r::anonymous_namespace{TextureDisplacement.cpp}::g_smoothed_texture_cache

g_texture_detail_cache

TextureDetailCache Slic3r::anonymous_namespace{TextureDisplacement.cpp}::g_texture_detail_cache

g_unwrap_cache

UnwrapCache Slic3r::anonymous_namespace{TextureDisplacement.cpp}::g_unwrap_cache

SOURCE_BLUR_MAX_PX

float Slic3r::anonymous_namespace{TextureDisplacement.cpp}::SOURCE_BLUR_MAX_PX = 48.f

constexpr

SOURCE_BLUR_SPAN

float Slic3r::anonymous_namespace{TextureDisplacement.cpp}::SOURCE_BLUR_SPAN = 0.05f

constexpr

UNWRAP_CACHE_MAX_ENTRIES

const size_t Slic3r::anonymous_namespace{TextureDisplacement.cpp}::UNWRAP_CACHE_MAX_ENTRIES = 8