def init_color_profiles():
global COLOR_PROFILES
COLOR_PROFILES['srgb'] = ImageCms.createProfile('sRGB')
#COLOR_PROFILES['argb'] = ImageCms.getOpenProfile(r'AdobeRGB.icc')
COLOR_PROFILES['argb'] = ImageCms.getOpenProfile(os.path.join(ICC_DATA_DIR, 'AdobeRGB.icc'))
def imageRGB(self, prof_out=False):
image = self.image()
alpha_band = False
if image.mode in ("LA", "PA", "RGBA"):
bands = image.split()
alpha_band = bands[-1]
image = Image.merge(image.mode[:-1], bands[:-1])
sRGB = ImageCms.createProfile("sRGB")
if "icc_profile" in image.info:
inputProfile = ImageCms.ImageCmsProfile(StringIO(image.info["icc_profile"]))
else:
if image.mode == "CMYK":
inputProfile = (dirpath(__file__) or ".") + "/Fogra27L.icm"
elif image.mode == "LAB":
inputProfile = ImageCms.createProfile("LAB")
else:
image = image.convert("RGB")
inputProfile = sRGB
if prof_out:
outputProfile = prof_out
else:
outputProfile = sRGB
new_image = ImageCms.profileToProfile(image, inputProfile, outputProfile, outputMode="RGB")
if alpha_band:
new_image.putalpha(alpha_band)
return new_image
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 get_image(image_name,
transform_list_val1=transform_list_val1,
transformList2=transformList2):
# 对眼底图去除黑边
img = prep.imread(image_name)
r_img, borders, mask = prep.process_without_gb(img)
r_img = Image.fromarray(r_img)
# 对图像进行处理,剪裁
image = transform_list_val1(r_img)
# 对图像进行色彩空间转换
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(
srgb_profile, lab_profile, "RGB", "LAB")
img_hsv = image.convert("HSV")
img_lab = ImageCms.applyTransform(image, rgb2lab_transform)
# 对图像进行数据类型转变，并变成（BWHC）格式
img_rgb = np.asarray(image).astype('float32')
img_hsv = np.asarray(img_hsv).astype('float32')
img_lab = np.asarray(img_lab).astype('float32')
img_rgb = transformList2(img_rgb).unsqueeze(0)
img_hsv = transformList2(img_hsv).unsqueeze(0)
img_lab = transformList2(img_lab).unsqueeze(0)
# 返回torch.tensor 格式数据
return torch.FloatTensor(img_rgb), torch.FloatTensor(
img_hsv), torch.FloatTensor(img_lab)
def imageRGB(self, prof_out=False):
image = self.image()
alpha_band = False
if image.mode in ('LA', 'PA', 'RGBA'):
bands = image.split()
alpha_band = bands[-1]
image = Image.merge(image.mode[:-1], bands[:-1])
sRGB = ImageCms.createProfile("sRGB")
if 'icc_profile' in image.info:
inputProfile = ImageCms.ImageCmsProfile(StringIO(image.info['icc_profile']))
else:
if image.mode == "CMYK":
inputProfile = (dirpath(__file__) or ".") + "/Fogra27L.icm"
elif image.mode == "LAB":
inputProfile = ImageCms.createProfile("LAB")
else:
image = image.convert('RGB')
inputProfile = sRGB
if prof_out:
outputProfile = prof_out
else:
outputProfile = sRGB
new_image = ImageCms.profileToProfile(image, inputProfile, outputProfile, outputMode="RGB")
if not alpha_band:
alpha_band = Image.new('L', image.size, 255)
new_image.putalpha(alpha_band)
return new_image
def imageRGB(self, prof_out=False):
image = self.image()
alpha_band = False
if image.mode in ('LA', 'PA', 'RGBA'):
bands = image.split()
alpha_band = bands[-1]
image = Image.merge(image.mode[:-1], bands[:-1])
sRGB = ImageCms.createProfile("sRGB")
if 'icc_profile' in image.info:
inputProfile = ImageCms.ImageCmsProfile(
StringIO(image.info['icc_profile']))
else:
if image.mode == "CMYK":
inputProfile = (dirpath(__file__) or ".") + "/Fogra27L.icm"
elif image.mode == "LAB":
inputProfile = ImageCms.createProfile("LAB")
else:
image = image.convert('RGB')
inputProfile = sRGB
if prof_out:
outputProfile = prof_out
else:
outputProfile = sRGB
new_image = ImageCms.profileToProfile(image,
inputProfile,
outputProfile,
outputMode="RGB")
if not alpha_band:
alpha_band = Image.new('L', image.size, 255)
new_image.putalpha(alpha_band)
return new_image
def bepaalWaardenEnPasAan(dir, name):
#Inlezen file
startImage = Image.open(dir + "/" + name)
if startImage.mode != "RGB":
startImage = startImage.convert("RGB")
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
lab2rgb_transform = ImageCms.buildTransformFromOpenProfiles(lab_profile, srgb_profile, "LAB", "RGB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(srgb_profile, lab_profile, "RGB", "LAB")
labReducedToneImage = ImageCms.applyTransform(startImage, rgb2lab_transform)
labOriginalToneImage = ImageCms.applyTransform(startImage, rgb2lab_transform)
labReducedTonePix = labReducedToneImage.load()
labOriginalTonePix = labOriginalToneImage.load()
w, h = labReducedToneImage.size
for x in range(w):
for y in range(h):
L, A, B = labReducedTonePix[x,y]
labReducedTonePix[x,y] = (128, A, B)
rgbReducedToneImage = ImageCms.applyTransform(labReducedToneImage, lab2rgb_transform)
rgbReducedColorImage = rgbReducedToneImage.convert('P', palette=Image.ADAPTIVE, colors=5).convert('RGB')
now = datetime.datetime.now().strftime('%Y%m%d %H%M%S')
rgbReducedColorImage.save(dir + "/" + name + now + " vervangenVolgensMap.JPG")
labReducedColorImage = ImageCms.applyTransform(rgbReducedColorImage, rgb2lab_transform)
labReducedColorPix = labReducedColorImage.load()
labReducedColorsMap = labReducedColorImage.getcolors(w * h)
labReducedColorsWithTonesDict = {}
for number, (L, A, B) in labReducedColorsMap:
labReducedColorsWithTonesDict[(A,B)] = [number,L,[0] * 256]
for x in range(w):
for y in range(h):
Lor,Aor,Bor = labOriginalTonePix[x,y]
Lr, Ar, Br = labReducedColorPix[x,y]
labReducedColorsWithTonesDict[Ar,Br][2][Lor] = labReducedColorsWithTonesDict[Ar,Br][2][Lor] +1
# omzetten van tellingen per lichtsterkte naar relatieve breedte per lichtsterkte
for tint, lichtsterkten in labReducedColorsWithTonesDict.items():
increase = lichtsterkten[0] / mountainProfileLength
lArray = lichtsterkten[2]
intfreq = numpy.empty(256, dtype=int)
for i in lArray:
intfreq[i]+=1
mountainProfile = lArray.groupby('receipt').receipt.count()
mountainProfile = numpy.empty(256, dtype=int) #array('i')
mpi = 0
drempel = increase / 2 # measure in the middle
for i in range(mountainProfileLength):
if lArray[mpi] >= drempel:
drempel += increase
mpi += 1
print(str(i) + " " + str(mpi))
mountainProfile[i] = lArray[mpi]
print(" d ")
for aantal, (L, A, B) in labReducedColorsMap:
print(str(aantal) + " " + str(L) + " " + str(A) + " " + str(B))
def open_im(im_name):
"""Opens and crops BMP file. Returns image numpy array and image size"""
image = Image.open("projects" + os.sep + im_name) #BMP has to be in dir "projects"
#Image cropping
pix = numpy.asarray(image)
pix = pix[:, :, 0:3] #drop the alpha channel
idx = numpy.where(pix - 255)[0:2] #drop the color when finding edges
box = list(map(min, idx))[::-1] + list(map(max, idx))[::-1] #box of non-white pixels
box[2] += 1
box[3] += 1
image = image.crop(box)
#Size check
width = image.size[0]
height = image.size[1]
#RGB to Lab color profile conversion
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(
srgb_profile, lab_profile, "RGB", "LAB"
)
im_lab = ImageCms.applyTransform(image, rgb2lab_transform)
im_array = numpy.array(im_lab, dtype='int64')
image.close()
return[im_array, width, height]
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 = [
(-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 gen_patches(dtpath):
data = Image.open(dtpath).convert("RGB")
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(
srgb_profile, lab_profile, "RGB", "LAB")
lab_im_data = ImageCms.applyTransform(data, rgb2lab_transform)
im_h, im_w = data.size
h = int(im_h / patch_dim[0])
w = int(im_w / patch_dim[1])
#print(im_h,im_w,h,w)
data_lst = []
# c = 0
for i in range(0, im_h, h):
for j in range(0, im_w, w):
# c+=1
box = (j, i, j + w, i + h)
a = lab_im_data.crop(box)
a = np.array(a)
norm = a / 255.0
norm = norm.flatten().reshape(1, 3888)
data_lst.append(norm)
# plt.figure(c)
# plt.imshow(a)
return data_lst
def hue_shift(img):
"""RGB to LAB, cache L. RGB to HSV, shift H to get H^SV. H^SV to L^A^B^. L^A^B^ to LA^B^."""
# Convert colourspace
srgb_p = ImageCms.createProfile("sRGB")
lab_p = ImageCms.createProfile("LAB")
#RGB to HSV
rgb2lab = ImageCms.buildTransformFromOpenProfiles(srgb_p, lab_p, "RGB",
"LAB")
img_lab = ImageCms.applyTransform(img, rgb2lab)
L = np.asarray(img_lab)[:, :, 0]
img_hsv = img.convert('HSV')
#hue shift
img_hsv = np.asarray(img_hsv).copy()
h = img_hsv[:, :, 0]
h = (h + 50) % 255
img_hsv[:, :, 0] = h
#retain original luminance
img_rgb = Image.fromarray(img_hsv, mode="HSV").convert('RGB')
img_lab_t = np.asarray(ImageCms.applyTransform(img_rgb, rgb2lab)).copy()
img_lab_t[:, :, 0] = L
#convert LAB to RGB
img_recolor = Image.fromarray(img_lab_t, mode="LAB")
lab2rgb = ImageCms.buildTransformFromOpenProfiles(lab_p, srgb_p, "LAB",
"RGB")
img_recolor = ImageCms.applyTransform(img_recolor, lab2rgb)
img_recolor.save('recolor.jpg')
return
def get_image(image_name):
image = Image.open(image_name).convert('RGB')
transformList2 = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
transform_list_val1 = transforms.Compose([
transforms.Resize(512),
transforms.CenterCrop(512),
])
image = transform_list_val1(image)
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(
srgb_profile, lab_profile, "RGB", "LAB")
img_hsv = image.convert("HSV")
img_lab = ImageCms.applyTransform(image, rgb2lab_transform)
img_rgb = np.asarray(image).astype('float32')
img_hsv = np.asarray(img_hsv).astype('float32')
img_lab = np.asarray(img_lab).astype('float32')
img_rgb = transformList2(img_rgb).unsqueeze(0)
img_hsv = transformList2(img_hsv).unsqueeze(0)
img_lab = transformList2(img_lab).unsqueeze(0)
return torch.FloatTensor(img_rgb), torch.FloatTensor(
img_hsv), torch.FloatTensor(img_lab)
def _sanitize(img):
"""
Convert image color mode to *RGB*. So it is easier for future
processing and the returned image is always safe to be saved as PNG file.
If the input file is in *Lab* color space, it is converted to *sRGB*.
:param img: Input image as PIL.Image object.
:return: sanitized image as PIL.Image object.
"""
if img.mode in ['RGB']:
img2 = img.copy()
elif img.mode == 'LAB':
# PIL cannot convert Lab to RGB automatically.
# Codes from https://stackoverflow.com/questions/52767317/
rgb_p = ImageCms.createProfile('sRGB')
lab_p = ImageCms.createProfile('LAB')
lab2rgb = ImageCms.buildTransformFromOpenProfiles(
lab_p, rgb_p, 'LAB', 'RGB')
img2 = ImageCms.applyTransform(img, lab2rgb)
else:
img2 = img.convert('RGB')
auto_log('%s(%s) --> %s.' % (img.format, img.mode, img2.mode))
return img2
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 __call__(self, img):
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(srgb_profile, lab_profile, "RGB", "LAB")
lab_im = ImageCms.applyTransform(img, rgb2lab_transform)
return lab_im
def _rgb_to_lab(image):
# Convert the image to LAB colour space - https://stackoverflow.com/a/53353542
srgb_p = ImageCms.createProfile("sRGB")
lab_p = ImageCms.createProfile("LAB")
rgb2lab = ImageCms.buildTransformFromOpenProfiles(srgb_p, lab_p, "RGB",
"LAB")
return ImageCms.applyTransform(image, rgb2lab)
def rgb_to_lab(im):
rgb = ImageCms.createProfile(colorSpace='sRGB')
lab = ImageCms.createProfile(colorSpace='LAB')
transform = ImageCms.buildTransform(inputProfile=rgb,
outputProfile=lab,
inMode='RGB',
outMode='LAB')
return ImageCms.applyTransform(im=im, transform=transform)
def split_image_lab(image):
# Channel order: L, a, b
image = Image.fromarray(image)
srgb_p = ImageCms.createProfile("sRGB")
lab_p = ImageCms.createProfile("LAB")
rgb2lab = ImageCms.buildTransformFromOpenProfiles(srgb_p, lab_p, "RGB",
"LAB")
image = ImageCms.applyTransform(image, rgb2lab)
return [np.array(x) for x in image.split()]
def __getitem__(self, index: int) -> Any:
image_path = self.image_names[index]
mask_path = self.mask_names[index]
with open(image_path, "rb") as image_file, open(mask_path,
"rb") as mask_file:
# Opening image
image = Image.open(image_file)
if self.image_color_mode == "rgb":
image = image.convert("RGB")
elif self.image_color_mode == "hsv":
image = image.convert("HSV")
elif self.image_color_mode == "lab":
## Converting to LAB colour space requires a few extra steps...
image = image.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")
image = ImageCms.applyTransform(image, rgb2lab)
elif self.image_color_mode == "ycbcr":
image = image.convert("YCbCr")
elif self.image_color_mode == "grayscale":
image = image.convert("L")
# Opening mask
mask = Image.open(mask_file)
if self.mask_color_mode == "rgb":
mask = mask.convert("RGB")
elif self.mask_color_mode == "grayscale":
mask = mask.convert("L")
# Creating dictionary for image-mask pair
sample = {"image": image, "mask": mask}
# Applying data augmentation
if self.data_augmentation and self.subset == "Train":
sample = transform(sample,
transformation_functions=[
random_rotation, random_brightness,
random_contrast, random_crop
])
# Transforming
if self.transform:
sample["image"] = self.transform(sample["image"])
if self.target_transform:
sample["mask"] = self.target_transform(sample["mask"])
return sample
def rgb_to_Lab(image):
image = Image.fromarray(image)
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(srgb_profile, lab_profile, "RGB", "LAB")
lab_im = np.asarray(ImageCms.applyTransform(image, rgb2lab_transform))
return lab_im
def RGB2LAB(img):
# Create an object to do the RGB to LAB conversion
srgb_profile = ImageCms.createProfile("sRGB")
lab_profile = ImageCms.createProfile("LAB")
rgb2lab_transform = ImageCms.buildTransformFromOpenProfiles(
srgb_profile, lab_profile, "RGB", "LAB")
# Generates the image in the LAB channel
lab_im = ImageCms.applyTransform(img, rgb2lab_transform)
# Return to LAB image
return (lab_im)
def rgb2lab( imageRGB ):
imageRGB = mat2rgbimg( imageRGB )
imageLAB = cms.profileToProfile(imageRGB, cms.createProfile("sRGB"), \
cms.createProfile("LAB"), \
outputMode="LAB" )
imageLAB = rgbimg2mat( imageLAB )
# PIL LAB images seem to be [0:255, 0:255, 0:255]
# rescale to [0:100, -128:127, -128:127]
imageLAB[:,:,0] *= (100.0/255.0)
imageLAB[:,:,1] -= 128
imageLAB[:,:,2] -= 128
return imageLAB
def pil_loader(path):
with open(path, 'rb') as f:
with Image.open(f) as img:
img = img.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(img, rgb2lab_transform)
# print(img)``
l, a, b = lab_im.split()
# print(l)
return img
def __init__(self, root, save_root=None, name_ext='.pkl'):
self.root = root
if save_root == None:
save_root = root
self.save_root = save_root
self.crop = transforms.Compose([
transforms.Resize(256, Image.ANTIALIAS),
])
srgb_profile = ImageCms.createProfile('sRGB')
lab_profile = ImageCms.createProfile('LAB')
self.labscale = ImageCms.buildTransformFromOpenProfiles(
srgb_profile, lab_profile, 'RGB', 'LAB')
def test_lab_color():
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)
assert_image(i, "LAB", (128, 128))
# i.save('temp.lab.tif') # visually verified vs PS.
assert_image_similar_tofile(i, "Tests/images/hopper.Lab.tif", 3.5)
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 lab2rgb( imageLAB ):
# PIL LAB images seem to be [0:255, 0:255, 0:255]
# rescale from [0:100, -128:127, -128:127]
imageLAB[:,:,0] *= (255.0/100.0)
imageLAB[:,:,1] += 128
imageLAB[:,:,2] += 128
imageLAB = mat2rgbimg( imageLAB, "LAB" )
imageRGB = cms.profileToProfile(imageLAB, cms.createProfile("LAB"), \
cms.createProfile("sRGB"), \
outputMode="RGB" )
imageRGB = rgbimg2mat( imageRGB )
return imageRGB
def test_lab_roundtrip():
# check to see if we're at least internally consistent.
psRGB = ImageCms.createProfile("sRGB")
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(psRGB, pLab, "RGB", "LAB")
t2 = ImageCms.buildTransform(pLab, psRGB, "LAB", "RGB")
i = ImageCms.applyTransform(hopper(), t)
assert i.info["icc_profile"] == ImageCmsProfile(pLab).tobytes()
out = ImageCms.applyTransform(i, t2)
assert_image_similar(hopper(), out, 2)
def test_lab_srgb(self):
psRGB = ImageCms.createProfile("sRGB")
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(pLab, psRGB, "LAB", "RGB")
with Image.open("Tests/images/hopper.Lab.tif") as img:
img_srgb = ImageCms.applyTransform(img, t)
# img_srgb.save('temp.srgb.tif') # visually verified vs ps.
self.assert_image_similar(hopper(), img_srgb, 30)
self.assertTrue(img_srgb.info["icc_profile"])
profile = ImageCmsProfile(BytesIO(img_srgb.info["icc_profile"]))
self.assertIn("sRGB", 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(lena(), t)
self.assert_image(i, "LAB", (128, 128))
# i.save('temp.lab.tif') # visually verified vs PS.
target = Image.open('Tests/images/lena.Lab.tif')
self.assert_image_similar(i, target, 30)
def _sanitize(img):
"""
Convert image color mode to *RGB*, *RGBA*, *L* or *LA*. So it is easier for future
processing and the returned image is always safe to be saved as PNG file.
If the input file is in *Lab* color space, it is converted to *sRGB*.
**Parameters**
img: :class:`PIL.Image`
Input image.
**Returns**
img: :class:`PIL.Image`
sanitized image.
"""
if img.mode in ['RGB', 'RGBA', 'L', 'LA']:
img2 = img.copy()
elif img.mode == 'RGBa':
img2 = img.convert('RGBA')
elif img.mode in ['1', 'I', 'F']:
img2 = img.convert('L')
elif img.mode in ['CMYK', 'YCbCr', 'HSV']:
img2 = img.convert('RGB')
elif img.mode == 'LAB':
# PIL cannot convert Lab to RGB automatically.
# Codes from https://stackoverflow.com/questions/52767317/
srgb_p = ImageCms.createProfile('sRGB')
lab_p = ImageCms.createProfile('LAB')
lab2rgb = ImageCms.buildTransformFromOpenProfiles(
lab_p, srgb_p, 'LAB', 'RGB')
img2 = ImageCms.applyTransform(img, lab2rgb)
elif img.mode == 'P':
# Seems that PIL have a bug when handling palette greyscale images with alpha
# channel. Although it can be decoded properly, img.palette.mode will give 'RGB'
# instead of 'RGBA', even if alpha channel is present. This means we can not
# determine whether the original image palette has alpha information or not.
# So here the image will be forced to convert to 'RGBA'.
img2 = img.convert('RGBA')
else:
print('[_sanitize] Unknown color mode: %s' % img.mode)
img2 = img.convert('RGBA')
print('[_sanitize] %s(%s) --> %s.' % (img.format, img.mode, img2.mode))
return img2
def test_exceptions(self):
# Test mode mismatch
psRGB = ImageCms.createProfile("sRGB")
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(pLab, psRGB, "LAB", "RGB")
self.assertRaises(ValueError, t.apply_in_place, hopper("RGBA"))
# the procedural pyCMS API uses PyCMSError for all sorts of errors
self.assertRaises(ImageCms.PyCMSError, ImageCms.profileToProfile,
hopper(), "foo", "bar")
self.assertRaises(ImageCms.PyCMSError, ImageCms.buildTransform, "foo",
"bar", "RGB", "RGB")
self.assertRaises(ImageCms.PyCMSError, ImageCms.getProfileName, None)
self.skip_missing()
self.assertRaises(ImageCms.PyCMSError, ImageCms.isIntentSupported,
SRGB, None, None)
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 imageRGB(self, width, height, prof_out=False):
if len(self.colorstops) == 0:
return False
colors = set()
for stop in self.colorstops:
colors.add(stop.color)
sRGB_colors = {}
for color in colors:
if color:
sRGB_colors[color] = self.swatchbook.materials[color].toRGB(prof_out) or (128, 128, 128)
# Color
image = Image.new('RGB', (width, height))
draw = ImageDraw.Draw(image)
for i in range(width):
pos = i / width
left = 0
right = len(self.colorstops) - 1
for j, stop in enumerate(self.colorstops):
if pos >= stop.position:
left = j
else:
right = j
break
sRGB_left = sRGB_colors[self.colorstops[left].color] if self.colorstops[left].color else (128, 128, 128)
sRGB_right = sRGB_colors[self.colorstops[right].color] if self.colorstops[right].color else (128, 128, 128)
if left == right or self.colorstops[left].color == self.colorstops[right].color:
r, g, b = sRGB_left
else:
seg_pos = (pos - self.colorstops[left].position) / (self.colorstops[right].position - self.colorstops[left].position)
if "midpoint" in self.colorstops[left].args:
midpoint = self.colorstops[left].args["midpoint"]
else:
midpoint = 0.5
factor = Gradient.get_factor(self.colorstops[left].interpolation, seg_pos, midpoint)
r, g, b = Gradient.interpolate(sRGB_left, sRGB_right, factor, self.colorstops[left].model, self.colorstops[left].args)
draw.line((i, 0, i, height), fill=(int(round(r * 0xFF)), int(round(g * 0xFF)), int(round(b * 0xFF))))
del draw
sRGB = ImageCms.createProfile("sRGB")
if prof_out:
new_image = ImageCms.profileToProfile(image, sRGB, prof_out)
else:
new_image = image
# Opacity
alpha = Image.new('L', (width, height), 255)
if len(self.opacitystops) > 0:
draw = ImageDraw.Draw(alpha)
for i in range(width):
try:
a = self.alphaAt(float(i) / width)
except TypeError:
a = 1
draw.line((i, 0, i, image.size[1]), fill=int(round(a * 0xFF)))
del draw
new_image.putalpha(alpha)
return new_image
def test_lab_srgb(self):
psRGB = ImageCms.createProfile("sRGB")
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(pLab, psRGB, "LAB", "RGB")
img = Image.open('Tests/images/hopper.Lab.tif')
img_srgb = ImageCms.applyTransform(img, t)
# img_srgb.save('temp.srgb.tif') # visually verified vs ps.
self.assert_image_similar(hopper(), img_srgb, 30)
self.assertTrue(img_srgb.info['icc_profile'])
profile = ImageCmsProfile(BytesIO(img_srgb.info['icc_profile']))
self.assertIn('sRGB', ImageCms.getProfileDescription(profile))
def test_lab_roundtrip(self):
# check to see if we're at least internally consistent.
psRGB = ImageCms.createProfile("sRGB")
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(psRGB, pLab, "RGB", "LAB")
t2 = ImageCms.buildTransform(pLab, psRGB, "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 _apply_icc(psd, image):
"""Apply ICC Color profile."""
from io import BytesIO
try:
from PIL import ImageCms
except ImportError:
logger.debug(
'ICC profile found but not supported. Install little-cms.'
)
return image
if image.mode not in ('RGB',):
logger.debug('%s ICC profile is not supported.' % image.mode)
return image
try:
in_profile = ImageCms.ImageCmsProfile(
BytesIO(psd.image_resources.get_data('ICC_PROFILE'))
)
out_profile = ImageCms.createProfile('sRGB')
return ImageCms.profileToProfile(image, in_profile, out_profile)
except ImageCms.PyCMSError as e:
logger.warning('PyCMSError: %s' % (e))
return image
def NormalisePILImageToRGB(pil_image: PILImage.Image) -> PILImage.Image:
if PILImageHasAlpha(pil_image):
desired_mode = 'RGBA'
else:
desired_mode = 'RGB'
if pil_image.mode != desired_mode:
if pil_image.mode == 'LAB':
pil_image = PILImageCms.profileToProfile(
pil_image,
PILImageCms.createProfile('LAB'),
PIL_SRGB_PROFILE,
outputMode='RGB')
else:
pil_image = pil_image.convert(desired_mode)
return pil_image
def add_profile():
in_file_list = [
"./picture/r.png", "./picture/o.png", "./picture/g.png",
"./picture/b.png", "./picture/w.png", "./picture/saturation.png"
]
out_file_list = [
"./picture/r_dci.png", "./picture/o_dci.png", "./picture/g_dci.png",
"./picture/b_dci.png", "./picture/w_dci.png",
"./picture/saturation_dci.png"
]
out_file_list2 = [
"./picture/r_sRGB.png", "./picture/o_sRGB.png", "./picture/g_sRGB_png",
"./picture/b_sRGB.png", "./picture/w_sRGB.png",
"./picture/saturation_sRGB.png"
]
dci_profile_name = "./picture/DCI-P3_modify.icc"
dci_profile = ImageCms.getOpenProfile(dci_profile_name)
sRGB_profile = ImageCms.getOpenProfile(dci_profile_name)
sRGB_profile_ref = ImageCms.createProfile('sRGB')
sRGB_profile.profile = sRGB_profile_ref
for idx, in_file in enumerate(in_file_list):
img = Image.open(in_file)
img.save(out_file_list[idx], icc_profile=dci_profile.tobytes())
img.save(out_file_list2[idx], icc_profile=sRGB_profile.tobytes())
def _channels_data_to_PIL(channels_data, channel_types, size, depth, icc_profile):
if Image is None:
raise Exception("This module requires PIL (or Pillow) installed.")
if size == (0, 0):
return
bands = {}
for channel, channel_type in zip(channels_data, channel_types):
pil_band = channel_id_to_PIL(channel_type)
if pil_band is None:
warnings.warn("Unsupported channel type (%d)" % channel_type)
continue
if channel.compression in [Compression.RAW, Compression.ZIP, Compression.ZIP_WITH_PREDICTION]:
if depth == 8:
im = _from_8bit_raw(channel.data, size)
elif depth == 16:
im = _from_16bit_raw(channel.data, size)
elif depth == 32:
im = _from_32bit_raw(channel.data, size)
else:
warnings.warn("Unsupported depth (%s)" % depth)
continue
elif channel.compression == Compression.PACK_BITS:
if depth != 8:
warnings.warn("Depth %s is unsupported for PackBits compression" % depth)
continue
im = frombytes('L', size, channel.data, "packbits", 'L')
else:
if Compression.is_known(channel.compression):
warnings.warn("Compression method is not implemented (%s)" % channel.compression)
else:
warnings.warn("Unknown compression method (%s)" % channel.compression)
continue
bands[pil_band] = im.convert('L')
mode = _get_mode(bands.keys())
merged_image = Image.merge(mode, [bands[band] for band in mode])
if mode == 'CMYK':
# invert CMYK data
merged_image = frombytes('CMYK', size, merged_image.tobytes(), 'raw',
'CMYK;I')
# convert with inner profile, better brightness
merged_image = merged_image.convert('RGB')
elif icc_profile is not None:
display_profile = ImageCms.createProfile('sRGB') # XXX: ImageCms.get_display_profile()?
ImageCms.profileToProfile(merged_image, icc_profile, display_profile, inPlace=True)
return merged_image
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 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 adobe_to_srgb(img):
srgb = ImageCms.createProfile('sRGB')
#icc = open('AdobeRGB.icc')
#icc = open(r'C:\Users\Joshua\cmdutils\AdobeRGB.icc', 'rb')
icc = open(os.path.join(ICC_DATA_DIR, 'AdobeRGB.icc'), 'rb')
img = ImageCms.profileToProfile(img, icc, srgb)
#img = ImageCms.profileToProfile(img, icc, srgb, renderingIntent = ImageCms.INTENT_SATURATION)
return img
def test_profile_object(self):
# same, using profile object
p = ImageCms.createProfile("sRGB")
# self.assertEqual(ImageCms.getProfileName(p).strip(),
# 'sRGB built-in - (lcms internal)')
# self.assertEqual(ImageCms.getProfileInfo(p).splitlines(),
# ['sRGB built-in', '', 'WhitePoint : D65 (daylight)', '', ''])
self.assertEqual(ImageCms.getDefaultIntent(p), 0)
self.assertEqual(ImageCms.isIntentSupported(
p, ImageCms.INTENT_ABSOLUTE_COLORIMETRIC,
ImageCms.DIRECTION_INPUT), 1)
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_exceptions(self):
# Test mode mismatch
psRGB = ImageCms.createProfile("sRGB")
pLab = ImageCms.createProfile("LAB")
t = ImageCms.buildTransform(pLab, psRGB, "LAB", "RGB")
self.assertRaises(ValueError, t.apply_in_place, hopper("RGBA"))
# the procedural pyCMS API uses PyCMSError for all sorts of errors
self.assertRaises(
ImageCms.PyCMSError,
ImageCms.profileToProfile, hopper(), "foo", "bar")
self.assertRaises(
ImageCms.PyCMSError,
ImageCms.buildTransform, "foo", "bar", "RGB", "RGB")
self.assertRaises(
ImageCms.PyCMSError,
ImageCms.getProfileName, None)
self.skip_missing()
self.assertRaises(
ImageCms.PyCMSError,
ImageCms.isIntentSupported, SRGB, None, None)
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_color_profile():
pLab = ImageCms.createProfile("LAB", 5000)
pLab = ImageCms.createProfile("LAB", 6500)
from io import BytesIO
from PIL import Image, ImageFilter, ImageChops, ImageCms
from django.utils.functional import cached_property
from easy_images.engine.base import BaseEngine
from easy_images.engine.engine_image import BaseEngineImage
from . import utils
RGB_PROFILE = ImageCms.createProfile('sRGB')
def _compare_entropy(start_slice, end_slice, slice, difference):
"""
Calculate the entropy of two slices (from the start and end of an axis),
returning a tuple containing the amount that should be added to the start
and removed from the end of the axis.
"""
start_entropy = utils.image_entropy(start_slice)
end_entropy = utils.image_entropy(end_slice)
if end_entropy and abs(start_entropy / end_entropy - 1) < 0.01:
# Less than 1% difference, remove from both sides.
if difference >= slice * 2:
return slice, slice
half_slice = slice // 2
return half_slice, slice - half_slice
if start_entropy > end_entropy:
return 0, slice
else:
return slice, 0
def test_lab_color_profile(self):
ImageCms.createProfile("LAB", 5000)
ImageCms.createProfile("LAB", 6500)
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())
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
# first, get a handle to an input profile, in this case we'll create
# an sRGB profile on the fly:
inputProfile = ImageCms.createProfile("sRGB")
# then, get a handle to the output profile
outputProfile = ImageCms.getOpenProfile(OUTPUT_PROFILE)
# make a transform from these
transform = ImageCms.buildTransformFromOpenProfiles(inputProfile, \
outputProfile, 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, "buildTransformFromOpenProfiles")
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()
# -*- coding: utf-8 -*-
from __future__ import absolute_import
import os
GRAY_PATH = os.path.join(os.path.dirname(__file__), 'icc_profiles', 'Gray-CIE_L.icc')
try:
from PIL import ImageCms
gray = ImageCms.ImageCmsProfile(GRAY_PATH)
sRGB = ImageCms.createProfile('sRGB')
except ImportError:
gray = None
sRGB = None
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()
