SGP 2023 graduate school - A quick journey into geometry processing

01/07/2023
-
My goals
>1. Give you some pointers
>2. Give you some good « tricks »
3

01/07/2023
-
Syllabus
>1. The hitch hacker’s guide
to geometry processing
>2. Packing your luggage
>3. Finding your way
>4. Connecting with friends
>5. Into darkness
>6. Planning your next trip
4

01/07/2023
-
1. The hitch hacker’s guide to Geometry Proc.
> Activate ("Gray beard’s provocative introduction")
6

> 1. Hitch hacker’s guide to G.P.

1979 Apple ][
6502 processor, 1MHz
64Kb RAM
Approx. 10 FLOPs

1979 Apple ][
64Kb RAM
Approx. 10 FLOPs
2023 PC
Core i7 gen4, 3 GHz
16Gb RAM
Approx. 300 GFLOPs

1979 Apple ][
64Kb RAM
Approx. 10 FLOPs
2023 PC
Core i7 gen4, 3 GHz
16Gb RAM
Approx. 300 GFLOPs
X 3 million !!!!
44 years

Boots in 20 seconds Boots in 3 minutes

Where did the 3 million acceleration factor go ?

What can you do in 20 seconds ?
3 GHz, 4 cores = 240 billions instructions !!

If you cannot do the job in less than 20 seconds
on a modern PC, then there is probably a
problem somewhere
What can you do in 20 seconds ?
3 GHz, 4 cores = 240 billions instructions !!

Where did the 1 million acceleration factor go ?
- Lost in abstraction -

Abstraction in Programming:
+ Separates concepts
+ Separates specification from Implementation

Abstraction in Programming:
+ Separates concepts
+ Separates specification from Implementation
- Sometimes separates things
that should be considered together !!

Futuristic programming
Usefullness (and coolness) are primary !

• Jonathan Shewchuk s Triangle and exact predicates
• Tetgen, MGTetra, MMG3d
• Omar Cornut s ImGUI library
• David Mount s ANN library
• The LUA prog. language
Futuristic programming
Examples of Futuristic codes
Usefullness (and coolness) are primary !

Geogram/Graphite Programming Priorities
1. Make it as simple as possible (but not simpler)

2. Make it as easy to use as possible

3. Make it as easy to compile as possible

4. Maximize speed

4. Maximize speed
5. Minimize memory consumption

4. Maximize speed
6. Minimize number of lines of code

4. Maximize speed
7. Minimize number of C++ classes

4. Maximize speed
Simplicity is the
ultimate sophistication

4. Maximize speed
8. Systematically document all classes, all functions, [+Biblio.]
9. Systematically document the implementation of all algorithms
10. Assertion checks everywhere
11. Zero warnings with all compilers / platforms
12. Perform systematic non-regression testing and mem.
check.

01/07/2023
-
30
> 2. Packing your luggage ….

01/07/2023
-
31
…. data structures

From several Computer Graphics / Mesh Processing 101 courses
- including (earlier versions of) mine -

Halfedges Design Principles
1. Individual combinatorial elements
can be created/destroyed at any time
in constant time
2. Basic operations (collapse, split, )
3. Higher-level operations on top of them
Halfedges and edgeuses, harmful or useful ?

+ Benefit of abstraction: layered design
in constant time

- Separates things that should have been considered together
in constant time

- Separates things that should have been considered together
Not the optimal level of granularity
in constant time

Indexed Mesh data structure (no data structure)

Objection ! (?) Deletion of one individual element is O(n) instead of constant
In fact: deleting 1 element = wrong granularity level !

Deleting a bunch of elements

Deleting a bunch of elements – operates also in O(n) – right granularity

Deleting a bunch of elements – operates also in O(n) – right granularity
Needs array permutation (not in the STL unfortunately,
but easy to implement, see GEOGRAM::permutation).

Summary:
•An array of vertices coordinates
•An array of triangle vertices indices

•An array of vertices coordinates
•An array of triangle vertices indices
•An array of triangle adjacencies (optional)
•An array of facet first indices (optional)
Summary:

Benefits of such a
non-datastructure, non-object, non-oriented, (non-)programming
1. Simpler code

Benefits of such a
1. Simpler code
2. Less memory;

Benefits of such a
1. Simpler code
2. Less memory;
3. Parallelization #pragma omp parallel for

Benefits of such a
1. Simpler code
2. Less memory;
4. Easy copy: memcpy()

Benefits of such a
1. Simpler code
2. Less memory;
5. Easy I/O: fread()/fwrite()

Benefits of such a
1. Simpler code
2. Less memory;
6. Properties/attributes are simply additional arrays

Benefits of such a
1. Simpler code
2. Less memory;
6. Properties/attributes are simply additional arrays
7. Directly understood by OpenGL: VertexBufferObject

A mesh = a bunch of arrays (std::vectors)

How do you iterate on a vector ?

Pre-2011:
for(std::vector<Thing>::iterator it = V.begin(); it!=V.end(); ++it) {
do something with *it
}

Pre-2011:
}
It s a pain to type
Clutters the source-code (less legible)

Pre-2011:
}
2011:
for(auto it = V.begin(); it!=V.end(); ++it) {
}

Pre-2011:
}
2011:
}
now:
for(auto&& i : V) {
do something with i
} How do you iterate on a vector ?

Warning: flying tomatoes alert ahead,
(modern C++ lovers might throw tomatoes at me)
!

Pre-2011:
}
2011:
}
now:
for(auto&& i : V) {
do something with I
} How do you iterate on a vector ?

How I iterate on a vector:
for(uint i=0; i<V.size(); ++i) {
do something with V[i];
}

}
+ Easy to understand, even by C-only and Fortran programmers
+ Compatible with all compilers
+ #pragma omp parallel-for friendly* (and also better vectorization)
- 15 additional keystrokes as compared to modern C++ range-for
*But use ints instead of uints, omp does not like uints

}
+ Easy to understand, even by C-only programmers
+ #pragma omp parallel-for friendly
The following code has been approved for
APPROPRIATE AUDIENCES
PG-13

}
+ Easy to understand, even by C-only programmers
+ #pragma omp parallel-for friendly
#define FOR(i,N) for(uint i=0; i<(N); ++i)
FOR(i,V.size()) {
}
+ Easy to understand, legible
+ Trivial iterations easy to spot
- Macros are evil
[Nicolas Ray]

Objection:
It is bad because it is not flexible,
what if you want to adapt your algorithm to another container ?

Objection:
Answer:
I m not going to use something else than a vector, because it is the best
choice for the mesh data structure. Why keeping a tuning knob on the
dash board if it is always on the same position ?
modern/generic != futuristic

Objection:
Answer:
I m not going to use something else than a vector, because it is the best
choice for the mesh data structure. Why keeping a tuning knob on the
dash board if it is always on the same position ? (think of the I-Phone)
The Nokia N95, a
modern/generic phone.
The I-phone,
a futuristic phone.

It is good because it has
everything that you need
The Nokia N95, a
The I-phone,
a futuristic phone.

It is even better because it has
nothing else than what you need
The Nokia N95, a
The I-phone,
a futuristic phone.

It is even better because it has
nothing else than what you need
Work is finished when you have
nothing to add and nothing to remove !
The Nokia N95, a
The I-phone,
a futuristic phone.

Why keeping a tuning knob on the dash board if it is always
on the same position ? (think of the I-Phone)
A parameter that always has the same value is not a parameter and should be
removed from the API.
A template that is instanced only once should not be a template.

Objection: but we loose genericity if we do that ???

Objection: but we loose genericity if we do that ???
Answer to objection: but we gain a lot, it declutters the
code, makes it more legible, reduces compilation times,
makes C++ compilation error messages more legible.

Rule of thumb:
Make it a parameter not before you need it with at least two different values.
Make it a template not before you need at least two different instanciations.
*regarding compilation time, legibiity of error messages and run-time flex.

Rule of thumb:
Make it a parameter not before you need it with at least two different values.
Make it a template not before you need at least two different instanciations.
About templates, consider less annoying* alternatives, such as
(1) object oriented programming / virtual functions
(2) or simply a parameter and if() statements
*regarding compilation time, legibility of error messages and run-time flex.

> 3. Finding your way….

…. Geometric search

Pointset processing

Transfer attributes
between meshes
(texture baking)

Raytracing with
meshes

How do you compute line-triangle intersection ?
[Moller Trumbore]
Google search “stack overflow intersection between line and triangle in 3D”,
See part 3 of the first answer, it is super well explained, I’m 100% objective :-)

Martin Carvaga
NVidia

NVidia
N1 N2 N3 N4 N5 N6 N7 01 02 03 04 05 06 07 08
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

NVidia
N1 N2 N3 N4 N5 N6 N7 01 02 03 04 05 06 07 08
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
left(n) = 2*n
right(n) = 2*n+1

NVidia
Triangles array

bool MeshFacetsAABB::ray_intersection_recursive(
const Ray& R, const vec3& dirinv, index_t n, index_t b, index_t e
) const
Node index
bbox[n]

) const
Facet sequence
[b, …, e-1]
Node index
bbox[n]

) const
Facet sequence
[b, …, e-1]
Node index
bbox[n]
Initialize traversal with (1, 0, nf)

) const {
if(!ray_box_intersection(R.origin, dirinv, bboxes_[n])) {
return false;
}
if(b + 1 == e) {
return ray_triangle_intersection(R.origin, R.direction, b);
}
index_t m = b + (e - b) / 2; index_t childl = 2 * n; index_t childr = 2 * n + 1;
return (
ray_intersection_recursive(R,dirinv,tmax,ignore_f, childl,b,m) ||
ray_intersection_recursive(R,dirinv,tmax,ignore_f, childr,m,e)
);
}

) const {
return false;
}
if(b + 1 == e) {
}
return (
);
}
Early skip
non-intersected boxes

) const {
return false;
}
if(b + 1 == e) {
}
return (
);
}
Leaves, with 1 triangle,
Compute ray-tri isect

) const {
return false;
}
if(b + 1 == e) {
}
return (
);
}
Recursive traversal

N1 N2 N3 N4 N5 N6 N7 01 02 03 04 05 06 07 08
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

N1 N2 N3 N4 N5 N6 N7 01 02 03 04 05 06 07 08
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Delage Devillers
Spatial sort in CGAL
std::nth_element()

Shadertoy
Geogram

Other topics on geometric search
AABB:
SAH (Surface Area Heuristic)
ZMAABB (Zero Memory) [Terdiman]
KdTrees
Pointsets, nearest neighbors queries

Other topics on geometric search
AABB:
SAH (Surface Area Heuristic)
ZMAABB (Zero Memory) [Terdiman]
KdTrees
Pointsets, nearest neighbors queries
Take home message:
Continuous arrays
As simple as possible
Only store what‟s necessary:
- permute elements of mesh
- plus a couple of additional arrays

>4. Connecting with friends ….

… Voronoi and Delaunay

Classical algorithm:
Bowyer & Watson
Much material online:
- Hang Si
- Jonathan Shewchuk
- CGAL manuals

Constrained Delaunay triangulation

Easty-to-read reference:
S.W. Sloan,
A fast algorithm for
generating constrained
Delaunay triangulation,
1992
Implementation in Geogram:
CDT2d
Constrained Delaunay triangulation

Pointset X Simplicial complex S

either triangulated surface
or tetrahedralized solid

either triangulated surface
or tetrahedralized solid
Embedded in IRd

Vor(X)|S (Intersection between Vor(X) and S)

Voronoi cells as iterative convex clipping
xi
“Meshless Voronoi diagrams”

Neighbors in increasing distance from xi
xi
x1
x2
x3
x4
x5
x6
x7
x8
x9
x10
x11

Bisector of xi, x1
xi
x1
x2
x3
x4
x5
x6
x7
x8
x9
x10
x11

Half-space clipping
xi
x1
x2
x3
x4
x5
x6
x7
x8
x9
x10
x11
π+(i,1)
π-(i,1)
This side: The other side:

Half-space clipping
xi
x1
x2
x3
x4
x5
x6
x7
x8
x9
x10
x11
π+(i,1)
π-(i,1)
This side: The other side:
Remove π-(i,1)

Half-space clipping
xi
x1
x2
x3
x4
x5
x6
x7
x8
x9
x10
x11
Then remove π-(i,2)

Half-space clipping
xi
x1
x2
x3
x4
x5
x6
x7
x8
x9
x10
x11
… then remove π-(i,3)

Half-space clipping
xi
x1
x2
x3
x4
x5
x6
x7
x8
x9
x10
x11

When should I stop ?
x1
x2
x3
x4
x5
x7
x8
x9
x10
x11
x6

When should I stop ? Rk
x1
x2
x3
x4
x5
x7
x8
x9
x10
x11
x6

When should I stop ? d(xi, xk) > 2 Rk
x1
x2
x3
x4
x5
x7
x8
x9
x10
x11
x6

Observation: d(xi, xk+1) > 2Rk → ∩ π+(i,k) = Vor(xi)
[L and Bonneel – Voronoi Parallel Linear Enumeration]
[Dey et.al – Localized co-cone]

“Radius of security” is reached

Note: Rk decreases and d(xi, xk) increases

Advantages:

Advantages:
(1) Compute Vor(X) ∩ S directly (start with f and clip)

Advantages:
(2) Replace Delaunay with ANN ! (no d! factor)

Advantages:
(2) Replace Delaunay with ANN ! (no d! factor)
(3) Parallelization is trivial (partition S and // in parts)

> 5. Into darkness ….
… geometric predicates

xi
xj
Elementary operation: cut a polygon
(or polyhedron) with a bisector
> 5. Into darkness …

xi
xj
Classify the vertices of the polygon

xi
xj
Sign( d(p,xj) – d(p,xi)) > 0

xi
xj
Sign( d(p,xj) – d(p,xi)) < 0

xi
xj
Compute the intersections

xi
xj
Compute the intersections - discard

xi
xj
xk Now clipping with the bisector of (xi, xk)

xi
xj
We need to classify all the points, including
these ones !

xi
xj
these ones !
(they are intersections between a
segment and a bisector)

xi
xj
these ones !
(they are intersections between a
segment and a bisector)
This generates a new intersection
(between a facet and two bisector)

Three configurations
1) Side(xi,xj,q) where q is a vertex of S

1) Side1(xi,xj,q)

1) Side1(xi,xj,q)
2) Side(xi,xj,q) where q = π(i,k) ∩ [p1,p2]

1) Side1(xi,xj,q)
2) Side2(xi,xj,xk,p1,p2)

1) Side1(xi,xj,q)
3) Side(xi,xj,q) where
q = π(i,k) ∩ π(i,l) ∩ [p1,p2,p3]

1) Side1(xi,xj,q)
3) Side3(xi,xj,xk, xl,p1,p2,p3)

1) Side1(xi,xj,q)
Implementations of exact predicates:
- J. Shewchuk‟s code
- CGAL (Pion, Meyer)

1) Side1(xi,xj,q)
Implementations of exact predicates:
- J. Shewchuk‟s code
- CGAL (Pion, Meyer)
They do not have Side1(), Side2(), Side3() (“exotic predicates”)

1) Side1(xi,xj,q)
How to implement Side1(), Side2(), Side3() ?
We need an exact “number type” with +,-,*,Sign()

Wish list:
• Easy to use
(no “Guru” needed for each new predicate)
• Reasonably efficient
• Easy to compile/integrate
(multi_precision.h, multi_precision.cpp and that‟s all)

Idea #1: (dense) multi-precision (GMP)
a0
a1
a2
a3
x 20
x 21*32
x 22*32
x 23*32
…
Each number is an array of (32 bits) integers:
Implement +,-,* (reasonably easy)
Sign: look at the leading non-zero component

a “limitation”:
c = a10 * 210*32 + b0

a “limitation”:
b0
0
0
a10
x 20
x 210*32
c = a10 * 210*32 + b0
…

Idea #2: (sparse) multi-precision
b0 | 0
a10 | 10
c = a10 * 210*32 + b0
Store the exponents of the components

b0 | 0
a10 | 10
c = a10 * 210*32 + b0
Exp. Exp.

b0 | 0
a10 | 10
c = a10 * 210*32 + b0
Exp. Exp.
mantissa mantissa

b0 | 0
a10 | 10
c = a10 * 210*32 + b0
Exp. Exp.
mantissa mantissa
These are floating point numbers !!!

Idea #3: expansions (Shewchuk)
x3 x2 x1
…
Each number is represented by the sum of an array of „components‟

x3 x2 x1
…
They are sorted in decreasing exponents

x3 x2 x1
…
They are „non-overlapping‟

x3 x2 x1
…
They are „non-overlapping‟
The sign is determined by the first component (highest exponent)

x2 x1
Two_sum(double a, double b)

x2 x1
+
Length:
l+m
Length l Length m

x2 x1
+
*
Length:
l+m
Length:
2*l
A double
Length l

* …
Length: 2*l*m
Expansion * Expansion product implemented by a recursive function
(“distillation”)
Length l Length m

* …
Performance ? 10 to 40 times slower than standard doubles
Length: 2*l*m
Length l Length m

* …
Use arithmetic filters
Adaptive precision [Shewchuk] ? Too complicated to get right
Length: 2*l*m
Length l Length m

* …
Use arithmetic filters
Adaptive precision [Shewchuk] ? Too complicated to get right
Quasi-static filters [Meyer and Pion] – FPG generator (easy to use)
Length: 2*l*m
Length l Length m

PCK (Predicate Construction Kit)
multi_precision.h / multi_precision.cpp
A “low-level” expansion class (allocates expansions on stack)
A “high-level” C++ number type (+,-,*,Sign overloads)
a script that generates the filter with FPG [Meyer and Pion] and the
exact precision version with expansions

PCK (Predicate Construction Kit)
multi_precision.h / multi_precision.cpp
A “low-level” expansion class (allocates expansions on stack)
A “high-level” C++ number type (+,-,*,Sign overloads)
a script that generates the filter with FPG [Meyer and Pion] and the
exact precision version with expansions
So we are done ?

xi
xj
Not yet !!

xi
xj
π(i,j) = {p | d2(p,xi) = d2(p,xj)}
[Voronoi]
[Edelsbrunner et.al]
[Devillers et.al]

xi
xj
πw(i,j) = {p | d2(p,xi) - wi = d2(p,xj) - wj}
[Voronoi]
[Devillers et.al]

xi
xj
[Voronoi]
[Devillers et.al]
The Voronoi diagram is replaced with a power diagram

xi
xj
[Voronoi]
[Devillers et.al]
Symbolic perturbation – Simulation of Simplicity:
Define the weight as a function of ε: wi = εi

xi
xj
[Voronoi]
[Devillers et.al]
Symbolic perturbation – Simulation of Simplicity:
Define the weight as a function of ε: wi = εi
The combinatorics is determined by the limit ε → 0

How to write side1(), side2(), side3(), side4() ?
d2(q,pj)-wj – d2(q,pi) + wi where:
q = πw(i,k1) ∩ … πw(i,kd) ∩ [p1,p2,p3…pd]

Solve for q in:
q Є πw(i,k1)
…
q Є πw(i,kd)
q Є [p1,p2,p3…pd]
{

q = (1/d) Q
Keep numerator and denom.
separate (remember, we are
not allowed to divide)
Solve for q in:
q Є πw(i,k1)
…
q Є πw(i,kd)
{

q = (1/d) Q
Inject q=(1/d) Q in side1() and mutliply by d to remove the division
Solve for q in:
q Є πw(i,k1)
…
q Є πw(i,kd)
{

q = (1/d) Q
Order the terms in wi = εi
Solve for q in:
q Є πw(i,k1)
…
q Є πw(i,kd)
{

q = (1/d) Q
Order the terms in wi = εi the constant one is non-perturbed predicate
if zero, the first non-zero one determines the sign
Solve for q in:
q Є πw(i,k1)
…
q Є πw(i,kd)
{

#include "kernel.pckh"
Sign predicate(side1)(
point(p0), point(p1), point(q0) DIM
) {
scalar r = sq_dist(p0,p1) ;
r -= 2*dot_at(p1,q0,p0) ;
generic_predicate_result(sign(r)) ;
begin_sos2(p0,p1)
sos(p0,POSITIVE)
sos(p1,NEGATIVE)
end_sos
}
Source PCK

point(p0), point(p1), point(q0) DIM
) {
scalar r = sq_dist(p0,p1) ;
r -= 2*dot_at(p1,q0,p0) ;
generic_predicate_result(sign(r)) ;
begin_sos2(p0,p1)
sos(p0,POSITIVE)
sos(p1,NEGATIVE)
end_sos
}
Source PCK
(p1-p0).(q0-p0)

#include "kernel.pckh“
Sign predicate(side2)( point(p0), point(p1), point(p2), point(q0), point(q1) DIM) {
scalar l1 = 1*sq_dist(p1,p0) ;
scalar a10 = 2*dot_at(p1,q0,p0);
scalar Delta = a11 - a10 ;
scalar DeltaLambda0 = a11 - l1 ;
scalar DeltaLambda1 = l1 - a10 ;
scalar r = Delta*l2 - a20*DeltaLambda0 - a21*DeltaLambda1 ;
Sign Delta_sign = sign(Delta) ;
Sign r_sign = sign(r) ;
generic_predicate_result(Delta_sign*r_sign) ;
begin_sos3(p0,p1,p2)
sos(p0, Sign(Delta_sign*sign(Delta-a21+a20)))
sos(p1, Sign(Delta_sign*sign(a21-a20)))
sos(p2, NEGATIVE)
end_sos
} Source PCK

sos(p2, NEGATIVE)
end_sos
} Source PCK
Denominator

sos(p2, NEGATIVE)
end_sos
} Source PCK
Barycentric
coords. of q

sos(p2, NEGATIVE)
end_sos
} Source PCK
Barycentric
coords. of q
Solely depend
on dot products
between input
points

sos(p2, NEGATIVE)
end_sos
} Source PCK
Result when in
generic position

sos(p2, NEGATIVE)
end_sos
} Source PCK
Symbolic
perturbation

Sign side2_exact_SOS(
const double* p0, const double* p1, const double* p2,
const double* q0, const double* q1,
coord_index_t dim
) {
const expansion& l1 = expansion_sq_dist(p1, p0, dim);
const expansion& l2 = expansion_sq_dist(p2, p0, dim);
const expansion& a10 = expansion_dot_at(p1, q0, p0, dim).scale_fast(2.0);
const expansion& Delta = expansion_diff(a11, a10);
Sign Delta_sign = Delta.sign();
vor_assert(Delta_sign != ZERO);
const expansion& DeltaLambda0 = expansion_diff(a11, l1);
const expansion& DeltaLambda1 = expansion_diff(l1, a10);
const expansion& r0 = expansion_product(Delta, l2);
const expansion& r1 = expansion_product(a20, DeltaLambda0).negate();
const expansion& r2 = expansion_product(a21, DeltaLambda1).negate();
const expansion& r = expansion_sum3(r0, r1, r2);
Sign r_sign = r.sign();
………..
Exact version with expansions

if(r_sign == ZERO) {
const double* p_sort[3];
p_sort[0] = p0;
p_sort[1] = p1;
p_sort[2] = p2;
std::sort(p_sort, p_sort + 3);
for(index_t i = 0; i < 3; ++i) {
if(p_sort[i] == p0) {
const expansion& z1 = expansion_diff(Delta, a21);
const expansion& z = expansion_sum(z1, a20);
Sign z_sign = z.sign();
len_side2_SOS = vor_max(len_side2_SOS, z.length());
if(z_sign != ZERO) {
return Sign(Delta_sign * z_sign);
}
}
const expansion& z = expansion_diff(a21, a20);
Sign z_sign = z.sign();
len_side2_SOS = vor_max(len_side2_SOS, z.length());
if(z_sign != ZERO) {
return Sign(Delta_sign * z_sign);
}
}
return NEGATIVE;
}
}
vor_assert_not_reached;
}
return Sign(Delta_sign * r_sign);
} Exact version with expansions

point(p0), point(p1), point(p2), point(p3),
point(q0), point(q1), point(q2) DIM
) {
scalar l1 = 1*sq_dist(p1,p0);
scalar b00 = a11*a22-a12*a21;
scalar b01 = a21-a22;
scalar b10 = a12*a20-a10*a22;
scalar b20 = a10*a21-a11*a20;
scalar Delta = b00+b10+b20;
scalar DeltaLambda0 =
b01*l1+b02*l2+b00 ;
b11*l1+b12*l2+b10 ;
b21*l1+b22*l2+b20 ;
scalar r = Delta*l3 - (
a30 * DeltaLambda0 +
a31 * DeltaLambda1 +
a32 * DeltaLambda2
) ;
generic_predicate_result(
Delta_sign*r_sign
) ;
begin_sos4(p0,p1,p2,p3)
sos(p0, Sign(Delta_sign*sign(
Delta-((b01+b02)*a30+
(b11+b12)*a31+
(b21+b22)*a32)
)))
sos(p1, Sign(Delta_sign*
sign((a30*b01)+
(a31*b11)+
(a32*b21))))
sos(p2, Sign(Delta_sign*sign(
(a30*b02)+
(a31*b12)+
(a32*b22))))
sos(p3, NEGATIVE)
end_sos
}
Source PCK

……….
scalar b00= det3x3(a11,a12,a13,a21,a22,a23,a31,a32,a33);
scalar b01=-det_111_2x3(a21,a22,a23,a31,a32,a33);
scalar b02= det_111_2x3(a11,a12,a13,a31,a32,a33);
scalar b10=-det3x3(a10,a12,a13,a20,a22,a23,a30,a32,a33);
scalar b20= det3x3(a10,a11,a13,a20,a21,a23,a30,a31,a33);
scalar b30=-det3x3(a10,a11,a12,a20,a21,a22,a30,a31,a32);
scalar Delta=b00+b10+b20+b30;
scalar DeltaLambda0 = b01*l1+b02*l2+b03*l3+b00;
……….
scalar r = Delta*l4 - (
a40*DeltaLambda0+
a41*DeltaLambda1+
a42*DeltaLambda2+
a43*DeltaLambda3
);
Sign Delta_sign = sign(Delta);
generic_predicate_result(Delta_sign*sign(r)) ;
begin_sos5(p0,p1,p2,p3,p4)
sos(p0, Sign( Delta_sign*sign(Delta - (
(b01+b02+b03)*a30 +
(b11+b12+b13)*a31 +
(b21+b22+b23)*a32 +
(b31+b32+b33)*a33
)))
)
sos(p1, Sign( Delta_sign*sign(a30*b01+a31*b11+a32*b21+a33*b31)))
sos(p4, NEGATIVE)
end_sos
}
q is the intersection of three bisectors and a tetrahedron embedded in nD
Note: There is a special case in 3d (no need for the tetrahedron) = insphere3d()
The code of the general
nD version (excerpt) :
Source PCK

A nice model for Thingy30K …
Putting everything together …

Take a closer look … Aaaahhhhhh !!!!

> Intersect; Remove internal boundaries; Tetgen

Aaaahhhhhh !!!!

More on this, to read on the beach:
- Chewchuk
- Sylvain Pion, FPG
- CGAL
- Tetwild, FastTetwild
- Attene, Cherchi, Livesu
- Thingy30K

>6. Planning your next trip ….

… GP in other sciences

Physics
Math
Computer
Science

Physics
Math
Computer
Science
Got the feeling that
there are intersting
things to discover
exactly here !

Physics
Math
Computer
Science
A journey in Mathland

Math
Optimal
transport
A numerical algorithm for
Semi-discrete OT in 3D,
ESAIM Math Modeling
and Analysis, L, 2015
Centroidal Power Diagrams,
ACM TOG/SIGGRAPH Asia,
Xin, L, Chen, Chu, Yue, Wang
2016
Notions of OT theory and how
to implement them on a
Computer,
Computer & Graphics,
L & Schwindt, 2018
BIRS Banff, BIRS Oaxaca,
Institut Fourier, Bonn

Math
Optimal
transport Recorded lecture
& slides on the web
Links from my webpage
brunolevy.github.io
SGP2018 Graduate Course

Math
The trip continues in Physland…
Optimal
transport
Physics
Computational
fluid
dynamics
C.S.

Free-surface fluid simulation, J. of computational Physics, B, 2022

Math
The trip continues in Physland…
Optimal
transport
Physics
Computational
fluid
dynamics
C.S.
Cosmology

Monthly Notices of the Royal Astron Soc., L, Mohayaee, S.von Hausegger 2021
Physical Review Letters, von Hausegger, L, Mohayaee, 2022
Physical Review Letters, Nikhaktar, Sheth, L, Mohayaee, 2022
Featured in Physics Magazine
A mathematical time machine to explore the origins of the Universe

Math
Love Physland, I settled down there !
Optimal
transport
Physics
Computational
fluid
dynamics
C.S.
Cosmology

>Epilogue ….
How GP (and Geogram) can help other sciences

The “product”: geogram (on github)

Is it good ?

Is it good ? Yes and no
23 years of code, 40 papers, 2 ERCs
+ functionalities, efficiency, small footprint
+ few dependencies
+ high portability (Linux/Mac/Win/Android/web)
+ heavily tested
- there is technical debt
- arrays/pointers-based,
API may feel a bit weird and low-level

Projects with Geogram
(industry and academic)

What GP can do for other sciences
- Dare computing what others would not dream of.
- Mix of math. and algorithmics.
- C++ ninjas, high tech (GPUs…).
- Irregular geometric data structures.

Voronoi/Laguerre diagrams of
astronomical size
(hundred millions cells)

> Deactivate ("Gray beard speaker"); switch to Q&A mode.

SGP 2023 graduate school - A quick journey into geometry processing

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à SGP 2023 graduate school - A quick journey into geometry processing

Similaire à SGP 2023 graduate school - A quick journey into geometry processing (20)

Plus de Bruno Levy

Plus de Bruno Levy (11)

Dernier

Dernier (20)

SGP 2023 graduate school - A quick journey into geometry processing