SurfaceTagAttributes.h

#pragma once
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
 
namespace wmtk {
 
using InputSet = uint64_t;
 
class SurfaceTagAttributes
{
    // Eleven bytes. The values are tiny -- a flag, a bbox side in [-1, 5], a class in {0, 1}, an
    // orientation count that is +-1 or 0 almost everywhere, a 64-bit input set -- but as int the
    // struct was 12 bytes, and the 3D meshes carry four of these per tet slot (the 2D ones three
    // per triangle slot) in storage preallocated several times over: on the largest tetwild
    // inputs that alone was most of a gigabyte. The class and the orientation share a byte as
    // bitfields; both are int8_t so every compiler packs them together. The input set took it
    // from 3 to 5 bytes, 8 more per tet slot: on Thingi10K 46024, the largest tetwild input of
    // the challenging set (156k tets after insertion, two iterations), peak RSS went from 1006
    // to 1017 MB (+1.1%), the simplification's per-face input id included. 64 bits rather than 16
    // so that simwild can give every label its own bit -- each tet tag's region as well as each
    // face tag -- and hold every surface face to its own labels' envelopes: segmented images
    // carry more than 16 labels. That is 6 bytes more per face record: on the same
    // 46024, one input, serial, peak RSS 1001 MB on main (3 bytes) and 1007 MB here (11 bytes).
public:
    // Bitfields cannot take default member initializers before C++20.
    SurfaceTagAttributes()
        : m_surface_class(0)
        , m_orientation(0)
    {}
 
    bool m_is_surface_fs = false;
    int8_t m_is_bbox_fs = -1;
 
    int8_t m_surface_class : 3;
 
    int8_t m_orientation : 5;
    static constexpr int max_orientation = 15;
 
    InputSet input_set() const
    {
        InputSet s = 0;
        for (size_t i = 0; i < sizeof(InputSet); ++i) s |= InputSet(m_input_set[i]) << (8 * i);
        return s;
    }
    void set_input_set(InputSet s)
    {
        for (size_t i = 0; i < sizeof(InputSet); ++i) m_input_set[i] = uint8_t(s >> (8 * i));
    }
    static constexpr int max_inputs = int(8 * sizeof(InputSet));
    uint8_t m_input_set[sizeof(InputSet)] = {};
 
    template <size_t N>
    static int ascending_parity(const std::array<size_t, N>& v)
    {
        int inversions = 0;
        for (size_t i = 0; i < N; ++i)
            for (size_t j = i + 1; j < N; ++j)
                if (v[i] > v[j]) ++inversions;
        return (inversions % 2 == 0) ? 1 : -1;
    }
 
    void set_orientation(int o)
    {
        m_orientation = int8_t(std::clamp(o, -max_orientation, max_orientation));
    }
 
    template <size_t N>
    int orientation_along(const std::array<size_t, N>& v) const
    {
        return m_orientation * ascending_parity(v);
    }
 
    template <size_t N>
    void set_orientation_along(const std::array<size_t, N>& v, int o)
    {
        set_orientation(o * ascending_parity(v));
    }
 
    void reset()
    {
        m_is_surface_fs = false;
        m_is_bbox_fs = -1;
        m_surface_class = 0;
        m_orientation = 0;
        set_input_set(0);
    }
 
    void merge(const SurfaceTagAttributes& attr)
    {
        m_is_surface_fs = m_is_surface_fs || attr.m_is_surface_fs;
        if (attr.m_is_bbox_fs >= 0) m_is_bbox_fs = attr.m_is_bbox_fs;
        if (attr.m_surface_class != 0) m_surface_class = attr.m_surface_class;
        set_input_set(input_set() | attr.input_set());
    }
};
 
static_assert(
    sizeof(SurfaceTagAttributes) == 3 + sizeof(InputSet),
    "keep the surface tags byte-sized");
 
} // namespace wmtk