amaazetools 0.1.4__tar.gz → 0.1.6__tar.gz

{amaazetools-0.1.4/amaazetools.egg-info → amaazetools-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: amaazetools
-Version: 0.1.4
+Version: 0.1.6
 Summary: Python package for mesh processing tools developed by AMAAZE
 Author-email: Jeff Calder <jwcalder@umn.edu>
 License: MIT

{amaazetools-0.1.4 → amaazetools-0.1.6}/amaazetools/trimesh.py

@@ -9,6 +9,8 @@ from numpy import matlib
 from plyfile import PlyData, PlyElement
 import scipy.sparse as sparse
 import scipy.spatial as spatial
+import scipy.sparse.csgraph as csgraph
+from collections import Counter
 from skimage import measure
 from skimage.color import convert_colorspace
 from sklearn.neighbors import NearestNeighbors
@@ -17,6 +19,7 @@ from . import edge_detection
 import sys
 import urllib.request as url
 
+
 #Non-Class Specific Functions
 
 
@@ -466,6 +469,120 @@ class mesh:
             F = sparse.spdiags(1/num_adj_tri,0,self.num_verts(),self.num_verts())@F
 
         return F
+    
+    def detect_holes(self):
+        """ finds vertices bordering on holes.
+
+            Returns
+            -------
+            holes : (num_verts) boolean array
+                holes[i] = 1 if vertex i borders on a hole, else 0
+        """
+        npts = self.num_verts()
+        ntri = self.num_tri()
+
+        T = self.triangles 
+        #sparse matrices don't seem to be smart enough to remove 0's here in construction. I was going to add 1 and then remove it - no need
+
+        VT = self.tri_vert_adj()
+        
+        ntri_per_vert = VT@np.ones(ntri) #need this later
+        max_tri = int(ntri_per_vert.max())
+
+        T1 = VT.multiply(T[:,0])
+        T2 = VT.multiply(T[:,1])
+        T3 = VT.multiply(T[:,2])
+
+        I = np.hstack((T1.row,T2.row,T3.row))
+        J = np.hstack((T1.data.astype(int), T2.data.astype(int),T3.data.astype(int)))
+
+        K = sparse.coo_matrix((np.ones(len(I)), (I,J)),shape=(npts,npts)).tocsr()
+        K.data = (K.data>0).astype(int) #the construction is additive - repeated index ~> counter 
+
+        ntri_per_vert2 = (K@np.ones(npts)) -1 
+        holes = ntri_per_vert2!=ntri_per_vert
+
+        return holes
+
+
+    def con_comp(self,Q=None,returncounts=False):
+        """ extracts connected components of mesh. 
+
+            Parameters
+            ----------
+            Q : (num_verts) boolean array , default is None
+                optional array to prune edges with. If input, only edges from True to True will be considered for connectivity. 
+                If not input (or None), all edges will be used for connectivity. 
+            returncounts: boolean, default is False
+                if true, will return counts for labels.
+                
+            Returns
+            -------
+            ncomp : number of connected components.
+            labels : (num_verts) integer array
+                labels of connected components for each point. values range from 0 to ncomp-1. 
+            counts : (ncomp) integer array 
+                (optional) returns number of points under each label. array sorted from 0 to ncomp-1.
+            
+
+        """
+        T = self.triangles
+        npts = self.num_verts()
+        E = np.vstack( (T[:,[0,1]], T[:,[1,2]], T[:,[2,0]])) #edges of T
+
+        if Q is not None:
+            ll = Q[E]
+            E = E[ll[:,0]&ll[:,1],:]
+        
+        E = np.vstack( (E,E[:,[1,0]]) )
+            
+        W = sparse.coo_matrix((np.ones((np.shape(E)[0])), (E[:,0],E[:,1])),shape=(npts,npts))
+            
+        ncomp,labels = csgraph.connected_components(W,directed=False)
+
+        if returncounts:
+            co = Counter(labels)
+            co = np.array(list(co.items()))
+            counts = co[np.argsort(co[:,0]),1]
+            return ncomp,labels,counts
+        else:
+            return ncomp,labels
+        
+    def extract_subtri(self,L):
+        """ extracts sub-triangulation from specified vertices
+
+            Parameters
+            ----------
+            L : (num_verts) boolean or (n) integer array
+                boolean identifier or integer indices of vertices to extract.             
+            Returns
+            -------
+            newpts : (n,3) float array
+                extracted points (i.e. pts[L,:]) 
+            newtri : (new_num_tri,3) integer array
+                triangles where only all 3 vertices are in the extract
+            
+        """
+
+        n_pts = self.num_verts()
+        tri = self.triangles
+        pts = self.points
+        
+        if L.dtype == np.dtype(bool):
+            pt_ind2keep =  np.where(L)[0]
+        else: 
+            pt_ind2keep = L
+
+        newind = np.arange(pt_ind2keep.shape[0])
+        
+        old2new = -1*np.ones(n_pts)
+        old2new[pt_ind2keep] = newind 
+        
+        newtri = old2new[tri]
+        newtri = newtri[ np.sum(newtri<0,1) ==0, :]
+        
+        newpts = pts[pt_ind2keep,:]
+        return newpts, newtri
 
     #Returns unit normal vectors to vertices (averaging adjacent faces and normalizing)
     def vertex_normals(self):

{amaazetools-0.1.4 → amaazetools-0.1.6/amaazetools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: amaazetools
-Version: 0.1.4
+Version: 0.1.6
 Summary: Python package for mesh processing tools developed by AMAAZE
 Author-email: Jeff Calder <jwcalder@umn.edu>
 License: MIT

{amaazetools-0.1.4 → amaazetools-0.1.6}/pyproject.toml

@@ -9,7 +9,7 @@ packages = ['amaazetools']
 
 [project]
 name = "amaazetools"
-version = "0.1.4"
+version = "0.1.6"
 authors = [
   { name="Jeff Calder", email="jwcalder@umn.edu" },
 ]