

def tile_raster_images(X, img_shape, tile_shape=None, tile_spacing=(1, 1), scale_rows_to_unit_interval=True, output_pixel_vals=True, min_dynamic_range=0.0001):
    '\n    Transform an array with one flattened image per row, into an array in which\n    images are reshaped and layed out like tiles on a floor.\n\n    This function is useful for visualizing datasets whose rows are images, and\n    also columns of matrices for transforming those rows (such as the first\n    layer of a neural net).\n\n    Parameters\n    ----------\n    X : numpy.ndarray or tuple of 4 channels or None\n        A 2-D array in which every row is a flattened image.\n    img_shape : tuple\n        The original shape of each image\n    tile_shape: tuple\n        The number of images to tile (rows, cols). Defaults to a square-ish         shape with the right area for the number of images.\n    min_dynamic_range: float, positive\n        Dynamic range of each image is used in scaling to the unit interval,         but images with less dynamic range than this will be scaled as if         this were the dynamic range.\n\n    Returns\n    -------\n    out_array : 2D array with same dtype as X\n        Array suitable for viewing as an image (See:`PIL.Image.fromarray`).\n    '
    if ((len(img_shape) == 3) and (img_shape[2] == 3)):
        if scale_rows_to_unit_interval:
            logger.warning("tile_raster_images' scaling routine messes up colour - try tile_slices_to_image")
        return tile_raster_images((X[:, 0::3], X[:, 1::3], X[:, 2::3], None), img_shape=img_shape[:2], tile_shape=tile_shape, tile_spacing=tile_spacing, scale_rows_to_unit_interval=scale_rows_to_unit_interval, output_pixel_vals=output_pixel_vals, min_dynamic_range=min_dynamic_range)
    if isinstance(X, tuple):
        n_images_in_x = X[0].shape[0]
    else:
        n_images_in_x = X.shape[0]
    if (tile_shape is None):
        tile_shape = most_square_shape(n_images_in_x)
    assert (len(img_shape) == 2)
    assert (len(tile_shape) == 2)
    assert (len(tile_spacing) == 2)
    out_shape = [(((ishp + tsp) * tshp) - tsp) for (ishp, tshp, tsp) in zip(img_shape, tile_shape, tile_spacing)]
    if isinstance(X, tuple):
        if scale_rows_to_unit_interval:
            raise NotImplementedError()
        assert (len(X) == 4)
        if output_pixel_vals:
            out_array = numpy.zeros((out_shape[0], out_shape[1], 4), dtype='uint8')
        else:
            out_array = numpy.zeros((out_shape[0], out_shape[1], 4), dtype=X.dtype)
        if output_pixel_vals:
            channel_defaults = [0, 0, 0, 255]
        else:
            channel_defaults = [0.0, 0.0, 0.0, 1.0]
        for i in xrange(4):
            if (X[i] is None):
                out_array[:, :, i] = (numpy.zeros(out_shape, dtype=('uint8' if output_pixel_vals else out_array.dtype)) + channel_defaults[i])
            else:
                out_array[:, :, i] = tile_raster_images(X[i], img_shape, tile_shape, tile_spacing, scale_rows_to_unit_interval, output_pixel_vals)
        return out_array
    else:
        (H, W) = img_shape
        (Hs, Ws) = tile_spacing
        out_scaling = 1
        if (output_pixel_vals and str(X.dtype).startswith('float')):
            out_scaling = 255
        out_array = numpy.zeros(out_shape, dtype=('uint8' if output_pixel_vals else X.dtype))
        for tile_row in xrange(tile_shape[0]):
            for tile_col in xrange(tile_shape[1]):
                if (((tile_row * tile_shape[1]) + tile_col) < X.shape[0]):
                    if scale_rows_to_unit_interval:
                        try:
                            this_img = scale_to_unit_interval(X[((tile_row * tile_shape[1]) + tile_col)].reshape(img_shape), eps=min_dynamic_range)
                        except ValueError:
                            raise ValueError(('Failed to reshape array of shape %s to shape %s' % (X[((tile_row * tile_shape[1]) + tile_col)].shape, img_shape)))
                    else:
                        this_img = X[((tile_row * tile_shape[1]) + tile_col)].reshape(img_shape)
                    out_array[(tile_row * (H + Hs)):((tile_row * (H + Hs)) + H), (tile_col * (W + Ws)):((tile_col * (W + Ws)) + W)] = (this_img * out_scaling)
        return out_array

dataset/ETHPy150Open lisa-lab/pylearn2/pylearn2/packaged_dependencies/theano_linear/imaging.py tile_raster_images/original