def test_q4a_apply_hue_adjustment(tmp_path):
img = data.rocket()
imsave(tmp_path / 'original.png', img)
# Adjust the hue in 45-degree increments.
for amount in range(0, 361, 45):
adj = adjustment.adjust_hue(img, amount)
imsave(tmp_path / f'adjusted-{amount}.png', img_as_ubyte(adj))
def test_q5a_custom_rgb_to_grey():
img = data.rocket()
img = img_as_float(img)
# Setting a weight to '1' and the rest to '0' is equivalent to selecting a
# particular colour channel.
assert_array_equal(adjustment.to_monochrome(img, 1, 0, 0), img[:, :, 0])
assert_array_equal(adjustment.to_monochrome(img, 0, 1, 0), img[:, :, 1])
assert_array_equal(adjustment.to_monochrome(img, 0, 0, 1), img[:, :, 2])
def test_q5c_negative_weights_throw_errors():
img = data.rocket()
with pytest.raises(ValueError):
adjustment.to_monochrome(img, -1/3, 1/3, 1/3)
with pytest.raises(ValueError):
adjustment.to_monochrome(img, 1/3, -1/3, 1/3)
with pytest.raises(ValueError):
adjustment.to_monochrome(img, 1/3, 1/3, -1/3)
.. [1] Shai Avidan and Ariel Shamir
"Seam Carving for Content-Aware Image Resizing"
http://www.cs.jhu.edu/~misha/ReadingSeminar/Papers/Avidan07.pdf
"""
from skimage import data, draw
from skimage import transform, util
import numpy as np
from skimage import filters, color
from matplotlib import pyplot as plt
hl_color = np.array([0, 1, 0])
img = data.rocket()
img = util.img_as_float(img)
eimg = filters.sobel(color.rgb2gray(img))
plt.title('Original Image')
plt.imshow(img)
######################################################################
resized = transform.resize(img, (img.shape[0], img.shape[1] - 200),
mode='reflect')
plt.figure()
plt.title('Resized Image')
plt.imshow(resized)
######################################################################
# RGB to grayscale # In this exercise you will load an image from scikit-image module data and make it grayscale, then compare both of them in the output. # We have preloaded a function show_image(image, title='Image') that displays the image using Matplotlib. You can check more about its parameters using ?show_image() or help(show_image) in the console. # Rocket # Instructions # 100 XP # Import the data and color modules from Scikit image. The first module provides example images, and the second, color transformation functions. # Load the rocket image. # Convert the RGB-3 rocket image to grayscale. # Import the modules from skimage from skimage import data, color # Load the rocket image rocket = data.rocket() # Convert the image to grayscale gray_scaled_rocket = color.rgb2gray(rocket) # Show the original image show_image(rocket, 'Original RGB image') # Show the grayscale image show_image(gray_scaled_rocket, 'Grayscale image')
for i in range(n):
if (vm[i] == max_v):
return i
return "error"
def optimal_binarization(image):
his = histogram(image)
# print ( his )
vm = varianzas(his, image)
# print( vm )
pos_vm = whereMax(vm)
print(pos_vm)
binimage = binarization(image, pos_vm)
# print( image )
return binimage
image = rgb2gray(data.rocket())
plt.figure()
plt.imshow(image)
bin_image = optimal_binarization(image * 255)
plt.figure()
plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.subplot(1, 2, 2)
plt.imshow(bin_image, cmap='gray')
plt.show()
#Está accediendo a los píxeles tales que están:
#Entre las filas 10 y 110 (excluida esta última)
#Entre las columnas 210 y 310 (excluida esta última)
#En el canal 0, que en el formato RGB es el canal Rojo
#Como hemos visto de los ejemplos anteriores, para mostrar una imagen se usa el comando imshow de la biblioteca de matplotlib.
#Veamos una variación de este comando.
# Cargamos la imagen chelsea en la variable img0
img0 = data.chelsea()
#Cargamos la imagen rocket en la variable img1
img1= data.rocket()
# La función subplots divide el espacio de la figura en subfiguras
# Los dos primeros parámetros que usamos aquí son el número de filas y columnas del subplot
# el tercer parámetro, figsize, es un parámetro que define el tamaño relativo de los subplots
f, ax = plt.subplots(1, 2, figsize=(20,10))
# Se muestra en el primer subplot la imagen 0, se le asigna un título y se eliminan los ejes del gráfico
ax[0].imshow(img0) # se muestra el primer subplot de la imagen 0
ax[0].set_title('Cat', fontsize=18) # se le asigna un titulo a la imagen y un tamaño
ax[0].axis ('off') # se le eliminan los ejes al grafico
# Se muestra en el primer subplot la imagen 0, se le asigna un título y se eliminan los ejes del gráfico
ax[1].imshow(img1) # se muestra el primer subplot de la imagen 0
The good news is that the algorithm used by scikit-image works very well for
enlarging images up to a certain point.
In this exercise you'll enlarge an image three times!!
You'll do this by rescaling the image of a rocket, that will be loaded from
the data module.
> Import the module and function needed to enlarge images, you'll do this by
rescaling.
> Import the data module.
> Load the rocket() image from data.
> Enlarge the rocket_image so it is 3 times bigger, with the anti aliasing
filter applied.
> Make sure to set multichannel to True or you risk your session timing out!
"""
import sys
from skimage.transform import rescale
from skimage.data import rocket
sys.path.append('./helpers')
from settings import nda_import_image, show_image, plot_comparison
img_rocket = rocket()
img_rocket_enlarged = rescale(img_rocket,
3,
anti_aliasing=True,
multichannel=True)
plot_comparison(img_rocket, img_rocket_enlarged, '3-times enlarged image')
from skimage import data from plic import colorspace TEST_SOURCE = [data.astronaut(), data.coffee(), data.chelsea(), data.rocket()] TEST_IMAGES = list(map(colorspace.rgb2rdgdb, TEST_SOURCE))
import skimage.filters as filters
import skimage.draw as draw
import skimage.color as color
import skimage.segmentation as seg # For comparison purposes
import cv2
"""**Importing gray image from sklear.data:**"""
image = data.checkerboard()
# image = data.binary_blobs() or image = data.camera()
plt.imshow(image, cmap = 'gray')
"""**Importing color image from sklearn.data:**"""
image = data.rocket()
# image = data.logo() or image = data.astronaut()
plt.imshow(image)
"""**Import a color image using a global URL:**"""
image = io.imread('https://www.gstatic.com/webp/gallery/1.jpg')
plt.imshow(image)
"""**Importing multiple images from local directory:**"""
image_array = io.ImageCollection('../images/*.png:../images/*.jpg')
print('Type: ', type(image_array))
"""**Customized function to show images:**"""
import sys
from skimage import data, color
sys.path.append('./helpers')
from settings import show_image
img_rocket = data.rocket()
img_grey_scaled_rocket = color.rgb2gray(img_rocket)
show_image(img_rocket)
show_image(img_grey_scaled_rocket)
from skimage.segmentation import mark_boundaries
import time
import matplotlib.image as mpimg
exec(open('/Users/Salim_Andre/Desktop/IMA/PRAT/code/pd_segmentation_0.py').read())
exec(open('/Users/Salim_Andre/Desktop/IMA/PRAT/code/tree.py').read())
### DATASET
PATH_img = '/Users/Salim_Andre/Desktop/IMA/PRAT/' # path to my own images
swans=mpimg.imread(PATH_img+'swans.jpg');
baby=mpimg.imread(PATH_img+'baby.jpg');
img_set = [data.astronaut(), data.camera(), data.coins(), data.checkerboard(), data.chelsea(), \
data.coffee(), data.clock(), data.hubble_deep_field(), data.horse(), data.immunohistochemistry(), \
data.moon(), data.page(), data.rocket(), swans, baby]
### IMAGE
I=img_as_float(img_set[0]);
### PARAMETERS FOR 0-HOMOLOGY GROUPS
mode='customized';
n_superpixels=10000;
RV_epsilon=30;
gauss_sigma=0.5;
list_events=[800];
n_pxl_min_ = 30;
density_excl=0.0;
entropy_thresh_=1.1;
"""Color transformations on 2D image.""" from skimage import data, color from skimage.filters import gaussian from skimage.io import imsave import matplotlib.pyplot as plt import numpy as np import compoda.core as coda from compoda.utils import truncate_range from matplotlib import rcParams rcParams['font.family'] = "serif" # rcParams['mathtext.fontset'] = 'dejavuserif' # load image orig = data.rocket() img = np.copy(orig) * 1.0 dims = img.shape # impute zeros idx1 = (img[..., 0] <= 0) + (img[..., 1] <= 0) + (img[..., 2] <= 0) gauss = gaussian(img, sigma=0.5, multichannel=True) img[idx1, :] = gauss[idx1, :] # rgb to hsv for control hsv = color.rgb2hsv(img) hsv[..., 0] = -np.abs(hsv[..., 0] - 0.5) + 0.5 # coda stuff angdif_norm_int = np.zeros(img.shape) temp = img.reshape(dims[0] * dims[1], dims[2]) * 1.0 bary = coda.closure(temp, 100)
import pylab as plt
from matplotlib.animation import FuncAnimation
from skimage import data
a = [data.astronaut(), data.camera(), data.rocket()]
fig = plt.figure(figsize=(3, 3))
def update(frame_index):
plt.imshow(a[frame_index % len(a)])
animation = FuncAnimation(fig, update, interval=1000)
plt.axis('off')
plt.show()
# Import the module and function to enlarge images
from skimage.transform import rescale
import matplotlib.pyplot as plt
import matplotlib
# Import the data module
from skimage import data
# Load the image from data
rocket_image = data.rocket()
# Enlarge the image so it is 3 times bigger
enlarged_rocket_image = rescale(rocket_image,
3,
anti_aliasing=True,
multichannel=True)
# Show original and resulting image
show_image(rocket_image)
show_image(enlarged_rocket_image, "3 times enlarged image")
# Adjusting brightness # exposure module is used for analyzing image light intensities using histograms from skimage import exposure, io, data image = data.rocket() #by default gamma value is 1 image_bright = exposure.adjust_gamma(image, gamma=0.5) image_dark = exposure.adjust_gamma(image, gamma=2) io.imshow_collection([image, image_bright, image_dark]) io.show()
def test_rocket():
""" Test that "rocket" image can be loaded. """
data.rocket()
tf.keras.layers.Dense(1024, activation=tf.nn.relu),
tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
#model.compile(optimizer = 'adam',
# loss = 'sparse_categorical_crossentropy')
#
#model.fit(training_images, training_labels, epochs=1)
#
#model.evaluate(test_images, test_labels)
#
#classifications = model.predict(test_images)
from skimage import data, color
rocket = data.rocket() #; plt.imshow(rocket)
def show_image(image, title='Title', cmap_type='gray'):
plt.imshow(image, cmap=cmap_type)
plt.title(title)
plt.axis('off')
plt.show()
def show_image_contour(image, contours):
plt.figure()
for n, contour in enumerate(contours):
plt.plot(contour[:, 1], contour[:, 0], linewidth=3)
plt.imshow(image, interpolation='nearest', cmap='gray_r')
plt.title('Contours')
