leibniz 0.1.0

The package provides a differentiable vector graphics rasterization loss.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

//! Linear winding contributions.

use ::burn::tensor::{Bool, Tensor, backend::Backend};

use crate::base::geometry::Indices;

use super::super::{contour, roots};
use super::{Values, segment_coordinate};

type Coefficients<B> = (Values<B>, Values<B>);

pub fn coefficients<B: Backend>(
    arguments: contour::Arguments<B>,
    indices: Indices,
) -> (Coefficients<B>, Coefficients<B>) {
    let start = indices.start();
    let end = indices.end();
    let x = point_coefficients(
        segment_coordinate(arguments.clone(), start, 0),
        segment_coordinate(arguments.clone(), end, 0),
    );
    let y = point_coefficients(
        segment_coordinate(arguments.clone(), start, 1),
        segment_coordinate(arguments, end, 1),
    );

    (x, y)
}

pub fn evaluate<B: Backend>(
    x_coefficients: Coefficients<B>,
    y_coefficients: Coefficients<B>,
    x: Values<B>,
    y: Values<B>,
) -> Values<B> {
    let (x1, x0) = x_coefficients;
    let (y1, y0) = y_coefficients;
    let roots = roots::linear::solve(y1.clone(), y0 - y);
    let x_offset = x - x0;
    let sign = y1.greater_elem(0.0).float() * 2.0 - 1.0;

    root_contribution(roots.t, roots.valid, x_offset, x1, sign)
}

fn point_coefficients<B: Backend>(p0: Values<B>, p1: Values<B>) -> Coefficients<B> {
    (p1 - p0.clone(), p0)
}

fn root_contribution<B: Backend>(
    t: Values<B>,
    valid: Tensor<B, 1, Bool>,
    x_offset: Values<B>,
    x_coefficient: Values<B>,
    sign: Values<B>,
) -> Values<B> {
    let curve_x = x_coefficient * t.clone();
    let valid = valid
        .bool_and(t.clone().greater_equal_elem(0.0))
        .bool_and(t.lower_equal_elem(1.0))
        .bool_and(curve_x.greater(x_offset));

    valid.float() * sign
}