def are_points_oob(self,points): """ Check if points are out-of-bounds """ (N,D) = points.shape assert D == self.dim L = np.any(points < row_vect(self.lower_bound),axis=1) U = np.any(points > row_vect(self.upper_bound) + self.fuzz,axis=1) assert (N,) == L.shape assert (N,) == U.shape return np.logical_or(L,U)
def cell_coords_to_low_points(self,cell_coords): assert isinstance(cell_coords,Coordinates) assert self.dim == cell_coords.dim assert cell_coords.check() C = cell_coords.coords oob = cell_coords.oob assert np.all(np.isnan(C[oob.mask,:])) low_points = row_vect(self.lower_bound) + C * row_vect(self.delta) assert is_mat(low_points) assert np.all(np.isnan(low_points[oob.mask,:])) assert cell_coords.shape == low_points.shape return low_points
def build_from_points(self,grid,points): assert is_mat(points) (N,D) = points.shape self.dim = D self.num = N self.shape = (N,D) low = grid.get_lower_boundary() high = grid.get_upper_boundary() # What boundary is violated; # -1 lower boundary, # +1 upper boundary U = sps.csc_matrix(points > high,dtype=np.integer) L = sps.csc_matrix(points < row_vect(low),dtype=np.integer) self.data = U - L # Mask of same self.mask = np.zeros(N,dtype=bool) oob_rows = self.data.nonzero()[0] self.mask[oob_rows] = True assert isinstance(self.mask,np.ndarray) assert (N,) == self.mask.shape # Sanity check assert np.all(self.mask == grid.are_points_oob(points)) # Pre-offset oob node or cell indices self.indices = self.find_oob_index() assert is_vect(self.indices) assert np.all(np.isnan(self.indices) == ~self.mask) assert self.check()
def node_indices_to_node_points(self,node_indices): assert is_vect(node_indices) (N,) = node_indices.shape node_coords = self.node_indexer.indices_to_coords(node_indices) assert isinstance(node_coords,Coordinates) oob = node_coords.oob C = node_coords.coords assert np.all(np.isnan(C[oob.mask,:])) node_points = row_vect(self.lower_bound) + C * row_vect(self.delta) assert is_mat(node_points) assert np.all(np.isnan(node_points[oob.mask,:])) assert node_coords.shape == node_points.shape return node_points
def get_neighbors(self,indices): (N,) = indices.shape D = self.dim shift = self.cell_shift() neighbors = col_vect(indices) + row_vect(shift) assert((N,2**D) == neighbors.shape) return neighbors
def cell_indices_to_mid_points(self,cell_indices): assert is_vect(cell_indices) low_points = cell_indices_to_low_points(self,cell_indices) mid_points = low_points + row_vect(0.5 * self.delta) assert is_mat(mid_points) assert mid_points.shape[0] == cell_indices.shape[0] return mid_points
def cell_coords_to_vertex_indices(self,cell_coords): assert isinstance(cell_coords,Coordinates) (N,D) = cell_coords.shape assert self.dim == D """ The low node index in the cell has the same coords in node-land as the cell in cell-land: | | -o - o- | x | -x - o- | | """ low_vertex = self.node_indexer.coords_to_indices(cell_coords) # Array of index offsets to reach every vertex in cell shift = self.node_indexer.cell_shift() assert (2**D,) == shift.shape vertices = col_vect(low_vertex) + row_vect(shift) assert (N,2**D) == vertices.shape """ Handle out of bound nodes. There is a constant offset for converting cell oob indices to node oob indices. Also the difference between max spatial indices. """ oob = cell_coords.oob if oob.has_oob(): # Figure out the right oob node oob_indices = cell_coords.oob.indices[oob.mask] offset = self.node_indexer.get_num_spatial_nodes() vertices[oob.mask,0] = oob_indices + offset vertices[oob.mask,1:] = np.nan return vertices
def are_coords_oob(self,coords): (N,D) = coords.shape assert D == self.dim L = np.any(coords < 0,axis=1) U = np.any(coords >= row_vect(self.lens),axis=1) return np.logical_or(L,U)