Slic3r::anonymous_namespace{Model.cpp} Namespace Reference

Classes
struct	ExclusionPrismFootprintTriangle

Functions
static double	cross_2d (const Vec2d &a, const Vec2d &b)
template<class DistanceFn>
static std::vector< Vec3d >	clip_polygon_by_signed_distance (const std::vector< Vec3d > &input, DistanceFn distance)
static std::vector< ExclusionPrismFootprintTriangle >	triangulated_prism_footprints (const Polygon &polygon)
static bool	triangle_bbox_intersects_prism_footprint (const Vec3d &p0, const Vec3d &p1, const Vec3d &p2, const ExclusionPrismFootprintTriangle &footprint)
static std::vector< Vec3d >	clip_model_triangle_to_prism (const Vec3d &p0, const Vec3d &p1, const Vec3d &p2, const double z_min, const double z_max, const ExclusionPrismFootprintTriangle &footprint)
static double	polygon_3d_area2 (const std::vector< Vec3d > &polygon)
static void	append_clipped_polygon (indexed_triangle_set &out, const std::vector< Vec3d > &polygon)
static bool	mesh_contains_point_linear (const indexed_triangle_set &its, const Vec3d &point)

---

Class Documentation

Slic3r::anonymous_namespace{Model.cpp}::ExclusionPrismFootprintTriangle

struct Slic3r::anonymous_namespace{Model.cpp}::ExclusionPrismFootprintTriangle

Collaboration diagram for Slic3r::anonymous_namespace{Model.cpp}::ExclusionPrismFootprintTriangle:

Class Members
Vec2d	max = Vec2d::Zero()
Vec2d	min = Vec2d::Zero()
array< Vec2d, 3 >	vertices

Function Documentation

append_clipped_polygon()

void Slic3r::anonymous_namespace{Model.cpp}::append_clipped_polygon ( indexed_triangle_set & out, const std::vector< Vec3d > & polygon )

static

{
    if (polygon.size() < 3)
        return;
 
    // Do not reserve exact capacity here. This helper may be called for many
    // clipped fragments, so let std::vector grow amortized through emplace_back.
    const int base = int(out.vertices.size());
    for (const Vec3d &point : polygon)
        out.vertices.emplace_back(point.cast<float>());
 
    for (size_t i = 1; i + 1 < polygon.size(); ++i) {
        stl_triangle_vertex_indices tri;
        tri << base, base + int(i), base + int(i + 1);
        out.indices.emplace_back(tri);
    }
}

References append_clipped_polygon().

Referenced by append_clipped_polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

clip_model_triangle_to_prism()

std::vector< Vec3d > Slic3r::anonymous_namespace{Model.cpp}::clip_model_triangle_to_prism ( const Vec3d & p0, const Vec3d & p1, const Vec3d & p2, const double z_min, const double z_max, const ExclusionPrismFootprintTriangle & footprint )

static

{
    std::vector<Vec3d> clipped = { p0, p1, p2 };
    clipped = clip_polygon_by_signed_distance(clipped, [z_min](const Vec3d &p) { return p.z() - z_min; });
    clipped = clip_polygon_by_signed_distance(clipped, [z_max](const Vec3d &p) { return z_max - p.z(); });
 
    for (size_t i = 0; i < footprint.vertices.size() && clipped.size() >= 3; ++i) {
        const Vec2d &a = footprint.vertices[i];
        const Vec2d &b = footprint.vertices[(i + 1) % footprint.vertices.size()];
        const Vec2d edge = b - a;
        clipped = clip_polygon_by_signed_distance(clipped, [a, edge](const Vec3d &p) {
            return cross_2d(edge, Vec2d(p.x() - a.x(), p.y() - a.y()));
        });
    }
 
    return clipped;
}

References clip_model_triangle_to_prism(), clip_polygon_by_signed_distance(), cross_2d(), and Slic3r::anonymous_namespace{Model.cpp}::ExclusionPrismFootprintTriangle::vertices.

Referenced by clip_model_triangle_to_prism().

Here is the call graph for this function:

Here is the caller graph for this function:

clip_polygon_by_signed_distance()

template<class DistanceFn>

std::vector< Vec3d > Slic3r::anonymous_namespace{Model.cpp}::clip_polygon_by_signed_distance ( const std::vector< Vec3d > & input, DistanceFn distance )

static

{
    constexpr double clip_epsilon = 1e-8;
    constexpr double duplicate_epsilon_sq = 1e-16;
 
    std::vector<Vec3d> output;
    if (input.empty())
        return output;
 
    auto append_point = [&output](const Vec3d &point) {
        if (output.empty() || (output.back() - point).squaredNorm() > duplicate_epsilon_sq)
            output.emplace_back(point);
    };
 
    Vec3d prev = input.back();
    double prev_distance = distance(prev);
    bool prev_inside = prev_distance >= -clip_epsilon;
    for (const Vec3d &curr : input) {
        const double curr_distance = distance(curr);
        const bool curr_inside = curr_distance >= -clip_epsilon;
 
        if (curr_inside != prev_inside) {
            const double denom = prev_distance - curr_distance;
            if (std::abs(denom) > clip_epsilon) {
                const double t = prev_distance / denom;
                append_point(prev + t * (curr - prev));
            }
        }
        if (curr_inside)
            append_point(curr);
 
        prev = curr;
        prev_distance = curr_distance;
        prev_inside = curr_inside;
    }
 
    if (output.size() > 1 && (output.front() - output.back()).squaredNorm() <= duplicate_epsilon_sq)
        output.pop_back();
 
    return output;
}

References clip_polygon_by_signed_distance().

Referenced by clip_model_triangle_to_prism(), and clip_polygon_by_signed_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

cross_2d()

double Slic3r::anonymous_namespace{Model.cpp}::cross_2d ( const Vec2d & a, const Vec2d & b )

static

{
    return a.x() * b.y() - a.y() * b.x();
}

References cross_2d().

Referenced by clip_model_triangle_to_prism(), cross_2d(), and triangulated_prism_footprints().

Here is the call graph for this function:

Here is the caller graph for this function:

mesh_contains_point_linear()

bool Slic3r::anonymous_namespace{Model.cpp}::mesh_contains_point_linear ( const indexed_triangle_set & its, const Vec3d & point )

static

{
    constexpr double ray_epsilon = 1e-6;
    const Vec3d ray_direction = Vec3d::UnitX();
    double nearest_hit_distance = std::numeric_limits<double>::infinity();
    size_t nearest_face = size_t(-1);
 
    for (size_t face_id = 0; face_id < its.indices.size(); ++face_id) {
        const stl_triangle_vertex_indices &face = its.indices[face_id];
        double distance;
        double u;
        double v;
        if (AABBTreeIndirect::detail::intersect_triangle(
                point, ray_direction,
                its.vertices[face[0]], its.vertices[face[1]], its.vertices[face[2]],
                distance, u, v, ray_epsilon) &&
            distance > 0.0 && distance < nearest_hit_distance) {
            nearest_hit_distance = distance;
            nearest_face = face_id;
        }
    }
 
    // This matches AABBMesh::hit_result::is_inside(): for a consistently
    // oriented closed mesh, the nearest face points along a ray leaving it.
    return nearest_face != size_t(-1) &&
           its_unnormalized_normal(its, nearest_face).cast<double>().dot(ray_direction) > 0.0;
}

References Slic3r::dot(), Slic3r::AABBTreeIndirect::detail::intersect_triangle(), Slic3r::its_unnormalized_normal(), and mesh_contains_point_linear().

Referenced by mesh_contains_point_linear().

Here is the call graph for this function:

Here is the caller graph for this function:

polygon_3d_area2()

double Slic3r::anonymous_namespace{Model.cpp}::polygon_3d_area2 ( const std::vector< Vec3d > & polygon )

static

{
    if (polygon.size() < 3)
        return 0.0;
 
    Vec3d normal = Vec3d::Zero();
    for (size_t i = 1; i + 1 < polygon.size(); ++i)
        normal += (polygon[i] - polygon.front()).cross(polygon[i + 1] - polygon.front());
    return normal.norm();
}

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

Referenced by polygon_3d_area2().

Here is the call graph for this function:

Here is the caller graph for this function:

triangle_bbox_intersects_prism_footprint()

bool Slic3r::anonymous_namespace{Model.cpp}::triangle_bbox_intersects_prism_footprint ( const Vec3d & p0, const Vec3d & p1, const Vec3d & p2, const ExclusionPrismFootprintTriangle & footprint )

static

{
    constexpr double bbox_epsilon = 1e-8;
    const double tri_min_x = std::min({ p0.x(), p1.x(), p2.x() });
    const double tri_max_x = std::max({ p0.x(), p1.x(), p2.x() });
    const double tri_min_y = std::min({ p0.y(), p1.y(), p2.y() });
    const double tri_max_y = std::max({ p0.y(), p1.y(), p2.y() });
 
    return tri_max_x >= footprint.min.x() - bbox_epsilon &&
           tri_min_x <= footprint.max.x() + bbox_epsilon &&
           tri_max_y >= footprint.min.y() - bbox_epsilon &&
           tri_min_y <= footprint.max.y() + bbox_epsilon;
}

References Slic3r::anonymous_namespace{Model.cpp}::ExclusionPrismFootprintTriangle::max, Slic3r::anonymous_namespace{Model.cpp}::ExclusionPrismFootprintTriangle::min, and triangle_bbox_intersects_prism_footprint().

Referenced by triangle_bbox_intersects_prism_footprint().

Here is the call graph for this function:

Here is the caller graph for this function:

triangulated_prism_footprints()

std::vector< ExclusionPrismFootprintTriangle > Slic3r::anonymous_namespace{Model.cpp}::triangulated_prism_footprints ( const Polygon & polygon )

static

{
    std::vector<ExclusionPrismFootprintTriangle> out;
    if (polygon.points.size() < 3)
        return out;
 
    ExPolygon expolygon;
    expolygon.contour = polygon;
    expolygon.contour.make_counter_clockwise();
 
    std::vector<Vec2d> triangles = triangulate_expolygon_2d(expolygon, NORMALS_UP);
    if (triangles.empty()) {
        triangles.reserve((polygon.points.size() - 2) * 3);
        const Vec2d first(unscale<double>(polygon.points.front().x()), unscale<double>(polygon.points.front().y()));
        for (size_t i = 1; i + 1 < polygon.points.size(); ++i) {
            triangles.emplace_back(first);
            triangles.emplace_back(unscale<double>(polygon.points[i].x()), unscale<double>(polygon.points[i].y()));
            triangles.emplace_back(unscale<double>(polygon.points[i + 1].x()), unscale<double>(polygon.points[i + 1].y()));
        }
    }
 
    out.reserve(triangles.size() / 3);
    for (size_t i = 0; i + 2 < triangles.size(); i += 3) {
        ExclusionPrismFootprintTriangle tri;
        tri.vertices = { triangles[i], triangles[i + 1], triangles[i + 2] };
 
        const double area = cross_2d(tri.vertices[1] - tri.vertices[0], tri.vertices[2] - tri.vertices[0]);
        if (std::abs(area) <= EPSILON)
            continue;
        if (area < 0.0)
            std::swap(tri.vertices[1], tri.vertices[2]);
 
        tri.min = tri.vertices[0].cwiseMin(tri.vertices[1]).cwiseMin(tri.vertices[2]);
        tri.max = tri.vertices[0].cwiseMax(tri.vertices[1]).cwiseMax(tri.vertices[2]);
        out.emplace_back(std::move(tri));
    }
 
    return out;
}

References Slic3r::area(), Slic3r::ExPolygon::contour, cross_2d(), EPSILON, Slic3r::Polygon::make_counter_clockwise(), Slic3r::anonymous_namespace{Model.cpp}::ExclusionPrismFootprintTriangle::max, Slic3r::anonymous_namespace{Model.cpp}::ExclusionPrismFootprintTriangle::min, Slic3r::NORMALS_UP, Slic3r::MultiPoint::points, Slic3r::triangulate_expolygon_2d(), triangulated_prism_footprints(), Slic3r::unscale(), and Slic3r::anonymous_namespace{Model.cpp}::ExclusionPrismFootprintTriangle::vertices.

Referenced by triangulated_prism_footprints().

Here is the call graph for this function:

Here is the caller graph for this function: