Function resolve_intersection_point_descriptor

source/kernel.cpp:1194–1407

point an intersection halfedge to the correct instance of an intersection point

// point an intersection halfedge to the correct instance of an intersection point
vd_t resolve_intersection_point_descriptor(
    const hmesh_t& ps,
    const hmesh_t& m0,
    hmesh_t& m1,
    const hd_t& m0_h,
    const vd_t& m0_h_tgt,
    const vd_t& m1_h_tgt,
    const bool m0_h_is_ox,
    /*const*/ std::vector<std::vector<int>>& m0_h_to_ply,
    /*const*/ std::unordered_map<vd_t, std::vector<hd_t>>& ivtx_to_incoming_hlist,
    /*const*/ std::unordered_map<hd_t, bool>& m0_sm_ihe_to_flag,
    const std::vector<std::pair<ed_t, fd_t>>& m0_ivtx_to_intersection_registry_entry,
    /*const*/ std::unordered_map<hd_t, hd_t>& m0_to_m1_ihe,
    // const std::map<vd_t, vd_t> &m0_to_ps_vtx,
    const std::vector<vd_t>& m0_to_ps_vtx,
    const int ps_vtx_cnt,
    const int sm_vtx_cnt,
    const int sm_face_count,
    const int m0_num_cutpath_halfedges)
{
    // the descriptor instance we want to return
    vd_t resolved_inst = m1_h_tgt;

    // First, we get list of all other halfedges in (in "m0") whose target-vertex
    // is the same as the target of the current halfedge
    const std::vector<hd_t>& incoming = SAFE_ACCESS(ivtx_to_incoming_hlist, m0_h_tgt);

    // the minimum number of halfedges whose target is "m0_h_tgt"
    // this "minimum" case come from interior edges
    MCUT_ASSERT(incoming.size() >= 2);

    // Second, we will now filter "incoming" (those pointing to "m0_h_tgt") by
    // keeping only the halfedges which are:
    // 1) Processed/transformed (so that we can use it to infer what to do with "resolved_inst")
    // 2) are incident to a traced polygon, and
    // 3) used by a traced polygon of the src-mesh
    //
    // The remaining halfedges will be the ones we can use to infer the correct value of "resolved_inst"

    std::vector<hd_t> halfedges_across_cut_path = incoming;

    // for each halfedge across the cut-path
    for (std::vector<hd_t>::iterator halfedge_across_cut_path_iter = halfedges_across_cut_path.begin();
         halfedge_across_cut_path_iter != halfedges_across_cut_path.end();) {

        const vd_t s = m0.source(*halfedge_across_cut_path_iter);
        const vd_t t = m0.target(*halfedge_across_cut_path_iter);
        const bool s_is_ivtx = m0_is_intersection_point(s, ps_vtx_cnt);
        const bool t_is_ivtx = m0_is_intersection_point(t, ps_vtx_cnt);

        // check if the halfedge is only next to the cut-mesh

        const bool is_ox_cs_h = (!s_is_ivtx && ps_is_cutmesh_vertex(SAFE_ACCESS(m0_to_ps_vtx, s), sm_vtx_cnt));
        const bool is_xo_cs_h = (!t_is_ivtx && ps_is_cutmesh_vertex(SAFE_ACCESS(m0_to_ps_vtx, t), sm_vtx_cnt));
        bool is_strictly_cs_h = is_ox_cs_h || is_xo_cs_h; // check if halfedge is used only by a cut-surface polygon
        const bool is_xx = s_is_ivtx && t_is_ivtx;

        if (!is_strictly_cs_h && is_xx) {