sdf_flat.py

Go to the documentation of this file.

import math
import numpy as np
 
R = 100  # radius of the indenter
d = 1 # indentation depth
 
xc = 0
yc = 0
zc = 0
 
def sdf(delta_t, t, x, y, z, tx, ty, tz, block_id):
    
    if block_id == -1:
        return np.ones_like(x)
 
    return zPlane.sDF(xc, yc, zc - d * t, x, y, z)
 
def grad_sdf(delta_t, t, x, y, z, tx, ty, tz, block_id):
    if block_id == -1:
        zeros = np.zeros_like(x)
        zeros = zeros.reshape((-1,1))
        grad_array = np.hstack([zeros, zeros, zeros])
        return grad_array
 
    return zPlane.gradSdf(xc, yc, zc - d * t, x, y, z)
 
def hess_sdf(delta_t, t, x, y, z, tx, ty, tz, block_id):
    if block_id == -1:
        zeros = np.zeros_like(x)
        zeros = zeros.reshape((-1,1))
        hess_array = np.hstack([zeros, zeros, zeros, zeros, zeros, zeros])
        # xx, yx, zx, yy, zy, zz
        return hess_array
    
    return zPlane.hessSdf(xc, yc, zc - d * t, x, y, z)
 
class Sphere:
    def sDF(r, xc, yc, zc, x, y, z):
        dx = np.subtract(x, xc)
        dy = np.subtract(y, yc)
        dz = np.subtract(z, zc)
        a = dx**2 + dy**2 + dz**2
        gap = np.sqrt(a) - r
        return gap
 
    def gradSdf(xc, yc, zc, x, y, z):
        a = (x-xc)**2 + (y-yc)**2 + (z-zc)**2
        c_val = np.sqrt(a)
        c_val_A = 1./c_val
        c_val_dx = c_val_A * (x-xc)
        c_val_dy = c_val_A * (y-yc)
        c_val_dz = c_val_A * (z-zc)
 
        c_val_dx = c_val_dx.reshape((-1,1))
        c_val_dy = c_val_dy.reshape((-1,1))
        c_val_dz = c_val_dz.reshape((-1,1))
        grad_array = np.hstack([c_val_dx,c_val_dy,c_val_dz])
        return grad_array
 
    def hessSdf(xc, yc, zc, x, y, z):
        x = x-xc
        y = y-yc
        z = z-zc
        Hxx = -x**2/(x**2 + y**2 + z**2)**(3/2) + 1/np.sqrt(x**2 + y**2 + z**2)
        Hzx = -x*z/(x**2 + y**2 + z**2)**(3/2)
        Hxy = -x*y/(x**2 + y**2 + z**2)**(3/2)
        Hyy = -y**2/(x**2 + y**2 + z**2)**(3/2) + 1/np.sqrt(x**2 + y**2 + z**2)
        Hzy = -y*z/(x**2 + y**2 + z**2)**(3/2)
        Hzz = -z**2/(x**2 + y**2 + z**2)**(3/2) + 1/np.sqrt(x**2 + y**2 + z**2)
        # xx, yx, zx, yy, zy, zz
        Hxx = Hxx.reshape((-1,1))
        Hzx = Hzx.reshape((-1,1))
        Hxy = Hxy.reshape((-1,1))
        Hyy = Hyy.reshape((-1,1))
        Hzy = Hzy.reshape((-1,1))
        Hzz = Hzz.reshape((-1,1))
        hess_array = np.hstack([Hxx, Hxy, Hzx, Hyy, Hzy, Hzz])
 
        return hess_array
 
 
class zPlane:
    def sDF(xc, yc, zc, x, y, z):
        return zc - z
 
    def gradSdf(xc, yc, zc, x, y, z):
        dx = np.zeros_like(x)
        dy = np.zeros_like(y)
        dz = np.ones_like(z)
        dx = dx.reshape((-1,1))
        dy = dy.reshape((-1,1))
        dz = dz.reshape((-1,1))
        grad_array = np.hstack([dx, dy, -dz])
        return grad_array
    
    def hessSdf(xc, yc, zc, x, y, z):
        zeros = np.zeros_like(x)
        zeros = zeros.reshape((-1,1))
 
        hess_array = np.hstack([zeros, zeros, zeros, zeros, zeros, zeros])
 
        # xx, yx, zx, yy, zy, zz
        return hess_array