plot3d 1.6.8__tar.gz → 1.7.0__tar.gz

{plot3d-1.6.8 → plot3d-1.7.0}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.1
 Name: plot3d
-Version: 1.6.8
+Version: 1.7.0
 Summary: Plot3D python utilities for reading and writing and also finding connectivity between blocks
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov
-Requires-Python: >=3.10.1,<4.0.0
+Requires-Python: >=3.10.12,<4.0.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: networkx
-Requires-Dist: numpy (==2.*)
+Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: scipy
 Requires-Dist: tqdm

{plot3d-1.6.8 → plot3d-1.7.0}/plot3d/__init__.py

@@ -1,7 +1,10 @@
 from __future__ import absolute_import
+from importlib import import_module     
+import os, warnings
 
-from .block import Block, reduce_blocks
-from .blockfunctions import rotate_block,get_outer_bounds,block_connection_matrix
+from .block import Block
+from .blockfunctions import rotate_block, get_outer_bounds, block_connection_matrix,split_blocks, plot_blocks, reduce_blocks, find_matching_faces
+from .block_merging_mixed_facepairs import combine_nxnxn_cubes_mixed_pairs
 from .connectivity import find_matching_blocks, get_face_intersection, connectivity_fast, face_matches_to_dict
 from .face import Face
 from .facefunctions import create_face_from_diagonals, get_outer_faces, find_connected_faces, find_bounding_faces,split_face,find_face_nearest_point,match_faces_dict_to_list,outer_face_dict_to_list,find_closest_block
@@ -14,8 +17,9 @@ from .split_block import split_blocks, Direction
 from .listfunctions import unique_pairs
 
 # Try importing metis
-try:
-    import metis
-    from .graph import block_to_graph,get_face_vertex_indices,get_starting_vertex,add_connectivity_to_graph, block_connectivity_to_graph
-except ImportError as ex:
-    print("Could not import metis. metis may not be configured \n {ex}")
+if os.getenv('METIS_DLL') is not None:
+    if import_module('metis') is not None:
+        import metis
+        from .graph import block_to_graph,get_face_vertex_indices,get_starting_vertex,add_connectivity_to_graph, block_connectivity_to_graph
+else:
+    print("METIS_DLL is not set. metis may not be configured. plot3D will function without metis")

{plot3d-1.6.8 → plot3d-1.7.0}/plot3d/block.py

@@ -2,17 +2,25 @@ import numpy as np
 import math 
 from tqdm import trange
 from typing import List
+from copy import deepcopy
+import numpy.typing as npt 
 
 class Block:
     """Plot3D Block definition
     """
-    def __init__(self, X:np.ndarray,Y:np.ndarray,Z:np.ndarray):
+    X: npt.NDArray
+    Y: npt.NDArray
+    Z: npt.NDArray
+    IMAX:int
+    JMAX:int
+    KMAX:int
+    def __init__(self, X:npt.NDArray,Y:npt.NDArray,Z:npt.NDArray):
         """Initializes the block using all the X,Y,Z coordinates of the block
 
         Args:
-            X (np.ndarray): All the X coordinates (i,j,k)
-            Y (np.ndarray): All the Y coordinates (i,j,k)
-            Z (np.ndarray): All the Z coordinates (i,j,k)
+            X (npt.NDArray): All the X coordinates (i,j,k)
+            Y (npt.NDArray): All the Y coordinates (i,j,k)
+            Z (npt.NDArray): All the Z coordinates (i,j,k)
 
         """
         self.IMAX,self.JMAX,self.KMAX = X.shape; 
@@ -24,6 +32,8 @@ class Block:
         self.cy = np.mean(Y)
         self.cz = np.mean(Z)
         
+    def __repr__(self):
+        return f"({self.IMAX},{self.JMAX},{self.KMAX})"
     
     def scale(self,factor:float):
         """Scales a mesh by a certain factor 
@@ -164,6 +174,20 @@ class Block:
                     v[i,j,k]= vol12/12
         return v
     
+    def get_faces(self):
+        """
+        Returns a dictionary of the six faces of the block.
+        Each face is a tuple of (X_face, Y_face, Z_face).
+        """
+        return {
+            'imin': (self.X[0,:,:], self.Y[0,:,:], self.Z[0,:,:]),
+            'imax': (self.X[-1,:,:], self.Y[-1,:,:], self.Z[-1,:,:]),
+            'jmin': (self.X[:,0,:], self.Y[:,0,:], self.Z[:,0,:]),
+            'jmax': (self.X[:,-1,:], self.Y[:,-1,:], self.Z[:,-1,:]),
+            'kmin': (self.X[:,:,0], self.Y[:,:,0], self.Z[:,:,0]),
+            'kmax': (self.X[:,:,-1], self.Y[:,:,-1], self.Z[:,:,-1]),
+        }
+        
     @property
     def size(self)->int:
         """returns the total number of nodes 
@@ -173,77 +197,6 @@ class Block:
         """
         return self.IMAX*self.JMAX*self.KMAX
 
-def checkCollinearity(v1:np.ndarray, v2:np.ndarray):
-    # Calculate their cross product
-    cross_P = np.cross(v1,v2) 
- 
-    # Check if their cross product
-    # is a NULL Vector or not
-    if (cross_P[0] == 0 and
-        cross_P[1] == 0 and
-        cross_P[2] == 0):
-        return True
-    else:
-        return False
-
-def calculate_outward_normals(block:Block):
-    # Calculate Normals
-    X = block.X
-    Y = block.Y
-    Z = block.Z
-    imax = block.IMAX
-    jmax = block.JMAX
-    kmax = block.KMAX 
-    # IMAX - Normal should be out of the page        
-    # Normals I direction: IMIN https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal
-    x = [X[0,0,0],X[0,jmax,0],X[0,0,kmax]] 
-    y = [Y[0,0,0],Y[0,jmax,0],Y[0,0,kmax]]
-    z = [Z[0,0,0],Z[0,jmax,0],Z[0,0,kmax]]
-    u = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]]) 
-    v = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
-    n_imin = np.cross(v1,v2)
-    
-    # Normals I direction: IMAX
-    x = [X[imax,0,0],X[imax,jmax,0],X[imax,0,kmax]] 
-    y = [Y[imax,0,0],Y[imax,jmax,0],Y[imax,0,kmax]]
-    z = [Z[imax,0,0],Z[imax,jmax,0],Z[imax,0,kmax]]
-    v1 = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]])
-    v2 = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
-    n_imax = np.cross(v1,v2)
-
-    # Normals J direction: JMIN
-    x = [X[0,0,0],X[imax,0,0],X[0,0,kmax]] 
-    y = [Y[0,0,0],Y[imax,0,0],Y[0,0,kmax]]
-    z = [Z[0,0,0],Z[imax,0,0],Z[0,0,kmax]]
-    v1 = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]])
-    v2 = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
-    n_jmin = np.cross(v1,v2)
-
-    # Normals J direction: JMAX
-    x = [X[0,jmax,0],X[imax,jmax,0],X[0,jmax,kmax]] 
-    y = [Y[0,jmax,0],Y[imax,jmax,0],Y[0,jmax,kmax]]
-    z = [Z[0,jmax,0],Z[imax,jmax,0],Z[0,jmax,kmax]]
-    v1 = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]])
-    v2 = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
-    n_jmax = np.cross(v1,v2)
-
-    # Normals K direction: KMIN
-    x = [X[imax,0,0],X[0,jmax,0],X[0,0,0]] 
-    y = [Y[imax,0,0],Y[0,jmax,0],Y[0,0,0]]
-    z = [Z[imax,0,0],Z[0,jmax,0],Z[0,0,0]]
-    v1 = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]])
-    v2 = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
-    n_kmin = np.cross(v1,v2)
-
-    # Normals K direction: KMAX
-    x = [X[imax,0,kmax],X[0,jmax,kmax],X[0,0,kmax]] 
-    y = [Y[imax,0,kmax],Y[0,jmax,kmax],Y[0,0,kmax]]
-    z = [Z[imax,0,kmax],Z[0,jmax,kmax],Z[0,0,kmax]]
-    v1 = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]])
-    v2 = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
-    n_kmax = np.cross(v1,v2)
-
-    return n_imin,n_jmin,n_kmin,n_imax,n_jmax,n_kmax
 
 def reduce_blocks(blocks:List[Block],factor:int):
     """reduce the blocks by a factor of (factor)

plot3d-1.7.0/plot3d/block_merging_mixed_facepairs.py

@@ -0,0 +1,301 @@
+from typing import Dict, List, Set, Tuple
+import numpy as np 
+from .block import Block
+from .blockfunctions import find_matching_faces, build_connectivity_graph, standardize_block_orientation
+from .write import write_plot3D
+
+
+def rotate_block_to_align_faces(X, Y, Z, face_from: str, face_to: str):
+    """
+    Rotate block2 geometry so that face_from aligns with face_to.
+    Currently supports: jmax → imin.
+    """
+    if (face_from, face_to) == ('jmax', 'imin'):
+        Xr = np.transpose(X, (1, 0, 2))
+        Yr = np.transpose(Y, (1, 0, 2))
+        Zr = np.transpose(Z, (1, 0, 2))
+        Xr = np.flip(Xr, axis=0)
+        Yr = np.flip(Yr, axis=0)
+        Zr = np.flip(Zr, axis=0)
+        return Xr, Yr, Zr
+    raise NotImplementedError(f"Rotation from {face_from} to {face_to} not implemented.")
+
+def combine_2_blocks_mixed_pairing(block1, block2, tol=1e-8):
+    """
+    Combine block1 and block2 by matching and aligning any pair of faces, including cross-axis combinations.
+    Automatically transposes and flips block2, and flips block1 if necessary to maintain monotonic physical direction.
+
+    This version generalizes the direction check to detect which of X, Y, or Z is varying most along the stacking axis,
+    and uses that to determine whether block1 needs to be flipped before concatenation.
+
+    Returns:
+        Block: The merged block with physically consistent orientation.
+    """
+    face1, face2, flip_flags = find_matching_faces(block1, block2, tol=tol)
+    if face1 is None or flip_flags is None:
+        print("No matching faces or incompatible orientation.")
+        return block1
+
+    flip_ud, flip_lr = flip_flags
+
+    face_axis_normal = {
+        'imin': (0, -1), 'imax': (0, 1),
+        'jmin': (1, -1), 'jmax': (1, 1),
+        'kmin': (2, -1), 'kmax': (2, 1),
+    }
+
+    axis1, dir1 = face_axis_normal[face1]
+    axis2, dir2 = face_axis_normal[face2] # type: ignore
+
+    # Transpose block2 to align its face axis with block1's
+    transpose = None
+    if axis1 != axis2:
+        if (axis1, axis2) in [(0, 1), (1, 0)]:
+            transpose = (1, 0, 2)
+        elif (axis1, axis2) in [(0, 2), (2, 0)]:
+            transpose = (2, 1, 0)
+        elif (axis1, axis2) in [(1, 2), (2, 1)]:
+            transpose = (0, 2, 1)
+
+    X2, Y2, Z2 = block2.X.copy(), block2.Y.copy(), block2.Z.copy()
+    if transpose:
+        X2, Y2, Z2 = np.transpose(X2, transpose), np.transpose(Y2, transpose), np.transpose(Z2, transpose)
+
+    # Apply local flips from face alignment
+    if face2 in ['imin', 'imax']:
+        if flip_ud: X2, Y2, Z2 = np.flip(X2, 1), np.flip(Y2, 1), np.flip(Z2, 1)
+        if flip_lr: X2, Y2, Z2 = np.flip(X2, 2), np.flip(Y2, 2), np.flip(Z2, 2)
+    elif face2 in ['jmin', 'jmax']:
+        if flip_ud: X2, Y2, Z2 = np.flip(X2, 0), np.flip(Y2, 0), np.flip(Z2, 0)
+        if flip_lr: X2, Y2, Z2 = np.flip(X2, 2), np.flip(Y2, 2), np.flip(Z2, 2)
+    elif face2 in ['kmin', 'kmax']:
+        if flip_ud: X2, Y2, Z2 = np.flip(X2, 0), np.flip(Y2, 0), np.flip(Z2, 0)
+        if flip_lr: X2, Y2, Z2 = np.flip(X2, 1), np.flip(Y2, 1), np.flip(Z2, 1)
+
+    # Determine stacking axis
+    stack_axis = axis1
+
+    # Identify which physical axis (X/Y/Z) changes most along the stacking axis
+    def get_dominant_step(A, axis):
+        n = A.shape[axis]
+        center = [s // 2 for s in A.shape]
+        center[axis] = slice(None)
+        values = A[tuple(center)]
+        return np.nanmean(values[-1] - values[0])
+
+    # Step values in block1
+    stepX1 = get_dominant_step(block1.X, stack_axis)
+    stepY1 = get_dominant_step(block1.Y, stack_axis)
+    stepZ1 = get_dominant_step(block1.Z, stack_axis)
+    dominant_axis = np.argmax(np.abs([stepX1, stepY1, stepZ1]))
+    step1 = [stepX1, stepY1, stepZ1][dominant_axis]
+
+    # Step values in block2 (transformed and flipped)
+    stepX2 = get_dominant_step(X2, stack_axis)
+    stepY2 = get_dominant_step(Y2, stack_axis)
+    stepZ2 = get_dominant_step(Z2, stack_axis)
+    step2 = [stepX2, stepY2, stepZ2][dominant_axis]
+
+    # Flip block1 if physical step directions are inconsistent
+    if np.sign(step1) != np.sign(step2):
+        block1.X = np.flip(block1.X, axis=stack_axis)
+        block1.Y = np.flip(block1.Y, axis=stack_axis)
+        block1.Z = np.flip(block1.Z, axis=stack_axis)
+
+    # Slice off overlapping face from block2
+    slicer = [slice(None)] * 3
+    slicer[stack_axis] = slice(1, None) if face2.endswith('min') else slice(0, -1) # type: ignore
+    X2s, Y2s, Z2s = X2[tuple(slicer)], Y2[tuple(slicer)], Z2[tuple(slicer)]
+
+    # Concatenate along stack axis
+    if face2.endswith('min'): # type: ignore
+        X = np.concatenate([block1.X, X2s], axis=stack_axis)
+        Y = np.concatenate([block1.Y, Y2s], axis=stack_axis)
+        Z = np.concatenate([block1.Z, Z2s], axis=stack_axis)
+    else:
+        X = np.concatenate([X2s, block1.X], axis=stack_axis)
+        Y = np.concatenate([Y2s, block1.Y], axis=stack_axis)
+        Z = np.concatenate([Z2s, block1.Z], axis=stack_axis)
+    return standardize_block_orientation(Block(X, Y, Z))
+
+
+
+def combine_blocks_mixed_pairs(blocks: List[Block], tol: float = 1e-8, max_tries: int = 4) -> Tuple[List[Block], List[int]]:
+    """
+    Combine as many blocks as possible from a group of up to 8 blocks via face matching.
+
+    Parameters
+    ----------
+    blocks : List[Block]
+        List of up to 8 Block objects.
+    tol : float
+        Tolerance for face matching.
+    max_tries : int
+        Number of passes to try merging the blocks further.
+
+    Returns
+    -------
+    merged_blocks : List[Block]
+        List of successfully merged Block objects (1 or more).
+    used_indices : List[int]
+        Indices of blocks that were used in any successful merge.
+    """
+    from itertools import combinations
+
+    remaining = list(enumerate(blocks))  # [(index, Block)]
+    used_indices = set()
+
+    # Initial merged_blocks are just the input blocks
+    merged_blocks = [blk for _, blk in remaining]
+    index_lookup = {id(blk): idx for idx, blk in remaining}
+
+    tries = 0
+    while len(merged_blocks) > 1 and tries < max_tries:
+        new_merged = []
+        merged_flags = [False] * len(merged_blocks)
+        used_this_pass = set()
+        skip = set()
+
+        i = 0
+        while i < len(merged_blocks):
+            if i in skip:
+                i += 1
+                continue
+
+            blk_a = merged_blocks[i]
+            merged = None
+            found = False
+
+            for j in range(i + 1, len(merged_blocks)):
+                if j in skip:
+                    continue
+                blk_b = merged_blocks[j]
+                face1, face2,_ = find_matching_faces(blk_a, blk_b, tol=tol)
+                if face1 is not None:
+                    try:
+                        merged = combine_2_blocks_mixed_pairing(blk_a, blk_b, tol=tol)
+                        found = True
+                        break
+                    except Exception as e:
+                        print(f"⚠️ Failed to merge blocks {i} and {j}: {e}")
+
+            if found:
+                new_merged.append(merged)
+                skip.update([i, j]) # type: ignore
+            else:
+                new_merged.append(blk_a)
+                skip.add(i)
+
+            i += 1
+
+        # Add any unmerged blocks at the end
+        for k in range(len(merged_blocks)):
+            if k not in skip:
+                new_merged.append(merged_blocks[k])
+
+        merged_blocks = new_merged
+        tries += 1
+
+    # Recover used indices (conservatively: all blocks involved in merging)
+    used_indices = list(range(len(blocks)))  # all blocks are assumed used here
+
+    return merged_blocks, used_indices
+
+def combine_nxnxn_cubes_mixed_pairs(
+    blocks: List[Block],
+    connectivities: List[List[Dict]],
+    cube_size: int = 2,
+    tol: float = 1e-8
+) -> List[Tuple[Block, Set[int]]]:
+    """
+    Find and combine all non-overlapping nxnxn cube groups of blocks
+    using face connectivity data and return the merged components.
+
+    Parameters
+    ----------
+    blocks : List[Block]
+        All input block objects.
+    connectivities : List of face match metadata pairs
+        Face connectivity between blocks.
+    cube_size : int
+        Size of the cube (e.g. 2 for 2x2x2, 4 for 4x4x4).
+    tol : float
+        Face match tolerance.
+
+    Returns
+    -------
+    List[Tuple[Block, Set[int]]]
+        A list of merged Block objects and their source block indices.
+    """
+    from itertools import product
+
+    used = set()
+    merged_groups = []
+    G = build_connectivity_graph(connectivities)
+
+    remaining_indices = list(range(len(blocks)))
+
+    def find_nxnxn_group(seed_index):
+        from collections import deque
+        visited = set()
+        queue = deque([seed_index])
+        group = set()
+
+        while queue and len(group) < cube_size ** 3:
+            idx = queue.popleft()
+            if idx in visited or idx in used:
+                continue
+            visited.add(idx)
+            group.add(idx)
+            for nbr in G.neighbors(idx):
+                if nbr not in visited and nbr not in used:
+                    queue.append(nbr)
+
+        return group if len(group) == cube_size ** 3 else None
+
+    while True:
+        before_len = len(remaining_indices)
+        merged_this_round = False
+        new_used = set()
+
+        i = 0
+        while i < len(remaining_indices):
+            seed_index = remaining_indices[i]
+            if seed_index in used:
+                i += 1
+                continue
+
+            group_indices = find_nxnxn_group(seed_index)
+            if not group_indices or group_indices & new_used:
+                i += 1
+                continue
+
+            group_block_list = [blocks[k] for k in sorted(group_indices)]
+            index_mapping = {i: orig_idx for i, orig_idx in enumerate(sorted(group_indices))}
+
+            try:
+                partial_merges, local_indices = combine_blocks_mixed_pairs(group_block_list, tol=tol)
+                for merged_block in partial_merges:
+                    merged_group = {index_mapping[i] for i in local_indices}
+                    merged_groups.append((merged_block, merged_group))
+                    # write_plot3D('block1.xyz',[merged_block])
+                    new_used.update(merged_group)
+                merged_this_round = True
+            except Exception as e:
+                print(f"⚠️ Skipping group {group_indices} due to error: {e}")
+                i += 1
+                continue
+
+            # Update remaining_indices and restart inner loop
+            remaining_indices = [idx for idx in remaining_indices if idx not in new_used]
+            i = 0
+
+        used.update(new_used)
+
+        if not merged_this_round or len(remaining_indices) == before_len:
+            print("✅ No further merges possible. Appending unmerged blocks.")
+            for idx in remaining_indices:
+                merged_groups.append((blocks[idx], {idx}))
+            break
+    
+    return merged_groups

plot3d-1.7.0/plot3d/blockfunctions.py

@@ -0,0 +1,361 @@
+from copy import deepcopy
+from itertools import combinations, product
+import math
+import numpy as np
+from typing import Dict, List, Optional, Set, Tuple
+from tqdm import trange
+from .facefunctions import create_face_from_diagonals, get_outer_faces, find_matching_faces,faces_match
+from .block import Block, reduce_blocks
+from .write import write_plot3D
+from .face import Face
+import tqdm
+import networkx as nx
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D  
+import numpy.typing as npt 
+
+def rotate_block(block,rotation_matrix:np.ndarray) -> Block:
+    """Rotates a block by a rotation matrix 
+
+    Args:
+        rotation_matrix (np.ndarray): 3x3 rotation matrix 
+
+    Returns:
+        Block: returns a new rotated block 
+    """
+    X = block.X.copy()
+    Y = block.Y.copy()
+    Z = block.Z.copy()
+    points = np.zeros(shape=(3,block.IMAX*block.JMAX*block.KMAX))
+    indx = 0
+    for i in range(block.IMAX):
+        for j in range(block.JMAX):
+            for k in range(block.KMAX):
+                points[0,indx] = block.X[i,j,k]
+                points[1,indx] = block.Y[i,j,k]
+                points[2,indx] = block.Z[i,j,k]
+                indx+=1
+    points_rotated = np.matmul(rotation_matrix,points)
+    indx=0
+    for i in range(block.IMAX):
+        for j in range(block.JMAX):
+            for k in range(block.KMAX):
+                X[i,j,k] = points_rotated[0,indx]
+                Y[i,j,k] = points_rotated[1,indx]
+                Z[i,j,k] = points_rotated[2,indx]
+                indx+=1
+                
+    return Block(X,Y,Z)
+
+def get_outer_bounds(blocks:List[Block]):
+    """Get outer bounds for a set of blocks
+
+    Args:
+        blocks (List[Block]): Blocks defining your shape
+
+    Returns:
+        (Tuple) containing: 
+
+            **xbounds** (Tuple[float,float]): xmin,xmax
+            **ybounds** (Tuple[float,float]): ymin,ymax
+            **zbounds** (Tuple[float,float]): zmin,zmax
+    """
+    xbounds = [blocks[0].X.min(),blocks[0].X.max()]
+    ybounds = [blocks[0].Y.min(),blocks[0].Y.max()]
+    zbounds = [blocks[0].Z.min(),blocks[0].Z.max()]
+    
+    for i in range(1,len(blocks)):
+        xmin = blocks[i].X.min()
+        xmax = blocks[i].X.max()
+
+        ymin = blocks[i].Y.min()
+        ymax = blocks[i].Y.max()
+
+        zmin = blocks[i].Z.min()
+        zmax = blocks[i].Z.max()
+
+        if xmin<xbounds[0]:
+            xbounds[0] = xmin
+        elif xmax>xbounds[1]:
+            xbounds[1] = xmax
+        
+        if ymin<ybounds[0]:
+            ybounds[0] = ymin
+        elif ymax>ybounds[1]:
+            ybounds[1] = ymax
+
+        if zmin<zbounds[0]:
+            zbounds[0] = zmin
+        elif zmax>zbounds[1]:
+            zbounds[1] = zmax
+    
+    return tuple(xbounds),tuple(ybounds),tuple(zbounds)
+
+def block_connection_matrix(blocks:List[Block],outer_faces:List[Dict[str,int]]=[],tol:float=1E-8):
+    """Creates a matrix representing how block edges are connected to each other 
+
+    Args:
+        blocks (List[Block]): List of blocks that describe the Plot3D mesh
+        outer_faces (List[Dict[str,int]], optional): List of outer faces remaining from connectivity. Useful if you are interested in finding faces that are exterior to the block. Also useful if you combine outerfaces with match faces, this will help identify connections by looking at split faces. Defaults to [].
+        tol (float, optional): Matching tolerance to look for when comparing face centroids.
+    
+    Returns:
+        (Tuple): containing
+
+            *connectivity* (np.ndarray): integer matrix defining how the blocks are connected to each other
+            *connectivity_i* (np.ndarray): integer matrix defining connectivity of all blocks where IMAX=IMIN
+            *connectivity_j* (np.ndarray): integer matrix defining connectivity of all blocks where JMAX=JMIN
+            *connectivity_k* (np.ndarray): integer matrix defining connectivity of all blocks where KMAX=KMIN
+            
+    """
+    # Reduce the size of the blocks by the GCD 
+    gcd_array = list()    
+    for block_indx in range(len(blocks)):
+        block = blocks[block_indx]
+        gcd_array.append(math.gcd(block.IMAX-1, math.gcd(block.JMAX-1, block.KMAX-1)))
+    gcd_to_use = min(gcd_array) # You need to use the minimum gcd otherwise 1 block may not exactly match the next block. They all have to be scaled the same way.
+    blocks = reduce_blocks(deepcopy(blocks),gcd_to_use)
+
+    # Face to List 
+    outer_faces_all = list()
+    for o in outer_faces:
+        face = create_face_from_diagonals(blocks[o['block_index']], int(o['IMIN']/gcd_to_use), int(o['JMIN']/gcd_to_use), 
+            int(o['KMIN']/gcd_to_use), int(o['IMAX']/gcd_to_use), int(o['JMAX']/gcd_to_use), int(o['KMAX']/gcd_to_use))
+        face.set_block_index(o['block_index'])
+        if "id" in o:
+            face.id = o['id']
+        outer_faces_all.append(face)
+
+    outer_faces = outer_faces_all
+
+    n = len(blocks)
+    connectivity = np.eye(n,dtype=np.int8)
+    combos = list(combinations(range(n),2))    
+    for indx in (pbar:=trange(len(combos))):
+        i,j = combos[indx]
+        pbar.set_description(f"Building block to block connectivity matrix: checking {i}")
+        b1 = blocks[i]
+
+        if len(outer_faces)==0:                     # Get the outerfaces to search
+            b1_outer_faces,_ = get_outer_faces(b1)
+        else:
+            b1_outer_faces = [o for o in outer_faces if o.BlockIndex == i] # type: ignore
+        
+        if i != j and connectivity[i,j]!=-1:
+            b2 = blocks[j]
+
+            if len(outer_faces)==0:                 # Get the outerfaces to search
+                b2_outer_faces,_ = get_outer_faces(b2)
+            else:
+                b2_outer_faces = [o for o in outer_faces if o.BlockIndex == j]                 # type: ignore
+
+            # Check to see if any of the outer faces of the blocks match   
+            connection_found=False             
+            for f1 in b1_outer_faces:
+                for f2 in b2_outer_faces:
+                    if (f1.is_connected(f2,tol)):   # type: ignore # Check if face centroid is the same
+                        connectivity[i,j] = 1       # Default block to block connection matrix 
+                        connectivity[j,i] = 1
+                        connection_found=True
+                        # c = np.sum(connectivity[i,:]==1)
+                        # print(f"block {i} connections {c}")
+                        break
+                if connection_found:
+                    break
+            if not connection_found:
+                connectivity[i,j] = -1
+                connectivity[j,i] = -1      
+    return connectivity
+
+def plot_blocks(blocks):
+    gcd_array = list()    
+    for block_indx in range(len(blocks)):
+        block = blocks[block_indx]
+        gcd_array.append(math.gcd(block.IMAX-1, math.gcd(block.JMAX-1, block.KMAX-1)))
+    gcd_to_use = min(gcd_array) # You need to use the minimum gcd otherwise 1 block may not exactly match the next block. They all have to be scaled the same way.
+    blocks = reduce_blocks(deepcopy(blocks),4)
+    
+    fig = plt.figure(figsize=(10, 8))
+    ax = fig.add_subplot(111, projection='3d')
+    markers = ['o', 's']  # alternate between circle and square
+
+    for i, b in enumerate(blocks):
+        color = f"C{i % 10}"
+        X, Y, Z = b.X, b.Y, b.Z
+        ax.scatter(X.ravel(), Y.ravel(), Z.ravel(), s=20, alpha=0.4, # type: ignore
+                   marker=markers[i % len(markers)], label=f'Block {i}', color=color)
+
+        # Draw lines along i-direction (axis 0)
+        for j in range(X.shape[1]):
+            for k in range(X.shape[2]):
+                ax.plot(X[:, j, k], Y[:, j, k], Z[:, j, k], color=color, linewidth=0.8, alpha=0.6)
+
+        # Draw lines along j-direction (axis 1)
+        for i_ in range(X.shape[0]):
+            for k in range(X.shape[2]):
+                ax.plot(X[i_, :, k], Y[i_, :, k], Z[i_, :, k], color=color, linewidth=0.8, alpha=0.6)
+
+        # Draw lines along k-direction (axis 2)
+        for i_ in range(X.shape[0]):
+            for j_ in range(X.shape[1]):
+                ax.plot(X[i_, j_, :], Y[i_, j_, :], Z[i_, j_, :], color=color, linewidth=0.8, alpha=0.6)
+
+    ax.set_xlabel('X')
+    ax.set_ylabel('Y')
+    ax.set_zlabel('Z') # type: ignore
+    ax.set_title('3D Block Grid with Connected Lines')
+    ax.legend()
+    plt.tight_layout()
+    plt.show()
+    
+def standardize_block_orientation(block:Block):
+    """Standardizes the orientation of a block so that its physical coordinates increase
+    consistently along each of the indexing axes:
+
+        - X increases along the i-axis
+        - Y increases along the j-axis
+        - Z increases along the k-axis
+
+    This ensures consistent face orientation and alignment across multiple blocks,
+    especially useful when merging, visualizing, or exporting grids. The function
+    checks the dominant physical component (X, Y, or Z) along each axis, and flips
+    the block along that axis if the component decreases.
+
+    Parameters:
+        block (Block): The input block to be standardized.
+
+    Returns:
+        Block: A new block instance with all three axes oriented consistently.
+    """
+
+    X, Y, Z = block.X.copy(), block.Y.copy(), block.Z.copy()
+    i_center = X.shape[0] // 2
+    j_center = X.shape[1] // 2
+    k_center = X.shape[2] // 2
+
+    # Check i-direction
+    dx_i = X[-1, j_center, k_center] - X[0, j_center, k_center]
+    if dx_i < 0:
+        X = np.flip(X, axis=0)
+        Y = np.flip(Y, axis=0)
+        Z = np.flip(Z, axis=0)
+
+    # Check j-direction
+    dy_j = Y[i_center, -1, k_center] - Y[i_center, 0, k_center]
+    if dy_j < 0:
+        X = np.flip(X, axis=1)
+        Y = np.flip(Y, axis=1)
+        Z = np.flip(Z, axis=1)
+
+    # Check k-direction
+    dz_k = Z[i_center, j_center, -1] - Z[i_center, j_center, 0]
+    if dz_k < 0:
+        X = np.flip(X, axis=2)
+        Y = np.flip(Y, axis=2)
+        Z = np.flip(Z, axis=2)
+
+    return Block(X, Y, Z)
+
+def checkCollinearity(v1:npt.NDArray, v2:npt.NDArray):
+    # Calculate their cross product
+    cross_P = np.cross(v1,v2) 
+ 
+    # Check if their cross product
+    # is a NULL Vector or not
+    if (cross_P[0] == 0 and
+        cross_P[1] == 0 and
+        cross_P[2] == 0):
+        return True
+    else:
+        return False
+    
+def calculate_outward_normals(block:Block):
+    # Calculate Normals
+    X = block.X
+    Y = block.Y
+    Z = block.Z
+    imax = block.IMAX
+    jmax = block.JMAX
+    kmax = block.KMAX 
+    # IMAX - Normal should be out of the page        
+    # Normals I direction: IMIN https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal
+    x = [X[0,0,0],X[0,jmax,0],X[0,0,kmax]] 
+    y = [Y[0,0,0],Y[0,jmax,0],Y[0,0,kmax]]
+    z = [Z[0,0,0],Z[0,jmax,0],Z[0,0,kmax]]
+    u = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]]) 
+    v = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
+    n_imin = np.cross(v1,v2) # type: ignore
+    
+    # Normals I direction: IMAX
+    x = [X[imax,0,0],X[imax,jmax,0],X[imax,0,kmax]] 
+    y = [Y[imax,0,0],Y[imax,jmax,0],Y[imax,0,kmax]]
+    z = [Z[imax,0,0],Z[imax,jmax,0],Z[imax,0,kmax]]
+    v1 = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]])
+    v2 = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
+    n_imax = np.cross(v1,v2)
+
+    # Normals J direction: JMIN
+    x = [X[0,0,0],X[imax,0,0],X[0,0,kmax]] 
+    y = [Y[0,0,0],Y[imax,0,0],Y[0,0,kmax]]
+    z = [Z[0,0,0],Z[imax,0,0],Z[0,0,kmax]]
+    v1 = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]])
+    v2 = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
+    n_jmin = np.cross(v1,v2)
+
+    # Normals J direction: JMAX
+    x = [X[0,jmax,0],X[imax,jmax,0],X[0,jmax,kmax]] 
+    y = [Y[0,jmax,0],Y[imax,jmax,0],Y[0,jmax,kmax]]
+    z = [Z[0,jmax,0],Z[imax,jmax,0],Z[0,jmax,kmax]]
+    v1 = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]])
+    v2 = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
+    n_jmax = np.cross(v1,v2)
+
+    # Normals K direction: KMIN
+    x = [X[imax,0,0],X[0,jmax,0],X[0,0,0]] 
+    y = [Y[imax,0,0],Y[0,jmax,0],Y[0,0,0]]
+    z = [Z[imax,0,0],Z[0,jmax,0],Z[0,0,0]]
+    v1 = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]])
+    v2 = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
+    n_kmin = np.cross(v1,v2)
+
+    # Normals K direction: KMAX
+    x = [X[imax,0,kmax],X[0,jmax,kmax],X[0,0,kmax]] 
+    y = [Y[imax,0,kmax],Y[0,jmax,kmax],Y[0,0,kmax]]
+    z = [Z[imax,0,kmax],Z[0,jmax,kmax],Z[0,0,kmax]]
+    v1 = np.array([x[1]-x[0],y[1]-y[0],z[1]-z[0]])
+    v2 = np.array([x[2]-x[0],y[2]-y[0],z[2]-z[0]])
+    n_kmax = np.cross(v1,v2)
+
+    return n_imin,n_jmin,n_kmin,n_imax,n_jmax,n_kmax
+
+def split_blocks(blocks:List[Block],gcd:int=4):
+    """Split blocks but also keep greatest common divisor
+
+    Args:
+        blocks (List[]): _description_
+        gcd (int, optional): _description_. Defaults to 4.
+    """
+    pass
+
+def common_neighbor(G: nx.Graph, a: int, b: int, exclude: Set[int]) -> Optional[int]:
+    """
+    Return a node that is connected to both `a` and `b` and not in `exclude`.
+    """
+    for n in G.neighbors(a):
+        if n in exclude:
+            continue
+        if G.has_edge(n, b):
+            return n
+    return None 
+
+def build_connectivity_graph(connectivities: List[List[Dict]]) -> nx.Graph:
+    """
+    Build an undirected graph from a list of face-to-face block connectivities.
+    Each edge connects two block indices.
+    """
+    G = nx.Graph()
+    for pair in connectivities:
+        block1 = pair['block1']['block_index'] # type: ignore
+        block2 = pair['block2']['block_index'] # type: ignore
+        G.add_edge(block1, block2)
+    return G

{plot3d-1.6.8 → plot3d-1.7.0}/plot3d/connectivity.py

@@ -58,8 +58,8 @@ def find_matching_blocks(block1:Block,block2:Block,block1_outer:List[Face], bloc
             if match:
                 break
         if match:
-            block1_outer.pop(p)
-            block2_outer.pop(q)
+            block1_outer.pop(p) # type: ignore
+            block2_outer.pop(q) # type: ignore
             block1_outer.extend(block1_split_faces)
             block2_outer.extend(block2_split_faces)
             block1_split_faces.clear()
@@ -395,10 +395,10 @@ def connectivity(blocks:List[Block]):
     outer_faces = list()      
     face_matches = list()
     matches_to_remove = list()
-    # df_matches, blocki_outerfaces, blockj_outerfaces = find_matching_blocks(blocks[4],blocks[7],1E-12)    # This function finds partial matches between blocks
     temp = [get_outer_faces(b) for b in blocks]
     block_outer_faces = [t[0] for t in temp]
     combos = combinations_of_nearest_blocks(blocks,6) # Find the 6 nearest Blocks and search through all that. 
+    # df_matches, blocki_outerfaces, blockj_outerfaces = find_matching_blocks(blocks[0],blocks[1],[block_outer_faces[0][0],block_outer_faces[0][1]],[block_outer_faces[1][0],block_outer_faces[1][1]],1E-12)    # This function finds partial matches between blocks
 
     t = trange(len(combos))    
     for indx in t:     # block i        

{plot3d-1.6.8 → plot3d-1.7.0}/plot3d/face.py

@@ -1,8 +1,21 @@
 from typing import Dict, List, Tuple
 import numpy as np
+import numpy.typing as npt
 import math
 
 class Face:
+    x:npt.NDArray
+    y:npt.NDArray
+    z:npt.NDArray
+    I:npt.NDArray
+    J:npt.NDArray
+    K:npt.NDArray
+    cx:float = 0
+    cy:float = 0 
+    cz:float = 0 
+    nvertex:int = 0 
+    blockIndex:int = 0 # not really needed except in periodicity 
+    id:int = 0 
     """Defines a Face of a block for example IMIN,JMIN,JMIN to IMAX,JMIN,JMIN
     """
     def __init__(self,nvertex:int=4):
@@ -18,12 +31,6 @@ class Face:
         self.I = np.zeros(4,dtype=np.int64)
         self.J = np.zeros(4,dtype=np.int64)
         self.K = np.zeros(4,dtype=np.int64)
-        self.cx = 0         # centroid 
-        self.cy = 0
-        self.cz = 0
-        self.nvertex=0
-        self.blockIndex = 0 # not really needed except in periodicity 
-        self.id = 0
         
     def to_dict(self):
         """Returns a dictionary representaon of a face
@@ -116,11 +123,6 @@ class Face:
         indx = list(set([indx_i]))[0] # Get the common one through a union
         return self.x[indx], self.y[indx], self.z[indx]
 
-    def scale(self,gcd:int):
-        self.I = int(self.I*gcd)
-        self.J = int(self.J*gcd)
-        self.K = int(self.K*gcd)
-
     def add_vertex(self, x:float,y:float,z:float, i:int, j:int, k:int):
         """Add vertex to define a face
 

{plot3d-1.6.8 → plot3d-1.7.0}/plot3d/facefunctions.py

@@ -1,10 +1,59 @@
-from typing import Dict, List
+from typing import Dict, List, Optional, Tuple
 from .listfunctions import unique_pairs
 from .block import Block, reduce_blocks
 from .face import Face 
 from copy import deepcopy
-import math
+import numpy.typing as npt
 import numpy as np
+import math
+
+def faces_match(face1: Tuple[npt.NDArray, npt.NDArray, npt.NDArray],face2: Tuple[npt.NDArray, npt.NDArray, npt.NDArray],tol: float = 1e-12) -> Tuple[bool, Optional[Tuple[bool, bool]]]:
+    """
+    Compare two block faces and return whether they match and the flip required on face2 to match face1.
+    Returns (True, (flip_ud, flip_lr)) if matching, otherwise (False, None).
+    """
+    def get_corners(X, Y, Z):
+        return np.array([
+            [X[0, 0], Y[0, 0], Z[0, 0]],
+            [X[0, -1], Y[0, -1], Z[0, -1]],
+            [X[-1, 0], Y[-1, 0], Z[-1, 0]],
+            [X[-1, -1], Y[-1, -1], Z[-1, -1]],
+        ])
+
+    X1, Y1, Z1 = face1
+    X2, Y2, Z2 = face2
+
+    if X1.shape != X2.shape:
+        return False, None
+
+    corners1 = get_corners(X1, Y1, Z1)
+    for flip_ud in [False, True]:
+        for flip_lr in [False, True]:
+            X2f, Y2f, Z2f = X2.copy(), Y2.copy(), Z2.copy()
+            if flip_ud:
+                X2f, Y2f, Z2f = np.flip(X2f, axis=0), np.flip(Y2f, axis=0), np.flip(Z2f, axis=0)
+            if flip_lr:
+                X2f, Y2f, Z2f = np.flip(X2f, axis=1), np.flip(Y2f, axis=1), np.flip(Z2f, axis=1)
+
+            corners2 = get_corners(X2f, Y2f, Z2f)
+            diffs = np.linalg.norm(corners1 - corners2, axis=1)
+            if np.all(diffs <= tol):
+                return True, (flip_ud, flip_lr)
+
+    return False, None
+def find_matching_faces(block1, block2, tol=1e-8):
+    """
+    Returns a tuple (face1_name, face2_name, flip_flags) if a matching face is found.
+    Otherwise returns (None, None, None).
+    """
+    faces1 = block1.get_faces()
+    faces2 = block2.get_faces()
+    for face1_name, face1_data in faces1.items():
+        for face2_name, face2_data in faces2.items():
+            match, flip_flags = faces_match(face1_data, face2_data, tol=tol)
+            if match:
+                return face1_name, face2_name, flip_flags
+    return None, None, None
 
 
 def get_outer_faces(block1:Block):
@@ -169,7 +218,6 @@ def find_connected_faces(face_to_search:Face,outer_faces:List[Face],connectivity
     all_matching_faces = list(set(all_matching_faces))  
     return all_matching_faces
 
-
 def find_closest_block(blocks:List[Block],x:np.ndarray,y:np.ndarray,z:np.ndarray,centroid:np.ndarray,translational_direction:str="x",minvalue:bool=True):
     """Find the closest block to an extreme in the x,y, or z direction and returns the targetting point. 
     Target point is the reference point where we want the closest block and the closest face 

{plot3d-1.6.8 → plot3d-1.7.0}/pyproject.toml

@@ -1,18 +1,18 @@
 [tool.poetry]
 name = "plot3d"
-version = "1.6.8"
+version = "1.7.0"
 description = "Plot3D python utilities for reading and writing and also finding connectivity between blocks"
 authors = ["Paht Juangphanich <paht.juangphanich@nasa.gov>"]
 
 [tool.poetry.dependencies]
-python = "^3.10.1"
-numpy = "2.*"
+python = "^3.10.12"
+numpy = "*"
 scipy = "*"
 pandas = "*"
 tqdm = "*"
 networkx = "*"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.deve.dependencies]
 
 [build-system]
 requires = ["poetry>=1.1.2"]

plot3d-1.6.8/plot3d/blockfunctions.py

@@ -1,179 +0,0 @@
-from copy import deepcopy
-from itertools import combinations
-import math
-import numpy as np
-from typing import Dict, List
-from tqdm import trange
-from .facefunctions import create_face_from_diagonals, get_outer_faces
-from .block import Block
-from .face import Face
-
-def rotate_block(block,rotation_matrix:np.ndarray) -> Block:
-    """Rotates a block by a rotation matrix 
-
-    Args:
-        rotation_matrix (np.ndarray): 3x3 rotation matrix 
-
-    Returns:
-        Block: returns a new rotated block 
-    """
-    X = block.X.copy()
-    Y = block.Y.copy()
-    Z = block.Z.copy()
-    points = np.zeros(shape=(3,block.IMAX*block.JMAX*block.KMAX))
-    indx = 0
-    for i in range(block.IMAX):
-        for j in range(block.JMAX):
-            for k in range(block.KMAX):
-                points[0,indx] = block.X[i,j,k]
-                points[1,indx] = block.Y[i,j,k]
-                points[2,indx] = block.Z[i,j,k]
-                indx+=1
-    points_rotated = np.matmul(rotation_matrix,points)
-    indx=0
-    for i in range(block.IMAX):
-        for j in range(block.JMAX):
-            for k in range(block.KMAX):
-                X[i,j,k] = points_rotated[0,indx]
-                Y[i,j,k] = points_rotated[1,indx]
-                Z[i,j,k] = points_rotated[2,indx]
-                indx+=1
-                
-    return Block(X,Y,Z)
-
-def reduce_blocks(blocks:List[Block],factor:int):
-    """reduce the blocks by a factor of (factor)
-
-    Args:
-        blocks (List[Block]): list of blocks to reduce in size
-        factor (int, optional): Number of indicies to skip . Defaults to 2.
-
-    Returns:
-        [type]: [description]
-    """
-    for i in range(len(blocks)):
-        blocks[i].X = blocks[i].X[::factor,::factor,::factor]
-        blocks[i].Y = blocks[i].Y[::factor,::factor,::factor]
-        blocks[i].Z = blocks[i].Z[::factor,::factor,::factor]
-        blocks[i].IMAX,blocks[i].JMAX,blocks[i].KMAX = blocks[i].X.shape
-    return blocks
-
-def get_outer_bounds(blocks:List[Block]):
-    """Get outer bounds for a set of blocks
-
-    Args:
-        blocks (List[Block]): Blocks defining your shape
-
-    Returns:
-        (Tuple) containing: 
-
-            **xbounds** (Tuple[float,float]): xmin,xmax
-            **ybounds** (Tuple[float,float]): ymin,ymax
-            **zbounds** (Tuple[float,float]): zmin,zmax
-    """
-    xbounds = [blocks[0].X.min(),blocks[0].X.max()]
-    ybounds = [blocks[0].Y.min(),blocks[0].Y.max()]
-    zbounds = [blocks[0].Z.min(),blocks[0].Z.max()]
-    
-    for i in range(1,len(blocks)):
-        xmin = blocks[i].X.min()
-        xmax = blocks[i].X.max()
-
-        ymin = blocks[i].Y.min()
-        ymax = blocks[i].Y.max()
-
-        zmin = blocks[i].Z.min()
-        zmax = blocks[i].Z.max()
-
-        if xmin<xbounds[0]:
-            xbounds[0] = xmin
-        elif xmax>xbounds[1]:
-            xbounds[1] = xmax
-        
-        if ymin<ybounds[0]:
-            ybounds[0] = ymin
-        elif ymax>ybounds[1]:
-            ybounds[1] = ymax
-
-        if zmin<zbounds[0]:
-            zbounds[0] = zmin
-        elif zmax>zbounds[1]:
-            zbounds[1] = zmax
-    
-    return tuple(xbounds),tuple(ybounds),tuple(zbounds)
-
-def block_connection_matrix(blocks:List[Block],outer_faces:List[Dict[str,int]]=[],tol:float=1E-8):
-    """Creates a matrix representing how block edges are connected to each other 
-
-    Args:
-        blocks (List[Block]): List of blocks that describe the Plot3D mesh
-        outer_faces (List[Dict[str,int]], optional): List of outer faces remaining from connectivity. Useful if you are interested in finding faces that are exterior to the block. Also useful if you combine outerfaces with match faces, this will help identify connections by looking at split faces. Defaults to [].
-        tol (float, optional): Matching tolerance to look for when comparing face centroids.
-    
-    Returns:
-        (Tuple): containing
-
-            *connectivity* (np.ndarray): integer matrix defining how the blocks are connected to each other
-            *connectivity_i* (np.ndarray): integer matrix defining connectivity of all blocks where IMAX=IMIN
-            *connectivity_j* (np.ndarray): integer matrix defining connectivity of all blocks where JMAX=JMIN
-            *connectivity_k* (np.ndarray): integer matrix defining connectivity of all blocks where KMAX=KMIN
-            
-    """
-    # Reduce the size of the blocks by the GCD 
-    gcd_array = list()    
-    for block_indx in range(len(blocks)):
-        block = blocks[block_indx]
-        gcd_array.append(math.gcd(block.IMAX-1, math.gcd(block.JMAX-1, block.KMAX-1)))
-    gcd_to_use = min(gcd_array) # You need to use the minimum gcd otherwise 1 block may not exactly match the next block. They all have to be scaled the same way.
-    blocks = reduce_blocks(deepcopy(blocks),gcd_to_use)
-
-    # Face to List 
-    outer_faces_all = list()
-    for o in outer_faces:
-        face = create_face_from_diagonals(blocks[o['block_index']], int(o['IMIN']/gcd_to_use), int(o['JMIN']/gcd_to_use), 
-            int(o['KMIN']/gcd_to_use), int(o['IMAX']/gcd_to_use), int(o['JMAX']/gcd_to_use), int(o['KMAX']/gcd_to_use))
-        face.set_block_index(o['block_index'])
-        if "id" in o:
-            face.id = o['id']
-        outer_faces_all.append(face)
-
-    outer_faces = outer_faces_all
-
-    n = len(blocks)
-    connectivity = np.eye(n,dtype=np.int8)
-    combos = list(combinations(range(n),2))    
-    for indx in (pbar:=trange(len(combos))):
-        i,j = combos[indx]
-        pbar.set_description(f"Building block to block connectivity matrix: checking {i}")
-        b1 = blocks[i]
-
-        if len(outer_faces)==0:                     # Get the outerfaces to search
-            b1_outer_faces,_ = get_outer_faces(b1)
-        else:
-            b1_outer_faces = [o for o in outer_faces if o.BlockIndex == i]
-        
-        if i != j and connectivity[i,j]!=-1:
-            b2 = blocks[j]
-
-            if len(outer_faces)==0:                 # Get the outerfaces to search
-                b2_outer_faces,_ = get_outer_faces(b2)
-            else:
-                b2_outer_faces = [o for o in outer_faces if o.BlockIndex == j]                
-
-            # Check to see if any of the outer faces of the blocks match   
-            connection_found=False             
-            for f1 in b1_outer_faces:
-                for f2 in b2_outer_faces:
-                    if (f1.is_connected(f2,tol)):   # Check if face centroid is the same
-                        connectivity[i,j] = 1       # Default block to block connection matrix 
-                        connectivity[j,i] = 1
-                        connection_found=True
-                        # c = np.sum(connectivity[i,:]==1)
-                        # print(f"block {i} connections {c}")
-                        break
-                if connection_found:
-                    break
-            if not connection_found:
-                connectivity[i,j] = -1
-                connectivity[j,i] = -1      
-    return connectivity