dymokomi/luce-geocore
Source of release 0.7.7
0.7.7 / src / selecting / convert.lucb
## Selection kernels over a mesh's connectivity: converting bits between the
## point, corner, face and edge domains, and growing, shrinking, bordering
## and flood filling (the walkers are walkers.lucb). They read the topology
## caches (edges, point-face, point-edge and edge-corner lists), which every
## mesh with the same connectivity shares, and write fresh bits.
## Bits of `source` elements converted to `destination` elements. With `all`, an element
## is selected when every related element is (a face whose points all are);
## otherwise when any is (a point of any selected face). Faces relate to
## their corners, points and edges; edges to their two points, their corners
## and their faces; corners to their point, face and edge.
pub func converted(topology: const Topology*, bits: Bits, source: Domain, destination: Domain, all: bool) -> BitsBuilder!:
let size = topology.size(destination)
var out = try BitsBuilder.zeros(size)
errdefer out.close()
if source == destination:
memory.copy(out.words(), bits.words, bits.words.length)
return out
if source == Domain.detail:
if bits.get(0): out.set_range(0, size)
return out
if destination == Domain.detail:
if (all and bits.population() == bits.count) or (not all and bits.any()): out.set(0)
return out
let hits = try new u32[size] --- in memory.heap
defer free(hits) in memory.heap
let totals = try new u32[size] --- in memory.heap
defer free(totals) in memory.heap
memory.set(u8[]((u8*)hits.data, size * 4), 0)
memory.set(u8[]((u8*)totals.data, size * 4), 0)
# Every relation is a list of (from, to) pairs over corners or edges.
if (source == Domain.point and destination == Domain.edge) or (source == Domain.edge and destination == Domain.point):
for edge in 0..<topology.edges():
for side in 0..<(usize)2:
let point = (usize)topology.edge_points[edge * 2 + side]
relate(bits, source == Domain.point, point, edge, hits, totals)
else:
for corner in 0..<topology.corners.length:
let a = element_of(topology, corner, source)
let b = element_of(topology, corner, destination)
let target = b
totals[target] += 1
if bits.get(a): hits[target] += 1
for element in 0..<size:
if totals[element] > 0 and (hits[element] == totals[element] if all else hits[element] > 0): out.set(element)
return out
## Count one (point, edge) relation in the direction of the conversion.
func relate(bits: Bits, point_first: bool, point: usize, edge: usize, hits: u32[], totals: u32[]):
let source = point if point_first else edge
let target = edge if point_first else point
totals[target] += 1
if bits.get(source): hits[target] += 1
## The element of `domain` a corner belongs to.
func element_of(topology: const Topology*, corner: usize, domain: Domain) -> usize:
match domain:
.point: return (usize)topology.corners[corner]
.face: return (usize)topology.corner_faces[corner]
.edge: return (usize)topology.corner_edges[corner]
_: return corner
## Neighbors across the domain's connector: faces through edges, points and
## edges through points, corners through points.
func connector(domain: Domain) -> Domain:
return Domain.edge if domain == Domain.face else Domain.point
## Neighbors across faces instead (Blender's face step): faces through
## their points, points and edges through their faces.
func face_step_connector(domain: Domain) -> Domain:
return Domain.point if domain == Domain.face else Domain.face
## `bits` and every element next to one of them, `steps` times.
pub func grown(topology: const Topology*, bits: Bits, domain: Domain, steps: usize) -> BitsBuilder!:
return try grown_through(topology, bits, domain, connector(domain), steps)
## `bits` and every element sharing a `link` element with one, `steps`
## times.
pub func grown_through(topology: const Topology*, bits: Bits, domain: Domain, link: Domain, steps: usize) -> BitsBuilder!:
var current = try BitsBuilder.copy_of(bits)
errdefer current.close()
for _ in 0..<steps:
var linked = try converted(topology, current.view(), domain, link, false)
defer linked.close()
var next = try converted(topology, linked.view(), link, domain, false)
current.close()
current = next
return current
## `bits` without the elements next to an unselected one, `steps` times.
pub func shrunk(topology: const Topology*, bits: Bits, domain: Domain, steps: usize) -> BitsBuilder!:
return try shrunk_through(topology, bits, domain, connector(domain), steps)
## `bits` without the elements sharing a `link` element with an
## unselected one, `steps` times.
pub func shrunk_through(topology: const Topology*, bits: Bits, domain: Domain, link: Domain, steps: usize) -> BitsBuilder!:
var current = try BitsBuilder.copy_of(bits)
errdefer current.close()
for _ in 0..<steps:
var outside = try BitsBuilder.copy_of(current.view())
defer outside.close()
outside.invert()
var reach = try grown_through(topology, outside.view(), domain, link, 1)
defer reach.close()
current.subtract(reach.view())
return current
## The selected elements next to an unselected one.
pub func bordered(topology: const Topology*, bits: Bits, domain: Domain) -> BitsBuilder!:
var outside = try BitsBuilder.copy_of(bits)
defer outside.close()
outside.invert()
var reach = try grown(topology, outside.view(), domain, 1)
errdefer reach.close()
reach.intersect(bits)
return reach
## Everything connected to `bits`: a breadth-first flood over faces sharing
## edges, or points and edges sharing points (corners through their points).
pub func connected(topology: const Topology*, bits: Bits, domain: Domain) -> BitsBuilder!:
if domain == Domain.corner or domain == Domain.detail:
var points = try converted(topology, bits, domain, Domain.point, false)
defer points.close()
var filled = try connected(topology, points.view(), Domain.point)
defer filled.close()
return try converted(topology, filled.view(), Domain.point, domain, false)
var out = try BitsBuilder.copy_of(bits)
errdefer out.close()
let queue = try new u32[topology.size(domain)] --- in memory.heap
defer free(queue) in memory.heap
var head: usize = 0
var tail: usize = 0
for word in 0..<bits.words.length:
var pending = bits.words[word]
while pending != 0:
queue[tail] = (u32)(word * 64 + (usize)trailing_zeros(pending))
tail += 1
pending = pending & (pending - 1)
while head < tail:
let element = (usize)queue[head]
head += 1
if domain == Domain.face:
for corner in (usize)topology.offsets[element]..<(usize)topology.offsets[element + 1]:
let edge = (usize)topology.corner_edges[corner]
for at in (usize)topology.edge_corner_offsets[edge]..<(usize)topology.edge_corner_offsets[edge + 1]:
let face = (usize)topology.corner_faces[(usize)topology.edge_corners[at]]
if not out.view().get(face):
out.set(face)
queue[tail] = (u32)face
tail += 1
else:
# Points reach points through their edges; edges reach edges
# through their points.
let ends: usize[2] = [element, 0] if domain == Domain.point else [(usize)topology.edge_points[element * 2], (usize)topology.edge_points[element * 2 + 1]]
let count: usize = 1 if domain == Domain.point else 2
for side in 0..<count:
let point = ends[side]
for at in (usize)topology.point_edge_offsets[point]..<(usize)topology.point_edge_offsets[point + 1]:
let edge = (usize)topology.point_edges[at]
var next = edge
if domain == Domain.point:
let a = (usize)topology.edge_points[edge * 2]
next = (usize)topology.edge_points[edge * 2 + 1] if a == point else a
if not out.view().get(next):
out.set(next)
queue[tail] = (u32)next
tail += 1
return out
let convert_parms: ParmSpec[2] = [
ParmSpec("To", ParmKind.menu, 2.0, 0.0, 2.0, 1, "Points|Edges|Faces", "The component type the selection becomes."),
ParmSpec("Rule", ParmKind.menu, 0.0, 0.0, 1.0, 1, "Touching|Contained", "Touching: every element the selection touches. Contained: only those all of whose points, edges or faces are selected.")]
func convert_rule() -> SelectRule:
return SelectRule("Select Convert", "Convert", "", "The selection as points, edges or faces: those it touches, or only those it contains (Maya's Convert Selection)", "Convert", "select-convert",
"points edges faces", any_picks, convert_parms, select_convert)
func select_convert(input: const RuleInput*) -> RuleOutput!:
let targets: Domain[3] = [Domain.point, Domain.edge, Domain.face]
let target = targets[(usize)math.clamp(input.parms.at(0), 0.0, 2.0)]
return RuleOutput(try converted(input.topology, input.group, input.domain, target, input.parms.at(1) != 0.0), target)