data/PDE2D/Solver/data_holder.py

import drjit as dr
import mitsuba as mi
import numpy as np
from PDE2D.Coefficient import *
from PDE2D.BoundaryShape import *
from PDE2D.utils import *
from PDE2D.Sampling import *
from mitsuba import Float, Point2f, TensorXf, Texture2f,Bool, UInt
from PDE2D import  DIM
from enum import IntEnum

class RegularizationType(IntEnum):
    none = 0,
    L2 = 1,
    tensorL2 = 2,
    L1 = 3,
    tensorL1 = 4,
    TV = 5,
    gradL1 = 6,
    gradL2 = 7,
    screeningL1 = 8,
    screeningL2 = 9


class DataHolder(object):
    def __init__(self, shape: Shape = Shape(), bbox_center: list = [0,0],
                 bbox_length = 2.1, max_window_grid = 8, 
                 max_mipmap_res = 1024, min_mipmap_res = 1,
                 max_z = 4, dist_texture_res = 512,
                 α : Coefficient = ConstantCoefficient("diffusion", 1), 
                 σ : Coefficient = ConstantCoefficient("screening", 0), 
                 f : Coefficient = ConstantCoefficient("source", 0), 
                 α_split : Coefficient = None,
                 σ_split : Coefficient = None, 
                 opt_param_shape: list = [], opt_param_α: list = [], 
                 opt_param_σ: list = [], opt_param_f: list = [], 
                 majorant_safety_low: float = 1.02, 
                 majorant_safety_high : float = 1.02,
                 default_majorant : float = None, 
                 verbose = False):
        self.shape = shape
        self.bbox_center = Point2f(bbox_center)
        self.bbox_length = Float(bbox_length)
        self.bbox = [[bbox_center[0] - bbox_length/2, bbox_center[1] - bbox_length/2],
                     [bbox_center[0] + bbox_length/2, bbox_center[1] + bbox_length/2]]
        self.max_mipmap_res = max_mipmap_res
        self.min_mipmap_res = min_mipmap_res
        self.max_window_grid = UInt32(max_window_grid)
        self.max_radius = bbox_length / min_mipmap_res * (max_window_grid - 1)
        self.verbose = verbose
        self.α = α
        self.σ = σ
        self.f = f
        # These are defined for fd computations.
        # When we deviate the coefficients, path splitting weights change 
        # We want fd forward computations to follow the same exact path.
        self.α_split = α_split if (α_split is not None) else α
        self.σ_split = σ_split if (σ_split is not None) else σ
        self.params_shape = opt_param_shape
        self.params_f = opt_param_f
        self.params_σ = opt_param_σ
        self.params_α = opt_param_α
        self.majorant_safety_high = majorant_safety_high
        self.majorant_safety_low = majorant_safety_low
        self.default_majorant = default_majorant
        self.has_continuous_neumann = self.shape.has_continuous_neumann
        self.has_delta = self.shape.has_delta
        self.NEE = self.shape.NEE
        self.Rscale = [Float(0), self.shape.max_distance]
        self.σscale = [Float(0.01), Float(10000)]
        self.meanfree_res = [256, 256] 
        self.dist_tex_res = dist_texture_res
        self.max_z = Float(max_z)
        self.effective_σ = self.calculate_effective_screening(res = self.max_mipmap_res)
        # We are multiplying the negative part with a safety factor as it might increase the througput too much.
        self.majorant = dr.maximum(self.effective_σ * self.majorant_safety_high, -self.effective_σ * self.majorant_safety_low) 
        self.σ_bar =dr.max(self.majorant.array) if self.default_majorant is None else Float(self.default_majorant)
        self.σ_bar = dr.maximum(1e-3, self.σ_bar)
        #self.create_opt_parameters()
            
    def σ_(self, σ, α, grad_α, laplacian_α):   # Equation 21 (2nd paper)
        return σ / α + 1/2 * (laplacian_α / α - dr.squared_norm(grad_α)/(2 * (α ** 2)))
            
    #def create_opt_parameters(self):
    #    self.opt_params = {}
    #    self.shape.get_opt_params(self.opt_params, self.params_shape)
    #    self.α.get_opt_params(self.opt_params, self.params_α)
    #    self.σ.get_opt_params(self.opt_params, self.params_σ)
    #    self.f.get_opt_params(self.opt_params, self.params_f)

    def get_opt_params(self, param_dict: dict, opt_params: list):
        self.shape.get_opt_params_shape(param_dict, opt_params)
        self.α.get_opt_params(param_dict, opt_params)
        self.σ.get_opt_params(param_dict, opt_params)
        self.f.get_opt_params(param_dict, opt_params)

    def update(self, opt):
        self.shape.update(opt)
        self.f.update(opt)
        self.σ.update(opt)
        self.α.update(opt)
        self.α_split = self.α
        self.σ_split = self.σ
        #self.create_accelaration()
                
    def create_accelaration(self):
        self.effective_σ = self.calculate_effective_screening(res = self.max_mipmap_res)
        self.majorant = dr.maximum(self.effective_σ * self.majorant_safety_high, -self.effective_σ * self.majorant_safety_low) 
        self.σ_bar =dr.max(self.majorant.array) if self.default_majorant is None else self.default_majorant
        self.σ_bar = dr.maximum(1e-3, self.σ_bar)
        self.majorant = (dr.maximum(1e-3, self.majorant))
        self.majorant_tex = TextureCoefficient("effective_screening", self.bbox, self.majorant.numpy(), interpolation = "linear")
        self.σ_mipmap = self.create_mipmap(self.majorant, min_res = self.min_mipmap_res, type = "max") 

        self.meanfree_tex = self.get_mean_free_image()
        self.r_best_tex, self.σ_best_tex, self.σ_begin_tex = self.get_Rσ_domain(res = self.dist_tex_res, n_bisection=5, n_grid_search=10)

    def get_mean_free_image(self, spp = 2**8, resolution = [256, 256]):
        R = self.Rscale[0] + (self.Rscale[1] - self.Rscale[0]) * dr.arange(Float, resolution[0]) / (resolution[0] - 1) 
        σ = self.σscale[0] * 2 ** (dr.arange(Float, resolution[1]) / (resolution[1] - 1) * dr.log2(self.σscale[1] / self.σscale[0]))
        RR, σσ = dr.meshgrid(R, σ, indexing = 'ij')
        RR = dr.repeat(RR, spp)
        σσ = dr.repeat(σσ, spp)
        
        z = Float(RR * dr.sqrt(σσ))
        sample = dr.arange(Float, spp) / spp + 1/(2 * spp)
        sample = dr.tile(sample, (resolution[0]) * resolution[1]) 
        green = GreensFunctionAnalytic(dim = DIM.Two, newton_steps = 8, grad = False)
        r, normG = green.sample(sample, RR, σσ)
        prob_boundary = 1 - σσ * normG
        result = r * (1-prob_boundary) + RR * prob_boundary
        result = dr.select(RR == 0, 0, result)
        result = TensorXf(dr.block_sum(result, spp) / spp)
        result = dr.reshape(TensorXf, result, shape = [resolution[0], resolution[1], 1])
        result_tex = Texture2f(result)
        return result_tex
    
    def get_mean_free_path(self, R, σ):
        Rgrid = 1 / self.meanfree_res[0]
        σgrid = 1 / self.meanfree_res[1]
        ind_R =  Rgrid / 2 + (R - self.Rscale[0]) / (self.Rscale[1] - self.Rscale[0]) * (1.0-Rgrid) 
        ind_σ = σgrid/2 + dr.log2(σ / self.σscale[0]) / dr.log2(self.σscale[1] / self.σscale[0]) * (1.0 - σgrid)
        return self.meanfree_tex.eval(Point2f(ind_σ, ind_R))[0]
        
    def calculate_effective_screening(self, res = 1024):
        with dr.suspend_grad():
            resolution  = [res, res]
            points = create_image_points(self.bbox, resolution, 1,  centered = True)
            active = Bool(True)
            if (self.shape.single_closed):
                active = self.shape.inside_closed_surface_mask(points)
            # Calculate the textures
            α_vals = self.α_split.get_value(points)
            grad_α, laplacian_α = self.α_split.get_grad_laplacian(points)
            σ_vals = self.σ_split.get_value(points)
            # Equation 21 (2nd paper)
            σ_new = self.σ_(σ_vals, α_vals, grad_α, laplacian_α)
            # Eliminate the calculations outside the boundary (if the given shape 
            # is single closed boundary)
            σ_new = dr.select(active, σ_new, 0)
            numpy_σ, tensor_σ  = create_image_from_result(σ_new, resolution)
            self.eff_screening_tex = TextureCoefficient("effective_screening", self.bbox, numpy_σ[0], interpolation = "linear")
            return tensor_σ[0]
            
    def create_mipmap(self, tensor, min_res, type = "max"):
        # Now create the mipmap hierarchy
        res = tensor.shape[0]
        num_iter = int(dr.floor(dr.log2(res // min_res)))
        n = res * res
        array = dr.zeros(Float, n * (num_iter + 1))
        current_res = res
        current_array = Float(tensor.array)
        dr.eval(current_array)
        dr.scatter(array, current_array, dr.arange(UInt, n))

        for k in range(num_iter):
            current_res //= 2
            i = dr.arange(UInt, current_res) * 2
            j = dr.arange(UInt, current_res) * 2
            ii, jj = dr.meshgrid(i, j, indexing = "ij")
            
            index00 = ii * current_res * 2 + jj
            index01 = ii * current_res * 2 + jj + 1
            index10 = (ii + 1) * current_res * 2 + jj
            index11 = (ii + 1) * current_res * 2 + jj + 1
    
            dr.eval(index00, index01, index10, index11)
            val00 = dr.gather(Float, current_array, index00)
            val01 = dr.gather(Float, current_array, index01)
            val10 = dr.gather(Float, current_array, index10)
            val11 = dr.gather(Float, current_array, index11)
            if type == "max":
                max0 = dr.maximum(val00, val01)
                max1 = dr.maximum(val10, val11)
                current_array = dr.maximum(max0, max1)
            elif type == "min":
                min0 = dr.minimum(val00, val01)
                min1 = dr.minimum(val10, val11)
                current_array = dr.minimum(min0, min1)
            elif type == "mean":
                current_array = (val00 + val01 + val10 + val11) / 4
            else:
                raise Exception("There is no such mipmap creation type.")
            current_tensor = TensorXf(current_array)
            current_tensor = dr.reshape(TensorXf, value = current_tensor, shape = [current_res, current_res])
            u_factor = res // current_res
            current_upsampled = upsample(current_tensor, scale_factor = [u_factor, u_factor])
            #current_upsampled = dr.upsample(current_tensor, scale_factor=[res//current_res, res//current_res])
            dr.scatter(array, current_upsampled.array, dr.arange(UInt, n) + (k+1) * n)
        tensor = TensorXf(array)
        tensor = dr.reshape(TensorXf, value = tensor, shape = [num_iter + 1, res, res])
        #return TensorXf(array, shape = [num_iter + 1, res, res])
        return tensor
    @dr.syntax
    def get_sphere_screening(self, points, radius):
        x = (points[0] - self.bbox[0][0]) / self.bbox_length
        y = 1.0 - (points[1] - self.bbox[0][1]) / self.bbox_length
        k_max, res_all,_ = self.σ_mipmap.shape
        #mask = mi.TensorXf(mi.Float(0) ,shape = [res_all, res_all])
        
        k_max -= 1
        # which mipmap level to select
        k =   UInt32(dr.ceil(dr.log2(2 * radius * res_all / ((self.max_window_grid - 1) * self.bbox_length))))
        
        k = dr.select(k > k_max, k_max, k)
        if k < 0:
            k = UInt32(0)
        #dr.select(k < 0, 0, k)
        # resolution of the selected grid
        res_decrease = UInt32(dr.round(Float(2)**Float(k)))
        
        #res_decrease = mi.UInt32(4)
        res = res_all // res_decrease
        
        n1_point = UInt32(dr.floor(y * res))
        n2_point = UInt32(dr.floor(x * res))
        
        # get the center grid val of sphere
        if self.max_window_grid % 2 == 0:
            n1 = UInt32(dr.round(y * res))
            n2 = UInt32(dr.round(x * res))
        else:
            n1 = n1_point
            n2 = n2_point
        
        # get the index of the window 
        n1_start = n1 - self.max_window_grid//2
        n2_start = n2 - self.max_window_grid//2
        #v = 0
        v = UInt32(0)
        # We start the majorant with the correspoinding grid where the point is inside
        index_point = k * res_all * res_all + n1_point * res_decrease * res_all + n2_point * res_decrease
        majorant = dr.gather(Float, self.σ_mipmap.array, index_point)
        
        #i = dr.arange(mi.UInt, res_decrease[0])
        #j = dr.arange(mi.UInt, res_decrease[0])
        #ii, jj = dr.meshgrid(i, j, indexing = "ij")
        #mask_indices = (ii + n1_point * res_decrease)  * res_all + jj + n2_point * res_decrease
        #dr.scatter(mask.array, mi.Float(1), mask_indices)
        grid_length = self.bbox_length / res
        
        #loop = mi.Loop("Iterate over grids and get the max majorant if it touches the sphere!", state= lambda : (v, majorant))
        while (v < self.max_window_grid**2):
            n1_iter = v // self.max_window_grid + n1_start
            n2_iter = v % self.max_window_grid + n2_start
            
            n1_iter = dr.select(n1_iter<0, 0, n1_iter)
            n1_iter = dr.select(n1_iter>=res, res-1, n1_iter)
            n2_iter = dr.select(n2_iter<0, 0, n2_iter)
            n2_iter = dr.select(n2_iter>=res, res-1, n2_iter)
  
            square_corner_x = self.bbox[0][0] + n2_iter * grid_length
            square_corner_y = self.bbox[0][1] + (res - n1_iter - 1) * grid_length
            corner = Point2f(square_corner_x, square_corner_y)
            dist = self.get_distance_to_square(points, corner, grid_length)
            
            #if dist[0] < radius:
            #    i = dr.arange(mi.UInt, res_decrease[0])
            #    j = dr.arange(mi.UInt, res_decrease[0])
            #    ii, jj = dr.meshgrid(i, j, indexing = "ij")
            #    mask_indices = (ii + n1_iter * res_decrease)  * res_all + jj + n2_iter * res_decrease
            #    dr.scatter(mask.array, mi.Float(1), mask_indices)
            index_point = k * res_all * res_all + n1_iter * res_decrease * res_all + n2_iter * res_decrease
            majorant_iter = dr.gather(Float, self.σ_mipmap.array, index_point)
            majorant = dr.select(dist < radius, dr.maximum(majorant_iter, majorant), majorant)
            v += 1
        #mask_tex = TextureCoefficient("mask", self.bbox, mask.numpy(), interpolation = "nearest")   
        return majorant
    
    def compute_regularization(self, λ : float, type : RegularizationType, 
                                resolution = [256, 256], spp = 1, coeff_str = "diffusion"):
        out_val = 0
        coeff = self.get_coefficient(coeff_str)
        if coeff.out_val is not None:
            out_val = coeff.out_val
        with dr.suspend_grad():
            points = self.shape.create_volume_points(resolution, spp)
            dL = dr.ones(Float, dr.width(points)) * dr.rcp(dr.width(points))
        if type == RegularizationType.none:
            reg = Float(0)

        elif type == RegularizationType.L2:
            vals = coeff.get_value(points)
            reg = dr.square(vals - out_val)

        elif type == RegularizationType.tensorL2:
            resolution = coeff.tensor.shape[0:2]
            reg = Float(0)
            dL = Float(1)
            for i in range(resolution[0]):
                for j in range(resolution[1]):
                    index = i * resolution[1] + j 
                    val = dr.gather(Float, self.α.tensor.array, index)
                    reg += dr.square(val - out_val)
        elif (type == RegularizationType.L1):
            vals = coeff.get_value(points) 
            reg = dr.abs(vals - out_val) 

        elif (type == RegularizationType.tensorL1):
            resolution = coeff.tensor.shape[0:2]
            reg = Float(0)
            dL = Float(1)
            for i in range(resolution[0]):
                for j in range(resolution[1]):
                    index = i * resolution[1] + j 
                    val = dr.gather(Float, self.α.tensor.array, index)
                    reg += dr.abs(val - out_val)
            reg /= ((resolution[0]) * resolution[1])

        elif (type == RegularizationType.TV):
            resolution = coeff.tensor.shape[0:2]
            reg = Float(0)
            dL = Float(1)
            for i in range(resolution[0]-1):
                for j in range(resolution[1]-1):
                    index = i * resolution[1] + j 
                    val = dr.gather(Float, self.α.tensor.array, index)
                    val1 = dr.gather(Float, self.α.tensor.array, index+1)
                    val2 = dr.gather(Float, self.α.tensor.array, index+resolution[1])
                    reg += dr.abs(val1 - val)
                    reg += dr.abs(val2 - val)
            reg /= ((resolution[0]-1) * resolution[1]-1)

        elif (type == RegularizationType.gradL1):
            grad = coeff.get_grad_laplacian(points)[0]
            reg =   dr.abs(grad[0]) + dr.abs(grad[1])

        elif(type == RegularizationType.gradL2):
            grad = coeff.get_grad_laplacian(points)[0]
            reg =   dr.squared_norm(grad)

        elif (type == RegularizationType.screeningL2) or (type == RegularizationType.screeningL1):
            σ = self.σ.get_value(points)
            α = self.α.get_value(points)
            grad_α, laplacian_α = self.α.get_grad_laplacian(points)
            σ_ = self.σ_(σ, α, grad_α, laplacian_α)
            reg = dr.square(σ_) if type == RegularizationType.screening_squared else dr.abs(σ_)

        else:
            raise Exception("There is no such regularization type.")
        return dL * reg * λ
    
    @dr.syntax
    def get_Rσ(self, points, radius, n_bisection = 10, n_grid_search = 10, screening_offset = Float(0)):
        σ_begin = self.get_sphere_screening(points, radius + 2 * screening_offset)
        σ = self.get_sphere_screening(points, radius + screening_offset)
        z = radius * dr.sqrt(σ)
        
        # We will shrink these radii for g
        r = Float(radius)
        # Here we shrink the radii of the spheres where z is high by bisection.
        # At each iter we shrink to the middle value of max and min z, and compute 
        # the corresponding z value by also querying the correct majorant value.
        # If we found something close enough to z_high, we end the iteration.
        if z > self.max_z:
            r_high = Float(radius)
            r_low  = self.max_z / dr.sqrt(σ)
            i = UInt32(0)
            while i < n_bisection:
                r_sep = (r_high + r_low) / 2
                σ_sep = self.get_sphere_screening(points, r_sep + screening_offset)
                z_sep = r_sep * dr.sqrt(σ_sep)
                if z_sep < self.max_z:
                    r_low = Float(r_sep)
                else:
                    r_high = Float(r_sep)
                i += 1
            r = Float(r_low)
            σ = self.get_sphere_screening(points, r + screening_offset)
            z = r * dr.sqrt(σ)
        
        # Now all z vals should be in the correct range that we can sample from.
        # We will compute the best radius value in terms of the mean free path 
        # by grid search.
        i = UInt32(0)
        meanfree_best = Float(0) 
        r_best = Float(0)
        while i < n_grid_search:
            r_iter = r * Float(i + 1) / n_grid_search
            σ_iter = self.get_sphere_screening(points, r_iter + screening_offset)
            meanfree_iter = self.get_mean_free_path(r_iter, σ_iter)
            if meanfree_iter > meanfree_best:
                meanfree_best = meanfree_iter
                r_best = r_iter
                σ = σ_iter
            i += 1
        
        return r_best, σ, σ_begin
        
    def get_coefficient(self, name : str = "diffusion"):
        if name == "diffusion":
            return self.α
        elif name == "screening":
            return self.σ
        elif name == "source":
            return self.f
        else:
            raise Exception("There is no such coefficient.")

    def get_Rσ_domain(self, res, n_bisection = 10, n_grid_search = 10):
        points = create_image_points(self.bbox, resolution = [res, res], spp = 1, centered = True)
        bi = self.shape.boundary_interaction(points, star_generation=False)
        # We will always add these small offset value while computing the majorant to 
        # account for the grid size. 
        s_offset = self.bbox_length / res / dr.sqrt(2) * 1.01
        self.radius_threshold = s_offset * 5
        
        r_best, σ_best, σ_begin = self.get_Rσ(points, bi.r, n_bisection = n_bisection, n_grid_search=n_grid_search,
                                     screening_offset=s_offset)
        # We need to be careful while using the corresponding radii as it does not represent 
        # exactly the correct radius values.
        r_image, _ = create_image_from_result(r_best, resolution = [res, res])
        σ_image, _ = create_image_from_result(σ_best, resolution = [res, res])
        σ_begin_image, _ = create_image_from_result(σ_begin, resolution = [res, res])
        r_best_tex = TextureCoefficient("Best-radius", self.bbox, r_image[0], interpolation = "nearest")
        σ_best_tex = TextureCoefficient("Best-majorant", self.bbox, σ_image[0], interpolation = "nearest")
        σ_begin_tex = TextureCoefficient("Beginning-majorant", self.bbox, σ_begin_image[0], interpolation = "nearest")
        return r_best_tex, σ_best_tex, σ_begin_tex
    
    @dr.syntax
    def get_Rσz(self, points, radius):
        r = self.r_best_tex.get_value(points)
        σ = self.σ_best_tex.get_value(points)
        σ_begin = self.σ_begin_tex.get_value(points)

        # If we chose a greater best radius due to discretization of the domain or 
        # if the distance is too small, then select the original distance for taking a step!
        if (radius < r) | (radius < 20 * self.shape.epsilon) | (radius < self.radius_threshold):
            r = radius
            σ = σ_begin 

        σ = dr.maximum(1e-3, σ)
        z = r * dr.sqrt(σ)
        # For rare cases, now the z value might be larger than the max z. Especially if the majorant 
        # is super high near the boundary.
        if z >= self.max_z:
            r *= (self.max_z / z)
            z = self.max_z
        # return the selected parameters for sampling the next step.
        return r, σ, z
        
    @dr.syntax
    def get_distance_to_square(self, point, corner, length):
        i = UInt32(0)
        min1 = Float(dr.inf)
        min2 = Float(dr.inf)
        p1 = Point2f(dr.nan)
        p2 = Point2f(dr.nan)
        while i < 4:
            n1 = Float(i // 2)
            n2 = Float(i %  2)
            corner_ = corner + length * (Point2f(0,1) * n1 + 
                                         Point2f(1,0) * n2)
            dist = dr.norm(corner_ - point)
            mask1 = dist < min1
            mask2 = dist < min2
            min2 = dr.select(mask1, min1, min2)
            min1 = dr.select(mask1, dist, min1)
            min2 = dr.select(~mask1 & mask2, dist, min2)
            p2 = Point2f(dr.select(mask1, p1, p2))
            p1 = Point2f(dr.select(mask1, corner_, p1))
            p2 = Point2f(dr.select(~mask1 & mask2, corner_, p2))
            i += 1
        vec1 = dr.normalize(p2 - p1)
        vec2 = point - p1
        d = dr.dot(vec1,vec2)
        d = dr.select(d<0, 0, d)
        d = dr.select(d>length, length, d)
        closest_point = p1 + d * vec1
        return dr.norm(point - closest_point)
        
    def zero_grad(self):
        self.α.zero_grad()
        self.σ.zero_grad()
        self.f.zero_grad()
        self.shape.zero_grad()
        
    def visualize(self, ax1, ax2, ax3, ax4, resolution = [512, 512], spp = 4):
        self.f.visualize(ax1, self.bbox, resolution, spp)
        self.σ.visualize(ax2, self.bbox, resolution, spp)
        self.α.visualize(ax3, self.bbox, resolution, spp)
        image, tensor = self.get_effective_screening(resolution, spp)
        plot_image(image[0], ax4)
        ax1.set_title("Source (f)")
        ax2.set_title("Screening (σ)")
        ax3.set_title("Diffusion (α)")
        ax4.set_title("Effective Screening (σ)")
        
    def get_effective_screening(self, resolution = [512, 512], spp = 4):
        points = create_image_points(self.bbox, resolution, spp)
        σ = self.σ.get_value(points)
        α = self.α.get_value(points)
        grad_α, laplacian_α = self.α.get_grad_laplacian(points)
        effective_σ = σ / α + 1/2 * (laplacian_α / α - dr.squared_norm(grad_α)/(2 * (α ** 2)))
        return create_image_from_result(effective_σ, resolution)
    
    def get_point_neumann(self, bi : BoundaryInfo, conf_number : UInt32) -> tuple[list[Float], list[Float], list[Float], list[Point2f]]:
        return self.shape.get_point_neumann(bi, conf_number)
    
    def sampleNEE_special(self, bi:BoundaryInfo, sample : Float, conf_number : UInt32):
         # If we have a special sampling routine for getting NEE. (sampling only electrodes.)
        return self.shape.sampleNEE(bi, sample, conf_number)
    
    @dr.syntax
    def sampleNEE(self, bi : BoundaryInfo, sample : Float, conf_numbers : list[UInt32]) -> tuple[Float, Float, Float, Point2f]:
        d, pdf_n_r, sampled_p = (Float(0), Float(1), Point2f(0))
        n_val = dr.zeros(ArrayXf, shape = (len(conf_numbers), dr.width(bi.origin)))
        if dr.hint(self.NEE == NEE.Normal, mode = 'scalar'): # Sample uniformly to the star part of the sphere.
            # Sampled direction for getting the Neumann contribution.
            dir_n, pdf_n = bi.sample_neumann(sample, bi.on_boundary)
            # Check the selected sample hits to the boundary shape with neumann value.
            #d, sampled_p, normals_n = self.shape.ray_intersect(bi.origin, dir_n, bi.on_boundary)
            ri = self.shape.ray_intersect(bi, dir_n, conf_numbers =conf_numbers)
            d = ri.t
            sampled_p = ri.intersected
            # If we hit to the boundary, add the contribution.
            if bi.is_star & (ri.t < bi.r) & ~ri.is_dirichlet:
                for i in range(len(conf_numbers)):
                    n_val[i] = Float(ri.neumann[i])
                pdf_n_r = pdf_n * dr.abs(dr.dot(dir_n, ri.normal)) * 2 * dr.pi # pdf multiplied with 2 * pi * bi.r
        
        elif dr.hint(self.NEE == NEE.BruteForce, mode = 'scalar'):
            dir_n, pdf_n = bi.sample_brute_force(sample)
            ri = self.shape.ray_intersect(bi, dir_n, conf_numbers =conf_numbers)
            d = ri.t
            sampled_p = ri.intersected

            if bi.is_star & (ri.t < bi.r) & ~ri.is_dirichlet:
                for i in range(len(conf_numbers)):
                    n_val[i] = Float(ri.neumann[i])
                pdf_n_r = pdf_n * dr.abs(dr.dot(dir_n, ri.normal)) * 2 * dr.pi # pdf multiplied with 2 * pi * bi.r
        return d, n_val, pdf_n_r, sampled_p
    

    def compute_high_conductance_points(self, max_num_points = 3, cond_threshold = 2, grad_threshold = 1, merge_distance = 0.2):
        bbox = self.shape.bbox
        bbox_center = Point2f(bbox[0][0] + bbox[1][0],
                              bbox[0][1] + bbox[1][1])
        bbox_length = max(bbox[1][0] - bbox[0][0], bbox[1][1] - bbox[0][1])

        if isinstance(self.shape, BoundaryWithDirichlets):
            points = self.shape.out_boundary.create_volume_points(resolution = [1024, 1024])
        else:
            points = self.shape.create_volume_points(resolution = [1024, 1024])

        val = self.α.get_value(points)
        grad, laplacian = self.α.get_grad_laplacian(points)
        mask = (dr.norm(grad) < grad_threshold) & (val > cond_threshold) & (laplacian < 0)
        indices = dr.compress(mask)
        points = dr.gather(Point2f, points, indices)
        if np.size(points.numpy()) == 0:
            return bbox_center.numpy().T

        #means = create_circle_points(origin=bbox_center, radius = bbox_length, 
        #                             resolution = 20, spp = 1, discrete_points= True)
        means = self.shape.create_volume_points(resolution = [16,16])

        means, groups = k_means(points, means, num_iter = 3)
        mask = ~dr.isnan(means[0] + means[1])
        indices = dr.compress(mask)
        means = dr.gather(Point2f, means, indices)

        """
        # Merge close points
        nmeans = dr.width(means)
        ind = dr.arange(UInt32, nmeans)
        for i in range(nmeans):
            if ind[i] == i:
                for j in range(i + 1, nmeans):
                    means_i = dr.gather(Point2f, means, i)
                    means_j = dr.gather(Point2f, means, j)
                    if dr.norm(means_i - means_j)[0] < merge_distance * bbox_length:
                        dr.scatter(means, Point2f(dr.nan), j)
                        ind[j] = i
        """
        # Recompute the means once more.
        #mask = ~dr.isnan(means[0] + means[1])
        #indices = dr.compress(mask)
        #means = dr.gather(Point2f, means, indices)
        means, groups = k_means(points, means, num_iter = 1)

        # Get the highest conduction region.∂
        val = self.α.get_value(points)
        cond_sum = dr.zeros(Float, dr.width(means))
        counter_sum = dr.zeros(Float, dr.width(means))
        dr.scatter_add(cond_sum, val, groups)
        dr.scatter_add(counter_sum, Float(1), groups)
        mean_cond = (cond_sum / counter_sum)
        
        # Now we sort with numpy to get the biggest mean conductance regions.
        mean_cond_np = mean_cond.numpy()
        
        #sort_index = mean_cond_np.argsort()[::-1][:num_points]
        sort_index = mean_cond_np.argsort()[::-1]
        
        # means
        means = means.numpy()[:, sort_index].T

        # Now we eliminate the points that are very close to the region 
        # we are interested in.
        n = means.shape[0]
        i = 0
        while(i < n):
            deleted_indices = []
            for k in range(i+1, n):
                dist = np.linalg.norm(means[i] - means[k])
                if dist < merge_distance * bbox_length:
                    deleted_indices.append(k)
            means = np.delete(means, deleted_indices, axis = 0)
            n = means.shape[0]
            i += 1
        num_points = min(means.shape[0], max_num_points)
        means =  means[:num_points]
        # Apply one last k-means
        #means = k_means(points, Point2f(means.T), num_iter = 2)[0].numpy()
        #return means.T
        if means.shape[0] == 0:
            means = np.zeros([1,2])
        return means
    
    def upsample2(self, coefficient = "diffusion"):
        coeff = self.get_coefficient(coefficient)
        coeff.upsample2()