Slic3r::sla::FaceHash Struct Reference

Collaboration diagram for Slic3r::sla::FaceHash:

Public Member Functions
	FaceHash (const indexed_triangle_set &its)
bool	find (const std::string &key)

Static Public Member Functions
static std::array< char, MAX_NUM_CHARS+1 >	to_chars (int64_t val)
static std::string	hash (const Vec< 3, int64_t > &v)
static std::string	facekey (const Vec3i &face, const std::vector< Vec3f > &vertices)

Public Attributes
std::unordered_set< std::string >	facehash

Static Public Attributes
static constexpr size_t	MAX_NUM_CHARS = 16

Detailed Description

Constructor & Destructor Documentation

FaceHash()

Slic3r::sla::FaceHash::FaceHash ( const indexed_triangle_set &  its )

inline

                                              : facehash(its.indices.size())
    {
        for (Vec3i face : its.indices) {
            std::swap(face(0), face(2));
            facehash.insert(facekey(face, its.vertices));
        }
    }

References indexed_triangle_set::indices, and indexed_triangle_set::vertices.

Member Function Documentation

facekey()

static std::string Slic3r::sla::FaceHash::facekey ( const Vec3i &  face, const std::vector< Vec3f > &  vertices  )

inlinestatic

    {
        // Scale to integer to avoid floating points
        std::array<Vec<3, int64_t>, 3> pts = {
            scaled<int64_t>(vertices[face(0)]),
            scaled<int64_t>(vertices[face(1)]),
            scaled<int64_t>(vertices[face(2)])
        };
 
        // Get the first two sides of the triangle, do a cross product and move
        // that vector to the center of the triangle. This encodes all
        // information to identify an identical triangle at the same position.
        Vec<3, int64_t> a = pts[0] - pts[2], b = pts[1] - pts[2];
        Vec<3, int64_t> c = a.cross(b) + (pts[0] + pts[1] + pts[2]) / 3;
 
        // Return a concatenated string representation of the coordinates
        return hash(c);
    }

find()

bool Slic3r::sla::FaceHash::find ( const std::string &  key )

inline

    {
        auto it = facehash.find(key);
        return it != facehash.end();
    }

hash()

static std::string Slic3r::sla::FaceHash::hash ( const Vec< 3, int64_t > &  v )

inlinestatic

    {
        std::string ret;
        ret.reserve(3 * MAX_NUM_CHARS);
 
        for (auto val : v)
            ret += to_chars(val).data();
 
        return ret;
    }

to_chars()

static std::array< char, MAX_NUM_CHARS+1 > Slic3r::sla::FaceHash::to_chars ( int64_t  val )

inlinestatic

    {
        std::array<char, MAX_NUM_CHARS + 1> ret;
 
        static const constexpr char * Conv = "0123456789abcdef";
 
        auto ptr = ret.begin();
        auto uval = static_cast<uint64_t>(std::abs(val));
        while (uval) {
            *ptr = Conv[uval & 0xf];
            ++ptr;
            uval = uval >> 4;
        }
        if (val < 0) { *ptr = '-'; ++ptr; }
        *ptr = '\0'; // C style string ending
 
        return ret;
    }

Member Data Documentation

facehash

std::unordered_set<std::string> Slic3r::sla::FaceHash::facehash

MAX_NUM_CHARS

constexpr size_t Slic3r::sla::FaceHash::MAX_NUM_CHARS = 16

staticconstexpr

---

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

• src/libslic3r/SLA/Hollowing.cpp