Slic3r::NormalUtils Class Reference

Collection of static function to create normals. More...

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/NormalUtils.hpp>

Public Types
enum class	VertexNormalType { AverageNeighbor , AngleWeighted , NelsonMaxWeighted }
using	Normal = Vec3f
using	Normals = std::vector<Normal>

Public Member Functions
	NormalUtils ()=delete

Static Public Member Functions
static Normal	create_triangle_normal (const stl_triangle_vertex_indices &indices, const std::vector< stl_vertex > &vertices)
	Create normal for triangle defined by indices from vertices.
static Normals	create_triangle_normals (const indexed_triangle_set &its)
	Create normals for each vertices.
static Normals	create_normals (const indexed_triangle_set &its, VertexNormalType type=VertexNormalType::NelsonMaxWeighted)
	Create normals for each vertex by averaging neighbor triangles normal.
static Normals	create_normals_average_neighbor (const indexed_triangle_set &its)
static Normals	create_normals_angle_weighted (const indexed_triangle_set &its)
static Normals	create_normals_nelson_weighted (const indexed_triangle_set &its)
static float	indice_angle (int i, const Vec3i32 &indice, const std::vector< stl_vertex > &vertices)
	Calculate angle of trinagle side.

Detailed Description

Collection of static function to create normals.

Member Typedef Documentation

Normal

using Slic3r::NormalUtils::Normal = Vec3f

Normals

using Slic3r::NormalUtils::Normals = std::vector<Normal>

Member Enumeration Documentation

VertexNormalType

enum class Slic3r::NormalUtils::VertexNormalType

strong

Enumerator
AverageNeighbor
AngleWeighted
NelsonMaxWeighted

                                {
        AverageNeighbor,
        AngleWeighted,
        NelsonMaxWeighted
    };

Constructor & Destructor Documentation

NormalUtils()

Slic3r::NormalUtils::NormalUtils ( )

delete

Member Function Documentation

create_normals()

std::vector< Vec3f > NormalUtils::create_normals ( const indexed_triangle_set & its, VertexNormalType type = VertexNormalType::NelsonMaxWeighted )

static

Create normals for each vertex by averaging neighbor triangles normal.

Parameters

its	Triangle indices and vertices
type	Type of calculation normals

Returns

Normal for each vertex

{
    switch (type) {
    case VertexNormalType::AverageNeighbor:
        return create_normals_average_neighbor(its);
    case VertexNormalType::AngleWeighted:
        return create_normals_angle_weighted(its);
    case VertexNormalType::NelsonMaxWeighted:
    default:
        return create_normals_nelson_weighted(its);
    }
}

References AngleWeighted, AverageNeighbor, create_normals_angle_weighted(), create_normals_average_neighbor(), create_normals_nelson_weighted(), and NelsonMaxWeighted.

Referenced by Slic3r::its_short_edge_collpase().

Here is the call graph for this function:

Here is the caller graph for this function:

create_normals_angle_weighted()

NormalUtils::Normals NormalUtils::create_normals_angle_weighted ( const indexed_triangle_set & its )

static

{
    size_t             count_vertices = its.vertices.size();
    std::vector<Vec3f> normals(count_vertices, Vec3f(.0f, .0f, .0f));
    std::vector<float> count(count_vertices, 0.f);
    for (const auto &indice : its.indices) {
        Vec3f normal = create_triangle_normal(indice, its.vertices);
        Vec3f angles(indice_angle(0, indice, its.vertices),
                     indice_angle(1, indice, its.vertices), 0.f);
        angles[2] = (M_PI - angles[0] - angles[1]);
        for (int i = 0; i < 3; ++i) {
            const float &weight = angles[i];
            normals[indice[i]] += normal * weight;
            count[indice[i]] += weight;
        }
    }
    // normalize to size 1
    for (auto &normal : normals) {
        size_t index = &normal - &normals.front();
        normal /= count[index];
    }
    return normals;
}

References count, create_triangle_normal(), indice_angle(), M_PI, and Slic3r::normal().

Referenced by create_normals().

Here is the call graph for this function:

Here is the caller graph for this function:

create_normals_average_neighbor()

NormalUtils::Normals NormalUtils::create_normals_average_neighbor ( const indexed_triangle_set & its )

static

{
    size_t             count_vertices = its.vertices.size();
    std::vector<Vec3f> normals(count_vertices, Vec3f(.0f, .0f, .0f));
    std::vector<unsigned int> count(count_vertices, 0);
    for (const auto &indice : its.indices) {
        Vec3f normal = create_triangle_normal(indice, its.vertices);
        for (int i = 0; i < 3; ++i) {
            normals[indice[i]] += normal;
            ++count[indice[i]];
        }
    }
    // normalize to size 1
    for (auto &normal : normals) {
        size_t index = &normal - &normals.front();
        normal /= static_cast<float>(count[index]);
    }
    return normals;
}

References count, create_triangle_normal(), and Slic3r::normal().

Referenced by create_normals().

Here is the call graph for this function:

Here is the caller graph for this function:

create_normals_nelson_weighted()

NormalUtils::Normals NormalUtils::create_normals_nelson_weighted ( const indexed_triangle_set & its )

static

{
    size_t             count_vertices = its.vertices.size();
    std::vector<Vec3f> normals(count_vertices, Vec3f(.0f, .0f, .0f));
    std::vector<float> count(count_vertices, 0.f);
    const std::vector<stl_vertex> &vertices = its.vertices;
    for (const auto &indice : its.indices) {
        Vec3f normal = create_triangle_normal(indice, vertices);
 
        const stl_vertex &v0 = vertices[indice[0]];
        const stl_vertex &v1 = vertices[indice[1]];
        const stl_vertex &v2 = vertices[indice[2]];
 
        float e0 = (v0 - v1).norm();
        float e1 = (v1 - v2).norm();
        float e2 = (v2 - v0).norm();
 
        Vec3f coefs(e0 * e2, e0 * e1, e1 * e2);
        for (int i = 0; i < 3; ++i) {
            const float &weight = coefs[i];
            normals[indice[i]] += normal * weight;
            count[indice[i]] += weight;
        }
    }
    // normalize to size 1
    for (auto &normal : normals) {
        size_t index = &normal - &normals.front();
        normal /= count[index];
    }
    return normals;
}

References count, create_triangle_normal(), and Slic3r::normal().

Referenced by create_normals().

Here is the call graph for this function:

Here is the caller graph for this function:

create_triangle_normal()

Vec3f NormalUtils::create_triangle_normal ( const stl_triangle_vertex_indices & indices, const std::vector< stl_vertex > & vertices )

static

Create normal for triangle defined by indices from vertices.

Parameters

indices	index into vertices
vertices	vector of vertices

Returns

normal to triangle(normalized to size 1)

{
    const stl_vertex &v0        = vertices[indices[0]];
    const stl_vertex &v1        = vertices[indices[1]];
    const stl_vertex &v2        = vertices[indices[2]];
    Vec3f             direction = (v1 - v0).cross(v2 - v0);
    direction.normalize();
    return direction;
}

References Slic3r::cross().

Referenced by create_normals_angle_weighted(), create_normals_average_neighbor(), create_normals_nelson_weighted(), and create_triangle_normals().

Here is the call graph for this function:

Here is the caller graph for this function:

create_triangle_normals()

std::vector< Vec3f > NormalUtils::create_triangle_normals ( const indexed_triangle_set & its )

static

Create normals for each vertices.

Parameters

its	indices and vertices

Returns

Vector of normals

{
    std::vector<Vec3f> normals;
    normals.reserve(its.indices.size());
    for (const auto &index : its.indices) {
        normals.push_back(create_triangle_normal(index, its.vertices));
    }
    return normals;
}

References create_triangle_normal().

Here is the call graph for this function:

indice_angle()

float NormalUtils::indice_angle ( int i, const Vec3i32 & indice, const std::vector< stl_vertex > & vertices )

static

Calculate angle of trinagle side.

Parameters

i	index to indices, define angle point
indice	address to vertices
vertices	vertices data

Returns

Angle [in radian]

{
    int i1 = (i == 0) ? 2 : (i - 1);
    int i2 = (i == 2) ? 0 : (i + 1);
 
    Vec3f v1 = vertices[i1] - vertices[i];
    Vec3f v2 = vertices[i2] - vertices[i];
 
    v1.normalize();
    v2.normalize();
 
    float w = v1.dot(v2);
    if (w > 1.f)
        w = 1.f;
    else if (w < -1.f)
        w = -1.f;
    return acos(w);
}

Referenced by create_normals_angle_weighted().

Here is the caller graph for this function:

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/NormalUtils.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/NormalUtils.cpp