Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.1

0.9.1 / src / patch_density.lucb

## Surface-interior sampling requirements for one face's independent row grid.
## A curved interior with straight trims must not collapse to one planar quad.
import memory
from luce_std import math
from luce_geocore.geocore import Vector3
from brep_types import Curve, Surface, BrepFace
from mapped_patch import parameter, point
from patch_sides import PatchSides, patch_sides, side_count
from curve_spacing import ArcMetric, raise_side

## Raise opposite edge counts from sampled interior curvature, never lower them.
pub func patch_density(face: BrepFace, surface: Surface, edges: const Curve[], counts: usize[], metrics: const ArcMetric[], divisions: i64, tolerance: f64) -> !:
    if surface.kind != 3: return
    let sides = try patch_sides(face, surface, edges, tolerance)
    if not sides.valid: return
    let boundary = try new Vector3[36] --- in memory.heap
    defer free(boundary) in memory.heap
    var seed = Vector3(0.5, 0.5, 0.0)
    for side in 0..<(usize)4:
        for at in 0..<(usize)9:
            let t = (f64)at / 8.0
            seed = try parameter(surface, try side_position(face, sides, side, t, edges, counts, metrics), seed, tolerance)
            boundary[side * 9 + at] = seed
    let cosine = math.cos(0.75 * 2.0 * math.pi / (4.0 * (f64)divisions))
    for axis in 0..<(usize)2:
        var count: usize = 1
        while count < (usize)(divisions * 4):
            var accepted = true
            for cross in 0..<(usize)5:
                let other = ((f64)cross + 0.5) / 5.0
                let start = try sample_cross(surface, boundary, 0.0, other, axis)
                let end = try sample_cross(surface, boundary, 1.0, other, axis)
                let chord = math.max(tolerance, end.subtract(start).length() / ((f64)divisions * (f64)divisions * 16.0))
                for interval in 0..<count:
                    var p = [Vector3(), Vector3(), Vector3(), Vector3(), Vector3()]
                    for sample in 0..<(usize)5:
                        p[sample] = try sample_cross(surface, boundary, ((f64)interval + (f64)sample / 4.0) / (f64)count, other, axis)
                    let span = p[4].subtract(p[0])
                    var deflection: f64 = 0.0
                    for sample in 1..<(usize)4:
                        let t = math.clamp(p[sample].subtract(p[0]).dot(span) / span.dot(span), 0.0, 1.0) if span.dot(span) > 1e-30 else 0.0
                        deflection = math.max(deflection, p[sample].subtract(p[0].add(span.multiply_scalar(t))).length())
                    if deflection > chord: accepted = false
                    if deflection > tolerance:
                        for a in 0..<(usize)4:
                            for b in a + 1..<(usize)4:
                                let da = p[a + 1].subtract(p[a])
                                let db = p[b + 1].subtract(p[b])
                                if da.dot(db) < cosine * da.length() * db.length(): accepted = false
                if not accepted: break
            if accepted: break
            count = (usize)math.min((f64)(count * 2), (f64)(divisions * 4))
        for side in [axis, axis + 2]:
            raise_side(face, sides, side, counts, metrics, count)

func side_position(face: BrepFace, sides: PatchSides, side: usize, fraction: f64, edges: const Curve[], counts: const usize[], metrics: const ArcMetric[]) -> Vector3!:
    var position = fraction * (f64)side_count(face, sides, side, counts)
    for segment in 0..<sides.lengths[side]:
        let use = face.uses[(sides.starts[side] + segment) % face.uses.length]
        let count = (f64)counts[index(use)]
        if position <= count or segment + 1 == sides.lengths[side]:
            let t = math.clamp(position / count, 0.0, 1.0)
            return try edges[index(use)].at(metrics[index(use)].station(t if use > 0 else 1.0 - t))
        position -= count
    return Vector3()

func index(use: i64) -> usize:
    return (usize)(use - 1 if use > 0 else -use - 1)

func interpolate(boundary: const Vector3[], side: usize, fraction: f64) -> Vector3:
    let scaled = math.clamp(fraction, 0.0, 1.0) * 8.0
    let low = (usize)math.min(7.0, math.floor(scaled))
    let t = scaled - (f64)low
    return boundary[side * 9 + low].multiply_scalar(1.0 - t).add(boundary[side * 9 + low + 1].multiply_scalar(t))

func sample_cross(s: Surface, boundary: const Vector3[], along: f64, other: f64, axis: usize) -> Vector3!:
    let u = along if axis == 0 else other
    let v = other if axis == 0 else along
    let a = boundary[0]
    let b = boundary[8]
    let c = boundary[18]
    let d = boundary[27]
    let bilinear = a.multiply_scalar((1.0 - u) * (1.0 - v)).add(b.multiply_scalar(u * (1.0 - v))).add(c.multiply_scalar(u * v)).add(d.multiply_scalar((1.0 - u) * v))
    let uv = interpolate(boundary, 0, u).multiply_scalar(1.0 - v).add(interpolate(boundary, 2, 1.0 - u).multiply_scalar(v)).add(interpolate(boundary, 3, 1.0 - v).multiply_scalar(1.0 - u)).add(interpolate(boundary, 1, v).multiply_scalar(u)).subtract(bilinear)
    return try point(s, uv)