Beispiel #1
0
    def test_initialize_weights_gdn(self):
        """Tests the function `initialize_weights_gdn`.
        
        An image is saved at
        "tfutils/pseudo_visualization/initialize_weights_gdn.png".
        The test is successful if the image
        contains a symmetric matrix. Besides,
        the GDN/IGDN weights must belong to the
        expected range.
        
        """
        nb_maps = 12
        min_gamma = 2.e-5

        node_gamma = tfuls.initialize_weights_gdn(nb_maps, min_gamma)
        with tf.Session() as sess:
            gamma = sess.run(node_gamma)
        minimum = numpy.amin(gamma)
        maximum = numpy.amax(gamma)
        print('The GDN/IGDN weights must belong to [{}, 0.01].'.format(
            min_gamma))
        print('Minimum of the GDN/IGDN weights: {}'.format(minimum))
        print('Maximum of the GDN/IGDN weights: {}'.format(maximum))
        image_uint8 = numpy.round(255. * (gamma - minimum) /
                                  (maximum - minimum)).astype(numpy.uint8)
        tls.save_image(
            'tfutils/pseudo_visualization/initialize_weights_gdn.png',
            image_uint8)
 def test_save_image(self):
     """Tests the function `save_image`.
     
     An image is saved at "tools/pseudo_visualization/save_image.png".
     The test is successful if this image is
     identical to "tools/pseudo_data/rgb_web.png".
     
     """
     rgb_uint8 = tls.read_image_mode('tools/pseudo_data/rgb_web.jpg',
                                     'RGB')
     tls.save_image('tools/pseudo_visualization/save_image.png',
                    rgb_uint8)
 def test_rows_to_images(self):
     """Tests the function `rows_to_images`.
     
     The test is successful if, for i = 0 ... 3,
     "tools/pseudo_visualization/rows_to_images/rows_to_images_i.png"
     is identical to
     "tools/pseudo_visualization/images_to_rows/images_to_rows_i.png".
     
     """
     rows_uint8 = numpy.load('tools/pseudo_data/rows_uint8.npy')
     images_uint8 = tls.rows_to_images(rows_uint8, 64, 64)
     for i in range(images_uint8.shape[3]):
         tls.save_image('tools/pseudo_visualization/rows_to_images/rows_to_images_{}.png'.format(i),
                        images_uint8[:, :, :, i])
def write_luminances(reference_uint8, path_to_before_jpeg2000):
    """Writes the luminance images.
    
    Parameters
    ----------
    reference_uint8 : numpy.ndarray
        3D array with data-type `numpy.uint8`.
        Luminance images. `reference_uint8[i, :, :]`
        is the ith luminance image.
    path_to_before_jpeg2000 : str
        Path to the folder in which
        the luminance images are saved.
    
    """
    for i in range(reference_uint8.shape[0]):
        tls.save_image(os.path.join(path_to_before_jpeg2000, 'reference_{}.png'.format(i)),
                       reference_uint8[i, :, :])
    def test_read_400(self):
        """Tests the function `read_400`.
        
        An image is saved at
        "hevc/pseudo_visualization/read_400.png".
        The test is successful if this image
        is identical to the image at
        "hevc/pseudo_visualization/write_400.png".
        
        """
        height = 525
        width = 700
        nb_frames = 1
        data_type = numpy.uint8

        expanded_luminance_uint8 = hevc.hevc.read_400(
            'hevc/pseudo_data/luminance_nightshot.yuv', height, width,
            nb_frames, data_type)
        luminance_uint8 = numpy.squeeze(expanded_luminance_uint8, axis=2)
        tls.save_image('hevc/pseudo_visualization/read_400.png',
                       luminance_uint8)
Beispiel #6
0
 def test_crop_option_2d(self):
     """Tests the function `crop_option_2d`.
     
     A 1st image is saved at
     "tools/pseudo_visualization/crop_option_2d/luminance_image.png".
     A 2nd image is saved at
     "tools/pseudo_visualization/crop_option_2d/crop_random.png".
     A 3rd image is saved at
     "tools/pseudo_visualization/crop_option_2d/crop_center.png".
     The test is successful if the 2nd image
     is a random crop of the 1st image and the
     3rd image is a central crop of the 1st image.
     
     """
     width_crop = 64
     
     luminance_uint8 = numpy.load('tools/pseudo_data/luminances_uint8.npy')[0, :, :, 0]
     crop_0 = tls.crop_option_2d(luminance_uint8,
                                 width_crop,
                                 True)
     crop_1 = tls.crop_option_2d(luminance_uint8,
                                 width_crop,
                                 False)
     tls.save_image('tools/pseudo_visualization/crop_option_2d/luminance_image.png',
                    luminance_uint8)
     tls.save_image('tools/pseudo_visualization/crop_option_2d/crop_random.png',
                    crop_0)
     tls.save_image('tools/pseudo_visualization/crop_option_2d/crop_center.png',
                    crop_1)
Beispiel #7
0
 def test_crop_repeat_2d(self):
     """Tests the function `crop_repeat_2d`.
     
     A 1st image is saved at
     "tools/pseudo_visualization/crop_repeat_2d/luminance_image.png".
     A 2nd image is saved at
     "tools/pseudo_visualization/crop_repeat_2d/crop_0.png".
     A 3rd image is saved at
     "tools/pseudo_visualization/crop_repeat_2d/crop_1.png".
     The test is successful if the 2nd image
     is an enlarged crop of the bottom-left
     of the 1st image and the 3rd image is
     an enlarged crop of the top-right of
     the 1st image.
     
     """
     image_uint8 = numpy.load('tools/pseudo_data/luminances_uint8.npy')[0, :, :, 0]
     crop_0 = tls.crop_repeat_2d(image_uint8, image_uint8.shape[0] - 81, 0)
     crop_1 = tls.crop_repeat_2d(image_uint8, 0, image_uint8.shape[1] - 81)
     tls.save_image('tools/pseudo_visualization/crop_repeat_2d/luminance_image.png',
                    image_uint8)
     tls.save_image('tools/pseudo_visualization/crop_repeat_2d/crop_0.png',
                    crop_0)
     tls.save_image('tools/pseudo_visualization/crop_repeat_2d/crop_1.png',
                    crop_1)
Beispiel #8
0
 def test_create_imagenet(self):
     """Tests the function `create_imagenet` in the file "datasets/imagenet/imagenet.py".
     
     An image is saved at
     "datasets/imagenet/pseudo_visualization/create_imagenet/training_i.png",
     i in {0, 1}. An image is saved at
     "datasets/imagenet/pseudo_visualization/create_imagenet/validation_i.png",
     i in {0, 1}.
     The test is successful if each saved image is
     the luminance crop of a different RGB image in
     the folder "datasets/imagenet/pseudo_data/". Besides,
     if the saved image is named "training_...", it must
     be a random crop. If the saved image is named
     "validation_...", it must be a central crop.
     
     """
     width_crop = 192
     nb_training = 2
     nb_validation = 2
     path_to_training = 'datasets/imagenet/pseudo_data/pseudo_training_data.npy'
     path_to_validation = 'datasets/imagenet/pseudo_data/pseudo_validation_data.npy'
     
     # The images in the folder "datasets/imagenet/pseudo_data/"
     # are large. Therefore, none of them is dumped.
     datasets.imagenet.imagenet.create_imagenet('datasets/imagenet/pseudo_data/',
                                                width_crop,
                                                nb_training,
                                                nb_validation,
                                                path_to_training,
                                                path_to_validation)
     pseudo_training_data = numpy.load(path_to_training)
     path_to_folder_vis = 'datasets/imagenet/pseudo_visualization/'
     for i in range(nb_training):
         tls.save_image(os.path.join(path_to_folder_vis, 'training_{}.png'.format(i)),
                        pseudo_training_data[i, :, :, 0])
     pseudo_validation_data = numpy.load(path_to_validation)
     for i in range(nb_validation):
         tls.save_image(os.path.join(path_to_folder_vis, 'validation_{}.png'.format(i)),
                        pseudo_validation_data[i, :, :, 0])
def write_digits(reference_uint8, path_to_before):
    """Writes the RGB digits.
    
    Parameters
    ----------
    reference_uint8 : numpy.ndarray
        2D array with data-type `numpy.uint8`.
        RGB digits. `reference_uint8[i, :]`
        contains the ith RGB digit.
    path_to_before : str
        Path to the folder in which the
        RGB digits are saved.
    
    """
    # The function `tls.row_to_images` checks that
    # `reference_uint8.dtype` is equal to `numpy.uint8`
    # and `reference_uint8.ndim` is equal to 2.
    images_uint8 = tls.rows_to_images(reference_uint8, 32, 32)
    for i in range(images_uint8.shape[3]):
        tls.save_image(
            os.path.join(path_to_before, 'reference_{}.png'.format(i)),
            images_uint8[:, :, :, i])
 def test_write_400(self):
     """Tests the function `write_400`.
     
     An image is saved at
     "hevc/pseudo_visualization/write_400.png".
     The test is successful if this image
     is identical to the image at
     "hevc/pseudo_visualization/read_400.png".
     
     """
     path_to_yuv = 'hevc/pseudo_data/luminance_nightshot.yuv'
     rgb_uint8 = tls.read_image_mode('hevc/pseudo_data/rgb_nightshot.jpg',
                                     'RGB')
     luminance_uint8 = tls.rgb_to_ycbcr(rgb_uint8)[:, :, 0]
     tls.save_image('hevc/pseudo_visualization/write_400.png',
                    luminance_uint8)
     if os.path.isfile(path_to_yuv):
         print('"{}" exists. Remove it manually and restart the same test.'.
               format(path_to_yuv))
     else:
         hevc.hevc.write_400(numpy.expand_dims(luminance_uint8, axis=2),
                             path_to_yuv)
    def test_compress_hevc(self):
        """Tests the function `compress_hevc`.
        
        A 1st image is saved at
        "hevc/pseudo_visualization/compress_hevc/luminance_before.png".
        A 2nd image is saved at
        "hevc/pseudo_visualization/compress_hevc/luminance_after.png".
        The test is successful if the 2nd
        image corresponds to the 1st image
        with HEVC compression artefacts.
        
        """
        path_to_before_hevc = 'hevc/temp/luminance_before_hevc.yuv'
        path_to_after_hevc = 'hevc/temp/luminance_after_hevc.yuv'
        path_to_cfg = 'hevc/configuration/intra.cfg'
        path_to_bitstream = 'hevc/temp/bitstream.bin'
        qp = 42

        rgb_uint8 = tls.read_image_mode('hevc/pseudo_data/rgb_nightshot.jpg',
                                        'RGB')
        (height_initial, width_initial, _) = rgb_uint8.shape
        height_surplus = height_initial % 8
        width_surplus = width_initial % 8
        luminance_uint8 = tls.rgb_to_ycbcr(rgb_uint8)[0:height_initial -
                                                      height_surplus,
                                                      0:width_initial -
                                                      width_surplus, 0]
        tls.save_image(
            'hevc/pseudo_visualization/compress_hevc/luminance_before.png',
            luminance_uint8)
        luminance_before_hevc_uint8 = numpy.expand_dims(luminance_uint8,
                                                        axis=2)
        luminance_after_hevc_uint8 = hevc.hevc.compress_hevc(
            luminance_before_hevc_uint8, path_to_before_hevc,
            path_to_after_hevc, path_to_cfg, path_to_bitstream, qp, True)
        tls.save_image(
            'hevc/pseudo_visualization/compress_hevc/luminance_after.png',
            numpy.squeeze(luminance_after_hevc_uint8, axis=2))
 def checking_p_3(self, str_scope, index_gdn, path):
     """Saves the image of the GDN/IGDN weights.
     
     Parameters
     ----------
     str_scope : str
         Scope of the GDN/IGDN weights.
     index_gdn : int
         Index of the GDN/IGDN weights. The
         index belongs to [|1, 6|].
     path : str
         Path to the saved image. The path
         ends with ".png".
     
     """
     with tf.variable_scope(str_scope, reuse=True):
         gamma_float32 = tf.get_variable('gamma_{}'.format(index_gdn),
                                         dtype=tf.float32).eval()
     minimum = numpy.amin(gamma_float32)
     maximum = numpy.amax(gamma_float32)
     gamma_uint8 = numpy.round(255. * (gamma_float32 - minimum) /
                               (maximum - minimum)).astype(numpy.uint8)
     tls.save_image(path, gamma_uint8)
"""A script to create the Kodak test set."""

import argparse
import numpy

import datasets.kodak.kodak
import tools.tools as tls

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Creates the Kodak test set.')
    parser.parse_args()
    
    path_to_kodak = 'datasets/kodak/results/kodak.npy'
    path_to_list_rotation = 'datasets/kodak/results/list_rotation.pkl'
    
    datasets.kodak.kodak.create_kodak('http://r0k.us/graphics/kodak/kodak/',
                                      'datasets/kodak/data',
                                      path_to_kodak,
                                      path_to_list_rotation)
    
    # Two luminance images from the Kodak test set are checked visually.
    reference_uint8 = numpy.load(path_to_kodak)
    tls.save_image('datasets/kodak/visualization/luminance_3.png',
                   reference_uint8[2, :, :])
    tls.save_image('datasets/kodak/visualization/luminance_11.png',
                   reference_uint8[10, :, :])


# Definissez la comvoliution à laquelle correspond diff_mean_combo() :
def diff_mean_combo_2(x):
    return

# Definissez la comvoliution à laquelle correspond mean_3x3_combo(x, 2) :
def mean_3x3_combo_x2(x):
    return

# Exercice 7:
# Vous allez à présent programmer un détecteur de bord. Appliquez votre filtre
# build_conv_grad_sum_xy à une image I pour estimer son gradient grad_I.
# Construisez alors une image J valant 0 sur tous les points où abs(grad_I) < 100
# et 1 ailleurs.
# Faites variez ce seuil pour en regarder les effets

def extraction_des_bords(x):
    return

# Exercice 8
#

if __name__ == "__main__":

    x = load_image('isha.jpg')
    # A vous de jouez !

    # N'oubliez pas de définir rgb_to_grey
    x = rgb_to_grey(x)

    save_image(x, 'isha2.jpg')
def activate_latent_variable(sess, isolated_decoder, h_in, w_in, bin_widths, row_activation, col_activation,
                             idx_map_activation, activation_value, map_mean, height_crop, width_crop, path_to_crop):
    """Activates one latent variable and deactivates the others.
    
    One latent variable is activated and the others
    are deactivated. Then, the latent variable feature
    maps are quantized. Finally, the quantized latent
    variable feature maps are passed through the decoder
    of the entropy autoencoder.
    
    Parameters
    ----------
    sess : Session
        Session that runs the graph.
    isolated_decoder : IsolatedDecoder
        Decoder of the entropy autoencoder. The graph
        of the decoder is built to process one example
        at a time.
    h_in : int
        Height of the images returned by the
        isolated decoder.
    w_in : int
        Width of the images returned by the
        isolated decoder.
    bin_widths : numpy.ndarray
        1D array with data-type `numpy.float32`.
        Quantization bin widths at the end of the
        training.
    row_activation : int
        Row of the activated latent variable in the
        latent variable feature map of index `idx_map_activation`.
    col_activation : int
        Column of the activated latent variable in the
        latent variable feature map of index `idx_map_activation`.
    idx_map_activation : int
        Index of the latent variable feature map
        containing the activated latent variable.
    activation_value : float
        Activation value.
    map_mean : numpy.ndarray
        1D array with data-type `numpy.float32`.
        Latent variable feature map means.
    height_crop : int
        Height of the crop of the decoder output.
    width_crop : int
        Width of the crop of the decoder output.
    path_to_crop : str
        Path to the saved crop of the decoder
        output. The path ends with ".png".
    
    Raises
    ------
    ValueError
        If `row_activation` is not strictly positive.
    ValueError
        If `col_activation` is not strictly positive.
    
    """
    if row_activation <= 0:
        raise ValueError('`row_activation` is not strictly positive.')
    if col_activation <= 0:
        raise ValueError('`col_activation` is not strictly positive.')
    y_float32 = numpy.tile(numpy.reshape(map_mean, (1, 1, 1, csts.NB_MAPS_3)),
                           (1, h_in//csts.STRIDE_PROD, w_in//csts.STRIDE_PROD, 1))
    y_float32[0, row_activation, col_activation, idx_map_activation] = activation_value
    quantized_y_float32 = tls.quantize_per_map(y_float32, bin_widths)
    reconstruction_float32 = sess.run(
        isolated_decoder.node_reconstruction,
        feed_dict={isolated_decoder.node_quantized_y:quantized_y_float32}
    )
    reconstruction_uint8 = numpy.squeeze(tls.cast_bt601(reconstruction_float32),
                                         axis=(0, 3))
    
    # The ratio between the feature map height and the
    # decoded image height is equal to `csts.STRIDE_PROD`.
    row_offset = (row_activation - 1)*csts.STRIDE_PROD
    col_offset = (col_activation - 1)*csts.STRIDE_PROD
    tls.save_image(path_to_crop,
                   reconstruction_uint8[row_offset:row_offset + height_crop, col_offset:col_offset + width_crop])
def mask_maps(y_float32, sess, isolated_decoder, bin_widths, idx_unmasked_map, map_mean, height_crop, width_crop, paths):
    """Masks all the latent variable feature maps except one.
    
    All the latent variable feature maps except one
    are masked. Then, the latent variable feature maps
    are quantized. Finally, the quantized latent
    variable feature maps are passed through the
    decoder of the entropy autoencoder.
    
    Parameters
    ----------
    y_float32 : numpy.ndarray
        4D array with data-type `numpy.float32`.
        Latent variables. `y_float32[i, :, :, j]`
        is the jth latent variable feature map of
        the ith example.
    sess : Session
        Session that runs the graph.
    isolated_decoder : IsolatedDecoder
        Decoder of the entropy autoencoder. The graph
        of the decoder is built to process one example
        at a time.
    bin_widths : numpy.ndarray
        1D array with data-type `numpy.float32`.
        Quantization bin widths at the end of the
        training.
    idx_unmasked_map : int
        Index of the unmasked latent variable
        feature map.
    map_mean : numpy.ndarray
        1D array with data-type `numpy.float32`.
        Latent variable feature map means.
    height_crop : int
        Height of the crop of the decoder output.
    width_crop : int
        Width of the crop of the decoder output.
    paths : list
        The ith string in this list is the path
        to the ith saved crop of the decoder output.
        Each path ends with ".png".
    
    Raises
    ------
    ValueError
        If `len(paths)` is not equal to `y_float32.shape[0]`.
    
    """
    if len(paths) != y_float32.shape[0]:
        raise ValueError('`len(paths)` is not equal to `y_float32.shape[0]`.')
        
    # The same latent variable feature map is
    # iteratively overwritten in the loop below.
    masked_y_float32 = numpy.tile(numpy.reshape(map_mean, (1, 1, 1, y_float32.shape[3])),
                                  (1, y_float32.shape[1], y_float32.shape[2], 1))
    for i in range(y_float32.shape[0]):
        masked_y_float32[0, :, :, idx_unmasked_map] = y_float32[i, :, :, idx_unmasked_map]
        quantized_y_float32 = tls.quantize_per_map(masked_y_float32, bin_widths)
        reconstruction_float32 = sess.run(
            isolated_decoder.node_reconstruction,
            feed_dict={isolated_decoder.node_quantized_y:quantized_y_float32}
        )
        reconstruction_uint8 = numpy.squeeze(tls.cast_bt601(reconstruction_float32),
                                             axis=(0, 3))
        tls.save_image(paths[i],
                       reconstruction_uint8[0:height_crop, 0:width_crop])
Beispiel #17
0
def deepid(sample_path, predict):
    # align for image
    out_url = './util/data/'
    sample = align_face.alignMain(sample_path, out_url, predict)
    if sample == "Unable_align":
        return sample, None
    else:
        sample = tools.load_sample(sample)

    # load model from pre-trained model
    model = mx.model.FeedForward.load(prefix=a_args.prefix,
                                      epoch=a_args.epoch,
                                      ctx=mx.gpu(),
                                      numpy_batch_size=1)
    # create feature_extractor for deepid
    internals = model.symbol.get_internals()
    # get feature layer symbol out of internals
    fea_symbol = internals["fc3_output"]
    feature_extractor = mx.model.FeedForward(ctx=mx.gpu(),
                                             symbol=fea_symbol,
                                             numpy_batch_size=1,
                                             arg_params=model.arg_params,
                                             aux_params=model.aux_params,
                                             allow_extra_params=True)

    #exact sample_feature
    sample_feature = feature_extractor.predict(sample)

    # image for own class
    people = os.listdir('./people_image/')
    people_feature = []
    people_label = []
    if len(people) == 0:
        tools.save_image(sample_path, './people_image/x_' + str(len(people)),
                         sample_feature)
        return 'x'
    else:
        for i in people:
            path = './people_image/' + i
            img = os.listdir(path)
            random.shuffle(img)
            k = 0
            # load feature from file
            for j in img:
                if '.npy' in j and k < 5:
                    k += 1
                    people_feature.append(np.load(path + '/' + j))
                    people_label.append(i)

        # calculate the ratio of these images
        A, G = tools.load_A_G(a_args.A, a_args.G)
        people_ratio = [
            jb_model.Verify(A, G, sample_feature, people_feature[i])
            for i in xrange(len(people_label))
        ]
        people_result = tools.predict_face(people_ratio, 13, people_label)
        if people_result.count(0) == len(people_result):
            return 'unknow_person', sample_feature
        else:
            dic = {i: people_result.count(i) for i in people}
            fname = max(dic, key=dic.get)
            return fname, sample_feature
        help=
        'path to the folder storing the downloaded archive containing the original BSDS dataset',
        default='',
        metavar='')
    args = parser.parse_args()

    path_to_bsds = 'datasets/bsds/results/bsds.npy'
    path_to_list_rotation = 'datasets/bsds/results/list_rotation.pkl'

    # If `args.path_to_folder_tar` is equal to '', this
    # means that there is no need to download and extract
    # the archive "BSDS300-images.tgz".
    if args.path_to_folder_tar:
        path_to_tar = os.path.join(args.path_to_folder_tar,
                                   'BSDS300-images.tgz')
    else:
        path_to_tar = ''
    datasets.bsds.bsds.create_bsds(
        'https://www2.eecs.berkeley.edu/Research/Projects/CS/vision/bsds/BSDS300-images.tgz',
        args.path_to_folder_rgbs,
        path_to_bsds,
        path_to_list_rotation,
        path_to_tar=path_to_tar)

    # Two luminance images from the BSDS test set are checked visually.
    reference_uint8 = numpy.load(path_to_bsds)
    tls.save_image('datasets/bsds/visualization/luminance_7.png',
                   reference_uint8[7, :, :])
    tls.save_image('datasets/bsds/visualization/luminance_39.png',
                   reference_uint8[39, :, :])