Method compute

tools/Wires/Attributes/WireEdgePeriodicIndexAttribute.cpp:61–119

using namespace WireEdgePeriodicIndexAttributeHelper;

void WireEdgePeriodicIndexAttribute::compute(const WireNetwork& network) {
    const Float EPS = 1e-6;
    const size_t num_vertices = network.get_num_vertices();
    const size_t num_edges = network.get_num_edges();
    const MatrixFr& vertices = network.get_vertices();
    const MatrixIr& edges = network.get_edges();

    const VectorF bbox_min = vertices.colwise().minCoeff();
    const VectorF bbox_max = vertices.colwise().maxCoeff();
    const VectorF bbox_size = bbox_max - bbox_min;

    std::vector<bool> on_min_border(num_vertices, false);
    HashGrid::Ptr grid = HashGrid::create(EPS, network.get_dim());
    for (size_t i=0; i<num_vertices; i++) {
        const VectorF& v = vertices.row(i);
        grid->insert(i, v);
        if ((v-bbox_min).cwiseAbs().minCoeff() < EPS) {
            on_min_border[i] = true;
        }
    }

    m_values.resize(num_edges, 1);
    DupletMap<size_t> edge_map;
    for (size_t i=0; i<num_edges; i++) {
        const VectorI& edge = edges.row(i);
        Duplet key(edge[0], edge[1]);
        edge_map.insert(key, i);
        m_values(i, 0) = i;
    }

    FunctionList transforms = get_periodic_transforms(bbox_size);

    for (auto transform : transforms) {
        for (size_t i=0; i<num_edges; i++) {
            const VectorI& edge = edges.row(i);
            if (on_min_border[edge[0]] || on_min_border[edge[1]]) {
                VectorF v0 = transform(vertices.row(edge[0]));
                VectorF v1 = transform(vertices.row(edge[1]));

                VectorI opposite_v0_index = grid->get_items_near_point(v0);
                VectorI opposite_v1_index = grid->get_items_near_point(v1);
                if (opposite_v0_index.size() != 1 ||
                        opposite_v1_index.size() != 1) { continue; }

                Duplet key(opposite_v0_index[0], opposite_v1_index[0]);
                auto itr = edge_map.find(key);
                if (itr != edge_map.end()) {
                    if (itr->second.size() != 1) {
                        throw RuntimeError("Duplicated edge detected");
                    }
                    size_t j = itr->second[0];
                    size_t label = std::min(m_values(i, 0), m_values(j, 0));
                    m_values(i, 0) = label;
                    m_values(j, 0) = label;
                }
            }
        }
    }