Exemplo n.º 1
0
def export_figure(idx_row, df_slices_info, path_out):
    """ load image, segmentation and csv with centres
    1) draw figure with image, segmentation and csv
    2) draw expety annotation
    3) expert figure

    :param idx_row:
    :param df_slices_info:
    :param path_out:
    """
    _, row = idx_row
    img_name = os.path.splitext(os.path.basename(row['path_image']))[0]

    try:
        if img_name not in df_slices_info.index:
            logging.debug('missing image in annotation - "%s"', img_name)
            return

        img = tl_data.io_imread(row['path_image'])
        segm = tl_data.io_imread(row['path_segm'])
        df = pd.read_csv(os.path.join(row['path_centers']), index_col=0)
        centres = df[['X', 'Y']].values

        fig = figure_draw_img_centre_segm(None, img, centres, segm)

        row_slice = df_slices_info.loc[img_name]
        fig = figure_draw_annot_csv(fig, img, row_slice)

        tl_visu.figure_image_adjustment(fig, img.shape)
        fig.savefig(os.path.join(path_out, img_name + '.png'))
        plt.close(fig)
    except Exception:
        logging.exception('failed for: %s', img_name)
Exemplo n.º 2
0
def cluster_points_draw_export(dict_row, params, path_out=None):
    """ cluster points into centers and export visualisations

    :param dict dict_row:
    :param dict params:
    :param str path_out:
    :return dict:
    """
    assert all(n in dict_row for n in ['path_points', 'path_image', 'path_segm']), \
        'missing some required fields: %r' % dict_row
    name = os.path.splitext(os.path.basename(dict_row['path_points']))[0]
    points = tl_data.load_landmarks_csv(dict_row['path_points'])
    if not list(points):
        logging.debug('no points to cluster for "%s"', name)
    points = tl_data.swap_coord_x_y(points)

    centres, clust_labels = cluster_center_candidates(
        points, max_dist=params['DBSCAN_max_dist'], min_samples=params['DBSCAN_min_samples']
    )
    path_csv = os.path.join(path_out, FOLDER_CENTER, name + '.csv')
    tl_data.save_landmarks_csv(path_csv, tl_data.swap_coord_x_y(centres))

    path_visu = os.path.join(path_out, FOLDER_CLUSTER_VISUAL)

    img, segm = None, None
    if dict_row['path_image'] is not None and os.path.isfile(dict_row['path_image']):
        img = tl_data.io_imread(dict_row['path_image'])
    if dict_row['path_segm'] is not None and os.path.isfile(dict_row['path_segm']):
        segm = tl_data.io_imread(dict_row['path_segm'])

    export_draw_image_centers_clusters(path_visu, name, img, centres, points, clust_labels, segm)
    dict_row.update({'image': name, 'path_centers': path_csv, 'nb_centres': len(centres)})
    return dict_row
Exemplo n.º 3
0
def load_image_segm_center(idx_row, path_out=None, dict_relabel=None):
    """ by paths load images and segmentation and weather centers exist,
    load them if the path out is given redraw visualisation of inputs

    :param (int, DF:row) idx_row: tuple of index and row
    :param str path_out: path to output directory
    :param dict dict_relabel: look-up table for relabeling
    :return(str, ndarray, ndarray, [[int, int]]): idx_name, img_rgb, segm, centers
    """
    idx, row_path = idx_row
    for k in ['path_image', 'path_segm', 'path_centers']:
        row_path[k] = tl_data.update_path(row_path[k])
        if not os.path.exists(row_path[k]):
            raise FileNotFoundError('missing %s' % row_path[k])

    idx_name = get_idx_name(idx, row_path['path_image'])
    img_struc, img_gene = tl_data.load_img_double_band_split(
        row_path['path_image'], im_range=None)
    # img_rgb = np.array(Image.open(row_path['path_img']))
    img_rgb = tl_data.merge_image_channels(img_struc, img_gene)
    if np.max(img_rgb) > 1:
        img_rgb = img_rgb / float(np.max(img_rgb))

    seg_ext = os.path.splitext(os.path.basename(row_path['path_segm']))[-1]
    if seg_ext == '.npz':
        with np.load(row_path['path_segm'], allow_pickle=True) as npzfile:
            segm = npzfile[npzfile.files[0]]
        if dict_relabel is not None:
            segm = seg_lbs.merge_probab_labeling_2d(segm, dict_relabel)
    else:
        segm = tl_data.io_imread(row_path['path_segm'])
        if dict_relabel is not None:
            segm = seg_lbs.relabel_by_dict(segm, dict_relabel)

    if row_path['path_centers'] is not None and os.path.isfile(
            row_path['path_centers']):
        ext = os.path.splitext(os.path.basename(row_path['path_centers']))[-1]
        if ext == '.csv':
            centers = tl_data.load_landmarks_csv(row_path['path_centers'])
            centers = tl_data.swap_coord_x_y(centers)
        elif ext == '.png':
            centers = tl_data.io_imread(row_path['path_centers'])
            # relabel loaded segm into relevant one
            centers = np.array(LUT_ANNOT_CENTER_RELABEL)[centers]
        else:
            logging.warning('not supported file format %s', ext)
            centers = None
    else:
        centers = None

    if is_drawing(path_out):
        export_visual_input_image_segm(path_out, idx_name, img_rgb, segm,
                                       centers)

    return idx_name, img_rgb, segm, centers
Exemplo n.º 4
0
def group_images_frequent_colors(paths_img, ratio_threshold=1e-3):
    """ look  all images and estimate most frequent colours

    :param [str] paths_img: path to images
    :param float ratio_threshold: percentage of nb, clr pixels to be assumed as important
    :return [int]:

    >>> from skimage import data
    >>> from imsegm.utilities.data_io import io_imsave
    >>> path_img = './sample-image.png'
    >>> io_imsave(path_img, data.astronaut())
    >>> d_clrs = group_images_frequent_colors([path_img], ratio_threshold=3e-4)
    >>> sorted([d_clrs[c] for c in d_clrs], reverse=True)  # doctest: +NORMALIZE_WHITESPACE
    [27969, 1345, 1237, 822, 450, 324, 313, 244, 229, 213, 163, 160, 158, 157,
     150, 137, 120, 119, 117, 114, 98, 92, 92, 91, 81]
    >>> os.remove(path_img)
    """
    logging.debug('passing %i images', len(paths_img))
    dict_colors = dict()
    for path_im in paths_img:
        img = io_imread(path_im)
        local_dict_colors = image_frequent_colors(img, ratio_threshold)
        for clr in local_dict_colors:
            if clr not in dict_colors:
                dict_colors[clr] = 0
            dict_colors[clr] += local_dict_colors[clr]
    logging.info('img folder colours: %r', dict_colors)
    return dict_colors
Exemplo n.º 5
0
def extract_activation(path_img, path_out):
    name = os.path.splitext(os.path.basename(path_img))[0]
    img = io_imread(path_img)
    mask = img[:, :, 0] > 5

    im_struc = img[:, :, 0]
    im_struc_gauss = ndimage.gaussian_filter(im_struc, 1)
    im_gene = img[:, :, 1]
    im_gene_gauss = ndimage.gaussian_filter(im_gene, 1)

    mask_struc = im_struc_gauss > filters.threshold_otsu(im_struc_gauss[mask])
    ms = np.median(im_struc_gauss[mask_struc])
    mask_gene = im_gene_gauss > filters.threshold_otsu(im_gene_gauss[mask])
    mg = np.median(im_gene_gauss[mask_gene])

    ration_gene = np.sum(mask_gene) / float(np.sum(mask))
    coef = (ms / mg * 2.5) if ration_gene > 0.3 else (ms / mg * 5)
    im_mean = np.max(np.array([im_gene_gauss + (im_struc_gauss / coef)]), axis=0)

    otsu = filters.threshold_otsu(im_mean[mask])
    im_gene = im_mean.copy()
    im_gene[im_gene < otsu] = 0

    # gmm = GaussianMixture(n_components=3, n_init=10)
    # data = np.array([im_gene_gauss[mask].ravel(), im_struc_gauss[mask]]).T
    # gmm.fit(data)
    # id_max = np.argmax(gmm.means_[:, 0])
    # gm_mean = gmm.means_[id_max, 0]
    # gm_std = np.sqrt(gmm.covariances_[id_max, 0, 0])
    # im_gene[im_gene_gauss < (gm_mean - gm_std)] = 0

    # p_out = os.path.join(path_out, name)
    export_image(path_out, im_gene, name)
Exemplo n.º 6
0
def load_image(path_img, img_type=TYPE_LOAD_IMAGE):
    """ load image from given path according specification

    :param str path_img:
    :param str img_type:
    :return ndarray:
    """
    path_img = os.path.abspath(os.path.expanduser(path_img))
    assert os.path.isfile(path_img), 'missing: "%s"' % path_img
    if img_type == 'segm':
        img = tl_data.io_imread(path_img)
    elif img_type == '2d_struct':
        img, _ = tl_data.load_img_double_band_split(path_img)
        assert img.ndim == 2, 'image can be only single color'
    else:
        logging.error('not supported loading img_type: %s', img_type)
        img = tl_data.io_imread(path_img)
    logging.debug('image shape: %r, value range %f - %f', img.shape, img.min(),
                  img.max())
    return img
def main(path_annot, path_out, nb_comp=5):
    list_paths = sorted(glob.glob(path_annot))
    logging.info('nb images: %i SAMPLES: %r', len(list_paths),
                 [os.path.basename(p) for p in list_paths[:5]])
    list_segms = []
    for path_seg in list_paths:
        seg = tl_data.io_imread(path_seg)
        list_segms.append(seg)

    list_rays, _ = tl_rg.compute_object_shapes(list_segms,
                                               ray_step=RAY_STEP,
                                               interp_order='spline',
                                               smooth_coef=1)
    logging.info('nb eggs: %i, nb rays: %i', len(list_rays), len(list_rays[0]))

    x_axis = np.linspace(0, 360, len(list_rays[0]), endpoint=False)
    df = pd.DataFrame(np.array(list_rays), columns=x_axis.astype(int))
    path_csv = os.path.join(path_out, NAME_CSV_RAY_ALL)
    logging.info('exporting all Rays: %s', path_csv)
    df.to_csv(path_csv)

    # SINGLE MODEL
    model, list_cdf = tl_rg.transform_rays_model_cdf_mixture(list_rays, 1)
    cdf = np.array(np.array(list_cdf))

    # path_model = os.path.join(path_out, NAME_NPZ_MODEL_SINGLE)
    # logging.info('exporting model: %s', path_model)
    # np.savez(path_model, name='cdf', cdfs=cdf, mix_model=model)
    path_model = os.path.join(path_out, NAME_PKL_MODEL_SINGLE)
    logging.info('exporting model: %s', path_model)
    with open(path_model, 'wb') as fp:
        pickle.dump({'name': 'cdf', 'cdfs': cdf, 'mix_model': model}, fp)

    # MIXTURE MODEL
    model, list_mean_cdf = tl_rg.transform_rays_model_sets_mean_cdf_mixture(
        list_rays, nb_comp)

    # path_model = os.path.join(path_out, NAME_NPZ_MODEL_MIXTURE)
    # logging.info('exporting model: %s', path_model)
    # np.savez(path_model, name='set_cdfs', cdfs=list_mean_cdf,
    #                     mix_model=model)
    path_model = os.path.join(path_out, NAME_PKL_MODEL_MIXTURE)
    logging.info('exporting model: %s', path_model)
    with open(path_model, 'wb') as fp:
        pickle.dump(
            {
                'name': 'set_cdfs',
                'cdfs': list_mean_cdf,
                'mix_model': model
            }, fp)
def load_correct_segm(path_img):
    """ load segmentation and correct it with simple morphological operations

    :param str path_img:
    :return (ndarray, ndarray):
    """
    assert os.path.isfile(path_img), 'missing: %s' % path_img
    logging.debug('loading image: %s', path_img)
    img = tl_data.io_imread(path_img)
    seg = (img > 0)
    seg = morphology.binary_opening(seg, selem=morphology.disk(25))
    seg = morphology.remove_small_objects(seg)
    seg_lb = measure.label(seg)
    seg_lb[seg == 0] = 0
    return seg, seg_lb
Exemplo n.º 9
0
def load_sample_image(name_img=IMAGE_LENNA):
    """ load sample image

    :param str name_img:
    :return ndarray:

    >>> img = load_sample_image(IMAGE_LENNA)
    >>> img.shape
    (512, 512, 3)
    """
    path_img = get_image_path(name_img)
    assert os.path.exists(path_img), 'missing: "%s"' % path_img
    logging.debug('image (%s): %s', os.path.exists(path_img), path_img)
    img = io_imread(path_img)
    return img
Exemplo n.º 10
0
def load_sample_image(name_img=IMAGE_LENNA):
    """ load sample image

    :param str name_img:
    :return ndarray:

    >>> img = load_sample_image(IMAGE_LENNA)
    >>> img.shape
    (512, 512, 3)
    """
    path_img = get_image_path(name_img)
    if not os.path.isfile(path_img):
        raise FileNotFoundError('missing: "%s"' % path_img)
    logging.debug('image (%s): %s', os.path.exists(path_img), path_img)
    img = io_imread(path_img)
    return img
Exemplo n.º 11
0
def perform_quantize_image(path_image, list_colors, method='color'):
    """ perform the quantization together with loading and exporting

    :param str path_image:
    :param [(int, int, int)] list_colors: list of possible colours
    """
    logging.debug('quantize img: "%s"', path_image)
    im = tl_data.io_imread(path_image)
    if not im.ndim == 3:
        logging.warning('not valid color image of dims %r', im.shape)
        return
    im = im[:, :, :3]
    # im = io.imread(path_image)[:, :, :3]
    if method == 'color':
        im_q = seg_annot.quantize_image_nearest_color(im, list_colors)
    elif method == 'position':
        im_q = seg_annot.quantize_image_nearest_pixel(im, list_colors)
    else:
        logging.error('not implemented method "%s"', method)
        im_q = np.zeros(im.shape)
    path_image = os.path.splitext(path_image)[0] + '.png'
    tl_data.io_imsave(path_image, im_q.astype(np.uint8))
Exemplo n.º 12
0
def load_experiment(path_expt, name, path_dataset=None, path_images=None,
                    nb_workers=NB_WORKERS):
    path_atlas = os.path.join(path_expt, BASE_NAME_ATLAS + name + '.png')
    atlas = io_imread(path_atlas)
    if (atlas.max() == 255 or atlas.max() == 1.) and len(np.unique(atlas)) < 128:
        # assume it is scratched image
        atlas = sk_segm.relabel_sequential(atlas)[0]

    path_csv = os.path.join(path_expt, BASE_NAME_ENCODE + name + '.csv')
    df_weights = pd.read_csv(path_csv, index_col=None)

    path_npz = os.path.join(path_expt, BASE_NAME_DEFORM + name + '.npz')
    if os.path.isfile(path_npz):
        dict_deforms = dict(np.load(open(path_npz, 'rb')))
        assert len(df_weights) == len(dict_deforms), \
            'unresistant weights (%i) and (%i)' \
            % (len(df_weights), len(dict_deforms))
    else:
        dict_deforms = None

    segms = load_images(path_dataset, df_weights['image'].values, nb_workers)
    images = load_images(path_images, df_weights['image'].values, nb_workers)

    return atlas, df_weights, dict_deforms, segms, images