HashEdge Struct Reference

Collaboration diagram for HashEdge:

Public Member Functions
bool	operator== (const HashEdge &rhs) const
bool	operator!= (const HashEdge &rhs) const
int	hash (int M) const
void	load_exact (stl_file *stl, const stl_vertex *a, const stl_vertex *b)
bool	load_nearby (const stl_file *stl, const stl_vertex &a, const stl_vertex &b, float tolerance)

Public Attributes
uint32_t	key [6]
int	facet_number
int	which_edge
HashEdge *	next

Private Member Functions
bool	vertex_lower (const stl_vertex &a, const stl_vertex &b)

Detailed Description

Member Function Documentation

hash()

int HashEdge::hash ( int  M ) const

inline

{ return ((key[0] / 11 + key[1] / 7 + key[2] / 3) ^ (key[3] / 11  + key[4] / 7 + key[5] / 3)) % M; }

References key.

Referenced by HashTableEdges::insert_edge().

Here is the caller graph for this function:

load_exact()

void HashEdge::load_exact ( stl_file *  stl, const stl_vertex *  a, const stl_vertex *  b  )

inline

  {
    {
        stl_vertex diff = (*a - *b).cwiseAbs();
        float max_diff = std::max(diff(0), std::max(diff(1), diff(2)));
        stl->stats.shortest_edge = std::min(max_diff, stl->stats.shortest_edge);
      }
 
      // Ensure identical vertex ordering of equal edges.
      // This method is numerically robust.
      if (vertex_lower(*a, *b)) {
      } else {
        // This edge is loaded backwards.
        std::swap(a, b);
        this->which_edge += 3;
      }
      memcpy(&this->key[0], a->data(), sizeof(stl_vertex));
      memcpy(&this->key[3], b->data(), sizeof(stl_vertex));
      // Switch negative zeros to positive zeros, so memcmp will consider them to be equal.
      for (size_t i = 0; i < 6; ++ i) {
        unsigned char *p = (unsigned char*)(this->key + i);
  #if BOOST_ENDIAN_LITTLE_BYTE
        if (p[0] == 0 && p[1] == 0 && p[2] == 0 && p[3] == 0x80)
            // Negative zero, switch to positive zero.
            p[3] = 0;
  #else /* BOOST_ENDIAN_LITTLE_BYTE */
        if (p[0] == 0x80 && p[1] == 0 && p[2] == 0 && p[3] == 0)
            // Negative zero, switch to positive zero.
            p[0] = 0;
  #endif /* BOOST_ENDIAN_LITTLE_BYTE */
      }
  }

References cwiseAbs(), stl_stats::shortest_edge, stl_file::stats, and vertex_lower().

Referenced by stl_check_facets_exact(), and stl_fill_holes().

Here is the call graph for this function:

Here is the caller graph for this function:

load_nearby()

bool HashEdge::load_nearby ( const stl_file *  stl, const stl_vertex &  a, const stl_vertex &  b, float  tolerance  )

inline

  {
    // Index of a grid cell spaced by tolerance.
    typedef Eigen::Matrix<int32_t,  3, 1, Eigen::DontAlign> Vec3i;
    Vec3i vertex1 = ((a - stl->stats.min) / tolerance).cast<int32_t>();
    Vec3i vertex2 = ((b - stl->stats.min) / tolerance).cast<int32_t>();
    static_assert(sizeof(Vec3i) == 12, "size of Vec3i incorrect");
 
    if (vertex1 == vertex2)
      // Both vertices hash to the same value
      return false;
 
    // Ensure identical vertex ordering of edges, which vertices land into equal grid cells.
    // This method is numerically robust.
    if ((vertex1[0] != vertex2[0]) ? 
        (vertex1[0] < vertex2[0]) : 
        ((vertex1[1] != vertex2[1]) ? 
            (vertex1[1] < vertex2[1]) : 
            (vertex1[2] < vertex2[2]))) {
      memcpy(&this->key[0], vertex1.data(), sizeof(stl_vertex));
      memcpy(&this->key[3], vertex2.data(), sizeof(stl_vertex));
    } else {
      memcpy(&this->key[0], vertex2.data(), sizeof(stl_vertex));
      memcpy(&this->key[3], vertex1.data(), sizeof(stl_vertex));
      this->which_edge += 3; /* this edge is loaded backwards */
    }
    return true;
  }

References stl_stats::min, and stl_file::stats.

Referenced by stl_check_facets_nearby().

Here is the caller graph for this function:

operator!=()

bool HashEdge::operator!= ( const HashEdge &  rhs ) const

inline

{ return ! (*this == rhs); }

operator==()

bool HashEdge::operator== ( const HashEdge &  rhs ) const

inline

{ return memcmp(key, rhs.key, sizeof(key)) == 0; }

References key.

vertex_lower()

bool HashEdge::vertex_lower ( const stl_vertex &  a, const stl_vertex &  b  )

inlineprivate

                                                                     {
      return (a(0) != b(0)) ? (a(0) < b(0)) :
             ((a(1) != b(1)) ? (a(1) < b(1)) : (a(2) < b(2)));
  }

Referenced by load_exact().

Here is the caller graph for this function:

Member Data Documentation

facet_number

int HashEdge::facet_number

Referenced by HashTableEdges::edges_equal(), HashTableEdges::match_neighbors_nearby(), HashTableEdges::record_neighbors(), stl_check_facets_exact(), stl_check_facets_nearby(), and stl_fill_holes().

key

uint32_t HashEdge::key[6]

Referenced by hash(), and operator==().

next

HashEdge* HashEdge::next

Referenced by HashTableEdges::HashTableEdges(), HashTableEdges::~HashTableEdges(), and HashTableEdges::insert_edge().

which_edge

int HashEdge::which_edge

Referenced by HashTableEdges::match_neighbors_nearby(), HashTableEdges::record_neighbors(), stl_check_facets_exact(), stl_check_facets_nearby(), and stl_fill_holes().

---

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

• src/admesh/connect.cpp