Mathematics | Scicho

Constructing Complex Shapes with Signed Distance Functions: The Heart Example

Sun, 07 Apr 2024 00:00:00 +0000

In this notebook, we’ll implement a signed distance function for a heart shape using Python and visualize it using matplotlib.

Function Definitions

The following functions are defined:

line_sdf: Calculates the signed distance from a point to a line segment.
circle_sdf: Calculates the signed distance from a point to a circle.
intersect_sdf: Calculates the signed distance field resulting from the intersection of two distance fields.
union_sdf: Calculates the signed distance field resulting from the union of two distance fields.

 1import numpy as np
 2import matplotlib.pyplot as plt
 3
 4def line_sdf(P, x1, y1, x2, y2):
 5 """
 6 Calculate the signed distance from a point P to a line segment
 7 defined by two endpoints (x1, y1) and (x2, y2).
 8 """
 9
10 a = np.array([x2 - x1, y2 - y1])
11 a = a / np.linalg.norm(a)
12 b = P - np.array([x1, y1])
13 d = np.dot(b, np.array([a[1], -a[0]]))
14 return d
15
16def circle_sdf(P, xc, yc, r):
17 """
18 Calculate the signed distance from a point P to a circle defined by its center (xc, yc) and radius r.
19 """
20 return np.sqrt((P[0] - xc) ** 2 + (P[1] - yc) ** 2) - r
21
22def intersect_sdf(d1, d2):
23 """
24 Calculate the signed distance field resulting from the intersection of two distance fields (d1 and d2).
25 """
26 return max(d1, d2)
27
28def union_sdf(d1, d2):
29 """
30 Calculate the signed distance field resulting from the union of two distance fields (d1 and d2).
31 """
32 return min(d1, d2)

Tangent Point Calculation

The find_tangent_point function finds the tangent point that has a specified distance from the bottom tip of the heart shape. This function is inspired by and .

 1def find_tangent_point(x1, y1, d1, x2, y2, d2):
 2 """
 3 Find the tangent point that has radius(d1) distance from center of circle
 4 and calculated distance (d2) from the bottom tip of the heart. The result is
 5 limited to desired tangent point.
 6 """
 7
 8 centerdx = x1 - x2
 9 centerdy = y1 - y2
10 R = np.sqrt(centerdx**2 + centerdy**2)
11
12 if not (abs(d1 - d2) <= R and R <= d1 + d2):
13 # No intersections
14 return []
15
16 d1d2 = d1**2 - d2**2
17 a = d1d2 / (2 * R**2)
18
19 c = np.sqrt(2 * (d1**2 + d2**2) / R**2 - (d1d2**2) / R**4 - 1)
20
21 fx = (x1 + x2) / 2 + a * (x2 - x1)
22 gx = c * (y2 - y1) / 2
23 # ix1 = fx + gx
24 ix2 = fx - gx
25
26 fy = (y1 + y2) / 2 + a * (y2 - y1)
27 gy = c * (x1 - x2) / 2
28 # iy1 = fy + gy
29 iy2 = fy - gy
30
31 return [ix2, iy2]

Heart Shape SDF

The heart_sdf function calculates the signed distance from a point to a heart shape defined by two circles and three line segments.

 1def heart_sdf(p, r=4):
 2 """
 3 Calculate the signed distance from a point P to a heart shape defined by two circles and three line segments.
 4
 5 The heart shape consists of two circles representing the left and right sides, and three line segments representing the bottom tip and the tangent lines connecting the circles.
 6
 7 Parameters:
 8 p (tuple): A tuple containing the coordinates (x, y) of the point P.
 9 r (float): The radius of the heart shape. Default is 4.
10
11 Returns:
12 float: The signed distance from the point P to the heart shape. Negative values indicate that the point is inside the heart shape, zero indicates that the point is on the boundary, and positive values indicate that the point is outside the heart shape.
13
14 Note:
15 The heart shape is constructed based on mathematical equations and geometric calculations. The function utilizes signed distance functions (SDFs) for circles and lines to determine the distance from the point P to various components of the heart shape.
16 """
17 # Some experimental ratio for the center of circles based on their radius
18 a = r * 3 / 4
19
20 circle1 = circle_sdf(p, -a, 0, r) # Left Circle
21 circle2 = circle_sdf(p, a, 0, r) # Right Circle
22
23 # Distance from bottom tip to center of circles
24 d2c = np.sqrt((a - 0) ** 2 + (0 - 2 * a - r) ** 2)
25
26 # Distance to tangent point of circle using Pythagorean theorem
27 d2t = np.sqrt(d2c**2 - r**2)
28
29 tpr = find_tangent_point(
30 a, 0, r, 0, -2 * a - r, d2t
31 ) # Tangent point on right circle
32
33 line1 = line_sdf(p, -tpr[0], tpr[1], 0, -2 * a - r)
34 line2 = line_sdf(p, 0, -2 * a - r, tpr[0], tpr[1])
35 line3 = line_sdf(p, tpr[0], tpr[1], -tpr[0], tpr[1])
36
37 # Create a triangle which base is the line that
38 # connects tangent points and the vertex point is heart bottom tip
39
40 dl = intersect_sdf(intersect_sdf(line1, line2), line3)
41
42 d = union_sdf(union_sdf(circle1, circle2), dl)
43
44 return d

Visualization

The plot_sdf function plots the signed distance function. This function is adopted from project.

 1def plot_sdf(SDF, BdBox=[-10, 10, -12, 8], n=300):
 2 """
 3 Plots the signed distance function.
 4 """
 5 x, y = np.meshgrid(
 6 np.linspace(BdBox[0], BdBox[1], n),
 7 np.linspace(BdBox[2], BdBox[3], n),
 8 )
 9 points = np.hstack([x.reshape((-1, 1)), y.reshape((-1, 1))])
10
11 sdf = np.fromiter(map(SDF, points), dtype=float)
12
13 inner = np.where(sdf <= 0, 1, 0)
14
15 _, ax = plt.subplots(figsize=(8, 6))
16 _ = ax.imshow(
17 inner.reshape((n, n)),
18 extent=(BdBox[0], BdBox[1], BdBox[2], BdBox[3]),
19 origin="lower",
20 cmap="Reds",
21 alpha=0.8,
22 )
23 ax.contour(x, y, sdf.reshape((n, n)), levels=[0], colors="gold", linewidths=2)
24 ax.set_xlabel("X", fontweight="bold")
25 ax.set_ylabel("Y", fontweight="bold")
26 ax.set_title("SDF Visualization", fontweight="bold", fontsize=16)
27 ax.set_aspect("equal")
28
29 plt.show()

Now let’s execute the plot_sdf function to visualize the signed distance function for the heart shape.

1plot_sdf(heart_sdf)

The full code, ready to copy and try, is also available at .

Exploring Boolean Operations in SDFs: Union, Difference, and Intersection

Mon, 18 Mar 2024 00:00:00 +0000

In our of Signed Distance Functions (SDFs), we unveiled their power in representing and manipulating geometric shapes. We also delved into the intricacies of SDFs for lines and rectangles. Now, let’s unlock the potential of Boolean operations on SDFs, enabling the creation of even more complex shapes.

Merging Shapes with Union: A Powerful Tool

The Union operation in SDFs allows us to combine two or more shapes, essentially merging them into a single new shape. Mathematically, the union of two SDFs, $SDF_1$ and $SDF_2$, representing shapes A and B respectively, can be expressed as:

$$ SDF_{Union}(P) = min(SDF_1(P), SDF_2(P)) $$

This operation essentially takes the minimum distance value from either SDF at each point (P). Points outside of both shape A or B will have a positive SDF value, indicating they lie outside the combined shape. Points within both shapes A and B will have a negative value, signifying their position inside the resulting union shape.

Union of Two Circles

The visualization of the union of two circles SDF is also available at using module.

Carving Shapes with Difference: Subtracting One from Another

The Difference operation in Signed Distance Functions (SDFs) enables us to sculpt one shape by subtracting another. Mathematically, the difference of $SDF1$ and $SDF2$, representing shapes A and B respectively, can be defined as:

$$ SDF_{Difference}(P)=max(SDF_1(P),−SDF_2(P)) $$

Here, the negative of $SDF_2$ is taken prior to the maximum operation. This action effectively reverses the sign of distances originating from shape B. Points lying outside both shapes, as well as points residing inside shape A but also within shape B, will yield a positive SDF value. This indicates that they belong to the exterior of the resultant shape after the difference operation. Points situated within shape A but outside shape B will generate a negative value, denoting their inclusion within the final difference shape.

Difference of Two Circles (Circle 1 - Circle 2)

The visualization of the difference of two circles SDF is also available at using module.

Finding the Common Ground: Intersection of Shapes

The Intersection operation in SDFs allows us to identify the region where two shapes overlap. Mathematically, the intersection of $SDF_1$ and $SDF_2$ can be expressed as:

$$ SDF_{Intersection}(P) = max(SDF_1(P), SDF_2(P)) $$

In this case, the maximum distance value is taken. Points outside both shapes A and B will have positive SDF values. Points inside either shape A or B (but not their overlap) will also have positive values. Points that lie within the overlapping region of both shapes A and B will have a negative SDF value, signifying their location within the intersection.

Intersection of Two Circles

The visualization of the intersection of two circles SDF is also available at using module.

A Composition of Lines: The SDF of a Rectangle

While we’ve explored circles and other shapes, it’s important to remember that even seemingly basic shapes can be constructed using SDFs and Boolean operations. Take a rectangle, for instance. We can define a rectangle as the intersection of four lines, each representing the distance to an edge:

The distance to the top edge of the rectangle.
The distance to the bottom edge.
The distance to the left edge.
The distance to the right edge.

Rectangle SDF

The visualization of the rectangle defined by intersection of 4 lines is also available at using module.

The order of these intersections does not matter. Taking the maximum distance (intersection) from all four lines simultaneously would define a rectangle. Alternatively, we can perform the intersection progressively.

This concept extends beyond rectangles. Any polygon can be defined similarly using the intersection of line SDFs representing distances to its edges.

Defining Complex Domains with SDF Boolean Operations

By mastering Boolean operations on SDFs, we unlock the ability to create mathematically defined representations of even intricate 2D domains. From simple geometric shapes to elaborate, user-defined patterns, these techniques empower us to model a vast array of scenarios. This opens doors for various applications, from scientific simulations to artistic expression, all leveraging the power of mathematics and code to define complex shapes and spaces.

Mathematics of 2D Shapes: Line and Rectangle SDFs Unveiled

Fri, 15 Dec 2023 00:00:00 +0000

In our of Signed Distance Functions (SDFs), we demystified their role in representing and manipulating geometric shapes. Now, let’s delve deeper into the mathematical intricacies of SDFs, focusing specifically on lines and rectangles in 2D geometry.

The Significance of Line SDFs

A Line Signed Distance Function (SDF) assigns a real number to each point in space, representing the distance from that point to the nearest point on a specified line. The sign of this distance indicates whether the point lies to the left or right of the line. Mathematically, the signed distance from a point $ P(x,y) $ to a line $L$ defined by two points $ (x_1, y_1) $ and $ (x_2, y_2) $ on it can be calculated in three steps:

Vector Representation:
- Define vector $ \mathbf{a} $ as the direction vector of the line: $$ \mathbf{a} = \begin{bmatrix} x_2 - x_1 \ y_2 - y_1 \end{bmatrix} $$
- Normalize $ \mathbf{a} $ to obtain a unit vector $ \hat{\mathbf{a}} $: $$ \hat{\mathbf{a}} = \frac{\mathbf{a}}{|\mathbf{a}|} $$
Position Vector:
- Define vector $ \mathbf{b} $ as the position vector from any point on the line $L$ to point $ P $: $$ \mathbf{b} = \begin{bmatrix} x - x_1 \ y - y_1 \end{bmatrix} $$
Dot Product:
- Calculate the dot product of $ \mathbf{b} $ and a vector perpendicular to $ \mathbf{a} $: $$ d = \mathbf{b} \cdot \begin{bmatrix} a_y \ -a_x \end{bmatrix} $$

Understanding Line SDF Values

Positive SDF: Points to the right of the line (when facing along the line’s direction) will have a positive SDF value.
Negative SDF: Points to the left of the line will have a negative SDF value.
Zero SDF: Points lying on the line will have an SDF value of zero.

The visualization of line SDF is available at using module.

Unraveling Rectangle SDFs

Continuing our exploration of signed distance functions (SDFs), let’s delve into rectangles. A rectangle can be defined by its bottom-left corner coordinates $(x_1, y_1)$ and top-right corner coordinates $(x_2, y_2)$. The signed distance function $d_{\text{Rectangle}}$ for a point $P = (x, y)$ to this rectangle is expressed as:

$$ d_{\text{Rectangle}}(P) = \max\left(x_1 - x, x - x_2, y_1 - y, y - y_2, 0\right) $$

The function accounts for the distances to each side of the rectangle, considering negative distances for points inside the rectangle and positive distances for points outside. The overall signed distance is determined by taking the maximum among these distances.

Directionality Matters

For rectangles, the order of corner points matters, affecting the orientation of the SDF. Ensure consistency in the order to maintain a coherent representation.

The visualization of rectangle SDF is available at using module.

Other 2D Shapes with Known SDFs

In addition to , and , various other 2D shapes have well-defined SDFs. While we won’t delve deep into them in this post, some noteworthy shapes include ellipses, triangles, and regular polygons.

By understanding the mathematics behind SDFs for lines and rectangles, we pave the way for more advanced explorations into 2D geometry and computational modeling. Stay tuned for future posts as we continue our journey through the captivating world of implicit geometry.

Feel free to experiment with the provided mathematical expressions and incorporate visual illustrations to enhance your understanding. Mathematics becomes a powerful tool when coupled with visualization.

Happy exploring!

Demystifying Signed Distance Functions

Sun, 10 Dec 2023 00:00:00 +0000

Demystifying Signed Distance Functions

In the realm of mathematics and computer graphics, signed distance functions (SDFs) play a pivotal role in representing and manipulating geometric shapes. Unlike traditional polygonal meshes, which store vertices and connectivity information, SDFs define shapes implicitly, offering a powerful and flexible approach to 3D modeling and simulation.

What is a Signed Distance Function?

At its core, an SDF is a mathematical function that assigns a real number to each point in space, representing the distance from that point to the nearest boundary of a specified shape. This distance value carries a sign, indicating whether the point lies inside, outside, or on the boundary of the shape.

Properties of Signed Distance Functions

Non-parametric Representation: SDFs describe shapes without explicit geometric data, making them ideal for representing complex shapes and adapting to deformations.
Global Shape Representation: SDFs provide a global representation of a shape, allowing for efficient proximity queries and intersection detection crucial for computational geometry.
Differentiable: SDFs are differentiable, enabling smooth transitions between different shape representations and their derivatives, a key aspect in mesh generation.

Applications of Signed Distance Functions

Mesh Generation for Physics Simulations: SDFs are widely used in physics simulations to represent objects and their interactions, enabling the creation of high-quality meshes representing objects with complex shapes, realistic collision detection and physics calculations.
Level of Detail (LOD): SDFs facilitate efficient LOD management by allowing for the creation of high-quality representations at various levels of detail.
Procedural Modeling: SDFs are the foundation of procedural modeling techniques, enabling the creation of organic and complex shapes from simple mathematical rules.
Graphics Rendering: SDFs play a crucial role in ray tracing algorithms, enabling ray casting and intersection detection for realistic graphics rendering.

Understanding the Mathematical Significance

In mathematical terms, the sign of the distance values generated by the SDF holds crucial information about the relative position of a point to the shape:

Negative Values: Points with negative SDF values lie inside the shape’s boundary. The magnitude of the negative value represents how far inside the point is relative to the nearest surface.
Positive Values: Points with positive SDF values are located outside the shape. Similar to negative values, the magnitude indicates the distance from the point to the nearest surface outside the shape.
Zero Value: A point with an SDF value of zero resides exactly on the shape’s boundary.

Mathematically, the SDF function can be represented as follows for a given point $P$ in space:

$$ SDF(P) = \text{Distance from } P \text{ to the nearest surface} $$

The sign of $SDF(P)$ provides a concise indication of whether the point $P$ is inside, outside, or on the boundary of the represented shape.

This mathematical understanding is foundational for computational geometry algorithms and plays a pivotal role in mesh generation processes, guiding the placement of vertices and defining the geometry of the resulting mesh.

Mathematical Example: SDF for a Circle

Consider a two-dimensional space ($x, y$) and a circle centered at the origin with a radius of $r$. The SDF for this circle ($SDF_{\text{circle}}$) at a given point $(x, y)$ can be expressed as follows:

$$ SDF_{\text{circle}}(x, y) = \sqrt{x^2 + y^2} - r $$

In this equation:

$SDF_{\text{circle}}(x, y)$ is the signed distance function for the circle.
$\sqrt{x^2 + y^2}$ calculates the Euclidean distance from the point $(x, y)$ to the origin.
$r$ is the radius of the circle.

Now, let’s break down the sign of $SDF_{\text{circle}}(x, y)$ based on the relative position of the point to the circle:

If $SDF_{\text{circle}}(x, y) < 0$, the point $(x, y)$ is inside the circle.
If $SDF_{\text{circle}}(x, y) > 0$, the point $(x, y)$ is outside the circle.
If $SDF_{\text{circle}}(x, y) = 0$, the point $(x, y)$ is exactly on the boundary of the circle.

This mathematical example illustrates how the SDF values can be computed for a simple geometric shape like a circle, forming the basis for more complex computations in computational geometry and mesh generation.

Example Python Code: Creating a Circle SDF

The following Python code defines an SDF function for a circle:

1import numpy as np
2
3def circle_sdf(x, y, center = [0,0], radius = 80):
4 return np.sqrt((x - center[0])**2 + (y - center[1])**2) - radius

This function takes two-dimensional coordinates as input and returns the distance from the point to the circle’s boundary.

Signed Distance Function Visualization

The visualization of circle SDF is also available at using module.