def test_auxiliary_channels_isolated(self):
# test data in aux channels does not affect non-aux channels
aux_channel_formats = [
# format, profile, color-only format, source test image
('RGBA', 'sRGB', 'RGB', hopper('RGBA')),
('RGBX', 'sRGB', 'RGB', hopper('RGBX')),
('LAB', 'LAB', 'LAB', Image.open('Tests/images/hopper.Lab.tif')),
]
for src_format in aux_channel_formats:
for dst_format in aux_channel_formats:
for transform_in_place in [True, False]:
# inplace only if format doesn't change
if transform_in_place and src_format[0] != dst_format[0]:
continue
# convert with and without AUX data, test colors are equal
source_profile = ImageCms.createProfile(src_format[1])
destination_profile = ImageCms.createProfile(dst_format[1])
source_image = src_format[3]
test_transform = ImageCms.buildTransform(source_profile, destination_profile, inMode=src_format[0], outMode=dst_format[0])
# test conversion from aux-ful source
if transform_in_place:
test_image = source_image.copy()
ImageCms.applyTransform(test_image, test_transform, inPlace=True)
else:
test_image = ImageCms.applyTransform(source_image, test_transform, inPlace=False)
# reference conversion from aux-less source
reference_transform = ImageCms.buildTransform(source_profile, destination_profile, inMode=src_format[2], outMode=dst_format[2])
reference_image = ImageCms.applyTransform(source_image.convert(src_format[2]), reference_transform)
self.assert_image_equal(test_image.convert(dst_format[2]), reference_image)
def test_sanity():
# basic smoke test.
# this mostly follows the cms_test outline.
v = ImageCms.versions() # should return four strings
assert_equal(v[0], '1.0.0 pil')
assert_equal(list(map(type, v)), [str, str, str, str])
# internal version number
assert_match(ImageCms.core.littlecms_version, "\d+\.\d+$")
i = ImageCms.profileToProfile(lena(), SRGB, SRGB)
assert_image(i, "RGB", (128, 128))
t = ImageCms.buildTransform(SRGB, SRGB, "RGB", "RGB")
i = ImageCms.applyTransform(lena(), t)
assert_image(i, "RGB", (128, 128))
p = ImageCms.createProfile("sRGB")
o = ImageCms.getOpenProfile(SRGB)
t = ImageCms.buildTransformFromOpenProfiles(p, o, "RGB", "RGB")
i = ImageCms.applyTransform(lena(), t)
assert_image(i, "RGB", (128, 128))
t = ImageCms.buildProofTransform(SRGB, SRGB, SRGB, "RGB", "RGB")
assert_equal(t.inputMode, "RGB")
assert_equal(t.outputMode, "RGB")
i = ImageCms.applyTransform(lena(), t)
assert_image(i, "RGB", (128, 128))
# test PointTransform convenience API
im = lena().point(t)
def test_lab_roundtrip():
# check to see if we're at least internally consistent.
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(SRGB, pLab, "RGB", "LAB")
t2 = ImageCms.buildTransform(pLab, SRGB, "LAB", "RGB")
i = ImageCms.applyTransform(lena(), t)
out = ImageCms.applyTransform(i, t2)
assert_image_similar(lena(), out, 2)
def assert_aux_channel_preserved(self, mode,
transform_in_place, preserved_channel):
def create_test_image():
# set up test image with something interesting in the tested aux
# channel.
nine_grid_deltas = [ # noqa: E128
(-1, -1), (-1, 0), (-1, 1),
(0, -1), (0, 0), (0, 1),
(1, -1), (1, 0), (1, 1),
]
chans = []
bands = ImageMode.getmode(mode).bands
for band_ndx in range(len(bands)):
channel_type = 'L' # 8-bit unorm
channel_pattern = hopper(channel_type)
# paste pattern with varying offsets to avoid correlation
# potentially hiding some bugs (like channels getting mixed).
paste_offset = (
int(band_ndx / float(len(bands)) * channel_pattern.size[0]),
int(band_ndx / float(len(bands) * 2) * channel_pattern.size[1])
)
channel_data = Image.new(channel_type, channel_pattern.size)
for delta in nine_grid_deltas:
channel_data.paste(
channel_pattern,
tuple(paste_offset[c] + delta[c] * channel_pattern.size[c]
for c in range(2)),
)
chans.append(channel_data)
return Image.merge(mode, chans)
source_image = create_test_image()
source_image_aux = source_image.getchannel(preserved_channel)
# create some transform, it doesn't matter which one
source_profile = ImageCms.createProfile("sRGB")
destination_profile = ImageCms.createProfile("sRGB")
t = ImageCms.buildTransform(
source_profile, destination_profile, inMode=mode, outMode=mode)
# apply transform
if transform_in_place:
ImageCms.applyTransform(source_image, t, inPlace=True)
result_image = source_image
else:
result_image = ImageCms.applyTransform(
source_image, t, inPlace=False)
result_image_aux = result_image.getchannel(preserved_channel)
self.assert_image_equal(source_image_aux, result_image_aux)
def test_lab_roundtrip(self):
# check to see if we're at least internally consistent.
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(SRGB, pLab, "RGB", "LAB")
t2 = ImageCms.buildTransform(pLab, SRGB, "LAB", "RGB")
i = ImageCms.applyTransform(hopper(), t)
self.assertEqual(i.info['icc_profile'],
ImageCmsProfile(pLab).tobytes())
out = ImageCms.applyTransform(i, t2)
self.assert_image_similar(hopper(), out, 2)
def convert_profile_pil_transform(image_pil, transform, inPlace=False):
if not have_cms:
return image_pil
image_out = ImageCms.applyTransform(image_pil, transform, inPlace)
if inPlace:
return image_pil
return image_out
def test_sanity(self):
# basic smoke test.
# this mostly follows the cms_test outline.
v = ImageCms.versions() # should return four strings
self.assertEqual(v[0], '1.0.0 pil')
self.assertEqual(list(map(type, v)), [str, str, str, str])
# internal version number
self.assertRegexpMatches(ImageCms.core.littlecms_version, r"\d+\.\d+$")
self.skip_missing()
i = ImageCms.profileToProfile(hopper(), SRGB, SRGB)
self.assert_image(i, "RGB", (128, 128))
i = hopper()
ImageCms.profileToProfile(i, SRGB, SRGB, inPlace=True)
self.assert_image(i, "RGB", (128, 128))
t = ImageCms.buildTransform(SRGB, SRGB, "RGB", "RGB")
i = ImageCms.applyTransform(hopper(), t)
self.assert_image(i, "RGB", (128, 128))
i = hopper()
t = ImageCms.buildTransform(SRGB, SRGB, "RGB", "RGB")
ImageCms.applyTransform(hopper(), t, inPlace=True)
self.assert_image(i, "RGB", (128, 128))
p = ImageCms.createProfile("sRGB")
o = ImageCms.getOpenProfile(SRGB)
t = ImageCms.buildTransformFromOpenProfiles(p, o, "RGB", "RGB")
i = ImageCms.applyTransform(hopper(), t)
self.assert_image(i, "RGB", (128, 128))
t = ImageCms.buildProofTransform(SRGB, SRGB, SRGB, "RGB", "RGB")
self.assertEqual(t.inputMode, "RGB")
self.assertEqual(t.outputMode, "RGB")
i = ImageCms.applyTransform(hopper(), t)
self.assert_image(i, "RGB", (128, 128))
# test PointTransform convenience API
hopper().point(t)
def test_lab_srgb():
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(pLab, SRGB, "LAB", "RGB")
img = Image.open('Tests/images/lena.Lab.tif')
img_srgb = ImageCms.applyTransform(img, t)
# img_srgb.save('temp.srgb.tif') # visually verified vs ps.
assert_image_similar(lena(), img_srgb, 30)
def test_lab_color():
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(SRGB, pLab, "RGB", "LAB")
# need to add a type mapping for some PIL type to TYPE_Lab_8 in findLCMSType,
# and have that mapping work back to a PIL mode. (likely RGB)
i = ImageCms.applyTransform(lena(), t)
assert_image(i, "LAB", (128, 128))
# i.save('temp.lab.tif') # visually verified vs PS.
target = Image.open('Tests/images/lena.Lab.tif')
assert_image_similar(i, target, 30)
def test_lab_srgb(self):
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(pLab, SRGB, "LAB", "RGB")
img = Image.open('Tests/images/lena.Lab.tif')
img_srgb = ImageCms.applyTransform(img, t)
# img_srgb.save('temp.srgb.tif') # visually verified vs ps.
self.assert_image_similar(lena(), img_srgb, 30)
self.assertTrue(img_srgb.info['icc_profile'])
profile = ImageCmsProfile(BytesIO(img_srgb.info['icc_profile']))
self.assertTrue('sRGB' in ImageCms.getProfileDescription(profile))
def test_lab_color(self):
psRGB = ImageCms.createProfile("sRGB")
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(psRGB, pLab, "RGB", "LAB")
# Need to add a type mapping for some PIL type to TYPE_Lab_8 in
# findLCMSType, and have that mapping work back to a PIL mode
# (likely RGB).
i = ImageCms.applyTransform(hopper(), t)
self.assert_image(i, "LAB", (128, 128))
# i.save('temp.lab.tif') # visually verified vs PS.
target = Image.open('Tests/images/hopper.Lab.tif')
self.assert_image_similar(i, target, 3.5)
def test_simple_lab():
i = Image.new('RGB', (10, 10), (128, 128, 128))
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(SRGB, pLab, "RGB", "LAB")
i_lab = ImageCms.applyTransform(i, t)
assert_equal(i_lab.mode, 'LAB')
k = i_lab.getpixel((0, 0))
assert_equal(k, (137, 128, 128)) # not a linear luminance map. so L != 128
L = i_lab.getdata(0)
a = i_lab.getdata(1)
b = i_lab.getdata(2)
assert_equal(list(L), [137] * 100)
assert_equal(list(a), [128] * 100)
assert_equal(list(b), [128] * 100)
def test_simple_lab(self):
i = Image.new('RGB', (10, 10), (128, 128, 128))
psRGB = ImageCms.createProfile("sRGB")
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(psRGB, pLab, "RGB", "LAB")
i_lab = ImageCms.applyTransform(i, t)
self.assertEqual(i_lab.mode, 'LAB')
k = i_lab.getpixel((0, 0))
# not a linear luminance map. so L != 128:
self.assertEqual(k, (137, 128, 128))
l = i_lab.getdata(0)
a = i_lab.getdata(1)
b = i_lab.getdata(2)
self.assertEqual(list(l), [137] * 100)
self.assertEqual(list(a), [128] * 100)
self.assertEqual(list(b), [128] * 100)
def test_simple_lab():
i = Image.new("RGB", (10, 10), (128, 128, 128))
psRGB = ImageCms.createProfile("sRGB")
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(psRGB, pLab, "RGB", "LAB")
i_lab = ImageCms.applyTransform(i, t)
assert i_lab.mode == "LAB"
k = i_lab.getpixel((0, 0))
# not a linear luminance map. so L != 128:
assert k == (137, 128, 128)
l_data = i_lab.getdata(0)
a_data = i_lab.getdata(1)
b_data = i_lab.getdata(2)
assert list(l_data) == [137] * 100
assert list(a_data) == [128] * 100
assert list(b_data) == [128] * 100
def test_simple_lab(self):
i = Image.new('RGB', (10, 10), (128, 128, 128))
psRGB = ImageCms.createProfile("sRGB")
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(psRGB, pLab, "RGB", "LAB")
i_lab = ImageCms.applyTransform(i, t)
self.assertEqual(i_lab.mode, 'LAB')
k = i_lab.getpixel((0, 0))
# not a linear luminance map. so L != 128:
self.assertEqual(k, (137, 128, 128))
l_data = i_lab.getdata(0)
a_data = i_lab.getdata(1)
b_data = i_lab.getdata(2)
self.assertEqual(list(l_data), [137] * 100)
self.assertEqual(list(a_data), [128] * 100)
self.assertEqual(list(b_data), [128] * 100)
def get_lab_for_all(path, num):
lab_all = []
count = 0
for filename in os.listdir(path):
if num != 'all' and count > num:
break
#print(count)
count += 1
image_path = path + filename
im = Image.open(image_path)
if im.mode != "RGB":
im = im.convert("RGB").resize((224, 224))
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(
srgb_profile, lab_profile, "RGB", "LAB")
lab_im = ImageCms.applyTransform(im, rgb2lab_transform)
lab_all.append(np.array(lab_im))
return np.array(lab_all)
result = result[:5]
result = result.lower()
return result
im = Image.open('captcha.png')
# Convert to L*a*b colorspace is more complex:
rgb = ImageCms.createProfile(colorSpace='sRGB')
lab = ImageCms.createProfile(colorSpace='LAB')
transform = ImageCms.buildTransform(inputProfile=rgb,
outputProfile=lab,
inMode='RGB',
outMode='LAB')
lab_im = ImageCms.applyTransform(im=im, transform=transform)
lab_im = rescale(lab_im)
l, a, b = lab_im.split()
# Convert to numpy array and apply the threshold to remove lines
np_a = np.array(a)
threshold = 180
np_a[np_a < threshold] = 0
np_a[np_a > threshold] = 255
# Invert the image: we want black text on a white background
np_a = 255 - np_a
a = Image.fromarray(np_a)
def test_sanity():
# basic smoke test.
# this mostly follows the cms_test outline.
v = ImageCms.versions() # should return four strings
assert_equal(v[0], '0.1.0 pil')
assert_equal(map(type, v), [str, str, str, str])
# internal version number
assert_match(ImageCms.core.littlecms_version, "\d+\.\d+$")
i = ImageCms.profileToProfile(lena(), SRGB, SRGB)
assert_image(i, "RGB", (128, 128))
t = ImageCms.buildTransform(SRGB, SRGB, "RGB", "RGB")
i = ImageCms.applyTransform(lena(), t)
assert_image(i, "RGB", (128, 128))
p = ImageCms.createProfile("sRGB")
o = ImageCms.getOpenProfile(SRGB)
t = ImageCms.buildTransformFromOpenProfiles(p, o, "RGB", "RGB")
i = ImageCms.applyTransform(lena(), t)
assert_image(i, "RGB", (128, 128))
t = ImageCms.buildProofTransform(SRGB, SRGB, SRGB, "RGB", "RGB")
assert_equal(t.inputMode, "RGB")
assert_equal(t.outputMode, "RGB")
i = ImageCms.applyTransform(lena(), t)
assert_image(i, "RGB", (128, 128))
# get profile information for file
assert_equal(
ImageCms.getProfileName(SRGB).strip(),
'IEC 61966-2.1 Default RGB colour space - sRGB')
assert_equal(
ImageCms.getProfileInfo(SRGB).splitlines(), [
'sRGB IEC61966-2.1', '',
'Copyright (c) 1998 Hewlett-Packard Company', '',
'WhitePoint : D65 (daylight)', '', 'Tests/icc/sRGB.icm'
])
assert_equal(ImageCms.getDefaultIntent(SRGB), 0)
assert_equal(
ImageCms.isIntentSupported(SRGB, ImageCms.INTENT_ABSOLUTE_COLORIMETRIC,
ImageCms.DIRECTION_INPUT), 1)
# same, using profile object
p = ImageCms.createProfile("sRGB")
assert_equal(
ImageCms.getProfileName(p).strip(), 'sRGB built-in - (lcms internal)')
assert_equal(
ImageCms.getProfileInfo(p).splitlines(),
['sRGB built-in', '', 'WhitePoint : D65 (daylight)', '', ''])
assert_equal(ImageCms.getDefaultIntent(p), 0)
assert_equal(
ImageCms.isIntentSupported(p, ImageCms.INTENT_ABSOLUTE_COLORIMETRIC,
ImageCms.DIRECTION_INPUT), 1)
# extensions
i = Image.open("Tests/images/rgb.jpg")
p = ImageCms.getOpenProfile(StringIO(i.info["icc_profile"]))
assert_equal(
ImageCms.getProfileName(p).strip(),
'IEC 61966-2.1 Default RGB colour space - sRGB')
# the procedural pyCMS API uses PyCMSError for all sorts of errors
assert_exception(ImageCms.PyCMSError,
lambda: ImageCms.profileToProfile(lena(), "foo", "bar"))
assert_exception(
ImageCms.PyCMSError,
lambda: ImageCms.buildTransform("foo", "bar", "RGB", "RGB"))
assert_exception(ImageCms.PyCMSError,
lambda: ImageCms.getProfileName(None))
assert_exception(ImageCms.PyCMSError,
lambda: ImageCms.isIntentSupported(SRGB, None, None))
# test PointTransform convenience API
im = lena().point(t)
# try fetching the profile for the current display device
assert_no_exception(lambda: ImageCms.get_display_profile())
def rgb_to_lab(x):
img = Image.fromarray(x.astype('uint8'), mode='RGB')
return np.array(ImageCms.applyTransform(img, rgb2lab)).astype('float32')
def hexencode(rgb):
r=rgb[0]
g=rgb[1]
b=rgb[2]
return '#%02x%02x%02x' % (r,g,b)
im = Image.open("WIJMF_180128_085454_00133.JPG")
if im.mode != "RGB":
im = im.convert("RGB")
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(srgb_profile, lab_profile, "RGB", "LAB")
lab_im = ImageCms.applyTransform(im, rgb2lab_transform)
pixLab = lab_im.load()
for x in range(0,im.width//2):
for y in range(0,im.height):
(L,A,B)= pixLab[x,y]
pixLab[x,y]=(int(y*255/im.height),A,B)
lab2rgb_transform = ImageCms.buildTransformFromOpenProfiles(lab_profile, srgb_profile, "LAB", "RGB")
im2 = ImageCms.applyTransform(lab_im,lab2rgb_transform)
im2.save("WIJMF_180128_085454_00133_L128.JPG")
lab_im = ImageCms.applyTransform(im, rgb2lab_transform)
pixLab = lab_im.load()
for x in range(0,im.width//2):
for y in range(0,im.height):
(L,A,B)= pixLab[x,y]
pixLab[x,y]=(L,128,128)
def __call__(self, img):
if img.mode != "LAB":
img = img.convert("LAB")
return ImageCms.applyTransform(img, self.t)
def lab_to_rgb(x):
img = Image.fromarray(x.astype('uint8'), mode='LAB')
return np.array(ImageCms.applyTransform(img, lab2rgb)).astype('float32')
from PIL import Image, ImageCms
im = Image.open(image_path)
if im.mode != "RGB":
im = im.convert("RGB")
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(
srgb_profile, lab_profile, "RGB", "LAB")
lab_im = ImageCms.applyTransform(im, rgb2lab_transform)
#!/usr/local/bin/python3
import numpy as np
from PIL import Image, ImageCms
# Open image and discard alpha channel which makes wheel round rather than square
im = Image.open('images/3.jpg').convert('RGB')
# Convert to Lab colourspace
srgb_p = ImageCms.createProfile("sRGB")
lab_p = ImageCms.createProfile("LAB")
rgb2lab = ImageCms.buildTransformFromOpenProfiles(srgb_p, lab_p, "RGB", "LAB")
Lab = ImageCms.applyTransform(im, rgb2lab)
# Split into constituent channels so we can save 3 separate greyscales
L, a, b = Lab.split()
#a_np[1] is the a part of LAB
a_np = np.array(a)
print(a)
print(a_np[1])
L.save('L.png')
a.save('a.png')
b.save('b.png')
r, g, b = [int(i) for i in colorline[-3:]]
colors += [Mapcolor(colorname, r, g, b)]
from PIL import Image, ImageCms
#Build a transformation from RGB to CIELAB (which is good for color closeness checking)
#Not gonna use this transformation just yet, but setting it up.
srgb_p = ImageCms.createProfile("sRGB")
lab_p = ImageCms.createProfile("LAB")
rgb2lab = ImageCms.buildTransformFromOpenProfiles(srgb_p, lab_p, "RGB", "LAB")
#Take the colors we've gathered and make an image out of them.
color_palette = Image.new("RGB", (1, len(colors)))
for y in range(len(colors)):
color_palette.putpixel((0, y), (colors[y].r, colors[y].g, colors[y].b))
#convert that image to LAB
lab_palette = ImageCms.applyTransform(color_palette, rgb2lab)
im = Image.open(input_filename).convert('RGB')
Lab = ImageCms.applyTransform(im, rgb2lab)
lab_pix = Lab.load()
width, height = im.size
print("Image size is: " + str(im.size))
print(
"If it's not 128x128, all bets are off! This script is made for 128x128.")
#Output_image stores a pixel representation of your palettized image.
output_image = Image.new("RGB", (width, height))
for y in range(height):
for x in range(width):
#palette color that most closely matches this pixel
else:
# something failed...
print("profileToProfile in-place failed: %s" %result)
print("profileToProfile in-place test completed successfully.")
if TEST_buildTransform == True:
# make a transform using the input and output profile path strings
transform = ImageCms.buildTransform(INPUT_PROFILE, OUTPUT_PROFILE, INMODE, \
OUTMODE)
# now, use the trnsform to convert a couple images
im = Image.open(IMAGE)
# transform im normally
im2 = ImageCms.applyTransform(im, transform)
outputImage(im2, "buildTransform")
# then transform it again using the same transform, this time in-place.
result = ImageCms.applyTransform(im, transform, inPlace = True)
outputImage(im, "buildTransform_inPlace")
print("buildTransform test completed successfully.")
# and, to clean up a bit, delete the transform
# this should call the C destructor for the transform structure.
# Python should also do this automatically when it goes out of scope.
del(transform)
if TEST_buildTransformFromOpenProfiles == True:
# we'll actually test a couple profile open/creation functions here too
bepaalDominanteKleurenDir = '/home/willem/PycharmProjects/CamoBuilder/bepaalDominanteKleuren/'
kleurParametersDir = '/home/willem/PycharmProjects/CamoBuilder/kleurParameters/'
name = 'lenteAlmer.jpg'
sampleSize = 1000
# In[3]:
im = Image.open(bepaalDominanteKleurenDir + "/" + name)
if im.mode != "RGB":
im = im.convert("RGB")
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(
srgb_profile, lab_profile, "RGB", "LAB")
lab_im = ImageCms.applyTransform(im, rgb2lab_transform)
w, h = lab_im.size
labColors = lab_im.getcolors(w * h)
npImageOrig = np.array(lab_im)
npImage = npImageOrig.reshape(w * h, 3)
pdImage = pd.DataFrame(npImage, columns=['L', 'A', 'B'])
# In[4]:
wcss = []
start = 4
end = 17
for i in range(start, end):
kmeans = KMeans(n_clusters=i,
init='k-means++',
max_iter=300,
else:
# something failed...
print "profileToProfile in-place failed: %s" % result
print "profileToProfile in-place test completed successfully."
if TEST_buildTransform == True:
# make a transform using the input and output profile path strings
transform = ImageCms.buildTransform(INPUT_PROFILE, OUTPUT_PROFILE, INMODE, \
OUTMODE)
# now, use the trnsform to convert a couple images
im = Image.open(IMAGE)
# transform im normally
im2 = ImageCms.applyTransform(im, transform)
outputImage(im2, "buildTransform")
# then transform it again using the same transform, this time in-place.
result = ImageCms.applyTransform(im, transform, inPlace=True)
outputImage(im, "buildTransform_inPlace")
print "buildTransform test completed successfully."
# and, to clean up a bit, delete the transform
# this should call the C destructor for the transform structure.
# Python should also do this automatically when it goes out of scope.
del (transform)
if TEST_buildTransformFromOpenProfiles == True:
# we'll actually test a couple profile open/creation functions here too
def bepaalWaardenEnPasAan(dir, name):
#Inlezen file
im = Image.open(dir + "/" + name)
if im.mode != "RGB":
im = im.convert("RGB")
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(srgb_profile, lab_profile, "RGB", "LAB")
lab_im = ImageCms.applyTransform(im, rgb2lab_transform)
w, h = lab_im.size
labColors = lab_im.getcolors(w*h)
labColorsGeenLD = {}
for color in labColors:
col = (color[1][1],color[1][2])
aant = color[0]
if col in labColorsGeenLD:
labColorsGeenLD[col] = labColorsGeenLD[col] + aant
else:
labColorsGeenLD[col] = aant
print(str(len(labColorsGeenLD)))
colorParametersList = []
for (a,b) , aant in labColorsGeenLD.items():
colorParametersList.append(ColorParameters(a,b,aant))
wegstreeplijst = sorted(colorParametersList, key=lambda x: x.waardeGecorrigeerd, reverse=True)
for eigen in wegstreeplijst:
eigen.verdeeldNu = float(eigen.waardeOrigineel)
for buur in colorParametersList:
afstand = int(hypot((eigen.a - buur.a), (eigen.b - buur.b))) # math.sqrt 60.234
if afstand < 5:
eigen.buren.append(buur)
teller = 1
while len(wegstreeplijst) > 1:
print("iteratie " + str(teller))
teller = teller + 1
for eigen in wegstreeplijst:
if len(eigen.buren) == 0 or eigen.verdeeldNu < 50:
for buur in eigen.buren:
buur.buren.remove(eigen)
wegstreeplijst.remove(eigen)
else:
vraag = 0
for buur in eigen.buren:
vraag = vraag + buur.verdeeldNu
bijdrage = eigen.verdeeldNu // (vraag * 2)
for buur in eigen.buren:
buur.verdeeldStraks = buur.verdeeldStraks + buur.verdeeldNu * bijdrage
for eigen in wegstreeplijst:
eigen.verdeeldNu = eigen.verdeeldStraks
eigen.verdeeldStraks = eigen.verdeeldStraks // 2
#toekennen nevenkleuren aan hoofdkleur
wegstreeplijst = sorted(colorParametersList, key=lambda x: x.verdeeldStraks, reverse=True)
hoofdkleurenLijst = wegstreeplijst[:7]
wegstreeplijst = wegstreeplijst[7:]
for eigen in wegstreeplijst:
minAfstand =10000000
for hoofdKleur in hoofdkleurenLijst:
if minAfstand > int(hypot((eigen.a - hoofdKleur.a), (eigen.b - hoofdKleur.b))):
minAfstand = int(hypot((eigen.a - hoofdKleur.a), (eigen.b - hoofdKleur.b)))
eigen.vervangenDoor = hoofdKleur
hoofdKleur.vervangt.append(eigen)
#foto aanpassen op basis van de lijst
pixOud = lab_im.load()
lab2rgb_transform = ImageCms.buildTransformFromOpenProfiles(lab_profile, srgb_profile, "LAB", "RGB")
vervangDict = {}
for color in colorParametersList:
vervangDict[(color.a, color.b)] = color.vervangenDoor
now = datetime.datetime.now().strftime('%Y%m%d %H%M%S')
imgNew = Image.new('LAB', (w, h), (255, 255, 255))
pixNew = imgNew.load()
for x in range(w):
for y in range(h):
L,A,B = pixOud[x,y]
vervangColor = vervangDict[(A,B)]
pixNew[x,y] = (L, vervangColor.a, vervangColor.b)
imgRGB = ImageCms.applyTransform(imgNew, lab2rgb_transform)
imgRGB.save(dir + "/" + name + now + " vervangenVolgensMap.JPG")
def __call__(self, lab_tensor):
lab_tensor = lab_tensor.mul(255).byte()
np_img = np.transpose(lab_tensor.cpu().numpy(), (1, 2, 0))
img = Image.fromarray(np_img, mode='LAB')
img = ImageCms.applyTransform(img, self.rgbscale)
return img
def profile_conversion(image):
maybe_icc = image.info.get("icc_profile")
if not prefer_embedded or maybe_icc is None:
return ImageCms.applyTransform(image, transform)
em_profile = ImageCms.ImageCmsProfile(io.BytesIO(maybe_icc))
return ImageCms.profileToProfile(image, em_profile, profiles[1], renderingIntent=intent, outputMode=modes[1])
def bepaalWaardenEnPasAan(dir, name, sampleSize):
# Inlezen file
im = Image.open(dir + "/" + name)
if im.mode != "RGB":
im = im.convert("RGB")
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(
srgb_profile, lab_profile, "RGB", "LAB")
lab_im = ImageCms.applyTransform(im, rgb2lab_transform)
w, h = lab_im.size
labColors = lab_im.getcolors(w * h)
npImageOrig = np.array(lab_im)
npImage = npImageOrig.reshape(w * h, 3)
pdImage = pd.DataFrame(npImage, columns=['L', 'A', 'B'])
kmeans = KMeans(n_clusters=aantalKleuren)
kmeans.fit(pdImage)
y_kmeans = kmeans.predict(pdImage)
npCenters = kmeans.cluster_centers_.astype(int)
if sampleSize > pdImage['L'].size:
sampleSize = pdImage['L'].size
selectie = random.sample(list(range(0, pdImage['L'].size)), sampleSize)
L = pdImage.iloc[selectie, 0]
A = pdImage.iloc[selectie, 1]
B = pdImage.iloc[selectie, 2]
C = y_kmeans[selectie]
fig, ax = plt.subplots()
ax.scatter(L, A, c=C, s=50, cmap='viridis')
ax.set_xlabel('L')
ax.set_ylabel('A')
ax.scatter(npCenters[:, 0], npCenters[:, 1], c='black', s=200, alpha=0.5)
plt.show()
fig, ax = plt.subplots()
ax.scatter(L, B, c=C, s=50, cmap='viridis')
ax.set_xlabel('L')
ax.set_ylabel('B')
ax.scatter(npCenters[:, 0], npCenters[:, 2], c='black', s=200, alpha=0.5)
plt.show()
fig, ax = plt.subplots()
ax.scatter(A, B, c=C, s=50, cmap='viridis')
ax.set_xlabel('A')
ax.set_ylabel('B')
ax.scatter(npCenters[:, 1], npCenters[:, 2], c='black', s=200, alpha=0.5)
plt.show()
pdImage['groep'] = y_kmeans
groepen = list(range(0, aantalKleuren))
pdCenters = pd.DataFrame(npCenters, columns=['Ln', 'An', 'Bn'])
pdCenters['groep'] = groepen
pdImageTransform = pdImage.join(pdCenters.set_index('groep'), on='groep')
pdImageNieuw = pdImageTransform.iloc[:, 4:7]
npImageNieuw = pdImageNieuw.to_numpy()
npImageNieuw = npImageNieuw.reshape(h, w, 3, order="C")
imageNiew = Image.fromarray(numpy.uint8(npImageNieuw), mode='LAB')
lab2rgb_transform = ImageCms.buildTransformFromOpenProfiles(
lab_profile, srgb_profile, "LAB", "RGB")
imgRGB = ImageCms.applyTransform(imageNiew, lab2rgb_transform)
now = datetime.datetime.now().strftime('%Y%m%d %H%M%S')
imgRGB.save(dir + "/" + name + now + " vervangenVolgensMapC.JPG")
# Exporteren van kleuren en tellingen
npImageRGB = np.array(imgRGB)
npImageRGB = npImageRGB.reshape(w * h, 3)
pdImageRGB = pd.DataFrame(npImageRGB, columns=['R', 'G', 'B'])
pdImageRGB['aantal'] = 1
export = pdImageRGB.groupby(['R', 'G',
'B'])['aantal'].count().reset_index()
print(export)
export.to_csv(name + now + '.csv')
#~ new_height = 1200
#~ new_width = new_height * width / height
#~ new_width = 1200
#~ new_height = new_width * height / width
#~ height = im.size[0]
#~ width = im.size[1]
if im.mode is not 'RGB':
print(i + ' is ' + im.mode)
popa = ImageCms.getOpenProfile(SRGB_PROFILE)
popa2 = ImageCms.getOpenProfile(CMYK_PROFILE)
trans = ImageCms.buildTransform(popa2, popa, 'CMYK', 'RGB')
convo = ImageCms.applyTransform(im, trans)
#~ convo = convo.resize([new_height, new_width] , Image.ANTIALIAS)
#~ cdata = list(convo.getdata())
#~ nimage = Image.new('RGB',im.size)
#~ nimage.putdata(cdata)
#~ nimage.save('ready/'+i, 'JPEG', quality=95, dpi=(72,72))
convo.save('ready/' + i, 'JPEG', quality=100, dpi=(72, 72))
convo.close()
#~ time.sleep(5)
else:
print(i + ' is ' + im.mode)
#~ cdata = list(im.getdata())
#~ nimage = Image.new('RGB',im.size)
#~ nimage.putdata(cdata)
#~ nimage.save('ready/'+i, 'JPEG', quality=95, dpi=(72,72))
#~ im = im.resize([new_height, new_width] , Image.ANTIALIAS)
def assert_aux_channel_preserved(self, mode, transform_in_place,
preserved_channel):
def create_test_image():
# set up test image with something interesting in the tested aux channel.
# fmt: off
nine_grid_deltas = [ # noqa: E131
(-1, -1),
(-1, 0),
(-1, 1),
(0, -1),
(0, 0),
(0, 1),
(1, -1),
(1, 0),
(1, 1),
]
# fmt: on
chans = []
bands = ImageMode.getmode(mode).bands
for band_ndx in range(len(bands)):
channel_type = "L" # 8-bit unorm
channel_pattern = hopper(channel_type)
# paste pattern with varying offsets to avoid correlation
# potentially hiding some bugs (like channels getting mixed).
paste_offset = (
int(band_ndx / float(len(bands)) *
channel_pattern.size[0]),
int(band_ndx / float(len(bands) * 2) *
channel_pattern.size[1]),
)
channel_data = Image.new(channel_type, channel_pattern.size)
for delta in nine_grid_deltas:
channel_data.paste(
channel_pattern,
tuple(paste_offset[c] +
delta[c] * channel_pattern.size[c]
for c in range(2)),
)
chans.append(channel_data)
return Image.merge(mode, chans)
source_image = create_test_image()
source_image_aux = source_image.getchannel(preserved_channel)
# create some transform, it doesn't matter which one
source_profile = ImageCms.createProfile("sRGB")
destination_profile = ImageCms.createProfile("sRGB")
t = ImageCms.buildTransform(source_profile,
destination_profile,
inMode=mode,
outMode=mode)
# apply transform
if transform_in_place:
ImageCms.applyTransform(source_image, t, inPlace=True)
result_image = source_image
else:
result_image = ImageCms.applyTransform(source_image,
t,
inPlace=False)
result_image_aux = result_image.getchannel(preserved_channel)
self.assert_image_equal(source_image_aux, result_image_aux)
def load_pil(self, pil_img):
"""
Load an already opened PIL image.
Parameters
----------
pil_img : :class:`PIL.Image.Image`
The image.
Returns
-------
A new :class:`Image`.
Notes
-----
This function should be used instead of :meth:`Image.from_pil` because
may postprocess the image in various ways, depending on the loader
configuration.
"""
# If we're cropping, do it.
if self.crop is not None:
upper = self.crop[0]
right = pil_img.width - self.crop[1]
lower = pil_img.height - self.crop[2]
left = self.crop[3]
# This operation can trigger PIL decompression-bomb aborts, so
# avoid them in the standard, non-thread-safe, way.
old_max = pil_image.MAX_IMAGE_PIXELS
try:
pil_image.MAX_IMAGE_PIXELS = None
pil_img = pil_img.crop((left, upper, right, lower))
finally:
pil_image.MAX_IMAGE_PIXELS = old_max
# If an unrecognized mode, try to standardize it. The weird PIL modes
# don't generally support an alpha channel, so we convert to RGB.
try:
ImageMode(pil_img.mode)
except ValueError:
print(
'warning: trying to convert image file to RGB from unexpected bitmode "%s"'
% pil_img.mode)
if self.black_to_transparent:
# Avoid double-converting in the next filter.
pil_img = pil_img.convert('RGBA')
else:
pil_img = pil_img.convert('RGB')
# Convert pure black to transparent -- make sure to do this before any
# colorspace processing.
#
# As far as I can tell, PIL has no good way to modify an image on a
# pixel-by-pixel level in-place, which is really annoying. For now I'm
# doing this processing in Numpy space, but for an image that almost
# fills up memory we might have to use a different approach since this
# one will involve holding two buffers at once.
if self.black_to_transparent:
if pil_img.mode != 'RGBA':
pil_img = pil_img.convert('RGBA')
a = np.asarray(pil_img)
a = a.copy() # read-only buffer => writeable
for i in range(a.shape[0]):
nonblack = (a[i, ..., 0] > 0)
np.logical_or(nonblack, a[i, ..., 1] > 0, out=nonblack)
np.logical_or(nonblack, a[i, ..., 2] > 0, out=nonblack)
a[i, ..., 3] *= nonblack
# This is my attempt to preserve the image metadata and other
# attributes, swapping out the pixel data only. There is probably
# a better way to do this
new_img = pil_image.fromarray(a, mode=pil_img.mode)
pil_img.im = new_img.im
del a, new_img
# Make sure that we end up in the right color space. From experience, some
# EPO images have funky colorspaces and we need to convert to sRGB to get
# the tiled versions to appear correctly.
if self.colorspace_processing != 'none' and 'icc_profile' in pil_img.info:
assert self.colorspace_processing == 'srgb' # more modes, one day?
try:
from PIL import ImageCms
# ImageCms doesn't raise import error if the implementation is unavailable
# "for doc purposes". To see if it's available we need to actually try to
# do something:
out_prof = ImageCms.createProfile('sRGB')
except ImportError:
print(
'''warning: colorspace processing requested, but no `ImageCms` module found in PIL.
Your installation of PIL probably does not have colorspace support.
Colors will not be transformed to sRGB and therefore may not appear as intended.
Compare toasty's output to your source image and decide if this is acceptable to you.
Consider a different setting of the `--colorspace-processing` argument to avoid this warning.''',
file=sys.stderr)
else:
from io import BytesIO
in_prof = ImageCms.getOpenProfile(
BytesIO(pil_img.info['icc_profile']))
xform = ImageCms.buildTransform(in_prof, out_prof,
pil_img.mode, pil_img.mode)
ImageCms.applyTransform(pil_img, xform, inPlace=True)
return Image.from_pil(pil_img)
def test_sanity():
# basic smoke test.
# this mostly follows the cms_test outline.
v = ImageCms.versions() # should return four strings
assert_equal(v[0], '0.1.0 pil')
assert_equal(list(map(type, v)), [str, str, str, str])
# internal version number
assert_match(ImageCms.core.littlecms_version, "\d+\.\d+$")
i = ImageCms.profileToProfile(lena(), SRGB, SRGB)
assert_image(i, "RGB", (128, 128))
t = ImageCms.buildTransform(SRGB, SRGB, "RGB", "RGB")
i = ImageCms.applyTransform(lena(), t)
assert_image(i, "RGB", (128, 128))
p = ImageCms.createProfile("sRGB")
o = ImageCms.getOpenProfile(SRGB)
t = ImageCms.buildTransformFromOpenProfiles(p, o, "RGB", "RGB")
i = ImageCms.applyTransform(lena(), t)
assert_image(i, "RGB", (128, 128))
t = ImageCms.buildProofTransform(SRGB, SRGB, SRGB, "RGB", "RGB")
assert_equal(t.inputMode, "RGB")
assert_equal(t.outputMode, "RGB")
i = ImageCms.applyTransform(lena(), t)
assert_image(i, "RGB", (128, 128))
# get profile information for file
assert_equal(ImageCms.getProfileName(SRGB).strip(),
'IEC 61966-2.1 Default RGB colour space - sRGB')
assert_equal(ImageCms.getProfileInfo(SRGB).splitlines(),
['sRGB IEC61966-2.1', '',
'Copyright (c) 1998 Hewlett-Packard Company', '',
'WhitePoint : D65 (daylight)', '',
'Tests/icc/sRGB.icm'])
assert_equal(ImageCms.getDefaultIntent(SRGB), 0)
assert_equal(ImageCms.isIntentSupported(
SRGB, ImageCms.INTENT_ABSOLUTE_COLORIMETRIC,
ImageCms.DIRECTION_INPUT), 1)
# same, using profile object
p = ImageCms.createProfile("sRGB")
assert_equal(ImageCms.getProfileName(p).strip(),
'sRGB built-in - (lcms internal)')
assert_equal(ImageCms.getProfileInfo(p).splitlines(),
['sRGB built-in', '', 'WhitePoint : D65 (daylight)', '', ''])
assert_equal(ImageCms.getDefaultIntent(p), 0)
assert_equal(ImageCms.isIntentSupported(
p, ImageCms.INTENT_ABSOLUTE_COLORIMETRIC,
ImageCms.DIRECTION_INPUT), 1)
# extensions
i = Image.open("Tests/images/rgb.jpg")
p = ImageCms.getOpenProfile(BytesIO(i.info["icc_profile"]))
assert_equal(ImageCms.getProfileName(p).strip(),
'IEC 61966-2.1 Default RGB colour space - sRGB')
# the procedural pyCMS API uses PyCMSError for all sorts of errors
assert_exception(ImageCms.PyCMSError, lambda: ImageCms.profileToProfile(lena(), "foo", "bar"))
assert_exception(ImageCms.PyCMSError, lambda: ImageCms.buildTransform("foo", "bar", "RGB", "RGB"))
assert_exception(ImageCms.PyCMSError, lambda: ImageCms.getProfileName(None))
assert_exception(ImageCms.PyCMSError, lambda: ImageCms.isIntentSupported(SRGB, None, None))
# test PointTransform convenience API
im = lena().point(t)
# try fetching the profile for the current display device
assert_no_exception(lambda: ImageCms.get_display_profile())
def bepaalWaardenEnPasAan(dir, name):
# Inlezen file
im = Image.open(dir + "/" + name)
if im.mode != "RGB":
im = im.convert("RGB")
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(srgb_profile, lab_profile, "RGB", "LAB")
lab_im = ImageCms.applyTransform(im, rgb2lab_transform)
w, h = lab_im.size
labColors = lab_im.getcolors(w * h)
labColorsGereduceerd = {}
for color in labColors:
npColor = np.array([round(color[1][0], -1),
round(color[1][1], -1),
round(color[1][2], -1)])
colorHash = npColor[0] // 10 + npColor[1] * 30 + npColor[2] * 9000
aant = color[0]
if colorHash in labColorsGereduceerd:
labColorsGereduceerd[colorHash][0] = labColorsGereduceerd[colorHash][0] + aant
else:
labColorsGereduceerd[colorHash] = [aant, npColor]
print(str(len(labColorsGereduceerd)))
colorParametersList = [ColorParameters(origineel=colorGereduceerd[0],
npColor=colorGereduceerd[1])
for colorGereduceerd in labColorsGereduceerd.values()]
for eigen in colorParametersList:
for buur in colorParametersList:
afstand = np.linalg.norm(eigen.npColor - buur.npColor) # math.sqrt 60.234
if afstand > 0:
eigen.waardeGecorrigeerd = eigen.waardeGecorrigeerd + buur.waardeOrigineel // afstand
else:
eigen.waardeGecorrigeerd = eigen.waardeGecorrigeerd + buur.waardeOrigineel
wegstreeplijst = sorted(colorParametersList, key=lambda x: x.waardeGecorrigeerd, reverse=True)
# belangrijkste kleuren
hoofdkleurenLijst = []
while len(wegstreeplijst) > 0:
hoofdKleur = wegstreeplijst[0]
wegstreeplijst.remove(hoofdKleur)
for kleur in wegstreeplijst:
if np.linalg.norm(hoofdKleur.npColor - kleur.npColor) < 70:
kleur.vervangenDoor = hoofdKleur
hoofdKleur.vervangt.append(kleur)
wegstreeplijst.remove(kleur)
else:
kleur.afstand = kleur.waardeGecorrigeerd * afstand
hoofdkleurenLijst.append(hoofdKleur)
wegstreeplijst.sort(key=lambda x: x.afstand_kwadraad, reverse=True)
print(len(wegstreeplijst))
print(len(hoofdkleurenLijst))
i = 1
# foto aanpassen op basis van de lijst
pixOud = lab_im.load()
lab2rgb_transform = ImageCms.buildTransformFromOpenProfiles(lab_profile, srgb_profile, "LAB", "RGB")
vervangDict = {}
for color in colorParametersList:
vervangDict[(color.npColor, color.b)] = color.vervangenDoor
now = datetime.datetime.now().strftime('%Y%m%d %H%M%S')
imgNew = Image.new('LAB', (w, h), (255, 255, 255))
pixNew = imgNew.load()
for x in range(w):
for y in range(h):
L, A, B = pixOud[x, y]
vervangColor = vervangDict[(A, B)]
pixNew[x, y] = (L, vervangColor.a, vervangColor.b)
imgRGB = ImageCms.applyTransform(imgNew, lab2rgb_transform)
imgRGB.save(dir + "/" + name + now + " vervangenVolgensMap.JPG")
import sys
sys.path.insert(0, ".")
from PIL import Image
from PIL import ImageCms
try:
filename = sys.argv[1]
except IndexError:
filename = "../pil-archive/cmyk.jpg"
i = Image.open(filename)
print(i.format)
print(i.mode)
print(i.size)
print(i.tile)
p = ImageCms.getMemoryProfile(i.info["icc_profile"])
print(repr(p.product_name))
print(repr(p.product_info))
o = ImageCms.createProfile("sRGB")
t = ImageCms.buildTransformFromOpenProfiles(p, o, i.mode, "RGB")
i = ImageCms.applyTransform(i, t)
i.show()
def bepaalWaardenEnPasAan(dir, name):
#Inlezen file
im = Image.open(dir + "/" + name)
if im.mode != "RGB":
im = im.convert("RGB")
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(
srgb_profile, lab_profile, "RGB", "LAB")
lab_im = ImageCms.applyTransform(im, rgb2lab_transform)
w, h = lab_im.size
labColors = lab_im.getcolors(w * h)
labColorsGeenLD = {}
for color in labColors:
col = (color[1][1], color[1][2])
aant = color[0]
if col in labColorsGeenLD:
labColorsGeenLD[col] = labColorsGeenLD[col] + aant
else:
labColorsGeenLD[col] = aant
print(str(len(labColorsGeenLD)))
colorParametersList = []
for (a, b), aant in labColorsGeenLD.items():
colorParametersList.append(ColorParameters(a, b, aant))
for eigen in colorParametersList:
for buur in colorParametersList:
afstand = int(hypot((eigen.a - buur.a),
(eigen.b - buur.b))) # math.sqrt 60.234
if afstand > 0:
eigen.waardeGecorrigeerd = eigen.waardeGecorrigeerd + buur.waardeOrigineel // afstand
else:
eigen.waardeGecorrigeerd = eigen.waardeGecorrigeerd + buur.waardeOrigineel
wegstreeplijst = sorted(colorParametersList,
key=lambda x: x.waardeGecorrigeerd,
reverse=True)
#belangrijkste kleuren
hoofdkleurenLijst = []
while len(wegstreeplijst) > 0:
hoofdKleur = wegstreeplijst[0]
wegstreeplijst.remove(hoofdKleur)
for kleur in wegstreeplijst:
if int(hypot((hoofdKleur.a - kleur.a),
(hoofdKleur.b - kleur.b))) < 70:
kleur.vervangenDoor = hoofdKleur
hoofdKleur.vervangt.append(kleur)
wegstreeplijst.remove(kleur)
else:
kleur.afstand = kleur.waardeGecorrigeerd * afstand
hoofdkleurenLijst.append(hoofdKleur)
wegstreeplijst.sort(key=lambda x: x.afstand_kwadraad, reverse=True)
print(len(wegstreeplijst))
print(len(hoofdkleurenLijst))
i = 1
#foto aanpassen op basis van de lijst
pixOud = lab_im.load()
lab2rgb_transform = ImageCms.buildTransformFromOpenProfiles(
lab_profile, srgb_profile, "LAB", "RGB")
vervangDict = {}
for color in colorParametersList:
vervangDict[(color.a, color.b)] = color.vervangenDoor
now = datetime.datetime.now().strftime('%Y%m%d %H%M%S')
imgNew = Image.new('LAB', (w, h), (255, 255, 255))
pixNew = imgNew.load()
for x in range(w):
for y in range(h):
L, A, B = pixOud[x, y]
vervangColor = vervangDict[(A, B)]
pixNew[x, y] = (L, vervangColor.a, vervangColor.b)
imgRGB = ImageCms.applyTransform(imgNew, lab2rgb_transform)
imgRGB.save(dir + "/" + name + now + " vervangenVolgensMap.JPG")
def __init__(self, source): #Pass in the argument image location
#get the location of the image
self.source = source
#determine if the image is local or hosted, then open it
if 'http' in self.source:
if(_verbose):
print 'Reading from URL'
file = cStringIO.StringIO(urllib.urlopen(self.source).read())
self.image = Image.open(file)
else:
try:
self.image = Image.open(self.source)
except IOError:
print self.source
print "Cannot load image. Be sure to include 'http://'' if loading from a website!"
sys.exit()
sRGB = ImageCms.createProfile("sRGB")
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(sRGB, pLab, "RGB", "LAB")
self.labImage = ImageCms.applyTransform(self.image, t)
self.imageWidth, self.imageHeight = self.image.size #Set width and height, which correspond to tuple values from self.image.size
self.screenWidth, self.screenHeight = int(screen.split()[7]), int(screen.split()[9][:-1])
self.lost_res = 0.0
self.lost_aspect = 0.0
self.temp_rating = self.calcAvgImageTemp()
self.final_rating = self.calcImageScore()
