senoquant 1.0.0b1__py3-none-any.whl

senoquant/tabs/segmentation/stardist_onnx_utils/_stardist/plot/render.py

@@ -0,0 +1,298 @@
+from __future__ import print_function, unicode_literals, absolute_import, division
+import numpy as np
+from csbdeep.utils import normalize
+from ..matching import matching
+from .plot import random_label_cmap
+
+
+def _single_color_integer_cmap(color = (.3,.4,.5)):
+    from matplotlib.colors import Colormap
+    
+    assert len(color) in (3,4)
+    
+    class BinaryMap(Colormap):
+        def __init__(self, color):
+            self.color = np.array(color)
+            if len(self.color)==3:
+                self.color = np.concatenate([self.color,[1]])
+        def __call__(self, X, alpha=None, bytes=False):
+            res = np.zeros(X.shape+(4,), np.float32)
+            res[...,-1] = self.color[-1]
+            res[X>0] = np.expand_dims(self.color,0)
+            if bytes:
+                return np.clip(256*res,0,255).astype(np.uint8)
+            else:
+                return res
+    return BinaryMap(color)
+                       
+
+
+
+def render_label(lbl, img = None, cmap = None, cmap_img = "gray", alpha = 0.5, alpha_boundary = None, normalize_img = True):
+    """Renders a label image and optionally overlays it with another image. Used for generating simple output images to asses the label quality
+
+    Parameters
+    ----------
+    lbl: np.ndarray of dtype np.uint16
+        The 2D label image 
+    img: np.ndarray 
+        The array to overlay the label image with (optional)
+    cmap: string, tuple, or callable
+        The label colormap. If given as rgb(a)  only a single color is used, if None uses a random colormap 
+    cmap_img: string or callable
+        The colormap of img (optional)
+    alpha: float 
+        The alpha value of the overlay. Set alpha=1 to get fully opaque labels
+    alpha_boundary: float
+        The alpha value of the boundary (if None, use the same as for labels, i.e. no boundaries are visible)
+    normalize_img: bool
+        If True, normalizes the img (if given)
+
+    Returns
+    -------
+    img: np.ndarray
+        the (m,n,4) RGBA image of the rendered label 
+
+    Example
+    -------
+
+    from scipy.ndimage import label, zoom      
+    img = zoom(np.random.uniform(0,1,(16,16)),(8,8),order=3)            
+    lbl,_ = label(img>.8)
+    u1 = render_label(lbl, img = img, alpha = .7)
+    u2 = render_label(lbl, img = img, alpha = 0, alpha_boundary =.8)
+    plt.subplot(1,2,1);plt.imshow(u1)
+    plt.subplot(1,2,2);plt.imshow(u2)
+
+    """
+    from skimage.segmentation import find_boundaries
+    try:
+        from matplotlib.colormaps import get_cmap
+    except:
+        from matplotlib.cm import get_cmap
+        
+    
+    alpha = np.clip(alpha, 0, 1)
+
+    if alpha_boundary is None:
+        alpha_boundary = alpha
+        
+    if cmap is None:
+        cmap = random_label_cmap()
+    elif isinstance(cmap, tuple):
+        cmap = _single_color_integer_cmap(cmap)
+    else:
+        pass
+        
+    cmap = get_cmap(cmap) if isinstance(cmap, str) else cmap
+    cmap_img = get_cmap(cmap_img) if isinstance(cmap_img, str) else cmap_img
+
+    # render image if given
+    if img is None:
+        im_img = np.zeros(lbl.shape+(4,),np.float32)
+        im_img[...,-1] = 1
+        
+    else:
+        assert lbl.shape[:2] == img.shape[:2]
+        img = normalize(img) if normalize_img else img
+        if img.ndim==2:
+            im_img = cmap_img(img)
+        elif img.ndim==3:
+            im_img = img[...,:4]
+            if img.shape[-1]<4:
+                im_img = np.concatenate([img, np.ones(img.shape[:2]+(4-img.shape[-1],))], axis = -1)
+        else:
+            raise ValueError("img should be 2 or 3 dimensional")
+            
+                
+            
+    # render label
+    im_lbl = cmap(lbl)
+
+    mask_lbl = lbl>0
+    mask_bound = np.bitwise_and(mask_lbl,find_boundaries(lbl, mode = "thick"))
+    
+    # blend
+    im = im_img.copy()
+    
+    im[mask_lbl] = alpha*im_lbl[mask_lbl]+(1-alpha)*im_img[mask_lbl]
+    im[mask_bound] = alpha_boundary*im_lbl[mask_bound]+(1-alpha_boundary)*im_img[mask_bound]
+        
+    return im
+
+
+def random_hls(n=2**16, h0 = .33, l0 = (.8,1), s0 = (.5,.8)  ):
+    """
+    h0 = 0 -> red
+    h0 = 0.33 -> green
+    h0 = 0.66 -> blue
+    h0 = 0.833 -> magenta
+    """
+    _f = lambda x: (x,)*2 if np.isscalar(x) else tuple(x)
+    h0,s0,l0 = map(_f,(h0,s0,l0))
+
+    h = np.random.uniform(*h0,n)
+    s = np.random.uniform(*s0,n)
+    l = np.random.uniform(*l0,n)
+
+    return h,l,s
+
+def cmap_from_hls(h,l,s):
+    import matplotlib
+    import colorsys
+    h = h%1
+    l = np.clip(l,0,1)
+    s = np.clip(s,0,1)
+
+    cols = np.stack([colorsys.hls_to_rgb(_h,_l,_s) for _h,_l,_s in zip(h,l,s)],axis=0)
+    cols[0] = 0
+    return matplotlib.colors.ListedColormap(cols)
+
+def match_labels(y0,y):
+    """match labels from y to y0"""
+    res = matching(y0,y,report_matches=True, thresh =.1)
+    if len(res.matched_pairs)==0:
+        print("no matching found")
+        return y
+    
+    ind_matched0, ind_matched = tuple(zip(*res.matched_pairs))
+    
+    ind_unmatched = (set(np.unique(y))-{0}) - set(ind_matched)
+
+    leftover_labels = set(np.arange(1,np.max(ind_matched0))) - set(ind_matched0)
+
+    leftover_labels = leftover_labels.union(set(np.max(ind_matched0)+1+np.arange(len(ind_unmatched)-len(leftover_labels))))
+
+    assert len(leftover_labels)>= len(ind_unmatched)
+
+    
+    print(f"matched: {len(ind_matched)} unmatched: {len(ind_unmatched)}")
+    u = np.zeros_like(y)
+    for ind0,ind in zip(ind_matched0, ind_matched):
+        u[y==ind] = ind0
+
+    for ind,ind2 in zip(ind_unmatched, leftover_labels):
+        u[y==ind] = ind2
+    
+    return u
+
+
+
+def render_label_pred(y_true, y_pred,
+                      img = None, cmap_img = "gray", normalize_img = True, 
+                      tp_alpha = .6, fp_alpha = .6, fn_alpha = .6,
+                      matching_kwargs = dict(thresh=0.5)):
+    """Renders an image that shows segmentation errors between y_true and y_pred 
+
+    Correctly matched objects (TP) are colored green (with transparency tp_alpha)
+    Erronously detected objects (FP) are colored red (with transparency fp_alpha)
+    MIssing GT objects (FN) are colored blue (with transparency fn_alpha)
+
+    Parameters
+    ----------
+    y_true: np.ndarray of dtype np.uint16
+        The 2D GT label image 
+    y_pred: np.ndarray of dtype np.uint16
+        The 2D prediction label image 
+    img: np.ndarray 
+        The array to overlay the label image with (optional)
+    cmap_img: string or callable
+        The colormap of img (optional)
+    tp_alpha: float 
+        The alpha value of the TP 
+    fp_alpha: float 
+        The alpha value of the FP 
+    fn_alpha: float 
+        The alpha value of the FN 
+    matching_kwargs: dict
+        The parameters of stardist.matching.matching that are used to compute the TP/FP/FN
+    normalize_img: bool
+        If True, normalizes the img (if given)
+
+    Returns
+    -------
+    img: np.ndarray
+        the (m,n,4) RGBA image of the rendered image
+
+    Example
+    ------- 
+
+    from scipy.ndimage import label, zoom      
+    img = zoom(np.random.uniform(0,1,(16,16)),(8,8),order=3)
+    y_true = label(img>.9)[0]
+    y_pred = label(img>.02)[0]
+    plt.imshow(render_label_pred(y_true, y_pred, img=img))
+
+    """
+    
+    try:
+        from matplotlib.colormaps import get_cmap
+    except:
+        from matplotlib.cm import get_cmap
+
+    assert y_true.shape == y_pred.shape
+    
+    matching_kwargs["report_matches"] = True
+    res = matching(y_true, y_pred, **matching_kwargs)
+
+    all_true = set(np.unique(y_true))-{0}
+    all_pred = set(np.unique(y_pred))-{0}
+
+    pairs = np.array(res.matched_pairs)
+    scores = np.array(res.matched_scores)
+    ind_tp_pairs = np.where(scores>=matching_kwargs["thresh"])[0]
+    tp_true, tp_pred = tuple(zip(*pairs[ind_tp_pairs]))
+    tp = tp_pred
+    fn = all_true.difference(tp_true)
+    fp = all_pred.difference(tp_pred)
+
+    assert res.tp == len(tp)
+    assert res.fp == len(fp)
+    assert res.fn == len(fn)
+
+    mask_tp = np.isin(y_pred, tuple(tp))
+    mask_fn = np.isin(y_true, tuple(fn))
+    mask_fp = np.isin(y_pred, tuple(fp))
+
+    def gen_maps(n, h0,l0,s0):
+        h,l,s = random_hls(n,h0,l0,s0)
+        return cmap_from_hls(h,l,s), cmap_from_hls(h,1.4*l,s)
+
+    n0 = np.max(y_pred)+1
+
+    # green
+    cmap_tp, cmap_border_tp = gen_maps(n0, h0 = (.25,.35) , l0 = (.4,.6), s0 = (.5,.7))
+    # red
+    cmap_fp, cmap_border_fp = gen_maps(n0, h0 = (0,.1) , l0 = (.4,.6), s0 = (.5,.7))
+    # blue
+    cmap_fn, cmap_border_fn = gen_maps(n0, h0 = (.6,.7) , l0 = (.4,.6), s0 = (.5,.7))
+
+    im_tp = cmap_tp(y_pred)
+    im_fp = cmap_fp(y_pred)
+    im_fn = cmap_fn(y_true)
+
+    # render image if given
+    if img is None:
+        im_img = np.zeros(y_true.shape+(4,),np.float32)
+        im_img[...,-1] = 1
+    else:
+        assert y_true.shape[:2] == img.shape[:2]
+        img = normalize(img) if normalize_img else img
+        cmap_img = get_cmap(cmap_img) if isinstance(cmap_img, str) else cmap_img
+        if img.ndim==2:
+            im_img = cmap_img(img)
+        elif img.ndim==3:
+            im_img = img[...,:4]
+            if img.shape[-1]<4:
+                im_img = np.concatenate([img, np.ones(img.shape[:2]+(4-img.shape[-1],))], axis = -1)
+        else:
+            raise ValueError("img should be 2 or 3 dimensional")
+        
+        
+    # blend
+    im = im_img.copy()
+    
+    im[mask_tp] = tp_alpha*im_tp[mask_tp]+(1-tp_alpha)*im_img[mask_tp]
+    im[mask_fp] = fp_alpha*im_fp[mask_fp]+(1-fp_alpha)*im_img[mask_fp]
+    im[mask_fn] = fn_alpha*im_fn[mask_fn]+(1-fn_alpha)*im_img[mask_fn]
+    return im

senoquant/tabs/segmentation/stardist_onnx_utils/_stardist/rays3d.py

@@ -0,0 +1,373 @@
+"""
+Ray factory
+
+classes that provide vertex and triangle information for rays on spheres
+
+Example:
+
+    rays = Rays_Tetra(n_level = 4)
+
+    print(rays.vertices)
+    print(rays.faces)
+
+"""
+from __future__ import print_function, unicode_literals, absolute_import, division
+import numpy as np
+from scipy.spatial import ConvexHull
+import copy
+import warnings
+
+class Rays_Base(object):
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+        self._vertices, self._faces = self.setup_vertices_faces()
+        self._vertices = np.asarray(self._vertices, np.float32)
+        self._faces = np.asarray(self._faces, int)
+        self._faces = np.asanyarray(self._faces)
+
+    def setup_vertices_faces(self):
+        """has to return
+
+         verts , faces
+
+         verts = ( (z_1,y_1,x_1), ... )
+         faces ( (0,1,2), (2,3,4), ... )
+
+         """
+        raise NotImplementedError()
+
+    @property
+    def vertices(self):
+        """read-only property"""
+        return self._vertices.copy()
+
+    @property
+    def faces(self):
+        """read-only property"""
+        return self._faces.copy()
+
+    def __getitem__(self, i):
+        return self.vertices[i]
+
+    def __len__(self):
+        return len(self._vertices)
+
+    def __repr__(self):
+        def _conv(x):
+            if isinstance(x,(tuple, list, np.ndarray)):
+                return "_".join(_conv(_x) for _x in x)
+            if isinstance(x,float):
+                return "%.2f"%x
+            return str(x)
+        return "%s_%s" % (self.__class__.__name__, "_".join("%s_%s" % (k, _conv(v)) for k, v in sorted(self.kwargs.items())))
+    
+    def to_json(self):
+        return {
+            "name": self.__class__.__name__,
+            "kwargs": self.kwargs
+        }
+
+    def dist_loss_weights(self, anisotropy = (1,1,1)):
+        """returns the anisotropy corrected weights for each ray"""
+        anisotropy = np.array(anisotropy)
+        assert anisotropy.shape == (3,)
+        return np.linalg.norm(self.vertices*anisotropy, axis = -1)
+
+    def volume(self, dist=None):
+        """volume of the starconvex polyhedron spanned by dist (if None, uses dist=1)
+        dist can be a nD array, but the last dimension has to be of length n_rays
+        """
+        if dist is None: dist = np.ones_like(self.vertices)
+
+        dist = np.asarray(dist)
+        
+        if not dist.shape[-1]==len(self.vertices):
+            raise ValueError("last dimension of dist should have length len(rays.vertices)")
+        # all the shuffling below is to allow dist to be an arbitrary sized array (with last dim n_rays)
+        # self.vertices -> (n_rays,3)
+        # dist -> (m,n,..., n_rays)
+        
+        # dist  -> (m,n,..., n_rays, 3)
+        dist = np.repeat(np.expand_dims(dist,-1), 3, axis = -1)
+        # verts  -> (m,n,..., n_rays, 3)
+        verts = np.broadcast_to(self.vertices, dist.shape)
+
+        # dist, verts  -> (n_rays, m,n, ..., 3)        
+        dist = np.moveaxis(dist,-2,0)
+        verts = np.moveaxis(verts,-2,0)
+
+        # vs -> (n_faces, 3, m, n, ..., 3)
+        vs = (dist*verts)[self.faces]
+        # vs -> (n_faces, m, n, ..., 3, 3)
+        vs = np.moveaxis(vs, 1,-2)
+        # vs -> (n_faces * m * n, 3, 3)        
+        vs = vs.reshape((len(self.faces)*int(np.prod(dist.shape[1:-1])),3,3))
+        d = np.linalg.det(list(vs)).reshape((len(self.faces),)+dist.shape[1:-1])
+        
+        return -1./6*np.sum(d, axis = 0)
+    
+    def surface(self, dist=None):
+        """surface area of the starconvex polyhedron spanned by dist (if None, uses dist=1)"""
+        dist = np.asarray(dist)
+        
+        if not dist.shape[-1]==len(self.vertices):
+            raise ValueError("last dimension of dist should have length len(rays.vertices)")
+
+        # self.vertices -> (n_rays,3)
+        # dist -> (m,n,..., n_rays)
+        
+        # all the shuffling below is to allow dist to be an arbitrary sized array (with last dim n_rays)
+        
+        # dist  -> (m,n,..., n_rays, 3)
+        dist = np.repeat(np.expand_dims(dist,-1), 3, axis = -1)
+        # verts  -> (m,n,..., n_rays, 3)
+        verts = np.broadcast_to(self.vertices, dist.shape)
+
+        # dist, verts  -> (n_rays, m,n, ..., 3)        
+        dist = np.moveaxis(dist,-2,0)
+        verts = np.moveaxis(verts,-2,0)
+
+        # vs -> (n_faces, 3, m, n, ..., 3)
+        vs = (dist*verts)[self.faces]
+        # vs -> (n_faces, m, n, ..., 3, 3)
+        vs = np.moveaxis(vs, 1,-2)
+        # vs -> (n_faces * m * n, 3, 3)        
+        vs = vs.reshape((len(self.faces)*int(np.prod(dist.shape[1:-1])),3,3))
+       
+        pa = vs[...,1,:]-vs[...,0,:]
+        pb = vs[...,2,:]-vs[...,0,:]
+
+        d = .5*np.linalg.norm(np.cross(list(pa), list(pb)), axis = -1)
+        d = d.reshape((len(self.faces),)+dist.shape[1:-1])
+        return np.sum(d, axis = 0)
+
+    
+    def copy(self, scale=(1,1,1)):
+        """ returns a copy whose vertices are scaled by given factor"""
+        scale = np.asarray(scale)
+        assert scale.shape == (3,)
+        res = copy.deepcopy(self)
+        res._vertices *= scale[np.newaxis]
+        return res 
+
+
+
+    
+def rays_from_json(d):
+    return eval(d["name"])(**d["kwargs"])
+
+
+################################################################
+
+class Rays_Explicit(Rays_Base):
+    def __init__(self, vertices0, faces0):
+        self.vertices0, self.faces0 = vertices0, faces0
+        super().__init__(vertices0=list(vertices0), faces0=list(faces0))
+        
+    def setup_vertices_faces(self):
+        return self.vertices0, self.faces0
+    
+
+class Rays_Cartesian(Rays_Base):
+    def __init__(self, n_rays_x=11, n_rays_z=5):
+        super().__init__(n_rays_x=n_rays_x, n_rays_z=n_rays_z)
+
+    def setup_vertices_faces(self):
+        """has to return list of ( (z_1,y_1,x_1), ... )  _"""
+        n_rays_x, n_rays_z = self.kwargs["n_rays_x"], self.kwargs["n_rays_z"]
+        dphi = np.float32(2. * np.pi / n_rays_x)
+        dtheta = np.float32(np.pi / n_rays_z)
+
+        verts = []
+        for mz in range(n_rays_z):
+            for mx in range(n_rays_x):
+                phi = mx * dphi
+                theta = mz * dtheta
+                if mz == 0:
+                    theta = 1e-12
+                if mz == n_rays_z - 1:
+                    theta = np.pi - 1e-12
+                dx = np.cos(phi) * np.sin(theta)
+                dy = np.sin(phi) * np.sin(theta)
+                dz = np.cos(theta)
+                if mz == 0 or mz == n_rays_z - 1:
+                    dx += 1e-12
+                    dy += 1e-12
+                verts.append([dz, dy, dx])
+
+        verts = np.array(verts)
+
+        def _ind(mz, mx):
+            return mz * n_rays_x + mx
+
+        faces = []
+
+        for mz in range(n_rays_z - 1):
+            for mx in range(n_rays_x):
+                faces.append([_ind(mz, mx), _ind(mz + 1, (mx + 1) % n_rays_x), _ind(mz, (mx + 1) % n_rays_x)])
+                faces.append([_ind(mz, mx), _ind(mz + 1, mx), _ind(mz + 1, (mx + 1) % n_rays_x)])
+
+        faces = np.array(faces)
+
+        return verts, faces
+
+
+class Rays_SubDivide(Rays_Base):
+    """
+    Subdivision polyehdra
+
+    n_level = 1 -> base polyhedra
+    n_level = 2 -> 1x subdivision
+    n_level = 3 -> 2x subdivision
+                ...
+    """
+
+    def __init__(self, n_level=4):
+        super().__init__(n_level=n_level)
+
+    def base_polyhedron(self):
+        raise NotImplementedError()
+
+    def setup_vertices_faces(self):
+        n_level = self.kwargs["n_level"]
+        verts0, faces0 = self.base_polyhedron()
+        return self._recursive_split(verts0, faces0, n_level)
+
+    def _recursive_split(self, verts, faces, n_level):
+        if n_level <= 1:
+            return verts, faces
+        else:
+            verts, faces = Rays_SubDivide.split(verts, faces)
+            return self._recursive_split(verts, faces, n_level - 1)
+
+    @classmethod
+    def split(self, verts0, faces0):
+        """split a level"""
+
+        split_edges = dict()
+        verts = list(verts0[:])
+        faces = []
+
+        def _add(a, b):
+            """ returns index of middle point and adds vertex if not already added"""
+            edge = tuple(sorted((a, b)))
+            if not edge in split_edges:
+                v = .5 * (verts[a] + verts[b])
+                v *= 1. / np.linalg.norm(v)
+                verts.append(v)
+                split_edges[edge] = len(verts) - 1
+            return split_edges[edge]
+
+        for v1, v2, v3 in faces0:
+            ind1 = _add(v1, v2)
+            ind2 = _add(v2, v3)
+            ind3 = _add(v3, v1)
+            faces.append([v1, ind1, ind3])
+            faces.append([v2, ind2, ind1])
+            faces.append([v3, ind3, ind2])
+            faces.append([ind1, ind2, ind3])
+
+        return verts, faces
+
+
+class Rays_Tetra(Rays_SubDivide):
+    """
+    Subdivision of a tetrahedron
+
+    n_level = 1 -> normal tetrahedron (4 vertices)
+    n_level = 2 -> 1x subdivision (10 vertices)
+    n_level = 3 -> 2x subdivision (34 vertices)
+                ...
+    """
+
+    def base_polyhedron(self):
+        verts = np.array([
+            [np.sqrt(8. / 9), 0., -1. / 3],
+            [-np.sqrt(2. / 9), np.sqrt(2. / 3), -1. / 3],
+            [-np.sqrt(2. / 9), -np.sqrt(2. / 3), -1. / 3],
+            [0., 0., 1.]
+        ])
+        faces = [[0, 1, 2],
+                 [0, 3, 1],
+                 [0, 2, 3],
+                 [1, 3, 2]]
+
+        return verts, faces
+
+
+class Rays_Octo(Rays_SubDivide):
+    """
+    Subdivision of a tetrahedron
+
+    n_level = 1 -> normal Octahedron (6 vertices)
+    n_level = 2 -> 1x subdivision (18 vertices)
+    n_level = 3 -> 2x subdivision (66 vertices)
+
+    """
+
+    def base_polyhedron(self):
+        verts = np.array([
+            [0, 0, 1],
+            [0, 1, 0],
+            [0, 0, -1],
+            [0, -1, 0],
+            [1, 0, 0],
+            [-1, 0, 0]])
+
+        faces = [[0, 1, 4],
+                 [0, 5, 1],
+                 [1, 2, 4],
+                 [1, 5, 2],
+                 [2, 3, 4],
+                 [2, 5, 3],
+                 [3, 0, 4],
+                 [3, 5, 0],
+                 ]
+
+        return verts, faces
+
+
+def reorder_faces(verts, faces):
+    """reorder faces such that their orientation points outward"""
+    def _single(face):
+        return face[::-1] if np.linalg.det(verts[face])>0 else face
+    return tuple(map(_single, faces))
+
+
+class Rays_GoldenSpiral(Rays_Base):
+    def __init__(self, n=70, anisotropy = None):
+        if n<4:
+            raise ValueError("At least 4 points have to be given!")
+        super().__init__(n=n, anisotropy = anisotropy if anisotropy is None else tuple(anisotropy))
+
+    def setup_vertices_faces(self):
+        n = self.kwargs["n"]
+        anisotropy = self.kwargs["anisotropy"]
+        if anisotropy is None:
+            anisotropy = np.ones(3)
+        else:
+            anisotropy = np.array(anisotropy)
+
+        # the smaller golden angle = 2pi * 0.3819...
+        g = (3. - np.sqrt(5.)) * np.pi
+        phi = g * np.arange(n)
+        # z = np.linspace(-1, 1, n + 2)[1:-1]
+        # rho = np.sqrt(1. - z ** 2)
+        # verts = np.stack([rho*np.cos(phi), rho*np.sin(phi),z]).T
+        #
+        z = np.linspace(-1, 1, n)
+        rho = np.sqrt(1. - z ** 2)
+        verts = np.stack([z, rho * np.sin(phi), rho * np.cos(phi)]).T
+
+        # warnings.warn("ray definition has changed! Old results are invalid!")
+
+        # correct for anisotropy
+        verts = verts/anisotropy
+        #verts /= np.linalg.norm(verts, axis=-1, keepdims=True)
+
+        hull = ConvexHull(verts)
+        faces = reorder_faces(verts,hull.simplices)
+
+        verts /= np.linalg.norm(verts, axis=-1, keepdims=True)
+
+        return verts, faces