Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.5

0.7.5 / src / geometries / polygon / subset.lucb

## Face subsets: Blast, Delete and component filtering. The kept faces keep
## their corner order, display triangles, normals (authored N included) and
## attributes; points no kept face uses are dropped. Every array is gathered
## in parallel: a subset of a 700k-face mesh costs a few milliseconds.

extend Mesh:
    func kept_faces(keep: Bits) -> interop.Reference[Mesh]!:
        let faces = self.offsets.count() - 1
        if keep.count != faces: error(errors.invalid, "face bits must cover the faces")
        if keep.population() == faces: return try self.snapshot()
        return try adopt_storage(try self.subset_storage(keep))

    ## Every face kept, the points no face uses dropped (the rest renumbered
    ## in order).
    pub func compacted() -> interop.Reference[Mesh]!:
        var all = try BitsBuilder.zeros(self.offsets.count() - 1)
        defer all.close()
        all.invert()
        return try adopt_storage(try self.subset_storage(all.view()))

    ## `faces` removed (or, with `keep`, only they kept); Luce's Blast/Delete.
    pub func without_faces(faces: const i64[], keep: bool = false) -> interop.Reference[Mesh]!:
        let count = self.offsets.count() - 1
        var bits = try BitsBuilder.zeros(count)
        defer bits.close()
        for face in faces:
            try checked(face, count)
            bits.set((usize)face)
        if not keep: bits.invert()
        return try self.kept_faces(bits.view())

    func subset_storage(keep: Bits) -> Mesh*!:
        let offsets = self.offsets.view()
        let corners = self.corners.view()
        let faces = offsets.length - 1
        # Output faces and corners in order: a serial prefix over faces.
        let face_map = try new i32[faces] --- in memory.heap
        defer free(face_map) in memory.heap
        var face_total: usize = 0
        var corner_total: usize = 0
        for face in 0..<faces:
            if keep.get(face):
                face_map[face] = (i32)face_total
                face_total += 1
                corner_total += (usize)(offsets[face + 1] - offsets[face])
            else:
                face_map[face] = -1
        # Points any kept face uses, numbered in point order.
        let points = self.positions.count()
        let point_map = try new i32[points] --- in memory.heap
        defer free(point_map) in memory.heap
        memory.set(u8[]((u8*)point_map.data, points * 4), 0)
        for face in 0..<faces:
            if face_map[face] < 0: continue
            for corner in (usize)offsets[face]..<(usize)offsets[face + 1]:
                point_map[(usize)corners[corner]] = 1
        var point_total: usize = 0
        for point in 0..<points:
            if point_map[point] != 0:
                point_map[point] = (i32)point_total
                point_total += 1
            else:
                point_map[point] = -1
        var point_parents = try Column[i32].allocate(point_total)
        defer point_parents.release()
        var face_parents = try Column[i32].allocate(face_total)
        defer face_parents.release()
        var corner_parents = try Column[i32].allocate(corner_total)
        defer corner_parents.release()
        var new_offsets = try Column[i32].allocate(face_total + 1)
        defer new_offsets.release()
        let pp = point_parents.span()
        for point in 0..<points:
            if point_map[point] >= 0: pp[(usize)point_map[point]] = (i32)point
        let fp = face_parents.span()
        let no = new_offsets.span()
        var at: i32 = 0
        for face in 0..<faces:
            if face_map[face] < 0: continue
            let slot = (usize)face_map[face]
            fp[slot] = (i32)face
            no[slot] = at
            at += offsets[face + 1] - offsets[face]
        no[face_total] = at
        var new_corners = try Column[i32].allocate(corner_total)
        defer new_corners.release()
        var new_triangles = try Column[i32].allocate((corner_total - face_total * 2) * 3)
        defer new_triangles.release()
        var new_normals = try Column[Float3].allocate(face_total)
        defer new_normals.release()
        var new_positions = try Column[Float3].allocate(point_total)
        defer new_positions.release()
        var exact: Column[Vector3]
        if self.is_precise(): exact = try Column[Vector3].allocate(point_total)
        defer exact.release()
        var work = SubsetWork(offsets, corners, self.triangles.view(), self.normals.view(), self.positions.view(), self.precise.view(),
                              face_parents.view(), no, point_map, point_parents.view(), new_corners.span(), corner_parents.span(), new_triangles.span(), new_normals.span(), new_positions.span(), exact.span())
        try parallel.for_each_range(face_total, 4096, (void*)&work, subset_faces)
        try parallel.for_each_range(point_total, 65536, (void*)&work, subset_points)
        let storage = try assembled(new_positions.take(), self.origin, new_offsets.take(), new_corners.take(), new_triangles.take(), new_normals.take(), exact.take())
        errdefer dispose_detached(storage)
        try self.transfer_attributes(storage, point_parents.view(), face_parents.view(), corner_parents.view(), true)
        return storage

struct SubsetWork:
    let offsets: const i32[]
    let corners: const i32[]
    let triangles: const i32[]
    let normals: const Float3[]
    let positions: const Float3[]
    let exact: const Vector3[]
    let face_parents: const i32[]
    let new_offsets: const i32[]
    let point_map: const i32[]
    let point_parents: const i32[]
    let out_corners: i32[]
    let corner_parents: i32[]
    let out_triangles: i32[]
    let out_normals: Float3[]
    let out_positions: Float3[]
    let out_exact: Vector3[]

func subset_faces(context: void*, first: usize, end: usize, worker: usize):
    let work = (SubsetWork*)context
    for face in first..<end:
        let old = (usize)work.face_parents[face]
        let start = (usize)work.offsets[old]
        let count = (usize)work.offsets[old + 1] - start
        let target = (usize)work.new_offsets[face]
        for at in 0..<count:
            work.out_corners[target + at] = work.point_map[(usize)work.corners[start + at]]
            work.corner_parents[target + at] = (i32)(start + at)
        # Triangles index corners: shift them from the old face's to the new.
        let from_triangle = (start - old * 2) * 3
        let to_triangle = (target - face * 2) * 3
        let shift = (i32)target - (i32)start
        for at in 0..<(count - 2) * 3:
            work.out_triangles[to_triangle + at] = work.triangles[from_triangle + at] + shift
        work.out_normals[face] = work.normals[old]

func subset_points(context: void*, first: usize, end: usize, worker: usize):
    let work = (SubsetWork*)context
    for point in first..<end:
        let old = (usize)work.point_parents[point]
        work.out_positions[point] = work.positions[old]
        if work.out_exact.length > 0: work.out_exact[point] = work.exact[old]

## The faces of `mesh` whose bits are set in `keep` (bits over the faces),
## with the points they use; the same mesh (shared) when every face is kept.
## Heap storage of `mesh` with every face kept and the points no face uses
## dropped (the rest renumbered in order): the polygons a Code run added on a
## point cloud, as a mesh of their own points.
pub func compacted_storage(mesh: const Mesh*) -> Mesh*!:
    var all = try BitsBuilder.zeros(mesh.offsets.count() - 1)
    defer all.close()
    all.invert()
    return try mesh.subset_storage(all.view())

pub func kept_faces(mesh: const Mesh*, keep: Bits) -> interop.Reference[Mesh]!:
    return try mesh.kept_faces(keep)