Python numpy 模块，atleast_3d() 实例源码

def to_rgb(img):
    """
    Converts the given array into a RGB image. If the number of channels is not
    3 the array is tiled such that it has 3 channels. Finally, the values are
    rescaled to [0,255) 

    :param img: the array to convert [nx, ny, channels]

    :returns img: the rgb image [nx, ny, 3]
    """
    img = np.atleast_3d(img)
    channels = img.shape[2]
    if channels < 3:
        img = np.tile(img, 3)

    img[np.isnan(img)] = 0
    img -= np.amin(img)
    img /= np.amax(img)
    img *= 255
    return img

def new_mesh_sampler(camera, render_source, engine):
    params = ensure_code_unit_params(camera._get_sampler_params(render_source))
    args = (
        np.atleast_3d(params['vp_pos']),
        np.atleast_3d(params['vp_dir']),
        params['center'],
        params['bounds'],
        np.atleast_3d(params['image']).astype('float64'),
        params['x_vec'],
        params['y_vec'],
        params['width'],
    )
    kwargs = {'lens_type': params['lens_type']}
    if engine == 'embree':
        sampler = mesh_traversal.EmbreeMeshSampler(*args, **kwargs)
    elif engine == 'yt':
        sampler = bounding_volume_hierarchy.BVHMeshSampler(*args, **kwargs)
    return sampler

def new_interpolated_projection_sampler(camera, render_source):
    params = ensure_code_unit_params(camera._get_sampler_params(render_source))
    params.update(transfer_function=render_source.transfer_function)
    params.update(num_samples=render_source.num_samples)
    args = (
        np.atleast_3d(params['vp_pos']),
        np.atleast_3d(params['vp_dir']),
        params['center'],
        params['bounds'],
        params['image'],
        params['x_vec'],
        params['y_vec'],
        params['width'],
        params['num_samples'],
    )
    kwargs = {'lens_type': params['lens_type']}
    if render_source.zbuffer is not None:
        kwargs['zbuffer'] = render_source.zbuffer.z
    else:
        kwargs['zbuffer'] = np.ones(params['image'].shape[:2], "float64")
    sampler = InterpolatedProjectionSampler(*args, **kwargs)
    return sampler

def to_rgb(img):
    """
    Converts the given array into a RGB image. If the number of channels is not
    3 the array is tiled such that it has 3 channels. Finally, the values are
    rescaled to [0,255) 

    :param img: the array to convert [nx, ny, channels]

    :returns img: the rgb image [nx, ny, 3]
    """
    img = np.atleast_3d(img)
    channels = img.shape[2]
    if channels < 3:
        img = np.tile(img, 3)

    img[np.isnan(img)] = 0
    img -= np.amin(img)
    img /= np.amax(img)
    img *= 255
    return img

def getData(X,F,window=(30,30),N=10):
    """
    #????? ? ????????????? ?????
    ?????? ?N:int
    ??: X:ndarray
    ?????: F:ndarray
    ????? window:tuple[int,int]
    """
    Y=[]
    windowGen=[]
    ysets= np.unique(F)
    def toY(i,j):
        windowGen.append([i,j,window[0],window[1]])
        a=list(np.hstack( np.atleast_2d (F[i:i+window[0],j:j+window[1]])) )
        Y.append(np.array( [a.count(i) for i in ysets ]) )
        Y[-1]= ysets[Y[-1]==max(Y[-1])][0]
        return np.atleast_3d([X[i:i+window[0],j:j+window[1]]])

    Xs=sum([[ toY(i,j) for j in  range(0,X.shape[1]-window[1]-1,N)] 
     for i in range(0,X.shape[0]-window[0]-1,10)],[])
    return np.array(Xs),np.array(Y),windowGen

def __init__(self, directory, filepath, image_size):
        """
        Constructor for an JAFFEInstance object.

        Args:
            directory (str): Base directory where the example lives.
            filename (str): The name of the file of the example.
            image_size (tuple<int>): Size to resize the image to.
        """

        filename = filepath.split('/')[-1]

        self.image = misc.imread( os.path.join(directory, filepath) )
        # some of the jaffe images are 3-channel greyscale, some are 1-channel!
        self.image = np.atleast_3d(self.image)[...,0] # make image 2d for sure
        # Resize and scale values to [0 1]
        self.image = misc.imresize( self.image, image_size )
        self.image = self.image / 255.0
        ident, _, N, _ = filename.split('.')
        # Note: the emotion encoded in the filename is the dominant
        # scoring emotion, but we ignore this and use precise emotion scores
        # from the semantic ratings table
        self.identity, self.N = ident, int(N) - 1 # 0-based instance numbering

def rotate_points(image, obj_list, angle):
        '''
        Rotates the points of the given objects by the given angle. The points will be translated
        into absolute coordinates. Therefore the image (resp. its shape) is needed.
        '''

        rotated_obj_list = []
        cosOfAngle = np.cos(2 * np.pi / 360 * -angle)
        sinOfAngle = np.sin(2 * np.pi / 360 * -angle)
        image_shape = np.array(np.atleast_3d(image).shape[0:2][::-1])
        rot_mat = np.array([[cosOfAngle, -sinOfAngle], [sinOfAngle, cosOfAngle]])
        for obj in obj_list:
            obj_name = obj[0]
            point = obj[1] * image_shape
            rotated_point = AugmentationCreator._rotate_vector_around_point(image_shape/2, point, rot_mat) / image_shape
            rotated_obj_list.append((obj_name, (rotated_point[0], rotated_point[1])))

        return rotated_obj_list

def rotate_bboxes(image, obj_list, angle):
        '''
        Rotates the bounding boxes of the given objects by the given angle. The bounding box will be
        translated into absolute coordinates. Therefore the image (resp. its shape) is needed.
        '''

        rotated_obj_list = []
        cosOfAngle = np.cos(2 * np.pi / 360 * -angle)
        sinOfAngle = np.sin(2 * np.pi / 360 * -angle)
        image_shape = np.array(np.atleast_3d(image).shape[0:2][::-1])
        rot_mat = np.array([[cosOfAngle, -sinOfAngle], [sinOfAngle, cosOfAngle]])
        for obj in obj_list:
            obj_name = obj[0]
            upper_left = obj[1]['upper_left'] * image_shape
            lower_right = obj[1]['lower_right'] * image_shape
            upper_left = AugmentationCreator._rotate_vector_around_point(image_shape/2, upper_left, rot_mat) / image_shape
            lower_right = AugmentationCreator._rotate_vector_around_point(image_shape/2, lower_right, rot_mat) / image_shape
            rotated_obj_list.append((obj_name, {'upper_left' : upper_left, 'lower_right' : lower_right}))

        return rotated_obj_list

def get_interpolated_pixel_color_rbspline(pts, s_im, size):
    """given pts in floats, linear interpolate pixel values nearby to get a good colour"""
    pts = clamp(pts, size)

    s_im = np.atleast_3d(s_im)
    ys,xs = size
    ycoords, xcoords = np.arange(ys), np.arange(xs)
    out = np.empty(pts.shape[1:] + (s_im.shape[-1],),dtype=s_im.dtype)

    pts_vec = pts.reshape((2,-1))
    out_vec = out.reshape((-1,s_im.shape[-1])) #flatten for easier vectorization
    for i in range(s_im.shape[-1]): #loop over color channels
        rbspline = RectBivariateSpline(ycoords, xcoords, s_im[...,i])
        out_vec[:,i] = rbspline.ev(pts_vec[0],pts_vec[1])
    return out


### Functions generating SL(2,C) matrices ###
# Do not need to be vectorized #

def apply_SL2C_elt_to_image(M_SL2C, src_image, out_size=None):

    s_im = np.atleast_3d(src_image)
    in_size = s_im.shape[:-1]
    if out_size is None:
        out_size = in_size
    #We are going to find the location in the source image that each pixel in the output image comes from

    #least squares matrix inversion (find X such that M @ X = I ==> X = inv(M) @ I = inv(M))
    Minv = np.linalg.lstsq(M_SL2C, np.eye(2))[0]
    #all of the x,y pairs in o_im:
    pts_out = np.indices(out_size).reshape((2,-1)) #results in a 2 x (num pixels) array of indices
    pts_out_a = angles_from_pixel_coords(pts_out, out_size)
    pts_out_s = sphere_from_angles(pts_out_a)
    pts_out_c = CP1_from_sphere(pts_out_s)
    pts_in_c = np.dot(Minv, pts_out_c) # (2x2) @ (2xn) => (2xn)
    pts_in_s = sphere_from_CP1(pts_in_c)
    pts_in_a = angles_from_sphere(pts_in_s)
    pts_in = pixel_coords_from_angles(pts_in_a, in_size)
    #reshape pts into 2 x image_shape for the interpolation
    o_im = get_interpolated_pixel_color(pts_in.reshape((2,)+out_size), s_im, in_size)

    return o_im

def _addto_netcdf(nf,var,data,units,long_name,notime=False):

    dimensions = nf.dimensions.items()

    if notime:
        dims = []
    else:
        dims = ['time',]

    for data_len in data.shape:
        dims.extend([dim for dim,dim_len in dimensions \
                     if dim_len.size==data_len])

    # WARNING: This only works for 2D lon/lat, this needs to change
    if len(dims)==3:
        input_data = np.atleast_3d(data.T).T
    else:
        input_data = data

    _create_variable(nf,var,tuple(dims))
    _insert_data(nf,var,input_data,units,long_name)

def spacegroup_from_data(no=None, symbol=None, setting=1, 
                         centrosymmetric=None, scaled_primitive_cell=None, 
                         reciprocal_cell=None, subtrans=None, sitesym=None, 
                         rotations=None, translations=None, datafile=None):
    """Manually create a new space group instance.  This might be
    usefull when reading crystal data with its own spacegroup
    definitions."""
    if no is not None:
        spg = Spacegroup(no, setting, datafile)
    elif symbol is not None:
        spg = Spacegroup(symbol, setting, datafile)
    else:
        raise SpacegroupValueError('either *no* or *symbol* must be given')

    have_sym = False
    if centrosymmetric is not None:
        spg._centrosymmetric = bool(centrosymmetric)
    if scaled_primitive_cell is not None:
        spg._scaled_primitive_cell = np.array(scaled_primitive_cell)
    if reciprocal_cell is not None:
        spg._reciprocal_cell = np.array(reciprocal_cell)
    if subtrans is not None:
        spg._subtrans = np.atleast_2d(subtrans)
        spg._nsubtrans = spg._subtrans.shape[0]
    if sitesym is not None:
        spg._rotations, spg._translations = parse_sitesym(sitesym)
        have_sym = True
    if rotations is not None:
        spg._rotations = np.atleast_3d(rotations)
        have_sym = True
    if translations is not None:
        spg._translations = np.atleast_2d(translations)
        have_sym = True
    if have_sym:
        if spg._rotations.shape[0] != spg._translations.shape[0]:
            raise SpacegroupValueError('inconsistent number of rotations and '
                                       'translations')
        spg._nsymop = spg._rotations.shape[0]
    return spg

def __new__(self, time, y, x, clf='lda', cvtype=None, clfArg={},
                cvArg={}):

        self.y = np.ravel(y)
        self.time = time

        # Define clf if it's not defined :
        if isinstance(clf, (int, str)):
            clf = defClf(y, clf=clf, **clfArg)
        self.clf = clf

        # Define cv if it's not defined :
        if isinstance(cvtype, str) and (cvtype is not None):
            cvtype = defCv(y, cvtype=cvtype, rep=1, **cvArg)
        self.cv = cvtype
        if isinstance(cvtype, list):
            cvtype = cvtype[0]
        # Check the size of x:
        x = np.atleast_3d(x)
        npts, ntrials = len(time), len(y)
        if x.shape[0] is not npts:
            raise ValueError('First dimension of x must be '+str(npts))
        if x.shape[1] is not ntrials:
            raise ValueError('Second dimension of x must be '+str(ntrials))

        da = np.zeros([npts, npts])
        # Training dimension
        for k in range(npts):
            xx = x[k, ...]
            # Testing dimension
            for i in range(npts):
                xy = x[i, ...]
                # If cv is defined, do a cv on the diagonal
                if (k == i) and (cvtype is not None):
                    da[i, k] = _cvscore(xx, y, clf, self.cv.cvr[0])[0]/100
                # If cv is not defined, let the diagonal at zero
                elif (k == i) and (cvtype is None):
                    pass
                else:
                    da[i, k] = accuracy_score(y, clf.fit(xx, y).predict(xy))
        return 100*da

def get_img_layout(
        file_records, frames_layout, tags,
        z_slice = 15,
        spacing_v = 5,
        spacing_h = 5,
        color=255,
):
    img_layout = None
    n_rows = len(frames_layout)
    n_cols = len(tags)
    for r, idx_frame in enumerate(frames_layout):
        print('frame:', idx_frame)
        tag_path_dict = file_records.get(idx_frame)
        if tag_path_dict is None:
            print('frame {:d} did not exist. skipping....'.format(idx_frame))
            continue
        offset_r = None
        for c, tag in enumerate(tags):
            path_this_tag = tag_path_dict.get(tag)
            print('using path:', path_this_tag)
            if path_this_tag is None:
                continue
            ar = tifffile.imread(path_this_tag)
            if img_layout is None:
                shape_layout = (
                    ar.shape[1]*n_rows + (n_rows - 1)*spacing_v,
                    ar.shape[2]*n_cols + (n_cols - 1)*spacing_h,
                    3,  # assume color image
                )
                img_layout = np.ones(shape_layout, dtype=np.uint8)*color
            if offset_r is None:
                offset_r = r*(ar.shape[1] + spacing_v)
            offset_c = c*(ar.shape[2] + spacing_h)
            img = np.atleast_3d(ar[z_slice, :, :, ])
            if (r, c) == (0, 0):
                functions.add_scale_bar(img, 20, 0.3)
            img_layout[offset_r:offset_r + ar.shape[1], offset_c:offset_c + ar.shape[2], ] = img
    return img_layout

def get_sampler_args(self, image):
        rotp = np.concatenate([self.orienter.inv_mat.ravel('F'), self.back_center.ravel()])
        args = (np.atleast_3d(rotp), np.atleast_3d(self.box_vectors[2]),
                self.back_center,
                (-self.width[0]/2.0, self.width[0]/2.0,
                 -self.width[1]/2.0, self.width[1]/2.0),
                image, self.orienter.unit_vectors[0], self.orienter.unit_vectors[1],
                np.array(self.width, dtype='float64'), self.transfer_function, self.sub_samples)
        return args, {'lens_type': 'plane-parallel'}

def get_sampler_args(self, image):
        rotp = np.concatenate([self.orienter.inv_mat.ravel('F'), self.back_center.ravel()])
        args = (np.atleast_3d(rotp), np.atleast_3d(self.box_vectors[2]),
                self.back_center,
            (-self.width[0]/2., self.width[0]/2.,
             -self.width[1]/2., self.width[1]/2.),
            image, self.orienter.unit_vectors[0], self.orienter.unit_vectors[1],
                np.array(self.width, dtype='float64'), self.sub_samples)
        return args, {'lens_type': 'plane-parallel'}

def new_volume_render_sampler(camera, render_source):
    params = ensure_code_unit_params(camera._get_sampler_params(render_source))
    params.update(transfer_function=render_source.transfer_function)
    params.update(transfer_function=render_source.transfer_function)
    params.update(num_samples=render_source.num_samples)
    args = (
        np.atleast_3d(params['vp_pos']),
        np.atleast_3d(params['vp_dir']),
        params['center'],
        params['bounds'],
        params['image'],
        params['x_vec'],
        params['y_vec'],
        params['width'],
        params['transfer_function'],
        params['num_samples'],
    )
    kwargs = {'lens_type': params['lens_type']}
    if "camera_data" in params:
        kwargs['camera_data'] = params['camera_data']
    if render_source.zbuffer is not None:
        kwargs['zbuffer'] = render_source.zbuffer.z
        args[4][:] = np.reshape(render_source.zbuffer.rgba[:], \
            (camera.resolution[0], camera.resolution[1], 4))
    else:
        kwargs['zbuffer'] = np.ones(params['image'].shape[:2], "float64")

    sampler = VolumeRenderSampler(*args, **kwargs)
    return sampler

def select_blocks(self, selector):
        mask = self.oct_handler.mask(selector, domain_id = self.domain_id)
        slicer = OctreeSubsetBlockSlice(self)
        for i, sl in slicer:
            yield sl, np.atleast_3d(mask[i,...])

def getData(X,F,window=(30,30),N=10):
    Y=[]

    windowGen=[]
#    ysets= np.unique(F)
    def toY(i,j):
        windowGen.append([i,j,window[0],window[1]])
        Y.append(np.sum(F[i:i+window[0],j:j+window[1]])/(window[0]*window[1]))
#        Y[-1]= ysets[Y[-1]==max(Y[-1])][0]
        Y[-1]=1 if Y[-1]>0.6 else 0
        return np.atleast_3d([X[i:i+window[0],j:j+window[1]]])

    Xs=sum([[ toY(i,j) for j in  range(0,X.shape[1]-window[1]-1,N)] 
     for i in range(0,X.shape[0]-window[0]-1,10)],[])
    return np.array(Xs),np.array(Y),windowGen

def fit(self, epochs_data, y):
        """Standardizes data across channels

        Parameters
        ----------
        epochs_data : array, shape (n_epochs, n_channels, n_times)
            The data to concatenate channels.
        y : array, shape (n_epochs,)
            The label for each epoch.

        Returns
        -------
        self : instance of Scaler
            Returns the modified instance.
        """
        if not isinstance(epochs_data, np.ndarray):
            raise ValueError("epochs_data should be of type ndarray (got %s)."
                             % type(epochs_data))

        X = np.atleast_3d(epochs_data)

        picks_list = dict()
        picks_list['mag'] = pick_types(self.info, meg='mag', ref_meg=False,
                                       exclude='bads')
        picks_list['grad'] = pick_types(self.info, meg='grad', ref_meg=False,
                                        exclude='bads')
        picks_list['eeg'] = pick_types(self.info, eeg=True, ref_meg=False,
                                       meg=False, exclude='bads')

        self.picks_list_ = picks_list

        for key, this_pick in picks_list.items():
            if self.with_mean:
                ch_mean = X[:, this_pick, :].mean(axis=1)[:, None, :]
                self.ch_mean_[key] = ch_mean  # TODO rename attribute
            if self.with_std:
                ch_std = X[:, this_pick, :].mean(axis=1)[:, None, :]
                self.std_[key] = ch_std  # TODO rename attribute

        return self

def transform(self, epochs_data, y=None):
        """Standardizes data across channels

        Parameters
        ----------
        epochs_data : array, shape (n_epochs, n_channels, n_times)
            The data.
        y : None | array, shape (n_epochs,)
            The label for each epoch.
            If None not used. Defaults to None.

        Returns
        -------
        X : array, shape (n_epochs, n_channels, n_times)
            The data concatenated over channels.
        """
        if not isinstance(epochs_data, np.ndarray):
            raise ValueError("epochs_data should be of type ndarray (got %s)."
                             % type(epochs_data))

        X = np.atleast_3d(epochs_data)

        for key, this_pick in six.iteritems(self.picks_list_):
            if self.with_mean:
                X[:, this_pick, :] -= self.ch_mean_[key]
            if self.with_std:
                X[:, this_pick, :] /= self.std_[key]

        return X

def inverse_transform(self, epochs_data, y=None):
        """ Inverse standardization of data across channels

        Parameters
        ----------
        epochs_data : array, shape (n_epochs, n_channels, n_times)
            The data.
        y : None | array, shape (n_epochs,)
            The label for each epoch.
            If None not used. Defaults to None.

        Returns
        -------
        X : array, shape (n_epochs, n_channels, n_times)
            The data concatenated over channels.
        """
        if not isinstance(epochs_data, np.ndarray):
            raise ValueError("epochs_data should be of type ndarray (got %s)."
                             % type(epochs_data))

        X = np.atleast_3d(epochs_data)

        for key, this_pick in six.iteritems(self.picks_list_):
            if self.with_mean:
                X[:, this_pick, :] += self.ch_mean_[key]
            if self.with_std:
                X[:, this_pick, :] *= self.std_[key]

        return X

def transform(self, epochs_data, y=None):
        """For each epoch, concatenate data from different channels into a single
        feature vector.

        Parameters
        ----------
        epochs_data : array, shape (n_epochs, n_channels, n_times)
            The data.
        y : None | array, shape (n_epochs,)
            The label for each epoch.
            If None not used. Defaults to None.

        Returns
        -------
        X : array, shape (n_epochs, n_channels * n_times)
            The data concatenated over channels
        """
        if not isinstance(epochs_data, np.ndarray):
            raise ValueError("epochs_data should be of type ndarray (got %s)."
                             % type(epochs_data))

        epochs_data = np.atleast_3d(epochs_data)

        n_epochs, n_channels, n_times = epochs_data.shape
        X = epochs_data.reshape(n_epochs, n_channels * n_times)
        # save attributes for inverse_transform
        self.n_epochs = n_epochs
        self.n_channels = n_channels
        self.n_times = n_times

        return X

def rotate_image(image, angle):
        '''
        Rotates the given image by the given angle.
        '''

        rows, cols, _ = np.atleast_3d(image).shape
        rot_mat = cv2.getRotationMatrix2D((cols/2, rows/2), angle, 1)

        return cv2.warpAffine(image, rot_mat, (cols, rows))

def translate_image(image, translation):
        '''
        Translates the given image with the given translation vector.
        '''

        rows, cols, _ = np.atleast_3d(image).shape
        trans_mat = np.array([[1, 0, translation[0]*cols], [0, 1, translation[1]*rows]])

        return cv2.warpAffine(image, trans_mat, (cols, rows))

def img_to_graph(img, mask=None, return_as=sparse.coo_matrix, dtype=None):
    """Graph of the pixel-to-pixel gradient connections

    Edges are weighted with the gradient values.

    Read more in the :ref:`User Guide <image_feature_extraction>`.

    Parameters
    ----------
    img : ndarray, 2D or 3D
        2D or 3D image
    mask : ndarray of booleans, optional
        An optional mask of the image, to consider only part of the
        pixels.
    return_as : np.ndarray or a sparse matrix class, optional
        The class to use to build the returned adjacency matrix.
    dtype : None or dtype, optional
        The data of the returned sparse matrix. By default it is the
        dtype of img

    Notes
    -----
    For sklearn versions 0.14.1 and prior, return_as=np.ndarray was handled
    by returning a dense np.matrix instance.  Going forward, np.ndarray
    returns an np.ndarray, as expected.

    For compatibility, user code relying on this method should wrap its
    calls in ``np.asarray`` to avoid type issues.
    """
    img = np.atleast_3d(img)
    n_x, n_y, n_z = img.shape
    return _to_graph(n_x, n_y, n_z, mask, img, return_as, dtype)

def get_interpolated_pixel_color(pts, s_im, size):
    """given pts in floats, linear interpolate pixel values nearby to get a good colour"""
    pts = clamp(pts, size)

    s_im = np.atleast_3d(s_im)
    ys,xs = size
    ycoords, xcoords = np.arange(ys), np.arange(xs)
    out = np.empty(pts.shape[1:] + (s_im.shape[-1],),dtype=s_im.dtype)
    for i in range(s_im.shape[-1]): #loop over color channels
        map_coordinates(s_im[...,i],pts,out[...,i],mode='nearest')
    return out

def _read_fluid_selection(self, chunks, selector, fields, size):
        rv = {}
        # Now we have to do something unpleasant
        chunks = list(chunks)
        if isinstance(selector, GridSelector):
            if not (len(chunks) == len(chunks[0].objs) == 1):
                raise RuntimeError
            g = chunks[0].objs[0]
            f = h5py.File(g.filename, 'r')
            gds = f.get("/Grid%08i" % g.id)
            for ftype, fname in fields:
                rv[(ftype, fname)] = np.atleast_3d(
                    gds.get(fname).value.transpose())
            f.close()
            return rv
        if size is None:
            size = sum((g.count(selector) for chunk in chunks
                        for g in chunk.objs))
        for field in fields:
            ftype, fname = field
            fsize = size
            rv[field] = np.empty(fsize, dtype="float64")
        ng = sum(len(c.objs) for c in chunks)
        mylog.debug("Reading %s cells of %s fields in %s grids",
                   size, [f2 for f1, f2 in fields], ng)
        ind = 0
        for chunk in chunks:
            f = None
            for g in chunk.objs:
                if f is None:
                    #print "Opening (count) %s" % g.filename
                    f = h5py.File(g.filename, "r")
                gds = f.get("/Grid%08i" % g.id)
                if gds is None:
                    gds = f
                for field in fields:
                    ftype, fname = field
                    ds = np.atleast_3d(gds.get(fname).value.transpose())
                    nd = g.select(selector, ds, rv[field], ind) # caches
                ind += nd
            f.close()
        return rv

def _to_graph(n_x, n_y, n_z, mask=None, img=None,
              return_as=sparse.coo_matrix, dtype=None):
    """Auxiliary function for img_to_graph and grid_to_graph
    """
    edges = _make_edges_3d(n_x, n_y, n_z)

    if dtype is None:
        if img is None:
            dtype = np.int
        else:
            dtype = img.dtype

    if img is not None:
        img = np.atleast_3d(img)
        weights = _compute_gradient_3d(edges, img)
        if mask is not None:
            edges, weights = _mask_edges_weights(mask, edges, weights)
            diag = img.squeeze()[mask]
        else:
            diag = img.ravel()
        n_voxels = diag.size
    else:
        if mask is not None:
            mask = astype(mask, dtype=np.bool, copy=False)
            mask = np.asarray(mask, dtype=np.bool)
            edges = _mask_edges_weights(mask, edges)
            n_voxels = np.sum(mask)
        else:
            n_voxels = n_x * n_y * n_z
        weights = np.ones(edges.shape[1], dtype=dtype)
        diag = np.ones(n_voxels, dtype=dtype)

    diag_idx = np.arange(n_voxels)
    i_idx = np.hstack((edges[0], edges[1]))
    j_idx = np.hstack((edges[1], edges[0]))
    graph = sparse.coo_matrix((np.hstack((weights, weights, diag)),
                              (np.hstack((i_idx, diag_idx)),
                               np.hstack((j_idx, diag_idx)))),
                              (n_voxels, n_voxels),
                              dtype=dtype)
    if return_as is np.ndarray:
        return graph.toarray()
    return return_as(graph)