mesh_split_edges.cc

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#include "BLI_array_utils.hh"
#include "BLI_index_mask.hh"
#include "BLI_ordered_edge.hh"
 
#include "BKE_attribute.hh"
#include "BKE_attribute_math.hh"
#include "BKE_customdata.hh"
#include "BKE_mesh.hh"
#include "BKE_mesh_mapping.hh"
 
#include "GEO_mesh_split_edges.hh"
#include "GEO_randomize.hh"
 
namespace blender::geometry {
 
static void propagate_vert_attributes(Mesh &mesh, const Span<int> new_to_old_verts_map)
{
  /* These types aren't supported for interpolation below. */
  CustomData_free_layers(&mesh.vert_data, CD_SHAPEKEY, mesh.verts_num);
  CustomData_free_layers(&mesh.vert_data, CD_CLOTH_ORCO, mesh.verts_num);
  CustomData_free_layers(&mesh.vert_data, CD_MVERT_SKIN, mesh.verts_num);
  CustomData_realloc(
      &mesh.vert_data, mesh.verts_num, mesh.verts_num + new_to_old_verts_map.size());
  mesh.verts_num += new_to_old_verts_map.size();
 
  bke::MutableAttributeAccessor attributes = mesh.attributes_for_write();
  for (const StringRef id : attributes.all_ids()) {
    if (attributes.lookup_meta_data(id)->domain != bke::AttrDomain::Point) {
      continue;
    }
    bke::GSpanAttributeWriter attribute = attributes.lookup_for_write_span(id);
    if (!attribute) {
      continue;
    }
 
    bke::attribute_math::gather(attribute.span,
                                new_to_old_verts_map,
                                attribute.span.take_back(new_to_old_verts_map.size()));
 
    attribute.finish();
  }
  if (float3 *orco = static_cast<float3 *>(
          CustomData_get_layer_for_write(&mesh.vert_data, CD_ORCO, mesh.verts_num)))
  {
    array_utils::gather(Span(orco, mesh.verts_num),
                        new_to_old_verts_map,
                        MutableSpan(orco, mesh.verts_num).take_back(new_to_old_verts_map.size()));
  }
  if (int *orig_indices = static_cast<int *>(
          CustomData_get_layer_for_write(&mesh.vert_data, CD_ORIGINDEX, mesh.verts_num)))
  {
    array_utils::gather(
        Span(orig_indices, mesh.verts_num),
        new_to_old_verts_map,
        MutableSpan(orig_indices, mesh.verts_num).take_back(new_to_old_verts_map.size()));
  }
}
 
static void propagate_edge_attributes(Mesh &mesh, const Span<int> new_to_old_edge_map)
{
  CustomData_free_layers(&mesh.edge_data, CD_FREESTYLE_EDGE, mesh.edges_num);
  CustomData_realloc(&mesh.edge_data, mesh.edges_num, mesh.edges_num + new_to_old_edge_map.size());
  mesh.edges_num += new_to_old_edge_map.size();
 
  bke::MutableAttributeAccessor attributes = mesh.attributes_for_write();
  for (const StringRef id : attributes.all_ids()) {
    if (attributes.lookup_meta_data(id)->domain != bke::AttrDomain::Edge) {
      continue;
    }
    if (id == ".edge_verts") {
      /* Edge vertices are updated and combined with new edges separately. */
      continue;
    }
    bke::GSpanAttributeWriter attribute = attributes.lookup_for_write_span(id);
    if (!attribute) {
      continue;
    }
    bke::attribute_math::gather(
        attribute.span, new_to_old_edge_map, attribute.span.take_back(new_to_old_edge_map.size()));
    attribute.finish();
  }
 
  if (int *orig_indices = static_cast<int *>(
          CustomData_get_layer_for_write(&mesh.edge_data, CD_ORIGINDEX, mesh.edges_num)))
  {
    array_utils::gather(
        Span(orig_indices, mesh.edges_num),
        new_to_old_edge_map,
        MutableSpan(orig_indices, mesh.edges_num).take_back(new_to_old_edge_map.size()));
  }
}
 
static IndexMask vert_selection_from_edge(const Span<int2> edges,
                                          const IndexMask &selected_edges,
                                          const int verts_num,
                                          IndexMaskMemory &memory)
{
  Array<bool> array(verts_num, false);
  selected_edges.foreach_index_optimized<int>(GrainSize(4096), [&](const int i) {
    array[edges[i][0]] = true;
    array[edges[i][1]] = true;
  });
  return IndexMask::from_bools(array, memory);
}
 
static BitVector<> selection_to_bit_vector(const IndexMask &selection, const int total_size)
{
  BitVector<> bits(total_size);
  selection.to_bits(bits);
  return bits;
}
 
static int corner_on_edge_connected_to_vert(const Span<int> corner_verts,
                                            const int corner,
                                            const IndexRange face,
                                            const int vert)
{
  if (corner_verts[corner] == vert) {
    return corner;
  }
  const int other = bke::mesh::face_corner_next(face, corner);
  BLI_assert(corner_verts[other] == vert);
  return other;
}
 
using CornerGroup = Vector<int>;
 
static Vector<CornerGroup> calc_corner_groups_for_vertex(const OffsetIndices<int> faces,
                                                         const Span<int> corner_verts,
                                                         const Span<int> corner_edges,
                                                         const GroupedSpan<int> edge_to_corner_map,
                                                         const Span<int> corner_to_face_map,
                                                         const BitSpan split_edges,
                                                         const Span<int> connected_corners,
                                                         const int vert)
{
  Vector<CornerGroup> groups;
  /* Each corner should only be added to a single group. */
  BitVector<> used_corners(connected_corners.size());
  for (const int start_corner : connected_corners) {
    CornerGroup group;
    Vector<int> corner_stack({start_corner});
    while (!corner_stack.is_empty()) {
      const int corner = corner_stack.pop_last();
      const int i = connected_corners.first_index(corner);
      if (used_corners[i]) {
        continue;
      }
      used_corners[i].set();
      group.append(corner);
      const int face = corner_to_face_map[corner];
      const int prev_corner = bke::mesh::face_corner_prev(faces[face], corner);
      /* Travel across the two edges neighboring this vertex, if they aren't split. */
      for (const int edge : {corner_edges[corner], corner_edges[prev_corner]}) {
        if (split_edges[edge]) {
          continue;
        }
        for (const int other_corner : edge_to_corner_map[edge]) {
          const int other_face = corner_to_face_map[other_corner];
          if (other_face == face) {
            /* Avoid continuing back to the same face. */
            continue;
          }
          const int neighbor_corner = corner_on_edge_connected_to_vert(
              corner_verts, other_corner, faces[other_face], vert);
          corner_stack.append(neighbor_corner);
        }
      }
    }
    if (!group.is_empty()) {
      groups.append(std::move(group));
    }
  }
 
  return groups;
}
 
/* Calculate groups of corners that are contiguously connected to each input vertex.
 * BLI_NOINLINE because MSVC 17.7 has a codegen bug here, given there is only a single call to this
 * function, not inlining it for all platforms won't affect performance. See
 * https://developercommunity.visualstudio.com/t/10448291 for details. */
BLI_NOINLINE static Array<Vector<CornerGroup>> calc_all_corner_groups(
    const OffsetIndices<int> faces,
    const Span<int> corner_verts,
    const Span<int> corner_edges,
    const GroupedSpan<int> vert_to_corner_map,
    const GroupedSpan<int> edge_to_corner_map,
    const Span<int> corner_to_face_map,
    const BitSpan split_edges,
    const IndexMask &affected_verts)
{
  Array<Vector<CornerGroup>> corner_groups(affected_verts.size(), NoInitialization());
  affected_verts.foreach_index(GrainSize(512), [&](const int vert, const int mask) {
    new (&corner_groups[mask])
        Vector<CornerGroup>(calc_corner_groups_for_vertex(faces,
                                                          corner_verts,
                                                          corner_edges,
                                                          edge_to_corner_map,
                                                          corner_to_face_map,
                                                          split_edges,
                                                          vert_to_corner_map[vert],
                                                          vert));
  });
  return corner_groups;
}
 
struct VertLooseEdges {
  Vector<int> selected;
  Vector<int> unselected;
};
 
static VertLooseEdges calc_vert_loose_edges(const GroupedSpan<int> vert_to_edge_map,
                                            const BitSpan loose_edges,
                                            const BitSpan split_edges,
                                            const int vert)
{
  VertLooseEdges info;
  for (const int edge : vert_to_edge_map[vert]) {
    if (loose_edges[edge]) {
      if (split_edges[edge]) {
        info.selected.append(edge);
      }
      else {
        info.unselected.append(edge);
      }
    }
  }
  return info;
}
 
static OffsetIndices<int> calc_vert_ranges_per_old_vert(
    const IndexMask &affected_verts,
    const Span<Vector<CornerGroup>> corner_groups,
    const GroupedSpan<int> vert_to_edge_map,
    const BitSpan loose_edges,
    const BitSpan split_edges,
    Array<int> &offset_data)
{
  offset_data.reinitialize(affected_verts.size() + 1);
  MutableSpan<int> new_verts_nums = offset_data;
  threading::parallel_for(affected_verts.index_range(), 2048, [&](const IndexRange range) {
    /* Start with -1 for the reused vertex. None of the final sizes should be negative. */
    new_verts_nums.slice(range).fill(-1);
    for (const int i : range) {
      new_verts_nums[i] += corner_groups[i].size();
    }
  });
  if (!loose_edges.is_empty()) {
    affected_verts.foreach_index(GrainSize(512), [&](const int vert, const int mask) {
      const VertLooseEdges info = calc_vert_loose_edges(
          vert_to_edge_map, loose_edges, split_edges, vert);
      new_verts_nums[mask] += info.selected.size();
      if (corner_groups[mask].is_empty()) {
        /* Loose edges share their vertex with a corner group if possible. */
        new_verts_nums[mask] += info.unselected.size() > 0;
      }
    });
  }
  return offset_indices::accumulate_counts_to_offsets(offset_data);
}
 
static void update_corner_verts(const int orig_verts_num,
                                const Span<Vector<CornerGroup>> corner_groups,
                                const OffsetIndices<int> new_verts_by_affected_vert,
                                MutableSpan<int> new_corner_verts)
{
  threading::parallel_for(corner_groups.index_range(), 512, [&](const IndexRange range) {
    for (const int new_vert : range) {
      const Span<CornerGroup> groups = corner_groups[new_vert];
      const IndexRange new_verts = new_verts_by_affected_vert[new_vert];
      for (const int group : groups.index_range().drop_back(1)) {
        const int new_vert = orig_verts_num + new_verts[group];
        new_corner_verts.fill_indices(groups[group].as_span(), new_vert);
      }
    }
  });
}
 
static OrderedEdge edge_from_corner(const OffsetIndices<int> faces,
                                    const Span<int> corner_verts,
                                    const Span<int> corner_to_face_map,
                                    const int corner)
{
  const int face = corner_to_face_map[corner];
  const int corner_next = bke::mesh::face_corner_next(faces[face], corner);
  return OrderedEdge(corner_verts[corner], corner_verts[corner_next]);
}
 
static Array<int2> calc_new_edges(const OffsetIndices<int> faces,
                                  const Span<int> corner_verts,
                                  const GroupedSpan<int> edge_to_corner_map,
                                  const Span<int> corner_to_face_map,
                                  const IndexMask &selected_edges,
                                  MutableSpan<int2> edges,
                                  MutableSpan<int> corner_edges,
                                  MutableSpan<int> r_new_edge_offsets)
{
  /* Calculate the offset of new edges assuming no new edges are identical and are merged. */
  selected_edges.foreach_index_optimized<int>(
      GrainSize(4096), [&](const int edge, const int mask) {
        r_new_edge_offsets[mask] = std::max<int>(edge_to_corner_map[edge].size() - 1, 0);
      });
  const OffsetIndices offsets = offset_indices::accumulate_counts_to_offsets(r_new_edge_offsets);
 
  Array<int2> new_edges(offsets.total_size());
 
  /* Count the number of final new edges per edge, to use as offsets if there are duplicates. */
  Array<int> num_edges_per_edge_merged(r_new_edge_offsets.size());
  std::atomic<bool> found_duplicate = false;
 
  /* The first new edge for each selected edge is reused-- we modify the existing edge in
   * place. Simply reusing the first new edge isn't enough because deduplication might make
   * multiple new edges reuse the original. */
  Array<bool> is_reused(corner_verts.size(), false);
 
  /* Calculate per-original split edge deduplication of new edges, which are stored by the
   * corner vertices of connected faces. Update corner verts to store the updated indices. */
  selected_edges.foreach_index(GrainSize(1024), [&](const int edge, const int mask) {
    if (edge_to_corner_map[edge].is_empty()) {
      /* Handle loose edges. */
      num_edges_per_edge_merged[mask] = 0;
      return;
    }
 
    const int new_edges_start = offsets[mask].start();
    Vector<OrderedEdge> deduplication;
    for (const int corner : edge_to_corner_map[edge]) {
      const OrderedEdge edge = edge_from_corner(faces, corner_verts, corner_to_face_map, corner);
      int index = deduplication.first_index_of_try(edge);
      if (UNLIKELY(index != -1)) {
        found_duplicate.store(true, std::memory_order_relaxed);
      }
      else {
        index = deduplication.append_and_get_index(edge);
      }
 
      if (index == 0) {
        is_reused[corner] = true;
      }
      else {
        corner_edges[corner] = edges.size() + new_edges_start + index - 1;
      }
    }
 
    const int new_edges_num = deduplication.size() - 1;
 
    edges[edge] = int2(deduplication.first().v_low, deduplication.first().v_high);
    new_edges.as_mutable_span()
        .slice(new_edges_start, new_edges_num)
        .copy_from(deduplication.as_span().drop_front(1).cast<int2>());
 
    num_edges_per_edge_merged[mask] = new_edges_num;
  });
 
  if (!found_duplicate) {
    /* No edges were merged, we can use the existing output array and offsets. */
    return new_edges;
  }
 
  /* Update corner edges to remove the "holes" left by merged new edges. */
  const OffsetIndices offsets_merged = offset_indices::accumulate_counts_to_offsets(
      num_edges_per_edge_merged);
  selected_edges.foreach_index(GrainSize(2048), [&](const int edge, const int mask) {
    const int difference = offsets[mask].start() - offsets_merged[mask].start();
    for (const int corner : edge_to_corner_map[edge]) {
      if (!is_reused[corner]) {
        corner_edges[corner] -= difference;
      }
    }
  });
 
  /* Create new edges without the empty slots for the duplicates */
  Array<int2> new_edges_merged(offsets_merged.total_size());
  threading::parallel_for(offsets_merged.index_range(), 1024, [&](const IndexRange range) {
    for (const int i : range) {
      new_edges_merged.as_mutable_span()
          .slice(offsets_merged[i])
          .copy_from(new_edges.as_span().slice(offsets[i].start(), offsets_merged[i].size()));
    }
  });
 
  r_new_edge_offsets.copy_from(num_edges_per_edge_merged);
  return new_edges_merged;
}
 
static void update_unselected_edges(const OffsetIndices<int> faces,
                                    const Span<int> corner_verts,
                                    const GroupedSpan<int> edge_to_corner_map,
                                    const Span<int> corner_to_face_map,
                                    const IndexMask &unselected_edges,
                                    MutableSpan<int2> edges)
{
  unselected_edges.foreach_index(GrainSize(1024), [&](const int edge) {
    const Span<int> edge_corners = edge_to_corner_map[edge];
    if (edge_corners.is_empty()) {
      return;
    }
    const int corner = edge_corners.first();
    const OrderedEdge new_edge = edge_from_corner(faces, corner_verts, corner_to_face_map, corner);
    edges[edge] = int2(new_edge.v_low, new_edge.v_high);
  });
}
 
static void swap_edge_vert(int2 &edge, const int old_vert, const int new_vert)
{
  if (edge[0] == old_vert) {
    edge[0] = new_vert;
  }
  else if (edge[1] == old_vert) {
    edge[1] = new_vert;
  }
}
 
static void reassign_loose_edge_verts(const int orig_verts_num,
                                      const IndexMask &affected_verts,
                                      const GroupedSpan<int> vert_to_edge_map,
                                      const BitSpan loose_edges,
                                      const BitSpan split_edges,
                                      const Span<Vector<CornerGroup>> corner_groups,
                                      const OffsetIndices<int> new_verts_by_affected_vert,
                                      MutableSpan<int2> edges)
{
  affected_verts.foreach_index(GrainSize(1024), [&](const int vert, const int mask) {
    const IndexRange new_verts = new_verts_by_affected_vert[mask];
    /* Account for the reuse of the original vertex by non-loose corner groups. In practice this
     * means using the new vertices for each split loose edge until we run out of new vertices.
     * We then expect the count to match up with the number of new vertices reserved by
     * #calc_vert_ranges_per_old_vert. */
    int new_vert_i = std::max<int>(corner_groups[mask].size() - 1, 0);
    if (new_vert_i == new_verts.size()) {
      return;
    }
    const VertLooseEdges vert_info = calc_vert_loose_edges(
        vert_to_edge_map, loose_edges, split_edges, vert);
    for (const int edge : vert_info.selected) {
      const int new_vert = orig_verts_num + new_verts[new_vert_i];
      swap_edge_vert(edges[edge], vert, new_vert);
      new_vert_i++;
      if (new_vert_i == new_verts.size()) {
        return;
      }
    }
    const int new_vert = orig_verts_num + new_verts[new_vert_i];
    for (const int orig_edge : vert_info.unselected) {
      swap_edge_vert(edges[orig_edge], vert, new_vert);
    }
  });
}
 
static Array<int> offsets_to_map(const IndexMask &mask, const OffsetIndices<int> offsets)
{
  Array<int> map(offsets.total_size());
  mask.foreach_index(GrainSize(1024), [&](const int i, const int mask) {
    map.as_mutable_span().slice(offsets[mask]).fill(i);
  });
  return map;
}
 
void split_edges(Mesh &mesh,
                 const IndexMask &selected_edges,
                 const bke::AttributeFilter & /*attribute_filter*/)
{
  const int orig_verts_num = mesh.verts_num;
  const Span<int2> orig_edges = mesh.edges();
  const OffsetIndices faces = mesh.faces();
 
  IndexMaskMemory memory;
  const IndexMask affected_verts = vert_selection_from_edge(
      orig_edges, selected_edges, orig_verts_num, memory);
  const BitVector<> selection_bits = selection_to_bit_vector(selected_edges, orig_edges.size());
  const bke::LooseEdgeCache &loose_edges = mesh.loose_edges();
 
  const GroupedSpan<int> vert_to_corner_map = mesh.vert_to_corner_map();
 
  Array<int> edge_to_corner_offsets;
  Array<int> edge_to_corner_indices;
  const GroupedSpan<int> edge_to_corner_map = bke::mesh::build_edge_to_corner_map(
      mesh.corner_edges(), orig_edges.size(), edge_to_corner_offsets, edge_to_corner_indices);
 
  Array<int> vert_to_edge_offsets;
  Array<int> vert_to_edge_indices;
  GroupedSpan<int> vert_to_edge_map;
  if (loose_edges.count > 0) {
    vert_to_edge_map = bke::mesh::build_vert_to_edge_map(
        orig_edges, orig_verts_num, vert_to_edge_offsets, vert_to_edge_indices);
  }
 
  const Array<int> corner_to_face_map = mesh.corner_to_face_map();
 
  const Array<Vector<CornerGroup>> corner_groups = calc_all_corner_groups(faces,
                                                                          mesh.corner_verts(),
                                                                          mesh.corner_edges(),
                                                                          vert_to_corner_map,
                                                                          edge_to_corner_map,
                                                                          corner_to_face_map,
                                                                          selection_bits,
                                                                          affected_verts);
 
  Array<int> vert_new_vert_offset_data;
  const OffsetIndices new_verts_by_affected_vert = calc_vert_ranges_per_old_vert(
      affected_verts,
      corner_groups,
      vert_to_edge_map,
      loose_edges.is_loose_bits,
      selection_bits,
      vert_new_vert_offset_data);
 
  MutableSpan<int> corner_verts = mesh.corner_verts_for_write();
  update_corner_verts(orig_verts_num, corner_groups, new_verts_by_affected_vert, corner_verts);
 
  Array<int> new_edge_offsets(selected_edges.size() + 1);
  Array<int2> new_edges = calc_new_edges(faces,
                                         corner_verts,
                                         edge_to_corner_map,
                                         corner_to_face_map,
                                         selected_edges,
                                         mesh.edges_for_write(),
                                         mesh.corner_edges_for_write(),
                                         new_edge_offsets);
  const IndexMask unselected_edges = selected_edges.complement(orig_edges.index_range(), memory);
  update_unselected_edges(faces,
                          corner_verts,
                          edge_to_corner_map,
                          corner_to_face_map,
                          unselected_edges,
                          mesh.edges_for_write());
 
  if (loose_edges.count > 0) {
    reassign_loose_edge_verts(orig_verts_num,
                              affected_verts,
                              vert_to_edge_map,
                              loose_edges.is_loose_bits,
                              selection_bits,
                              corner_groups,
                              new_verts_by_affected_vert,
                              mesh.edges_for_write());
  }
 
  const Array<int> edge_map = offsets_to_map(selected_edges, new_edge_offsets.as_span());
  propagate_edge_attributes(mesh, edge_map);
  mesh.edges_for_write().take_back(new_edges.size()).copy_from(new_edges);
 
  const Array<int> vert_map = offsets_to_map(affected_verts, new_verts_by_affected_vert);
  propagate_vert_attributes(mesh, vert_map);
 
  mesh.tag_edges_split();
 
  debug_randomize_vert_order(&mesh);
  debug_randomize_edge_order(&mesh);
}
 
}  // namespace blender::geometry