def _process_imgt(img,
gt,
gamma=0,
clahe=False,
gray=False,
xyz=False,
horizontal_flip=False,
width_shift_range=0,
height_shift_range=0,
vertical_flip=0,
rotate_range=0,
bw_gt=True):
img = exposure.rescale_intensity(img.astype(float), out_range=(0, 1))
if gray:
img = color.rgb2gray(img)
if xyz:
img = color.rgb2xyz(img)
img = exposure.rescale_intensity(img, out_range=(0, 1))
if clahe:
img = exposure.equalize_adapthist(img)
if gamma:
img = exposure.adjust_gamma(img, gamma)
img = exposure.rescale_intensity(img, out_range=(0, 1))
if img.ndim == 2:
img = np.expand_dims(img, -1)
img, gt = flip_img(img, gt, horizontal_flip, vertical_flip)
img, gt = shift_img(img, gt, width_shift_range, height_shift_range,
rotate_range)
return img, gt
def convert(colorspace, image):
# Normalize data.
image = image.astype('float32') / 255
#conver to HSL
if colorspace == "HSL":
image = convertHSL(image)
#conver to HSV
if colorspace == "HSV":
image = color.rgb2hsv(image)
#conver to XYZ
if colorspace == "XYZ":
image = color.rgb2xyz(image)
#conver to LUV
if colorspace == "LUV":
image = color.rgb2luv(image)
#conver to LAB
if colorspace == "LAB":
image = color.rgb2lab(image)
#conver to YUV
if colorspace == "YUV":
image = color.rgb2yuv(image)
print("finish")
from scipy.misc import imsave
imsave('test.png', image)
return image
def expand_colorspace_cv(img_str, printonoff='on'):
# param:
# img_str: the string of picture dir || picture list
# printonoff: print process in console whether or not
# return: the list of expanded colorspace picture list
t = time.time()
if isinstance(img_str, str):
if printonoff == 'on': print('|--- Convert classified picture [' + img_str + ']')
RGB = io.imread(img_str)
if RGB.shape[2] == 4: # exists alpha layer
RGB = RGB[:,:,0:3]
LAB = color.rgb2lab(RGB)
if printonoff == 'on': print('| |--- lab converted')
HSV = color.rgb2hsv(RGB)
if printonoff == 'on': print('| |--- hsv converted')
XYZ = color.rgb2xyz(RGB)
if printonoff == 'on': print('| |--- xyz converted')
(height, width, dimen) = RGB.shape
rgb = RGB.reshape(height * width, dimen); del RGB
lab = LAB.reshape(height * width, dimen); del LAB
hsv = HSV.reshape(height * width, dimen); del HSV
xyz = XYZ.reshape(height * width, dimen); del XYZ
if printonoff == 'on': print('| ^--- reshaped')
img_size = (height, width)
expand = np.concatenate((rgb, lab, hsv, xyz), axis=1);del rgb, lab, hsv, xyz
if printonoff == 'on':
print('| |--- Combined = ' + str(round(sys.getsizeof(expand) / 8 / 1024 / 1024, 3)) + ' MB')
if printonoff == 'on': print('| ^--- Cost ' + str(round(time.time() - t, 3)) + ' s')
return expand, img_size
else:
RGB = img_str.reshape(1, img_str.shape[0], 3)
LAB = color.rgb2lab(RGB)
if printonoff == 'on': print('| | |--- lab converted')
HSV = color.rgb2hsv(RGB)
if printonoff == 'on': print('| | |--- hsv converted')
XYZ = color.rgb2xyz(RGB)
if printonoff == 'on': print('| | |--- xyz converted')
rgb = img_str; del RGB
lab = LAB[0]; del LAB
hsv = HSV[0]; del HSV
xyz = XYZ[0]; del XYZ
if printonoff == 'on': print('| | ^--- reshaped')
expand = np.concatenate((rgb, lab, hsv, xyz), axis=1); del rgb, lab, hsv, xyz
if printonoff == 'on':
print('| | |--- Combined = ' + str(round(sys.getsizeof(expand)/8/1024/1024, 3)) + ' MB')
if printonoff == 'on': print('| | ^--- Cost ' + str(round(time.time() - t, 3)) + ' s')
return expand
def from_rgb_to_xyz(rgb_colors, normalize=True):
xyz_colors = rgb2xyz(rgb_colors)
if normalize:
return xyz_colors / np.max(xyz_colors)
else:
return xyz_colors
def test_xyz_rgb_roundtrip(self, channel_axis):
img_rgb = img_as_float(self.img_rgb)
img_rgb = np.moveaxis(img_rgb, source=-1, destination=channel_axis)
round_trip = xyz2rgb(rgb2xyz(img_rgb, channel_axis=channel_axis),
channel_axis=channel_axis)
assert_array_almost_equal(round_trip, img_rgb)
def test_rgb2xyz_conversion(self):
gt = np.array([[[0.950456, 1., 1.088754],
[0.538003, 0.787329, 1.06942],
[0.592876, 0.28484, 0.969561],
[0.180423, 0.072169, 0.950227]],
[[0.770033, 0.927831, 0.138527],
[0.35758, 0.71516, 0.119193],
[0.412453, 0.212671, 0.019334], [0., 0., 0.]]])
assert_almost_equal(rgb2xyz(self.colbars_array), gt)
def test_rgb2xyz_conversion(self):
gt = np.array([[[0.950456, 1. , 1.088754],
[0.538003, 0.787329, 1.06942 ],
[0.592876, 0.28484 , 0.969561],
[0.180423, 0.072169, 0.950227]],
[[0.770033, 0.927831, 0.138527],
[0.35758 , 0.71516 , 0.119193],
[0.412453, 0.212671, 0.019334],
[0. , 0. , 0. ]]])
assert_almost_equal(rgb2xyz(self.colbars_array), gt)
def preserve_color_cielch(content, stylized, image_name):
# extract info and convert to CIE-LCh for each image
rgbContent = io.imread(content)
labContent = color.lab2lch(
color.xyz2lab(color.rgb2xyz(numpy.asarray(rgbContent))))
labContentArray = numpy.array(labContent)
rgbStyle = io.imread(stylized)
labStyle = color.lab2lch(
color.xyz2lab(color.rgb2xyz(numpy.asarray(rgbStyle))))
labStyleArray = numpy.array(labStyle)
# color transfer
for i in range(len(labContentArray)):
for j in range(len(labContentArray[0])):
labContentArray[i][j][0] = labStyleArray[i][j][0]
labContentArray = color.xyz2rgb(
color.lab2xyz(color.lch2lab(labContentArray)))
viewer = ImageViewer(labContentArray)
viewer.show()
def build_features_from_arr(self, img_rgb):
# the third component `_` is actually the number of channels in RGB,
# which is already defined in the constant `NUM_RGB_CHANNELS`
num_rows, num_cols, _ = img_rgb.shape
num_pixels = num_rows * num_cols
img_lab = color.rgb2lab(img_rgb)
img_lab_l = img_lab[:, :, 0] # ACHTUNG: this is a view
X = np.zeros((num_pixels, self.num_pixel_features), dtype=np.float32)
# color features
# tpf.compute_color_features(X_img[:, self.color_slice])
img_lab_vec = img_lab.reshape(num_rows * num_cols, NUM_LAB_CHANNELS)
img_xyz_vec = color.rgb2xyz(img_rgb).reshape(num_rows * num_cols,
NUM_XYZ_CHANNELS)
img_ill_vec = np.dot(A, np.log(np.dot(B, img_xyz_vec.transpose()) +
1)).transpose()
X[:, :NUM_LAB_CHANNELS] = img_lab_vec
X[:,
NUM_LAB_CHANNELS:NUM_LAB_CHANNELS + NUM_ILL_CHANNELS] = img_ill_vec
# texture features
# tpf.compute_texture_features(X_img[:, self.texture_slice],
# self.sigmas, self.num_orientations)
for i, sigma in enumerate(self.sigmas):
base_kernel_arr = filters.get_texture_kernel(sigma)
for j, orientation in enumerate(range(self.num_orientations)):
# theta = orientation / num_orientations * np.pi
theta = orientation * 180 / self.num_orientations
oriented_kernel_arr = ndi.interpolation.rotate(
base_kernel_arr, theta)
img_filtered = ndi.convolve(img_lab_l, oriented_kernel_arr)
img_filtered_vec = img_filtered.flatten()
X[:, self.num_color_features + i * self.num_orientations +
j] = img_filtered_vec
# entropy features
# tpf.compute_entropy_features(X_img[:, self.entropy_slice],
# self.neighborhood, self.scales)
entropy_start = self.num_color_features + self.num_texture_features
X[:, entropy_start] = rank.entropy(img_lab_l.astype(np.uint16),
self.neighborhood).flatten()
for i, factor in enumerate(self.scales[1:], start=1):
img = transform.resize(
transform.downscale_local_mean(img_lab_l, (factor, factor)),
img_lab_l.shape).astype(np.uint16)
X[:,
entropy_start + i] = rank.entropy(img,
self.neighborhood).flatten()
return X
def alterXYZ(img):
img = color.rgb2xyz(img)
params = []
#X
img[:, :, 0] += randUnifC(-0.05, 0.05, params=params)
#Y
img[:, :, 1] += randUnifC(-0.05, 0.05, params=params)
#Z
img[:, :, 2] += randUnifC(-0.05, 0.05, params=params)
img = np.clip(img, 0, 1.0)
img = color.xyz2rgb(img)
img = np.clip(img, 0, 1.0)
return img
def G2_getfeatures(ims, fil_paras, gridshape, mode="reflect", cval=0):
'''
A routine which takes an array of images with 4 coords.
Dim 1 and 2: pixel position.
Dim 3: RGB channel index.
Dim 4: Time index.
'''
num_ims = ims.shape[3]
num_feats = gridshape[0] * gridshape[1]
out = np.zeros(num_ims * num_feats, dtype=np.float32).reshape(
(num_ims, num_feats))
# Generate the kernel prior to loop over images.
fil_values = fil_kernel(paras=fil_paras, n_stds=2)
# Iterate over images.
for i in range(num_ims):
featvec = np.arange(0, dtype=np.float32)
# Slice -> XYZ -> CIE Lab -> Take only Luminance channel.
im = col.xyz2lab(col.rgb2xyz(ims[:, :, :, i]))[:, :, 0]
# Convolution.
fil_response_real = ndi.convolve(input=im,
weights=fil_values["real"],
mode=mode,
cval=cval)
fil_response_imag = ndi.convolve(input=im,
weights=fil_values["imag"],
mode=mode,
cval=cval)
fil_response_magnitude = np.sqrt(
(fil_response_real**2 + fil_response_imag**2))
# Per-patch statistics.
imstats = patch_stats(image=fil_response_magnitude,
grid_h=gridshape[0],
grid_w=gridshape[1])
# Pass per-patch statistics through non-linearity to compute final feature vector.
imfeats = nonlin(imstats["mean"])
# Store the feature vector for this image.
out[i, :] = imfeats
# Output is the array of feature vectors, one feature vector for each image.
return out
def test_rgb2xyz_conversion(self, channel_axis):
gt = np.array([[[0.950456, 1., 1.088754],
[0.538003, 0.787329, 1.06942],
[0.592876, 0.28484, 0.969561],
[0.180423, 0.072169, 0.950227]],
[[0.770033, 0.927831, 0.138527],
[0.35758, 0.71516, 0.119193],
[0.412453, 0.212671, 0.019334], [0., 0., 0.]]])
img = np.moveaxis(self.colbars_array,
source=-1,
destination=channel_axis)
out = rgb2xyz(img, channel_axis=channel_axis)
out = np.moveaxis(out, source=channel_axis, destination=-1)
assert_almost_equal(out, gt)
def get_XYZ(image):
"""Transforms RGB Image into XYZ
Args:
image: image to convert
Returns:
XYZ information obtained from transformation
Usage:
>>> from PIL import Image
>>> from ipfml.processing import transform
>>> img = Image.open('./images/test_img.png')
>>> transform.get_XYZ(img).shape
(200, 200, 3)
"""
return color.rgb2xyz(image)
def task_1():
"""
Convert the color space of Lena.png from RGB to CIE XYZ
:return: None
"""
# Read the Lena rgb image with type uint8
rgb_img = io.imread('./images/Lena.png')
# Convert to CIE XYZ
xyz_img = rgb2xyz(rgb_img)
fig, ax = plt.subplots(1, 2)
# Display the image side by side with original
ax[0].imshow(rgb_img)
ax[0].set_axis_off()
ax[0].set_title('Original(RGB) Lena')
ax[1].imshow(xyz_img)
ax[1].set_axis_off()
ax[1].set_title('CIE XYZ Lena')
plt.show()
def loadData(path="../data/"):
"""
Question 1 (c)
Load data from the path given. The images are stored as input_n.tif
for n = {1...7}. The source lighting directions are stored in
sources.mat.
Paramters
---------
path: str
Path of the data directory
Returns
-------
I : numpy.ndarray
The 7 x P matrix of vectorized images
L : numpy.ndarray
The 3 x 7 matrix of lighting directions
s: tuple
Image shape
"""
im = [str(x) for x in range(1, 8)]
I = []
for i in im:
arr = imread(path + 'input_{}.tif'.format(i)).astype(np.uint16)
arr = rgb2xyz(arr)[:, :, 1]
s = arr.shape
I.append(arr.flatten())
I = np.array(I)
L = np.load(path + 'sources.npy').T
_, sv, _ = np.linalg.svd(I, full_matrices=False)
print("I matrix singular values:\n\t{}".format(sv))
return I, L, s
def salvarcombinacoes(img):
img_rgb = color.convert_colorspace(img, 'RGB', 'RGB')
img_hsv = color.convert_colorspace(img_rgb, 'RGB', 'HSV')
img_lab = color.rgb2lab(img_rgb)
img_hed = color.rgb2hed(img_rgb)
img_luv = color.rgb2luv(img_rgb)
img_rgb_cie = color.convert_colorspace(img_rgb, 'RGB', 'RGB CIE')
img_xyz = color.rgb2xyz(img_rgb)
img_cmy = rgb2cmy(img_rgb)
lista = [img_rgb, img_hsv, img_lab, img_hed, img_luv, img_rgb_cie, img_xyz, img_cmy]
lista2 = ["rgb", "hsv", "lab", "hed", "luv", "rgb_cie", "xyz", "cmy"]
for i in range(len(lista)):
for j in range(len(lista)):
for k in range(3):
for l in range(3):
nome = lista2[i] + str(k) + lista2[j] + str(l) + ".jpg"
io.imsave(nome, juntarcanais(lista[i][:, :,k], lista[j][:, :, l]), )
return
def loadData(path="../data/"):
"""
Question 1 (c)
Load data from the path given. The images are stored as input_n.tif
for n = {1...7}. The source lighting directions are stored in
sources.mat.
Paramters
---------
path: str
Path of the data directory
Returns
-------
I : numpy.ndarray
The 7 x P matrix of vectorized images
L : numpy.ndarray
The 3 x 7 matrix of lighting directions
s: tuple
Image shape
"""
I = []
for i in range(7):
image = imread(os.path.join(path, f'input_{i+1}.tif'))
if image.dtype != np.uint16:
image = image.astype(np.uint16)
# Luminance channel is Y
image = rgb2xyz(image)[:, :, 1]
s = image.shape
I.append(image.flatten())
I = np.asarray(I)
# print(I.dtype)
L = np.load(os.path.join(path, "sources.npy")).T
# print(I.shape, L.shape)
return I, L, s
def get_XYZ_Y(image):
"""Transforms RGB Image into XYZ and returns Y
Args:
image: image to convert
Returns:
The Y chanel from XYZ information
Usage:
>>> from PIL import Image
>>> from ipfml.processing import transform
>>> img = Image.open('./images/test_img.png')
>>> y = transform.get_XYZ_Y(img)
>>> y.shape
(200, 200)
"""
xyz = color.rgb2xyz(image)
return xyz[:, :, 1]
def xyz_shift(img, kt):
"""Apply chromatic aberration."""
img = color.rgb2xyz(img)
shp = img.shape
red = img[:, :, 0]
green = img[:, :, 1]
blue = img[:, :, 2]
# split channels, make shift
red = tf.resize(red, output_shape=(shp[0], shp[1]))
green = tf.resize(green, output_shape=(shp[0] - kt, shp[1] - kt))
blue = tf.resize(blue, output_shape=(shp[0] - 2 * kt, shp[1] - 2 * kt))
w, h = blue.shape
ktd2 = int(kt / 2)
red_n = np.reshape(red[kt:-kt, kt:-kt], (w, h, 1))
green_n = np.reshape(green[ktd2:-1 * ktd2, ktd2:-1 * ktd2], (w, h, 1))
blue_n = np.reshape(blue[:, :], (w, h, 1))
new_im = np.concatenate((red_n, green_n, blue_n), axis=2)
new_im = tf.resize(new_im, (shp[0], shp[1]))
new_im = color.xyz2rgb(new_im)
return new_im
def loadData(path="../data/"):
"""
Question 1 (c)
Load data from the path given. The images are stored as input_n.tif
for n = {1...7}. The source lighting directions are stored in
sources.mat.
Paramters
---------
path: str
Path of the data directory
Returns
-------
I : numpy.ndarray
The 7 x P matrix of vectorized images
L : numpy.ndarray
The 3 x 7 matrix of lighting directions
s: tuple
Image shape
"""
img = imread('../data/input_1.tif')
H, W, _ = img.shape
s = (H, W)
I = np.zeros((7, H * W))
for i in range(7):
img = imread('../data/input_{}.tif'.format(i + 1))
img = rgb2xyz(img)
img = img[:, :, 1].flatten()
I[i, :] = img
L = np.load('../data/sources.npy')
L = L.T
return I, L, s
def load_data(folder_path, method='rgb'):
rgb_img, low_channel_img, hs_img = None, None, None
file_names = os.listdir(folder_path)
for file_name in file_names:
if '.mat' in file_name:
hs_file_path = os.path.join(folder_path, file_name)
rgb_img = create_rgb_from_hs(hs_file_path)
if method == 'lab':
low_channel_img = color.rgb2lab(rgb_img)
elif method == 'xyz':
low_channel_img = color.rgb2xyz(rgb_img)
else:
low_channel_img = rgb_img
data = scipy.io.loadmat(hs_file_path)
if 'reflectances' in data:
hs_img = data['reflectances']
hs_img = hs_img[:, :, :31]
hs_img = hs_img / np.max(hs_img)
return rgb_img, low_channel_img, hs_img
def extract_color_descriptors(image, space=None, verbose=False):
"""
Extract color descriptors of the image
Parameters
----------
image:
space:
None, equivalent to rgb
rgb
hsv
xyz
rgbcie
Returns
-------
Descriptors
"""
if space == 'hsv':
image = color.rgb2hsv(image)
elif space == 'xyz':
image = color.rgb2xyz(image)
elif space == 'rgbcie':
image = color.rgb2rgbcie(image)
elif space == 'gray' or space == 'grey':
image = color.rgb2gray(image)
gen = get_patch(image, size=1)
descs = []
for patch, coord in gen:
if verbose and coord[1] % 5 == 0 and coord[0] == 0:
print 'computed up to %d, %d' % coord
desc = patch.flatten()
desc = np.concatenate((desc, np.array(coord)))
descs.append(desc)
return np.array(descs)
def get_XYZ_Z(image):
"""Transforms RGB Image into XYZ and returns Z
Args:
image: image to convert
Returns:
The Z chanel from XYZ information
Raises:
ValueError: If `nb_bits` has unexpected value. `nb_bits` needs to be in interval [1, 8].
Usage:
>>> from PIL import Image
>>> from ipfml.processing import transform
>>> img = Image.open('./images/test_img.png')
>>> z = transform.get_XYZ_Z(img)
>>> z.shape
(200, 200)
"""
xyz = color.rgb2xyz(image)
return xyz[:, :, 2]
model.add(Convolution2D(64, 4, 4, border_mode='valid'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.5))
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3, border_mode='valid'))
model.add(Dropout(0.5))
model.add(Activation('relu'))
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dense(6))
model.add(Activation('softmax')) #aqui o certo é um htan
sgd = SGD()
model.compile(loss = 'categorical_crossentropy', optimizer = sgd)
env = gym.make('Pong-v0')
obs = env.reset()
xyz = color.rgb2xyz(obs)
y = xyz[:,:,1]
small = resize(y,(84,84))
in_obs = small.reshape(1, 1, 84, 84)
pred = model.predict(in_obs,batch_size=1,verbose=0)
print(pred)
#h = model.fit(X_train, Y_train, batch_size = 128, nb_epoch=3, validation_data =(X_test, Y_test), verbose=1)
def test_xyz2rgb_conversion(self):
# only roundtrip test, we checked rgb2xyz above already
assert_almost_equal(xyz2rgb(rgb2xyz(self.colbars_array)),
self.colbars_array)
def to_xyz(self):
return Image(rgb2xyz(self.to_rgb_from_gray()[:, :, :3])).convert_type(self.dtype)
def rgb2lms(rgbimage):
""""""
return XYZ2lms(rgb2xyz(rgbimage))
def test_xyz_rgb_roundtrip(self):
img_rgb = img_as_float(self.img_rgb)
assert_array_almost_equal(xyz2rgb(rgb2xyz(img_rgb)), img_rgb)
def test_xyz2rgb_conversion(self):
assert_almost_equal(xyz2rgb(rgb2xyz(self.colbars_array)),
self.colbars_array)
def test_xyz2rgb_conversion(self):
assert_almost_equal(xyz2rgb(rgb2xyz(self.colbars_array)),
self.colbars_array)
print "Thread %s. Opening file : %s" % (sys.argv[1], f)
### PROCESSING
# Read the image
A = io.imread(f)
# Constrast enhancement
print "Thread %s. Sigmoid transform for contrast." % sys.argv[1]
B = exposure.adjust_sigmoid(A, gain=12)
# Extract luminosity
print "Thread %s. Generating luminosity." % sys.argv[1]
C = color.rgb2xyz(B)[:, :, 1]
# Apply adaptive thresholding
print "Thread %s. Performing adaptive thresholding." % sys.argv[1]
D = filter.threshold_adaptive(C, 301)
D2 = filter.threshold_adaptive(C, 301, offset=-0.01)
# Clean
print "Thread %s. Cleaning image." % sys.argv[1]
E = morphology.remove_small_objects(~morphology.remove_small_objects(~D, 100), 100)
E2 = morphology.remove_small_objects(~morphology.remove_small_objects(~D2, 100), 100)
blur.append(np.abs(E[:2000, 1000:-1000] - E2[:2000, 1000:-1000]).sum() / 6368000.)
# Save to disk
io.imsave(f + "_processed.jpg", ski.img_as_float(E))
return plt
#Input's Block
#Single Reader
img = data.imread('img/nor.jpg', False,)
#Set Reader
#Convert Block
img_rgb = color.convert_colorspace(img, 'RGB', 'RGB') #No need
img_hsv = color.convert_colorspace(img_rgb, 'RGB', 'HSV')
img_lab = color.rgb2lab(img_rgb)
img_hed = color.rgb2hed(img_rgb)
img_luv = color.rgb2luv(img_rgb)
img_rgb_cie = color.convert_colorspace(img_rgb, 'RGB', 'RGB CIE')
img_xyz = color.rgb2xyz(img_rgb)
#Save Test Block
"""io.imsave("image_hsv.jpg", img_hsv, )
io.imsave("image_lab.jpg", img_lab, )
io.imsave("image_hed.jpg", img_hed, )
io.imsave("image_luv.jpg", img_luv, )
io.imsave("image_rgb_cie.jpg", img_rgb_cie, )
io.imsave("image_xyz.jpg", img_xyz, )
"""
#Layers Block
"""
canalExtration(img_rgb, "RGB").show()
canalExtration(img_hsv, "HSV").show()
canalExtration(img_lab, "LAB").show()
canalExtration(img_hed, "HED").show()
labels = morphology.watershed(-distance, markers, mask = clean) io.imshow(labels, interpolation = "nearest", cmap = plt.cm.spectral) # <codecell> io.imshow(filter.gaussian_filter(image, 31)) # <codecell> # Local density B = image[:, :, 2] #B = filter.gaussian_filter(np.abs(B - B.mean()), 31) #io.imshow(B > 1.1*filter.threshold_otsu(B)) io.imshow(color.rgb2xyz(image)[:, :, 2]) #local_density = filter.gaussian_filter(image[:,:,0], 41)# - filter.gaussian_filter(clean, 201) #io.imshow(local_density > 1.2 * filter.threshold_otsu(local_density, nbins = 1000)) #io.imshow(local_density - local_density.mean() > 0) """ #io.imshow(filter.gaussian_filter(clean, 51)) Q = (signal.convolve2d(ski.img_as_float(clean / clean.max()), ski.img_as_float(morphology.disk(201)), "valid"))# - filter.gaussian_filter(clean, 251)) Q -= Q.min() Q /= Q.max() io.imshow(Q) """ # <codecell>
def ColConv(px): out = col.rgb2xyz([[px]])[0][0] return out
def test_xyz_rgb_roundtrip(self):
img_rgb = img_as_float(self.img_rgb)
assert_array_almost_equal(xyz2rgb(rgb2xyz(img_rgb)), img_rgb)
def test_rgb2xyz_dtype(self):
img = self.colbars_array
img32 = img.astype('float32')
assert rgb2xyz(img).dtype == img.dtype
assert rgb2xyz(img32).dtype == img32.dtype
def hsi2lab(shi_pic):
tmp_rgb = color.hsv2rgb(hsv)
tmp_xyz = color.rgb2xyz(tmp_rgb)
return color.xyz2lab(tmp_xyz)
def test_xyz2rgb_dtype(self):
img = rgb2xyz(self.colbars_array)
img32 = img.astype('float32')
assert xyz2rgb(img).dtype == img.dtype
assert xyz2rgb(img32).dtype == img32.dtype
def test_rgb_to_xyz_against_skimage(random_rgb):
assert np.allclose(random_rgb.to_xyz(),
skcolor.rgb2xyz(random_rgb),
rtol=1e-2)
def trans(self, img):
rst = color.rgb2xyz(img)
print('============', rst.min(), rst.max())
return (rst * (200)).astype(np.uint8)
A = io.imread(files[0]) As = transform.rescale(A, 0.25) io.imshow(A) plt.grid(False) # <codecell> #B = exposure.adjust_sigmoid(A, gain=12) Bs = exposure.adjust_sigmoid(ski.img_as_float(As), gain=12) #io.imshow(B - exposure.adjust_sigmoid(ski.img_as_float(A), gain=12)) # <codecell> #C = color.rgb2xyz(B)[:, :, 1] Cs = color.rgb2xyz(Bs)[:, :, 1] io.imshow(Cs) plt.grid(0) # <codecell> #D = filter.threshold_adaptive(C, 301) Ds = filter.threshold_adaptive(Cs, 75) io.imshow(Ds) plt.grid(0) # <codecell> #E = morphology.remove_small_objects(~morphology.remove_small_objects(~D, 100), 100) Es = morphology.remove_small_objects(~morphology.remove_small_objects(~Ds, 10), 10) io.imshow(Es)
plt.axis("off")
plt.title("VonKries")
plt.tight_layout()
plt.show()
#----------------------------------------------------------------
# Chromatic adaptation with different methods
#----------------------------------------------------------------
else:
print(sorted(colour.CHROMATIC_ADAPTATION_TRANSFORMS))
# Test view condition
XYZ_w = np.array([234, 240, 220])
# Reference view condition
XYZ_wr = np.array([224, 187, 70])
method = 'Von Kries'
VonKries = colour.adaptation.chromatic_adaptation_VonKries(
rgb2xyz(im_gamma), XYZ_w, XYZ_wr, method)
try:
print(VonKries.shape)
except ValueError:
print('Dimentional error!')
fig = plt.figure(figsize=(4, 5))
fig.add_subplot(111)
plt.imshow(VonKries)
plt.title('VonKriesAdaptation')
plt.tight_layout()
plt.axis('off')
plt.show()
#---------------------------------------------------------------
# Colorsapce conversation- destation ATD
# Visualization channel with fake color
def rgb2xyz(self,imageArray):
return color.rgb2xyz(imageArray)
