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()