def image_with_contours_gen(image, bm1, bm2, color1, color2, bottom, up, left,
                            right, width, height, box_color, perf_box,
                            perf_col):
    # INPUTS: image of size (192,192,160), bm1 is the first set of contours (192,192,160,n_contours), bm2 is the second set of contours, col1 is the first set of colors, col2 is the second set of colors
    output = image
    output = gray2rgb(output)
    n_contours = bm1.shape[2]
    for contour_num in range(n_contours):
        edges = imfilter(bm1[:, :, contour_num] * 255, 'find_edges')
        output[edges > 0] = np.array(color1[contour_num, :])
    for contour_num in range(n_contours):
        edges = imfilter(bm2[:, :, contour_num] * 255, 'find_edges')
        output[edges > 0] = np.array(color2[contour_num, :])

    output[up, left:(left + width)] = box_color
    output[bottom, left:(left + width)] = box_color
    output[up:(up + height), left] = box_color
    output[up:(up + height), right] = box_color

    [left, right, up, bottom] = perf_box
    width = right - left
    height = bottom - up

    output[up, left:(left + width)] = perf_col
    output[bottom, left:(left + width)] = perf_col
    output[up:(up + height), left] = perf_col
    output[up:(up + height), right] = perf_col

    return output
Exemplo n.º 2
0
def check_invert_contrast(im):
    hist = np.histogram(im)[0]
    score = np.sum(hist[-3:])
    total = np.sum(hist)
    if score / float(total) > 0.15:
        return imfilter((1 - im), 'edge_enhance')
    else:
        return imfilter(im, 'edge_enhance')
Exemplo n.º 3
0
def image_with_contours_new(image, bm1, bm2, color1=rgb_dark, color2=rgb_light):
    output = image
    output = gray2rgb(output)
    n_contours = bm1.shape[2]
    for contour_num in range(n_contours):
        edges = imfilter(bm1[:,:,contour_num]*255, 'find_edges')
        output[edges>0] = np.array(color1[contour_num,:])
    for contour_num in range(n_contours):
        edges = imfilter(bm2[:,:,contour_num]*255, 'find_edges')
        output[edges>0] = np.array(color2[contour_num,:])
    return output
Exemplo n.º 4
0
def image_with_2contours(image, mask1, mask2, color1=rgb_dark, color2=rgb_light):
    vmin = -1000
    vmax = 3000
    output = ((image - vmin) * 255 / (vmax - vmin)).astype(np.uint8)
    mask1 = imfilter(mask1*255, 'find_edges')
    #mask1 = mask1.filter(ImageFilter.FIND_EDGES)
    mask2 = imfilter(mask2*255, 'find_edges')
    output = gray2rgb(output)
    output[mask1 > 0] = np.array(color1)
    output[mask2 > 0] = np.array(color2)
    return output
Exemplo n.º 5
0
def image_with_4contours(image, true1, true2, pred1, pred2, color1, color2):
    output = image
    true1 = imfilter(true1*255, 'find_edges')
    true2 = imfilter(true2*255, 'find_edges')
    pred1 = imfilter(pred1*255, 'find_edges')
    pred2 = imfilter(pred2*255, 'find_edges')
    output = gray2rgb(output)
    output[true1 > 0] = np.array(color1)
    output[true2 > 0] = np.array(color1)
    output[pred1 > 0] = np.array(color2)
    output[pred2 > 0] = np.array(color2)
    return output
Exemplo n.º 6
0
def image_with_contours_gen(image, bm1, bm2, color1, color2):
    # INPUTS: image of size (192,192,160), bm1 is the first set of contours (192,192,160,n_contours), bm2 is the second set of contours, col1 is the first set of colors, col2 is the second set of colors
    output = image
    output = gray2rgb(output)
    n_contours = bm1.shape[2]
    for contour_num in range(n_contours):
        edges = imfilter(bm1[:, :, contour_num] * 255, 'find_edges')
        output[edges > 0] = np.array(color1[contour_num, :])
    for contour_num in range(n_contours):
        edges = imfilter(bm2[:, :, contour_num] * 255, 'find_edges')
        output[edges > 0] = np.array(color2[contour_num, :])

    return output
Exemplo n.º 7
0
def sharpen_(cached,size):
    out=cached
    for k in range(size):
        out=misc.imfilter(out,'sharpen')
        print '.',
    print '->sharpen'
    return out;
Exemplo n.º 8
0
def blur_(cached, size):
    out = cached
    for k in range(size):
        out = misc.imfilter(out, "blur")
        print ".",
    print "->Blur", size
    return out
def generate_extra_data(n=3000, file_name=None, load_file=None, seed=None, rotate=True, emboss=True, elastic=False):
	print "Creating {} new images".format(n)
	if load_file:
		if not load_file.startswith("data/"):
			load_file = "data/" + load_file
		return np.load(load_file +".npy"), np.load(load_file+"_targets.npy")
	if seed:
		np.random.seed(seed)
	X = np.load("data/mnist_train_extra_inputs.npy")
	Y = np.load("data/mnist_train_extra_outputs.npy")
	positions = np.random.random_integers(0, X.shape[0]-1, n)
	transformed = X[positions,:]
	targets = Y[positions]
	final = np.zeros((n,48*48))
	angles = np.random.uniform(0,359, n)
	for i in range(n):
		temp = transformed[i,:].reshape((28,28))
		temp = imresize(temp, (48,48))
		if rotate:
			temp = imrotate(temp, angles[i], reshape=False)
		if emboss:
			temp = imfilter(temp,"emboss")
		if elastic:
			temp = elastic_distortion(temp, size=48)
		final[i,:] = temp.flatten()
	if file_name:
		if not file_name.startswith("data/"):
			file_name = "data/" + file_name
		np.save(file_name, final)
		np.save(file_name + "_targets", targets)
	return final, targets
Exemplo n.º 10
0
def sharpen_(cached, size):
    out = cached
    for k in range(size):
        out = misc.imfilter(out, "sharpen")
        print ".",
    print "->Sharpen", size
    return out
Exemplo n.º 11
0
def blur_(cached,size):
    out=cached
    for k in range(size):
        out=misc.imfilter(out,'blur')
        print '.',
    print '->blur'
    return out;
Exemplo n.º 12
0
def load_train_data(im_dir, dim=(4, 4)):
    # Load Images
    print("-- Reading Images")
    training_paths = pathlib.Path(im_dir).glob('*/images/*.png')
    training_sorted = sorted([x for x in training_paths])
    train_ims = np.array([
        rgb2gray(imageio.imread(str(x)))[:256, :256] for x in training_sorted
    ])
    train_ims = np.array([
        check_invert_contrast(train_ims[x]) for x in range(train_ims.shape[0])
    ])
    #Augment Code Added 1/16
    train_ims_blurred = np.array(
        [imfilter(train_ims[x], 'blur') for x in range(train_ims.shape[0])])
    train_ims = np.concatenate((train_ims, train_ims_blurred), axis=0)
    downsample = np.concatenate(
        [split_data(train_ims[x], dim=dim) for x in range(train_ims.shape[0])],
        axis=0)
    downsample_ims = downsample.reshape(
        (downsample.shape[0], downsample.shape[1], downsample.shape[2], 1))
    print downsample_ims.shape

    # Load Labels
    print("-- Reading Labels")
    label_paths = pathlib.Path(im_dir).glob('*/masks/')
    label_sorted = sorted([x for x in label_paths])
    labels = np.array([
        np.sum([
            rgb2gray(imageio.imread(str(x)))
            for x in pathlib.Path(y).glob('*.png')
        ],
               axis=0)[:256, :256] for y in label_sorted
    ])
    #For Augment Added 1/16
    labels2 = np.copy(labels)
    labels = np.concatenate((labels, labels2), axis=0)
    downsample_l = np.concatenate(
        [split_data(labels[x], dim=dim) for x in range(labels.shape[0])],
        axis=0)
    downsample_labs = downsample_l.reshape(
        (downsample_l.shape[0], downsample_l.shape[1], downsample_l.shape[2],
         1))
    print downsample_labs.shape

    # Add Zero Arrays
    add_zero_ims = np.zeros((int(0.15 * downsample.shape[0]),
                             downsample.shape[1], downsample.shape[2], 1))
    add_zero_labs = np.zeros((int(0.15 * downsample.shape[0]),
                              downsample.shape[1], downsample.shape[2], 1))
    final_ims = np.concatenate((downsample_ims, add_zero_ims),
                               axis=0).astype('float32')
    final_labs = np.concatenate((downsample_labs, add_zero_labs),
                                axis=0).astype('float32')

    cand = list(np.linspace(0, final_ims.shape[0] - 1, final_ims.shape[0]))
    idx = shuffle([int(x) for x in cand])
    shuffle_ims = final_ims[idx, :, :, :]
    shuffle_labs = final_labs[idx, :, :, :]
    return shuffle_ims.reshape(final_ims.shape), shuffle_labs.reshape(
        final_labs.shape)
Exemplo n.º 13
0
def get_chest_boundary(im, plot=False):

    size = im.shape[1]
    if plot == True:
        f, plots = plt.subplots(6, 1, figsize=(5, 30))
    binary = im < -320

    if plot == True:
        plots[0].axis('off')
        plots[0].imshow(binary, cmap=plt.cm.bone)

    cleared = clear_border(binary)
    temp_label = label(cleared)
    for region in regionprops(temp_label):
        if region.area < 300:
            for coordinates in region.coords:
                temp_label[coordinates[0], coordinates[1]] = 0
    cleared = temp_label > 0

    label_img = label(cleared)
    for region in regionprops(label_img):
        if region.eccentricity > 0.99 \
                or region.centroid[0] > 0.90 * size \
                or region.centroid[0] < 0.12 * size \
                or region.centroid[1] > 0.88 * size \
                or region.centroid[1] < 0.10 * size \
                or (region.centroid[1] > 0.46 * size and region.centroid[1] < 0.54 * size and region.centroid[
                    0] > 0.75 * size) \
                or (region.centroid[0] < 0.2 * size and region.centroid[1] < 0.2 * size) \
                or (region.centroid[0] < 0.2 * size and region.centroid[1] > 0.8 * size) \
                or (region.centroid[0] > 0.8 * size and region.centroid[1] < 0.2 * size) \
                or (region.centroid[0] > 0.8 * size and region.centroid[1] > 0.8 * size):
            for coordinates in region.coords:
                label_img[coordinates[0], coordinates[1]] = 0

    if plot == True:
        plots[1].axis('off')
        plots[1].imshow(label_img, cmap=plt.cm.bone)

    region_n = np.max(label_img)
    selem = disk(10)
    filled = np.zeros(cleared.shape, np.uint8)
    for i in range(1, region_n + 1):
        curr_region = np.zeros(cleared.shape, np.uint8)
        curr_region[label_img == i] = 1
        curr_region = binary_closing(curr_region, selem)
        curr_region = binary_fill_holes(curr_region)
        filled[curr_region == 1] = 1

    if plot == True:
        plots[2].axis('off')
        plots[2].imshow(filled, cmap=plt.cm.bone)

    filled_edge = misc.imfilter(filled.astype(np.float64), 'find_edges') / 255

    if plot == True:
        plots[3].axis('off')
        plots[3].imshow(filled_edge, cmap=plt.cm.bone)

    return filled_edge
Exemplo n.º 14
0
	def __smooth_group(self, arr):
		for i in range(0, self.smoothing):
			arr = misc.imfilter(arr, 'smooth');
			
			#arr = ndimage.filters.gaussian_filter(deepcopy(arr), 5, cval=255);
			for y in range(0, arr.shape[0]):
				for x in range(0, arr.shape[1]):
					arr[y][x] = 255 if arr[y][x] > self.threshold else 0;

		return arr;
Exemplo n.º 15
0
    def __smooth_group(self, arr):
        for i in range(0, self.smoothing):
            arr = misc.imfilter(arr, 'smooth')

            #arr = ndimage.filters.gaussian_filter(deepcopy(arr), 5, cval=255);
            for y in range(0, arr.shape[0]):
                for x in range(0, arr.shape[1]):
                    arr[y][x] = 255 if arr[y][x] > self.threshold else 0

        return arr
Exemplo n.º 16
0
def load_filtered_mnist_images():
    """
    :param *args: an option list
    :return: np.array of mnist images and np.array of mnist image classes
    The images are returned filtered by several image filters. Any filters
    that can be used with scipy.misc.imfilter may be used.
    """
    filters = ['emboss', 'blur']
    imgs, clss = load_raw_mnist_images()
    for index, img in enumerate(imgs):
        for filter in filters:
            img = imfilter(img, filter)
        imgs[index, :, :] = img
    return imgs, clss
Exemplo n.º 17
0
def mask_pos(cutnodule, max_layer):
    results = []
    #label the nodule first
    nodule = cutnodule[max_layer]
    [min_row, min_col, max_row, max_col] = regionprops(label(nodule))[0].bbox

    filled_edge = imfilter(nodule.astype(np.float64), 'find_edges') / 255
    for row in range(0, filled_edge.shape[0]):
        for col in range(0, filled_edge.shape[1]):
            if filled_edge[row, col] == 1:
                results.append([row, col])
    boundingbox = [[min_row, min_col], [min_row, max_col], [max_row, max_col],
                   [max_row, min_col]]
    return results, boundingbox
Exemplo n.º 18
0
def load_filtered_mnist_images():
    """
    :param *args: an option list
    :return: np.array of mnist images and np.array of mnist image classes
    The images are returned filtered by several image filters. Any filters
    that can be used with scipy.misc.imfilter may be used.
    """
    filters = ['emboss', 'blur']
    imgs, clss = load_raw_mnist_images()
    for index, img in enumerate(imgs):
        for filter in filters:
            img = imfilter(img, filter)
        imgs[index,:,:] = img
    return imgs, clss
Exemplo n.º 19
0
def blur_or_sharpen(im,
                    prob_blur=0.25,
                    min_sigma=0.5,
                    max_sigma=3.0,
                    prob_sharpen=0.25,
                    prng=np.random):
    prob_total = prob_blur + prob_sharpen
    assert prob_total <= 1.0
    uniform = prng.uniform()
    if uniform <= prob_blur:
        return blur(im, min_sigma=min_sigma, max_sigma=max_sigma, prng=prng)
    elif uniform <= prob_total:
        return np.expand_dims(imfilter(np.squeeze(im), "sharpen"), axis=-1)
    else:
        return im
Exemplo n.º 20
0
def run_tests(w, payload, k_range):
    os.chdir(os.path.dirname(os.path.abspath(__file__)))
    ROOT = os.getcwd()
    if not os.path.isdir("results"):
        os.mkdir("results")

    for k in k_range:
        for fn in os.listdir(os.path.join(ROOT, "pics")):
            src = misc.imread(os.path.join(ROOT, "pics", fn))
            dst = os.path.join(ROOT, "results",
                               "%s-%d" % (fn.split(".")[0], k))
            try:
                os.mkdir(dst)
            except EnvironmentError:
                print "skipping", fn, k
                continue
            os.chdir(dst)
            out = w.embed(src, payload, k)
            misc.imsave("orig.png", out)

            print "%s (k = %d)" % (fn, k)
            print "=" * 20
            print "Minimum JPG quality:", test_jpg(w, out)
            print "Max Gaussian sigma:", test_filter(
                w, out, "gauss-%s.png", gaussian_filter,
                [i / 10.0 for i in range(1, 50)])
            print "Max Laplacian of Gaussian sigma:", test_filter(
                w, out, "log-%s.png", gaussian_laplace,
                [i / 10.0 for i in range(1, 50)])
            print "Max tv-denoising weight:", test_filter(
                w, out, "tv-%s.png", tv_denoise, range(50, 1000, 25))
            print "Max noise ratio: ", test_filter(
                w, out, "noise-%s.png", add_noise,
                [i / 20.0 for i in range(1, 20)])
            print "Max random block coverage: ", test_filter(
                w, out, "blocks-%s.png",
                lambda img, k: add_blocks(img, k, 50, 50),
                [i / 20.0 for i in range(1, 20)])

            for flt in [
                    "contour", "detail", "edge_enhance", "edge_enhance_more",
                    "emboss", "find_edges", "smooth", "smooth_more", "sharpen"
            ]:
                print "Max iterations of %r:" % (flt, ), test_recursive_filter(
                    w, out, "%s-%%s.png" % (flt, ),
                    lambda img: misc.imfilter(img, flt), range(1, 30))
            print
Exemplo n.º 21
0
def ordered_combinatorial4(im):
    """
    Encode the image using combinatorial dithering for halftone with 2^4 levels

    Parameters
    ----------
    im: input image

    Return
    -------
    binary: output image
    """
    masked = (16.0 / 255.0) * _spm.imfilter(im, 'edge_enhance')
    masked = _np.floor(masked).astype('uint8')
    masked[masked > 15] = 15
    binary = _compiled.halftone.ordered_comb4_iterator(masked)
    return binary
Exemplo n.º 22
0
def wfm(FG, GT):
    dGT = np.asarray(GT, np.float32)
    dGT /= (GT.max() + 1e-8)

    E = np.abs(FG - dGT)
    Dst, Idxt = distance(dGT, return_indices=True)
    Et = E
    Et[~GT] = Et[Idxt[~GT]]
    EA = imfilter(Et, 'blur')
    MIN_E_EA = E
    MIN_E_EA[GT & EA < E] = EA[GT & EA < E]
    B = np.ones(GT.shape)
    B[~GT] = 2.0 - 1 * math.exp(math.log(1 - 0.5) / 5. * Dst[~GT])
    Ew = np.multiply(MIN_E_EA, B)

    TPw = np.sum(dGT[:] - np.sum(np.sum(Ew[GT])))
    FPw = np.sum(np.sum(Ew[~GT]))
    R = np.mean(Ew[GT])
    P = TPw
Exemplo n.º 23
0
def mask2contours(mask):
    sh = mask.shape
    contours = np.zeros((sh[0],sh[1],sh[2]))
    n_slices = sh[2]
    
    for s in range(n_slices):
        if s>0 and np.sum(mask[:,:,s-1].flatten())==0:
            contours[:,:,s] = mask[:,:,s]
        
        elif s<(n_slices-1) and np.sum(mask[:,:,s+1].flatten())==0:
            contours[:,:,s] = mask[:,:,s]
        else:
            diff = np.abs(mask[:,:,s]*1 - mask[:,:,s-1]*1)>0
            imf = imfilter(mask[:,:,s].astype('int'), 'find_edges')
            if np.sum(diff.flatten()>0):
                contours[:,:,s] = (diff+imf)>0
            else:
                contours[:, :, s] = imf
    return contours
Exemplo n.º 24
0
def __generalized_bayer(image, masks):
    """
    Convert a grayscale image in binary halftone image with n levels.

    Parameters
    ----------
    * im: numpy matrix, original grayscale image
    * masks: numpy array, set with all dot patterns used in halftone

    Return
    ----------
    * binary: numpy matrix, dithered binary image

    Written by Pedro Garcia Freitas <*****@*****.**>
    Copyright 2011 by Pedro Garcia Freitas

    see: http://www.sawp.com.br
    """
    # create and rescale new image to fit levels
    (levels, m, n) = masks.shape
    (h, l) = image.shape
    (step_x, step_y) = masks[0].shape
    masked = (levels / 255.0) * _spm.imfilter(image, 'edge_enhance')
    masked = _np.floor(masked).astype('uint8')
    masked[masked >= levels] = levels - 1
    binary = _np.zeros((m * h, n * l))

    # generate the halftoned image_path
    k = 0
    r = 0
    for i in range(h):
        for j in range(l):
            mask = int(masked[i, j])
            selected = masks[mask]
            xs = i + k
            xf = i + k + step_x
            ys = j + r
            yf = j + r + step_y
            binary[xs:xf, ys:yf] = selected[:, :]
            r = r + step_x - 1
        r = 0
        k = k + step_y - 1
    return binary
Exemplo n.º 25
0
def read_image(filename, show=True, thresh = 120):
    #import pdb;pdb.set_trace()
    img = spm.imread(filename, flatten = True)
    #img = spm.lena()
    img = spm.imresize(img, (100,100))
    img = spm.imfilter(img, ftype='find_edges')
    img = (img > thresh)
    img = img+0

    #remove outer edge
    img[:,0] = 0
    img[:,99] = 0
    img[0,:] =0
    img[99,:] = 0

    if np.sum(img) > (100*100)/2:
        img = 1-img
    if show:
        plt.imshow(img, interpolation='nearest', cmap='Greys')
        plt.show()
    return img
Exemplo n.º 26
0
Arquivo: test.py Projeto: Peaker/tau
def run_tests(w, payload, k_range):
    os.chdir(os.path.dirname(os.path.abspath(__file__)))
    ROOT = os.getcwd()
    if not os.path.isdir("results"):
        os.mkdir("results")
    
    for k in k_range:
        for fn in os.listdir(os.path.join(ROOT, "pics")):
            src = misc.imread(os.path.join(ROOT, "pics", fn))
            dst = os.path.join(ROOT, "results", "%s-%d" % (fn.split(".")[0], k))
            try:
                os.mkdir(dst)
            except EnvironmentError:
                print "skipping", fn, k
                continue
            os.chdir(dst)
            out = w.embed(src, payload, k)
            misc.imsave("orig.png", out)
            
            print "%s (k = %d)" % (fn, k)
            print "=" * 20
            print "Minimum JPG quality:", test_jpg(w, out)
            print "Max Gaussian sigma:", test_filter(w, out, "gauss-%s.png", gaussian_filter, 
                [i/10.0 for i in range(1,50)])
            print "Max Laplacian of Gaussian sigma:", test_filter(w, out, "log-%s.png", gaussian_laplace, 
                [i/10.0 for i in range(1,50)])
            print "Max tv-denoising weight:", test_filter(w, out, "tv-%s.png", tv_denoise, 
                range(50,1000,25))
            print "Max noise ratio: ", test_filter(w, out, "noise-%s.png", add_noise, 
                [i/20.0 for i in range(1, 20)])
            print "Max random block coverage: ", test_filter(w, out, "blocks-%s.png", 
                lambda img, k: add_blocks(img, k, 50, 50), [i/20.0 for i in range(1, 20)]) 

            for flt in ["contour", "detail", "edge_enhance", "edge_enhance_more", "emboss", 
                    "find_edges", "smooth", "smooth_more", "sharpen"]:
                print "Max iterations of %r:" % (flt,), test_recursive_filter(w, out, 
                    "%s-%%s.png" % (flt,), lambda img: misc.imfilter(img, flt), range(1, 30))
            print
Exemplo n.º 27
0
import cv2
import time
import pylab as pl
from scipy.misc import imresize, imfilter
import turtle

counter = 1

img = pl.flipud(pl.imread("inputImages/%05d.jpg" % counter))
levels = 8
size = 2**levels

img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

turtle.setup(img.shape[1], img.shape[0])
img = imfilter(imresize(img, (size, size)), 'blur')

turtle.setworldcoordinates(0, 0, size, -size)
turtle.tracer(1000, 0)

time.sleep(.5)

# hilbert curve turtle code stolen from
# falko's python example on stackoverflow
# https://codegolf.stackexchange.com/questions/36374/redraw-an-image-with-just-one-closed-curve


# define recursive hilbert curve
def hilbert(level, angle=90):
    global img
    if level == 0:
Exemplo n.º 28
0
Arquivo: hw8.py Projeto: yigong/AY250
def image_mani(image_array, mani):
    return imfilter(image_array, mani)
Exemplo n.º 29
0
def random_blur_image(image):
    return cv2.blur(image, (5, 5))
    img = Image.fromarray(image)
    img = img.filter(ImageFilter.BLUR)
    return np.array(img)
    return misc.imfilter(image, 'blur')
Exemplo n.º 30
0
    def upscale(self,
                img_path,
                scale_factor=2,
                save_intermediate=False,
                return_image=False,
                suffix="scaled",
                patch_size=8,
                mode="patch",
                verbose=True,
                evaluate=True):
        """
        Standard method to upscale an image.

        :param img_path:  path to the image
        :param scale_factor: scale factor can be any value, usually is an integer
        :param save_intermediate: saves the intermediate upscaled image (bilinear upscale)
        :param return_image: returns a image of shape (height, width, channels).
        :param suffix: suffix of upscaled image
        :param patch_size: size of each patch grid
        :param patch_stride: patch stride is generally 1.
        :param verbose: whether to print messages
        :param evaluate: evaluate the upscaled image on the original image.
        """
        import os
        from scipy.misc import imread, imresize, imsave, imfilter

        # Destination path
        path = os.path.splitext(img_path)
        filename = path[0] + "_" + suffix + "(%dx)" % (scale_factor) + path[1]

        # Read image
        scale_factor = int(scale_factor)
        true_img = imread(img_path, mode='RGB')
        init_height, init_width = true_img.shape[0], true_img.shape[1]
        if verbose: print("Old Size : ", true_img.shape)
        if verbose:
            print("New Size : (%d, %d, 3)" %
                  (init_height * scale_factor, init_width * scale_factor))

        images = None
        img_height, img_width = 0, 0

        denoise_models = ['Deep Denoise SR']

        if mode == 'patch':
            # Create patches
            if self.model_name in denoise_models:
                if patch_size % 4 != 0:
                    print(
                        "Deep Denoise requires patch size which is multiple of 4.\nSetting patch_size = 8."
                    )
                    patch_size = 8

            images = img_utils.make_patches(true_img, scale_factor, patch_size,
                                            verbose)

            nb_images = images.shape[0]
            img_height, img_width = images.shape[1], images.shape[2]
            print("Number of patches = %d, Patch Shape = (%d, %d)" %
                  (nb_images, img_height, img_width))
        else:
            # Use full image for super resolution
            img_height, img_width = self.__match_denoise_size(
                denoise_models, img_height, img_width, init_height, init_width,
                scale_factor)

            images = imresize(true_img, (img_height, img_width))
            images = np.expand_dims(images, axis=0)
            print("Image is reshaped to : (%d, %d, %d)" %
                  (images.shape[1], images.shape[2], images.shape[3]))

        # Save intermediate bilinear scaled image is needed for comparison.
        intermediate_img = None
        if save_intermediate:
            if verbose: print("Saving intermediate image.")
            fn = path[0] + "_intermediate_" + path[1]
            intermediate_img = imresize(
                true_img,
                (init_height * scale_factor, init_width * scale_factor))
            imsave(fn, intermediate_img)

        # Transpose and Process images
        img_conv = images.transpose((0, 3, 1, 2)).astype('float64') / 255

        model = self.create_model(img_height, img_width, load_weights=True)
        if verbose: print("Model loaded.")

        # Create prediction for image patches
        result = model.predict(img_conv, batch_size=128, verbose=verbose)

        if verbose: print("De-processing images.")

        # Deprocess patches
        result = result.transpose((0, 2, 3, 1)).astype('float64') * 255

        # Output shape is (original_height * scale, original_width * scale, nb_channels)
        if mode == 'patch':
            out_shape = (init_height * scale_factor, init_width * scale_factor,
                         3)
            result = img_utils.combine_patches(result, out_shape, scale_factor)
        else:
            result = result[
                0, :, :, :]  # Access the 3 Dimensional image vector

        result = np.clip(result, 0, 255).astype('uint8')
        result = imfilter(result, 'smooth_more')

        if verbose: print("\nCompleted De-processing image.")

        if return_image:
            # Return the image without saving. Useful for testing images.
            return result

        if verbose: print("Saving image.")
        imsave(filename, result)

        if evaluate:
            if verbose: print("Evaluating results.")
            # Convert initial image into correct format
            if intermediate_img is None:
                intermediate_img = imresize(
                    true_img,
                    (init_height * scale_factor, init_width * scale_factor))

            if mode == 'patch':
                intermediate_img = img_utils.make_patches(intermediate_img,
                                                          scale_factor,
                                                          patch_size,
                                                          upscale=False)
            else:
                img_height, img_width = self.__match_denoise_size(
                    denoise_models, img_height, img_width, init_height,
                    init_width, scale_factor)

                intermediate_img = imresize(true_img, (img_height, img_width))
                intermediate_img = np.expand_dims(intermediate_img, axis=0)

            intermediate_img = intermediate_img.transpose(
                (0, 3, 1, 2)).astype('float64') / 255

            eval_model = self.create_model(img_height,
                                           img_width,
                                           load_weights=True)

            # Evaluating the initial image patches, which gets transformed to the output image, to the input image
            error = eval_model.evaluate(img_conv,
                                        intermediate_img,
                                        batch_size=128)
            print("\nMean Squared Error of %s  : " % (self.model_name),
                  error[0])
            print("Peak Signal to Noise Ratio of %s : " % (self.model_name),
                  error[1])
Exemplo n.º 31
0
# 3.2.2 使用misc.imrotate进行图片的旋转
cat_data2 = misc.imrotate(cat_data, angle=90)  # 旋转90度
misc.imsave('cat2.jpg', cat_data2)  # 图片保存!
plt.imshow(cat_data2)
# misc.imshow(cat_angle)  # 另一种显示图片的方式---弹框式!

# 3.2.3 使用misc.imresize对图片进行缩放
cat_data3 = misc.imresize(cat_data, 0.5)  # 缩放为原来的0.5倍
plt.imshow(cat_data3)
cat_data3 = misc.imresize(cat_data, (100, 200))
plt.imshow(cat_data3)  # 缩放为指定的大小   这里表示100*200*3的jpg格式文件
misc.imsave('cat3.jpg', cat_data3)  # 图片保存!

# 3.2.4 使用misc.imfilter对图片进行过滤
cat_data4 = misc.imfilter(cat_data,
                          ftype='edge_enhance')  # ftype='edge_enhance'填写过滤方式
plt.imshow(cat_data4)
cat_data4 = misc.imfilter(cat_data, ftype='blur')  # 另一种过滤方式
plt.imshow(cat_data4)
cat_data4 = misc.imfilter(cat_data,
                          ftype='detail')  # 另一种过滤方式,当然还有其他多种过滤方式,自己查看帮助ctrl+i
plt.imshow(cat_data4)
'''3.3 图片处理---scipy.ndimage
用于操纵图片,包括:图片移动、图片旋转、图片缩放、图片切割、图片模糊处理...'''
import scipy.ndimage as ndimage
plt.imshow(misc.face())  # misc.face()是misc的内置图片,该图片是一只熊
face = misc.face(gray=True)  # 灰白处理
plt.imshow(face)
plt.imshow(face, cmap='gray')

face = misc.face(gray=False)
Exemplo n.º 32
0
from scipy import misc

misc.imshow(misc.imfilter(misc.face(), 'edge_enhance_more'))
Exemplo n.º 33
0
def sharpen_(cached,size):
    for k in range(size):
        cached=misc.imfilter(cached,'sharpen')
        print '.',
    print '->Sharpen',size
    return cached;
Exemplo n.º 34
0
def warpImage(inputIm, image, refIm, H):
    homography = H
    inverted_H = np.linalg.inv(homography)

    input_maxRow = inputIm.shape[0]
    input_maxCol = inputIm.shape[1]

    BACKGROUND_PIXEL = inputIm[0][0]
    print('background_pixel = ', BACKGROUND_PIXEL)

    ## WARP ##
    input_TOP_L = np.asarray(homography.dot(np.asarray([0, 0, 1])))
    input_TOP_L_actual = input_TOP_L[0][0] / input_TOP_L[0][2], input_TOP_L[0][
        1] / input_TOP_L[0][2]
    input_TOP_R = np.asarray(homography.dot(np.asarray([input_maxCol, 0, 1])))
    input_TOP_R_actual = input_TOP_R[0][0] / input_TOP_R[0][2], input_TOP_R[0][
        1] / input_TOP_R[0][2]
    input_BOT_L = np.asarray(homography.dot(np.asarray([0, input_maxRow, 1])))
    input_BOT_L_actual = input_BOT_L[0][0] / input_BOT_L[0][2], input_BOT_L[0][
        1] / input_BOT_L[0][2]
    input_BOT_R = np.asarray(
        homography.dot(np.asarray([input_maxCol, input_maxRow, 1])))
    input_BOT_R_actual = input_BOT_R[0][0] / input_BOT_R[0][2], input_BOT_R[0][
        1] / input_BOT_R[0][2]

    input_coords = []
    input_coords.append(input_TOP_L_actual)
    input_coords.append(input_TOP_R_actual)
    input_coords.append(input_BOT_L_actual)
    input_coords.append(input_BOT_R_actual)

    input_smallest_x = min([x[0] for x in input_coords])
    input_greatest_x = max([x[0] for x in input_coords])
    input_smallest_y = min([x[1] for x in input_coords])
    input_greatest_y = max([x[1] for x in input_coords])

    # find 4 corners in new image
    x_shape = int(input_greatest_x - input_smallest_x)
    y_shape = int(input_greatest_y - input_smallest_y)

    newImg = np.zeros((y_shape, x_shape, 3), dtype=np.uint8)
    for rows in range(newImg.shape[0]):
        for cols in range(newImg.shape[1]):
            homogenous_coords = np.asarray(
                [cols + input_smallest_x, rows + input_smallest_y, 1])
            input_coords = np.asarray(inverted_H.dot(homogenous_coords))

            # Convert out of homogenous
            input_coords_normed = (input_coords[0][0] / input_coords[0][2],
                                   input_coords[0][1] / input_coords[0][2])
            input_coords_actual = (int(input_coords_normed[0]),
                                   int(input_coords_normed[1]))

            if input_coords_actual[0] >= 0 and input_coords_actual[
                    0] < inputIm.shape[1]:
                if input_coords_actual[1] >= 0 and input_coords_actual[
                        1] < inputIm.shape[0]:
                    if not np.array_equal(
                            BACKGROUND_PIXEL, inputIm[input_coords_actual[1]][
                                input_coords_actual[0]]):
                        newImg[rows][cols] = inputIm[input_coords_actual[1]][
                            input_coords_actual[0]]

    ## MERGE ##
    # find 4 corners in new image
    x_min = min(input_smallest_x, 0)
    x_max = max(input_greatest_x, refIm.shape[1])
    y_min = min(input_smallest_y, 0)
    y_max = max(input_greatest_y, refIm.shape[0])

    x_shape = int(x_max - x_min)
    y_shape = int(y_max - y_min)

    stitchedImg = np.zeros((y_shape, x_shape, 3), dtype=np.uint8)

    for rows in range(stitchedImg.shape[0]):
        for cols in range(stitchedImg.shape[1]):
            homogenous_coords = np.asarray(
                [int(cols + x_min), int(rows + y_min), 1])
            input_coords = np.asarray(inverted_H.dot(homogenous_coords))

            # Convert out of homogenous
            input_coords_normed = (input_coords[0][0] / input_coords[0][2],
                                   input_coords[0][1] / input_coords[0][2])
            input_coords_actual = (int(input_coords_normed[0]),
                                   int(input_coords_normed[1]))

            if rows + (y_min) >= 0 and rows + y_min < refIm.shape[
                    0] and cols + x_min < refIm.shape[1] and (cols +
                                                              (x_min)) >= 0:
                stitchedImg[rows][cols] = refIm[int(rows + y_min)][int(cols +
                                                                       x_min)]
            if input_coords_actual[0] >= 0 and input_coords_actual[
                    0] < inputIm.shape[1]:
                if input_coords_actual[1] >= 0 and input_coords_actual[
                        1] < inputIm.shape[0]:
                    if not np.array_equal(
                            BACKGROUND_PIXEL, inputIm[input_coords_actual[1]][
                                input_coords_actual[0]]):
                        stitchedImg[rows][cols] = image[
                            input_coords_actual[1]][input_coords_actual[0]]

    fig, ax = plt.subplots(1, 2)
    img_vec2 = stitchedImg
    ax[0].imshow(img_vec2)
    blurred = cv2.medianBlur(stitchedImg, 15)
    sharpened = misc.imfilter(blurred, 'sharpen')
    ax[1].imshow(sharpened)
    plt.title('Merged Shirt with blurring')
    plt.show()
Exemplo n.º 35
0
	def Run(self, a, pixelStep, plot_all_figures_):

		crop_ = 0 #Testing parameter for cutting images
		vectorComputations = vut.Vector()
		# Adds up to [input] zeros before integer
		pad_string = lambda integer : '0'*(nbrOfIndexSpaces-len(str(integer))) + str(integer)

		# OBS! Can only handle up to 1000 vectors with this setup
		maxNbrOfVectors = 1000
		nbrOfIndexSpaces = len(str(maxNbrOfVectors-1))
		maxNbrOfVectors = 10**nbrOfIndexSpaces
		print 'There is space for: ', maxNbrOfVectors, ' in this calculation'



		# a is numpy array in two dimensions


		edges = imfilter(a,'find_edges')
		edges = where(edges >=1, 1, 0)
		#Tracing---------------------------------
		d = nonzero(edges) #create tuple y = d[0,:], x = d[1,:]
		vec = [d[0][0],d[1][0]] #Pick first non-zero value as y,x
		traced_edge = zeros_like(edges) # Matrix to store values in image format
		# traced_edge[vec[0], vec[1]] = 1

		cropping = array([[100,200], [200,300]])
		edges2 = edges[cropping[0,0]:cropping[0,1], cropping[1,0]:cropping[1,1]]

		edges[vec[0], vec[1]] = -2 #Mark starting pixel
		continue_ = 1
		loop_ = 0
		size_ = 0
		previous_size_ = 0
		vec_outline = vut.Vector()
		vec_outline.AddDimension('x')
		vec_outline.AddDimension('y')
		vec_outline.SetName('out_' + pad_string(1))

		while continue_:
			#print 'this: ', [vec[0], vec[1]]
			loop_+=1
			north = [vec[0]+1,vec[1]]; #print 'edge(north): ', edges[north[0], north[1]];
			east = [vec[0], vec[1] +1]; #print 'edge(east): ', edges[east[0], east[1]];
			south = [vec[0]-1,vec[1]]; #print 'edge(south): ', edges[south[0], south[1]];
			west = [vec[0], vec[1] -1]; #print 'edge(west): ', edges[west[0], west[1]];
			ne = [vec[0]+1,vec[1]+1]
			se = [vec[0]-1, vec[1] +1]
			sw = [vec[0]-1,vec[1]-1]
			nw = [vec[0]+1, vec[1] -1]


			traced_edge[vec[0], vec[1]] = 1; #Add current point to stack
			# print 'vec B4: ', (vec[1], vec[0])
			vec_outline.AddPoint((vec[1], vec[0]))
			# break
			if edges[north[0], north[1]] >= 1:
				vec = north; edges[north[0], north[1]] = -1; #print 'north'; check_starting_point = 1;
			elif edges[east[0], east[1]] >= 1:
				vec = east; edges[east[0], east[1]] = -1; #print 'east'; check_starting_point = 1;
			elif edges[south[0], south[1]] >= 1:
				vec = south; edges[south[0], south[1]] = -1; #print 'south'; check_starting_point = 1;
			elif edges[west[0], west[1]] >= 1:
				vec = west; edges[west[0], west[1]] = -1; #print 'west'; check_starting_point = 1;
			elif edges[ne[0], ne[1]] >= 1:
				vec = ne; edges[ne[0], ne[1]] = -1; #print 'ne'; check_starting_point = 1;
			elif edges[se[0], se[1]] >= 1:
				vec = se; edges[se[0], se[1]] = -1; #print 'se'; check_starting_point = 1;
			elif edges[sw[0], sw[1]] >= 1:
				vec = sw; edges[sw[0], sw[1]] = -1; #print 'sw'; check_starting_point = 1;
			elif edges[nw[0], nw[1]] >= 1:
				vec = nw; edges[nw[0], nw[1]] = -1; #print 'nw'; check_starting_point = 1;

			size_ = vec_outline.GetNbrOfPoints()

			# Check if next position is on trace
			if traced_edge[vec[0], vec[1]] >= 1:
				print 'Found starting point! ', vec
				print '@loop:', loop_, ' the size (after tracing) is: ', size_
				continue_ = 0
			elif size_ == previous_size_:
				print 'Size if tracing vector is frozen at: ', vec
				print '@loop:', loop_, ' the size (after tracing) is: ', size_
				print 'Breaking loop'
				continue_ = 0

			previous_size_ = size_

		# vv = [vec, vec1]
		# for x in range(vec[:,0])
		# print vec 


		# b[d] = 1


		#Check for concavity -------------------------------------------------------
		print '***Check concavity***'
		# print 'x: ', vec_outline.GetPoints_1Dim('x')
		# print 'first dim: ', vec_outline.GetDimensions()[0].GetName()
		vec = array(vec_outline.GetPoints_nDim(('y', 'x')))
		# print 'test vec: ', vec
		# print 'vec2 test: ', vec2
		# print len(vec)
		mem = zeros_like(a).astype(float)
		step_length = pixelStep
		isConcavity = 0
		newConcavity = 0
		all_Concavities = [] #Vector to store all concavities as homemade vector class
		appendVector = 1
		# step_length = 25
		currentConcavity = vut.Vector() #Workvariable for current vector, to be added to all_Concavities. Set to null when new vector found
		currentConcavity.SetName('con_000') #Initialize will be overwritten
		for i in range(step_length,(len(vec) - step_length)):
			# print 'index: ', i
			# print 'vec: ', vec[i]
			# print 'vec+: ', vec[i+step_length]
			# print 'vec-: ', vec[i-step_length]
			v1 = array(vec[i+step_length] - vec[i])
			v2 = array(vec[i] - vec[i-step_length])
			# print v1
			# print v2
			# dot_ = abs(dot(v1,(-1)*v2))
			# print dot_
			if abs(cross(v1,-v2)) <> 0:
				sign_cross = cross(v1,-v2)/abs(cross(v1,-v2))
				# print sign_cross
				dot_product = abs(dot(v1,(-1)*v2))
				if sign_cross == -1:
					if isConcavity == 0: #Enter new concavity
						newConcavity = 1
						isConcavity = 1
					if newConcavity == 1:
						# Check for 8-connectivity with existing vectors
						# print len(all_Concavities)
						for v in range(len(all_Concavities)):
							# test = all_Concavities[v].Is8Connected([vec[i][1], vec[i][0]])
							if all_Concavities[v].Is8Connected('x', vec[i][1], 'y', vec[i][0]) == 1:
								currentConcavity = all_Concavities[v]
								# print 'Continuing vector: ', currentConcavity
								appendVector = 0
								newConcavity = 0
					if newConcavity == 1: #We have not found an existing vector to append to
						prev_name = currentConcavity.GetName()
						currentConcavity = vut.Vector()
						currentConcavity.SetName('con_' + pad_string(int(prev_name[-nbrOfIndexSpaces:]) + 1))
						currentConcavity.AddDimension('x')
						currentConcavity.AddDimension('y')
						currentConcavity.AddDimension('value')
						# currentConcavity.AddDimension('active') # To turn off paired concavities in filtering
						# print 'Found new concavity at [y,x]: ', vec[i]
						appendVector = 1
						newConcavity = 0
				
					mem[vec[i][0], vec[i][1]] = 1
					# mem[vec[i][0], vec[i][1]] = dot_product
					currentConcavity.AddPoint(([vec[i][1],vec[i][0],dot_product]))
					# print 'Adding point: x: ', [vec[i][1], ' y: ', vec[i][0], 'value: ', dot_product]
				else:
					if isConcavity == 1: #Exit concavity
						# print 'Exit concavity at: ', vec[i]
						if appendVector == 1: #Do not append if we are continuing an old vector
							all_Concavities.append(currentConcavity)
						isConcavity = 0

		# Filter out all straight and lonely segments will get rid of most false concavities--------------------

		print '***Filtering***'

		print 'Number of concavities found: ', len(all_Concavities)

		new_all_Concavities = []
		for i in range(len(all_Concavities)):
			if all_Concavities[i].GetNbrOfPoints() > 2 and all_Concavities[i].IsStraight('y', 'x') == 0:
				new_all_Concavities.append(all_Concavities[i])

		all_Concavities = new_all_Concavities
		print 'Number of concavities after filtering: ', len(all_Concavities)


		# for i in range(len(all_Concavities)):
			# print all_Concavities[i].GetName()


		#Rescale image -----------------------------------------------------------------

		print '***Rescaling***'

		mem2 = zeros_like(a).astype(float)
		for i in range(len(all_Concavities)):
			# print all_Concavities[i].GetPoints('value')
			maximum = all_Concavities[i].Max('value')
			# print 'Maximum: ', maximum
			# pointsX = all_Concavities[i].GetPoints_nDim(('x'))
			pointsXY = all_Concavities[i].GetPoints_nDim(('x', 'y'))
			# pointsYX = all_Concavities[i].GetPoints_nDim(('y', 'x'))
			# print 'Points x is: ', pointsX
			# print 'Points xy is: ', pointsXY
			# print 'Points yx is: ', pointsYX
			# pointsY = all_Concavities[i].GetPoints_1Dim('y')
			# pointsVal = all_Concavities[i].GetPoints_1Dim('value')

			# print 'initial value: ', all_Concavities[i].GetPoints('value')
			for p in range(len(pointsXY)):
				unNormalizedValue = float(all_Concavities[i].GetPoints_1Dim('value')[p])
				# print 'unNormalizedValue: ', unNormalizedValue
				normalizedValue = unNormalizedValue/maximum
				# print 'normalizedValue: ', normalizedValue
				all_Concavities[i].SetPoint('value', p, normalizedValue)
				mem2[pointsXY[p][1], pointsXY[p][0]] = normalizedValue
			# print 'After rescaling: ', all_Concavities[i].GetPoints_1Dim('value')
					
		# print 'Dim: ', mem.shape
		# print 'Max: ', mem.max()
		# print 'Min: ', mem.min()
			# mem = (mem/(mem.max()-mem.min())) + mem.min()
		# print 'Max: ', mem.max()
		# print 'Min: ', mem.min()


		# Mark minimum of each concavity (hopefully central point)---------------------------------
		print '***Find center***'

		corners = zeros_like(a).astype(float)
		corners = where(traced_edge == 1, 0.2, 0)
		vec_corners = []
		gradients = []
		for i in range(len(all_Concavities)):
			print all_Concavities[i].GetPoints_1Dim('value')
			minimum = all_Concavities[i].Min('value')
			# print 'Minimum: ', minimum
			#Select only center point
			findCenter_points = all_Concavities[i].GetAllPointsWithValue('value', minimum) 
			#Draw gradient from all points
			# findCenter_points = all_Concavities[i].GetAllPoints()
			
			# print 'Points: ', findCenter_points
			# print 'Length: ', len(findCenter_points) 
			# if len(findCenter_points) == all_Concavities[i].GetNbrOfPoints:
				# print 'All minimum'
			# Several minimum: sort out the middle one
			if len(findCenter_points) > 1:
				print 'Several minimum found: '
				total_mean = 0
				for h in range(len(findCenter_points)):
					total_mean = total_mean + findCenter_points[h][0]
					print findCenter_points[h][0]
				mean = round(total_mean/(len(findCenter_points)))
				diff_smallest = 100
				chosen_point = findCenter_points[0][0] # Choose first point as default
				for h in range(len(findCenter_points)):
					mean_diff = mean - findCenter_points[h][0]
					# print 'Mean diff: ', mean_diff
					# print 'Diff smallest: ', diff_smallest
					if abs(mean_diff) < abs(diff_smallest):
						diff_smallest = mean_diff
						chosen_point = findCenter_points[h]
				# chosen_point = uint8(mean - mean_diff)				
				print 'Middle minimum is: ', chosen_point
				findCenter_points = [chosen_point]
			print 'Middle minimum len is: ', len(findCenter_points)

			for j in range(len(findCenter_points)):
		# Mark gradient in these points
				myIndex = self.GetPointIndex(vec_outline, findCenter_points[j][1][0], findCenter_points[j][1][1])
				# grad = all_Concavities[i].ComputeCurvatureGradient(findCenter_points[j][0], pixelStep)
				grad = vec_outline.ComputeCurvatureGradient(myIndex, pixelStep, 1)
				newPoint = array([findCenter_points[j][1][0] + 50*grad[0], findCenter_points[j][1][1] + 50*grad[1]]).astype(int)
				gradients.append([[findCenter_points[j][1][0],newPoint[0]], [findCenter_points[j][1][1],newPoint[1]]])
				newCorner = vut.Vector()
				newCorner.AddDimension('parent')
				newCorner.AddDimension('x')
				newCorner.AddDimension('y')
				newCorner.AddDimension('grad_x')
				newCorner.AddDimension('grad_y')
				newCorner.AddDimension('certainty') #How many possible corner points do we have in this concavity? can be only one
				parentIndex = int(all_Concavities[i].GetName()[-3:])
				newCorner.AddPoint((all_Concavities[i].GetName(), findCenter_points[j][1][0], findCenter_points[j][1][1], grad[0], grad[1], 1.0/len(findCenter_points)))
				newCorner.SetName('con_' + pad_string(parentIndex) + '_cor_' + pad_string(j + 1))
				vec_corners.append(newCorner)
				#corners[findCenter_points[j][1][1], findCenter_points[j][1][0]] = 0.7 #Draw corners directly on image
		print 'Number of corners found: ', len(vec_corners)

		#for i in range(len(vec_corners)):
		#	print vec_corners[i].GetCompletePoint(0)

		# Draw rays-------------------------------------------------------------------
		print '***Drawing lines***'
		# intersections = [] # Vector to keep full scale matrices - one for each corner/ray
		vec_intersections = [] #Vector for all intersections
		for i in range(len(vec_corners)):
			x0 = vec_corners[i].GetPoints_1Dim('x')[0]
			y0 = vec_corners[i].GetPoints_1Dim('y')[0]
			#print 'initial point: [', x0, ',', y0, ']'
			# certainty0 = vec_corners[i].GetPoints_1Dim('certainty')[0]
			grad_x0 = vec_corners[i].GetPoints_1Dim('grad_x')
			#print 'grad_x0', grad_x0
			grad_y0 = vec_corners[i].GetPoints_1Dim('grad_y')
			#print 'grad_y0', grad_y0
			# Compute line eq
			if grad_x0[0] <> 0: 
				k0 = (grad_y0[0]/grad_x0[0])
				m0 = y0 - x0*k0
			else: 
				k0 = 'INF'
				m0 = x0
			for j in range(i + 1, len(vec_corners)):
				x1 = vec_corners[j].GetPoints_1Dim('x')[0]
				y1 = vec_corners[j].GetPoints_1Dim('y')[0]
				#print 'second point: [', x1, ',', y1, ']'
				# certainty1 = vec_corners[j].GetPoints_1Dim('certainty')[0]
				grad_x1 = vec_corners[j].GetPoints_1Dim('grad_x')
				#print 'grad_x1', grad_x1
				grad_y1 = vec_corners[j].GetPoints_1Dim('grad_y')
				#print 'grad_y1', grad_y1
			#
				if grad_x1[0] <> 0: 
					k1 = (grad_y1[0]/grad_x1[0])
					m1 = y1 - x1*k1
				else: 
					k1 = 'INF'
					m1 = x1
				intersect = vectorComputations.ComputeIntersection([k0,m0], [k1,m1])
				intersect_name = vec_corners[i].GetName() + ' with ' + vec_corners[j].GetName()
				# if vec_outline.IsInside('x', intersect[0], 'y', intersect[1]):
				if intersect <> 'NULL':
					newIntersect = vut.Vector()
					con1 = vec_corners[i].GetName()
					con2 = vec_corners[i].GetName()
					if con1 == con2:
						print 'ERROR: Crossing with self'
					newIntersect.AddDimension('parent1') #corner
					newIntersect.AddDimension('parent2') #corner
					newIntersect.AddDimension('distance') # distance between corners
					newIntersect.AddDimension('intersect_x')
					newIntersect.AddDimension('intersect_y')
					newIntersect.AddDimension('certainty') #currently not in use
					cor_1 = [vec_corners[i].GetPoints_1Dim('x')[0], vec_corners[i].GetPoints_1Dim('y')[0]]
					cor_2 = [vec_corners[j].GetPoints_1Dim('x')[0], vec_corners[j].GetPoints_1Dim('y')[0]]
					distance = vectorComputations.ComputeDistance(cor_1, cor_2)
					print 'Distance: ', distance
					newIntersect.AddPoint((vec_corners[i].GetName(), vec_corners[j].GetName(), distance, intersect[0], intersect[1], 1.0))
					newIntersect.SetName(intersect_name)
					vec_intersections.append(newIntersect)
					# intersect.append(intersect_name)
					# intersections.append(intersect)


		print 'Number of intersections found: ', len(vec_intersections)
		for i in range(len(vec_intersections)):
			print vec_intersections[i].GetName()
		# Filter intersections


		# filteredIntersections = []
		vec_filteredIntersection = []
		for i in range(len(vec_intersections)):
			
			# if intersections[i][0] == 260.0:
			if vec_outline.IsInside('x', vec_intersections[i].GetPoints_1Dim('intersect_x')[0], 'y', vec_intersections[i].GetPoints_1Dim('intersect_y')[0]):
				# filteredIntersections.append(intersections[i])
				vec_filteredIntersection.append(vec_intersections[i])
		# intersections = filteredIntersections
		vec_intersections = vec_filteredIntersection

		print 'Number of intersections after filtering: ', len(vec_intersections)
		for i in range(len(vec_intersections)):
			print vec_intersections[i].GetName()
			#corners[intersections[i][1], intersections[i][0]] = 1 #Print intersections directly on image

		# Pair intersections ----------------------------------------------------------
		print '***Filtering intersections***'

		#THIS IS AS FAR AS WE HAVE DONE!!!
		# print 'All concavitiers: ', all_Concavities
		for i in range(len(vec_intersections)):
			print vec_intersections[i].GetName()
			print 'Parent 1 ', vec_intersections[i].GetPoints_1Dim('parent1')
			print 'Parent 2 ', vec_intersections[i].GetPoints_1Dim('parent2')
			print 'X ', vec_intersections[i].GetPoints_1Dim('intersect_x')
			print 'Y ', vec_intersections[i].GetPoints_1Dim('intersect_y')
			print 'Distance ', vec_intersections[i].GetPoints_1Dim('distance')
			
		for i in range(len(all_Concavities)):
			print all_Concavities[i].GetName()

		allowedConcavities = all_Concavities
			
		# Compute confidence matrix

		# Display figures --------------------------------------------------------------
		print '***Printing result***'

		# Zoom
		if crop_:
			if image_:
				mem2 = mem2[300:400,200:300]
				mem = mem[300:400,200:300]
				# corners = corners[300:400,200:300]
			elif shapes_:
				# mem2 = mem2[150:250,150:250]
				mem2 = mem2[250:450,200:400]

		#Add handling for first 5 & last 5
		# print mem.max()
		# print mem.min()
		black = zeros_like(a)

		if plot_all_figures_:
			fig1 = plt.figure()
			plot1 = fig1.add_subplot(111)
			plot1.set_title('Original')
			imshow(a,  cmap='hot', origin='lower')

			
			fig2 = plt.figure()
			plot2 = fig2.add_subplot(111)
			plot2.set_title('Edge')
			imshow(edges,  cmap='gray', origin='lower')

			fig4 = plt.figure()
			plot4 = fig4.add_subplot(111)
			plot4.set_title('Concavity cross product -1')
			imshow(mem,  cmap='hot', origin='lower')

			fig5 = plt.figure()
			plot5 = fig5.add_subplot(111)
			plot5.set_title('After filtering (may be zoomed)')
			myplot = imshow(mem2,  cmap='hot', origin='lower')
			fig5.colorbar(myplot, shrink=0.5, aspect=5)

			# trace2 = traced_edge[300:400,200:300]

		fig3 = plt.figure()
		plot3 = fig3.add_subplot(111)
		for i in range(len(gradients)):
			print gradients[i]
			plt.plot(gradients[i][0], gradients[i][1], linewidth=2.0, color='white')

		for i in range(vec_outline.GetNbrOfPoints()):
			plt.scatter(vec_outline.GetPoints_1Dim('x')[i], vec_outline.GetPoints_1Dim('y')[i], color = 'yellow')


		for i in range(len(vec_corners)):
			#print 'x: ', (vec_corners[i].GetPoints_1Dim('x')[0])
			#print 'y: ', (vec_corners[i].GetPoints_1Dim('y')[0])
			plt.scatter(vec_corners[i].GetPoints_1Dim('x')[0], vec_corners[i].GetPoints_1Dim('y')[0], color='red')
		# for i in range(len(vec_intersections)):
			#print intersections[i]
			#corners[intersections[i][1], intersections[i][0]] = 1 #Print intersections directly on image
			# plt.scatter(vec_intersections[i].GetPoints_1Dim('intersect_x')[0], vec_intersections[i].GetPoints_1Dim('intersect_y')[0], color='white')
		plot3.set_title('Trace with marked corners')
		imshow(black,  cmap='hot', origin='lower')



		# fig6 = plt.figure()
		# plot6 = fig6.add_subplot(111)
		# plot6.set_title('Raypoint1')
		# imshow(all_Rays[1],  cmap='hot', origin='lower')


		# imshow(a, cmap = cm.gray)# left plot in the image above
		plt.show()
Exemplo n.º 36
0
def my_imfilter(image,filter):  #which will work identically to the function below
  output = imfilter(image, filter) #replace your code here
Exemplo n.º 37
0
        print i,
        misc.imsave("out.png", filterfunc(misc.imread("out.png")))
        try:
            w.extract(misc.imread("out.png"))
        except ReedSolomonError:
            return prev_i
        prev_i = i
    return prev_i


if __name__ == "__main__":
    from scipy.ndimage.filters import gaussian_filter
    from skimage.filter import tv_denoise

    w = Watermarker(6, 3, 2394181, "bior3.3")
    out = w.embed(misc.imread("pics/lena.png"), "123456", 10)
    misc.imsave("out3.png", out)
    exit()
    #test_filter(w, out, lambda img, i: gaussian_filter(img, i / 10.0))
    #test_filter(w, out, tv_denoise)
    #print test_recursive_filter(w, out, lambda img: misc.imfilter(img, "smooth"))

    for flt in [
            "blur", "contour", "detail", "edge_enhance", "edge_enhance_more",
            "emboss", "find_edges", "smooth", "smooth_more", "sharpen"
    ]:
        print flt,
        print test_recursive_filter(w, out,
                                    lambda img: misc.imfilter(img, flt))
        print
Exemplo n.º 38
0
    start_time = time.time()
    x, min_val, info = fmin_l_bfgs_b(evaluator.loss, x.flatten(), fprime=evaluator.grads, maxfun=20)

    if prev_min_val == 0:
        improvement = 0
    else:
        improvement = (prev_min_val - min_val) / prev_min_val * 100

    print("Current loss value:", min_val, " Improvement : %0.3f" % improvement, "%")
    prev_min_val = min_val

    # save current generated image
    img = deprocess_image(x.copy())

    if not use_content_img:
        img = imfilter(img, ftype='smooth')
        img = imfilter(img, ftype='sharpen')

    if use_content_img and preserve_color and content is not None:
        img = original_color_transform(content, img)

    fname = target_img_prefix + '_at_iteration_%d.png' % (i + 1)
    imsave(fname, img)
    end_time = time.time()
    print('Image saved as', fname)
    print('Iteration %d completed in %ds' % (i + 1, end_time - start_time))

    if args.min_improvement != 0.0:
        if improvement < args.min_improvement and i > 1:
            print("Script is early stopping since improvement (%0.2f) < min improvement (%0.2f)" %
                  (improvement, args.min_improvement))
Exemplo n.º 39
0
Arquivo: all.py Projeto: KWMalik/tau
            w.extract(misc.imread("out.png"))
        except ReedSolomonError:
            return prev_i
        prev_i = i
    return prev_i


if __name__ == "__main__":
    from scipy.ndimage.filters import gaussian_filter
    from skimage.filter import tv_denoise

    w = Watermarker(6, 3, 2394181, "bior3.3")
    out = w.embed(misc.imread("pics/lena.png"), "123456", 10)
    misc.imsave("out3.png", out)
    exit()
    #test_filter(w, out, lambda img, i: gaussian_filter(img, i / 10.0))
    #test_filter(w, out, tv_denoise)
    #print test_recursive_filter(w, out, lambda img: misc.imfilter(img, "smooth"))
    
    for flt in ["blur", "contour", "detail", "edge_enhance", "edge_enhance_more", "emboss", "find_edges", "smooth", "smooth_more", "sharpen"]:
        print flt, 
        print test_recursive_filter(w, out, lambda img: misc.imfilter(img, flt))
        print







def sharpen(im, level):
    level = level.upper()
    intensity = {'HIGH': 3, 'MEDIUM': 2, "LOW": 1}
    for j in range(intensity[level]):
      im = misc.imfilter(im, 'sharpen')
    return im
Exemplo n.º 41
0
                                     maxfun=20)

    if prev_min_val == 0:
        improvement = 0
    else:
        improvement = (prev_min_val - min_val) / prev_min_val * 100

    print("Current loss value:", min_val, " Improvement : %0.3f" % improvement,
          "%")
    prev_min_val = min_val

    # save current generated image
    img = deprocess_image(x.copy())

    if not use_content_img:
        img = imfilter(img, ftype='smooth')
        img = imfilter(img, ftype='sharpen')

    if use_content_img and preserve_color and content is not None:
        img = original_color_transform(content, img)

    fname = target_img_prefix + '_at_iteration_%d.png' % (i + 1)
    imsave(fname, img)
    end_time = time.time()
    print('Image saved as', fname)
    print('Iteration %d completed in %ds' % (i + 1, end_time - start_time))

    if args.min_improvement != 0.0:
        if improvement < args.min_improvement and i > 1:
            print(
                "Script is early stopping since improvement (%0.2f) < min improvement (%0.2f)"
Exemplo n.º 42
0
 def sharpen(self):
     self.canvas_data = misc.imfilter(self.canvas_data, ftype='sharpen')
     self.draw_canvas()