def pw_transform(self, pwfn, verbose=False, **kwargs): """Spawn another frame sequence, pixelwise applying a user-provided function. Parameters: - `pwfn`: (`func`) -- a ``f(vector) -> vector`` function - `verbose`: (`Bool`) -- whether to be verbose while going through the pixels - `**kwargs``: keyword arguments to be passed to `self.pix_iter` """ #nrows, ncols = self.shape()[:2] if 'dtype' in kwargs: dtype = kwargs['dtype'] else: dtype = _dtype_ L = len(pwfn(np.random.randn(len(self)))) #testv = pwfn(self.pix_iter(rand=True,**kwargs).next()[0]) #L = len(testv) out = lib.memsafe_arr((L,) + self.shape(), dtype) for v, row, col in self.pix_iter(**kwargs): if verbose: sys.stderr.write('\rworking on pixel (%03d,%03d)'%(row, col)) out[:,row,col] = pwfn(v) if hasattr(out, 'flush'): out.flush() ## assuming the dz is not changed. if it *is*, provide new meta ## in kwargs if 'meta' in kwargs: newmeta = kwargs['meta'].copy() else: newmeta = self.meta.copy() return FSeq_arr(out, meta=newmeta)
def supp_from_obj(object, min_level=0, max_level=10, verbose=0, mode=0, weights=None): """Return support arrays from object""" sh = object.labels.shape new_shape = [object.level + 1] + list(sh) out = lib.memsafe_arr(new_shape, _dtype_) flat = flat_tree(object) nfl = len(flat) if weights is None: weights = [1] * (object.level + 1) for j, n in enumerate(flat): if verbose: sys.stderr.write('\rnode %d out of %d' % (j + 1, nfl)) if n.level > min_level and n.level <= max_level: val = weights[n.level] if mode == 1: out[n.level][n.labels == n.ind] = val elif mode == 2: out[n.level][n.labels == n.ind] = n.ind else: out[n.level][n.slice] = np.where(n.labels[n.slice] == n.ind, val, 0) return out
def as3darray(self, fslice=None, crop=None, dtype = _dtype_): """Return the frames as a `3D` array. //An alternative way is to use the __getitem__ interface: //``data = np.asarray(fs[10:100])`` Parameters: - `fslice`: (`int`, `tuple-like` or `None`) -- [start,] stop [, step] to go through frames - `crop`: (`slice` or `None`) -- a crop (tuple of slices) to take from each frame - `dtype`: (`type`) -- data type to use. Default, ``np.float64`` Returns: `3D` array `d`, where frames are stored in higher dimensions, such that ``d[0]`` is the first frame, etc. """ if fslice is None or isinstance(fslice, int): fslice = (fslice, ) shape = self.shape(crop) newshape = (len(self),) + shape out = lib.memsafe_arr(newshape, dtype) for k,frame in enumerate(itt.islice(self.frames(), *fslice)): out[k,:,:] = frame[crop] out = out[:k+1] if hasattr (out, 'flush'): out.flush() return out
def supp_from_connectivity(graph, nlevels): nodes = lib.flatten(graph) sh = nodes[0].labels.shape new_shape = [nlevels] + list(sh) out = lib.memsafe_arr(new_shape, _dtype_) * 0.0 for n in nodes: out[n.level][n.labels > 0] = 1.0 return out