def PsdToPngConverter(directory, filename): psd = PSDImage.load(directory + glo.s + filename) #print "psd.header\n " , psd.header merged_image = psd.as_PIL() # print "image being saved to: " , directory + glo.s + filename[:-4] + '.png' merged_image.save(directory + glo.s + filename[:-4] + '.png') return
def main(): """ psd-tools.py Usage: psd-tools.py convert <psd_filename> <out_filename> [options] psd-tools.py export_layer <psd_filename> <layer_index> <out_filename> [options] psd-tools.py debug <filename> [options] psd-tools.py -h | --help psd-tools.py --version Options: -v --verbose Be more verbose. --encoding <encoding> Text encoding [default: utf8]. """ args = docopt.docopt(main.__doc__) if args['--verbose']: logger.setLevel(logging.DEBUG) else: logger.setLevel(logging.INFO) encoding = args['--encoding'] if args['convert']: psd = PSDImage.load(args['<psd_filename>'], encoding=encoding) im = psd.as_PIL() im.save(args['<out_filename>']) elif args['export_layer']: psd = PSDImage.load(args['<psd_filename>'], encoding=encoding) index = int(args['<layer_index>']) im = psd.layers[index].as_PIL() im.save(args['<out_filename>']) print(psd.layers) psd.as_PIL() elif args['debug']: with open(args['<filename>'], "rb") as f: decoded = psd_tools.decoder.parse( psd_tools.reader.parse(f, encoding) ) print("\nHeader\n------") print(decoded.header) print("\nDecoded data\n-----------") pprint(decoded) print("\nLayers\n------") pprint(group_layers(decoded))
def export_tex(fn, downscale=2, ext='.png'): print 'processing', fn psd=PSDImage.load(fn+".psd") im=psd.as_PIL() wd,ht=im.size if downscale>1: im=im.resize((wd/downscale, ht/downscale), Image.ANTIALIAS) im.save(os.path.join(target_path, fn+ext))
def make_scene(psdPath, resDirPath): psdDirPath, psdFileName = os.path.split(psdPath) mapName = os.path.splitext(psdFileName)[0] mapDirPath = os.path.join(resDirPath, mapName) imageDirPath = os.path.join(mapDirPath, 'images') sceneFilePath = os.path.join(mapDirPath, 'scene.json') if not os.access(imageDirPath, os.R_OK): os.makedirs(imageDirPath) psd = PSDImage.load(psdPath) layerInfos = [] for layer in psd.layers: if layer.name == 'num': continue layerInfo = dict( name=layer.name.encode('utf8'), x=layer.bbox.x1, y=psd.header.height - layer.bbox.y2, w=layer.bbox.width, h=layer.bbox.height) layerInfos.append(layerInfo) if True: image = layer.as_PIL() image.save('{0}/{1}.png'.format(imageDirPath, layer.name)) sceneDict = dict(layers=layerInfos, header=dict(width=psd.header.width, height=psd.header.height)) open(sceneFilePath, 'w').write(json.dumps(sceneDict, indent=4))
def convert_psd_to_jpg(psd_path, jpg_path, *, quality, max_width=None, max_height=None): """ Convert a PSD at a given path to a JPG at a given path. Optional arguments for setting JPG quality from 0 to 100, max width in px, and max height in px. """ print('%s %s %s' % (psd_path, CONVERT_TO_CHAR, jpg_path)) img = PSDImage.load(psd_path).as_PIL() width, height = img.size if max_width or max_height: if max_width and max_height: new_size_a = downsize_by_height(width=width, height=height, new_height=max_height) new_size_b = downsize_by_width(width=width, height=height, new_width=max_width) if new_size_a[0] * new_size_a[1] <= new_size_b[0] * new_size_b[1]: new_size = new_size_a else: new_size = new_size_b elif max_height: new_size = downsize_by_height(width=width, height=height, new_height=max_height) elif max_width: new_size = downsize_by_width(width=width, height=height, new_width=max_width) (img.resize(new_size, resample=PIL.Image.ANTIALIAS) .save(jpg_path, quality=quality)) else: img.save(jpg_path, quality=quality)
def test_embedded(): # This file contains both an embedded and linked png psd = PSDImage.load(os.path.join(DATA_PATH, 'placedLayer.psd')) embedded = psd.embedded[0] assert embedded.filename == 'linked-layer.png' with open(os.path.join(DATA_PATH, 'linked-layer.png'), 'rb') as f: assert embedded.data == f.read()
def loadPSD( self, path ): image = PSDImage.load( path ) for processor in self.processors: processor.onLoadImage( image ) self.processGroup( image.layers ) self.dirty = True
def test_blend_transparent_areas(): psd = PSDImage.load(full_name('blend_modes2.psd')) composite_image = psd.as_PIL() merged_image = psd.as_PIL_merged() assert merged_image is not None assert tobytes(composite_image) == tobytes(merged_image)
def main(): """ psd-tools.py Usage: psd-tools.py <filename> [--encoding <encoding>] [--verbose] psd-tools.py convert <psd_filename> <out_filename> [--verbose] psd-tools.py export_layer <psd_filename> <layer_index> <out_filename> [--verbose] psd-tools.py -h | --help psd-tools.py --version Options: -v --verbose Be more verbose. --encoding <encoding> Text encoding [default: utf8]. """ args = docopt.docopt(main.__doc__) if args["--verbose"]: logger.setLevel(logging.DEBUG) else: logger.setLevel(logging.INFO) if args["convert"]: psd = PSDImage.load(args["<psd_filename>"]) im = psd.as_PIL() im.save(args["<out_filename>"]) elif args["export_layer"]: psd = PSDImage.load(args["<psd_filename>"]) index = int(args["<layer_index>"]) im = psd.layers[index].as_PIL() im.save(args["<out_filename>"]) print(psd.layers) psd.as_PIL() else: encoding = args["--encoding"] with open(args["<filename>"], "rb") as f: decoded = psd_tools.decoder.parse(psd_tools.reader.parse(f, encoding)) print(decoded.header) pprint.pprint(decoded.image_resource_blocks) pprint.pprint(decoded.layer_and_mask_data) pprint.pprint(decoded.image_data) pprint.pprint(group_layers(decoded))
def open_image(path): # if it's a psd maybe we can selectively specify layers? # e.g. "path/to/foo.psd{export}" return _sanitize_rgba( PSDImage.load(path).as_PIL() \ if path.lower().endswith('.psd') \ else Image.open(path) )
def loadPSD( self, path ): image = PSDImage.load( path ) #meta data bx0 , by0 , bx1 , by1 = image.bbox self.bbox = ( bx0, by0, bx1, by1 ) self.tileSize = ( bx1, by1 ) for layer in image.layers: theme = self.collectTheme( layer ) if theme : self.themes.append( theme )
def openImage( filepath ): name, ext = os.path.splitext( filepath ) if ext.lower() == '.psd': from psd_tools import PSDImage pimage = PSDImage.load( filepath ) if not pimage: sys.exit( 'failed loading file' ) img = pimage.as_PIL() else: img = Image.open(filepath) return img
def test_blend_modes_basics(): psd = PSDImage.load(full_name('blend_modes.psd')) composite_image = psd.as_PIL() merged_image = psd.as_PIL_merged() for i in range(27): is_separable = DIFF_STATS_PER_MODE[i][0] is_precise = DIFF_STATS_PER_MODE[i][1] deviation_neg = DIFF_STATS_PER_MODE[i][2] deviation_pos = DIFF_STATS_PER_MODE[i][3] match_count = DIFF_STATS_PER_MODE[i][4] y = i // 7 * 200 x = i % 7 * 200 bbox = (x, y, x + 200, y + 200) ethalon = composite_image.crop(bbox) result = merged_image.crop(bbox) if is_separable: diff = _get_diff_channels(ethalon, result) if is_precise: assert len(diff[0]) == 1 assert len(diff[1]) == 1 assert len(diff[2]) == 1 assert 127 in diff[0] assert 127 in diff[1] assert 127 in diff[2] else: keys_r = sorted(diff[0].keys()) keys_g = sorted(diff[1].keys()) keys_b = sorted(diff[2].keys()) min_color_value = min(keys_r[ 0], keys_g[ 0], keys_b[ 0]) max_color_value = max(keys_r[-1], keys_g[-1], keys_b[-1]) assert max_color_value - 127 == deviation_pos assert min_color_value - 127 == deviation_neg assert diff[0][127] >= match_count assert diff[1][127] >= match_count assert diff[2][127] >= match_count else: diff = _get_diff_luminance(ethalon, result) if is_precise: assert len(diff) == 1 assert 127 in diff else: keys = sorted(diff.keys()) assert keys[-1] - 127 == deviation_pos assert keys[ 0] - 127 == deviation_neg assert diff[127] >= match_count
def process(self): psd_file = self.arguments['<psd>'] psd = PSDImage.load(psd_file) print psd.header print psd.layers source_bbox = psd.bbox for item in psd.layers: if item.visible: self.encode(item, source_bbox)
def image_file_to_clipboard(fileObj, is_psd=False): '''Read an image file and write the image data into clipboard. See http://stackoverflow.com/questions/7050448/write-image-to-windows-clipboard-in-python-with-pil-and-win32clipboard ''' from psd_tools import PSDImage if is_psd: psd = PSDImage.from_stream(fileObj) image = psd.as_PIL() elif isinstance(fileObj, Image.Image): image = fileObj else: image = Image.open(fileObj) image_to_clipboard(image)
def writeLayerImages(filenameIn, outFolderName): psd = PSDImage.load(filenameIn) if not os.path.exists(outFolderName): os.makedirs(outFolderName) for curLayer in psd.layers: img = curLayer.as_PIL() slash = "/" if os.name != 'posix': slash = "\\" img.save(outFolderName + slash + curLayer.name + ".png")
def test_group_merging(): psd = PSDImage.load(full_name('blend_modes3.psd')) composite_image = psd.as_PIL() merged_image = psd.as_PIL_merged() group_left = psd.layers[1] group_right = psd.layers[0] assert group_left.blend_mode == BlendMode.PASS_THROUGH assert group_right.blend_mode == BlendMode.NORMAL layer_left = group_left.layers[0] layer_right = group_right.layers[0] assert layer_left.blend_mode == BlendMode.DIFFERENCE assert layer_right.blend_mode == BlendMode.DIFFERENCE assert merged_image is not None assert tobytes(composite_image) == tobytes(merged_image)
def image_file_to_clipboard(fileObj, is_psd=False): '''Read an image file and write the image data into clipboard. See http://stackoverflow.com/questions/7050448/write-image-to-windows-clipboard-in-python-with-pil-and-win32clipboard ''' if is_psd: psd = PSDImage.from_stream(fileObj) image =psd.as_PIL() else: image = Image.open(fileObj) sio = StringIO() image.convert('RGB').save(sio, 'BMP') data = sio.getvalue()[14:] sio.close() win32clipboard.OpenClipboard() try: win32clipboard.EmptyClipboard() win32clipboard.SetClipboardData(win32clipboard.CF_DIB, data) finally: win32clipboard.CloseClipboard()
def get_assets(self, dir=ASSETDIR): psd_file_loc = "%s/assets.psd" % ASSETDIR psd = PSDImage.load(psd_file_loc) x,y = psd.bbox[-2:] layers = {} for layer in psd.layers: layer_name = layer.name layer_as_pil = layer.as_PIL() layer_file_loc = "%s/%s.png" % (dir, layer_name) layer_as_pil.save(layer_file_loc) layers[layer_name] = { 'bbox':layer.bbox, 'loc':layer_file_loc } print "HEY",x,y return x,y, layers
def __init__(self, file_psd): self.special_file = open(file_psd, 'rb') list_hex = self.special_file.read() print self.special_file.readline() #print list_hex[0] self.file_analyse = PSDImage.load(file_psd) self.extract_header(list_hex) lastIndex = self.color_mode(list_hex) self.image_resource(list_hex, lastIndex) pass
def __call__(self, ground_truth_ref, psd_path, img_path, logger=None, generate=True): bin_data = None ann_data = None image_size = 0 unbinarized = np.array(PIL.Image.open(img_path).convert('L')) psd = PSDImage.open(str(psd_path)) for layer in psd: if layer.blend_mode == BlendMode.NORMAL: # assert layer.offset == (0, 0) layer_image = layer.topil().convert('L') image_size = layer.size bin_data = np.array(layer_image) elif layer.blend_mode == BlendMode.MULTIPLY: layer_image = layer.topil() alpha_mask = PIL.Image.fromarray((np.array(layer_image)[:, :, 3] > 128).astype(np.uint8) * 255) layer_image = layer_image.convert("RGB") # remove alpha channel ann_rgb_image = PIL.Image.new("RGB", image_size, (255, 255, 255)) ann_rgb_image.paste(layer_image, layer.offset, alpha_mask) # now reduce to palette # tmp = rgb_image.im.convert("P", 0, self._palette_image.im) # tmp = rgb_image._new(tmp) ann_data = self._rgb2labels(ann_rgb_image, bin_data, logger) gt = GroundTruth(ground_truth_ref, unbinarized, bin_data, ann_data) asset_path = gt.asset_path("seg", prefix="regions.", ext=".png") if asset_path.is_file(): gt.add_labels("regions", np.array(PIL.Image.open(asset_path))) else: gt.add_labels("regions", self._generate_regions(gt)) return gt
def create_psd_thumbnails(repo, file_id, path, size, thumbnail_file, file_size): try: from psd_tools import PSDImage except ImportError: logger.error("Could not find psd_tools installed. " "Please install by 'pip install psd_tools'") return (False, 500) token = seafile_api.get_fileserver_access_token(repo.id, file_id, 'view', '', use_onetime=False) if not token: return (False, 500) tmp_img_path = str(os.path.join(tempfile.gettempdir(), '%s.png' % file_id)) t1 = timeit.default_timer() inner_path = gen_inner_file_get_url(token, os.path.basename(path)) tmp_file = os.path.join(tempfile.gettempdir(), file_id) urlretrieve(inner_path, tmp_file) psd = PSDImage.load(tmp_file) merged_image = psd.as_PIL() merged_image.save(tmp_img_path) os.unlink(tmp_file) # remove origin psd file t2 = timeit.default_timer() logger.debug('Extract psd image [%s](size: %s) takes: %s' % (path, file_size, (t2 - t1))) try: ret = _create_thumbnail_common(tmp_img_path, thumbnail_file, size) os.unlink(tmp_img_path) return ret except Exception as e: logger.error(e) os.unlink(tmp_img_path) return (False, 500)
def psd_test() : psd = PSDImage.load('car.psd') print (psd.header) print (psd.layers) layer0 = psd.layers[0] #print (layer0.bbox) #print (layer_image) layer0 = psd.layers[0] print layer0 layer_image = layer0.as_PIL() layer_image.save('layer0.png') layer1 = psd.layers[1] layer_image = layer1.as_PIL() layer_image.save('layer1.png') layer2 = psd.layers[2] layer_image = layer2.as_PIL() layer_image.save('layer2.png')
def psd_test(): psd = PSDImage.load('car.psd') print(psd.header) print(psd.layers) layer0 = psd.layers[0] #print (layer0.bbox) #print (layer_image) layer0 = psd.layers[0] print layer0 layer_image = layer0.as_PIL() layer_image.save('layer0.png') layer1 = psd.layers[1] layer_image = layer1.as_PIL() layer_image.save('layer1.png') layer2 = psd.layers[2] layer_image = layer2.as_PIL() layer_image.save('layer2.png')
def loadPSD( self, path ): image = PSDImage.load( path ) #root layers for layer in image.layers: if not isinstance( layer, Group ): layerName = layer.name.encode( 'utf-8' ) if layerName == '@guide-top-face': x1,y1,x2,y2 = layer.bbox self.globalGuideTopFace = y1 for layer in image.layers: layerName = layer.name.encode( 'utf-8' ) if layerName.startswith( '//' ): continue if isinstance( layer, Group ): mo = re.match( r'\s*([\w\-\._]+)(\s*:\s*(.*))?\s*', layerName ) if mo: name, profix = mo.group(1), mo.group(3) or self.defaultDeckProfix meta = parseMetaTag( layerName ) for factory in self.deckFactories: deck = factory.build( self, layer, name, profix, meta ) if deck: self.decks.append( deck )
def combinator(self): baseFacePsd = PSDImage.open(self.getRandomFeature("base")) eyesImage = Image.open(self.getRandomFeature("eyes"), "r") noseMouthImage = Image.open(self.getRandomFeature("nose_mouth"), "r") baseFaceImage = self.findPsdLayerByName(baseFacePsd, "smudged").as_PIL() noseMouthLayer = self.findPsdLayerByName(baseFacePsd, "nose_mouth") eyesLayer = self.findPsdLayerByName(baseFacePsd, "eyes") finaleImage = Image.new("RGBA", baseFaceImage.size) finaleImage = self.resize(eyesLayer, eyesImage, finaleImage) # eyes finaleImage = self.resize(noseMouthLayer, noseMouthImage, finaleImage) # nose and mouth try: # hair overlay hairOverlayLayer = self.findPsdLayerByName(baseFacePsd, "hair_overlay") hairImage = hairOverlayLayer.as_PIL() finaleImage = self.resize(hairOverlayLayer, hairImage, finaleImage) except Exception: pass finaleImage = Image.alpha_composite(baseFaceImage, finaleImage) finaleImage.save(os.path.join(self.outputFolder, "product", "output_" + str(time.time()) + ".png"))
def psd2pdf(psd_file: str) -> None: pdf_file = psd_file[:-4] + '.pdf' psd = PSDImage.open(psd_file) size = psd.width, psd.height layers = {} pages = [] for layer in psd: number = ''.join(filter(str.isdigit, layer.name)) img = layer.topil() if img: var = sum(ImageStat.Stat(img).var) if var: layers[number] = img layer_numbers = list(layers.keys()) layer_numbers.sort(key=lambda x: int(x)) for page_num in layer_numbers: image = Image.new('RGBA', size, color='white') base_layer = layers[page_num] base_image = Image.composite(base_layer, image, get_masks(base_layer)) pages.append(base_image.convert('RGB')) pages[0].save(pdf_file, save_all=True, quality=90, append_images=pages[1:])
def loadPSD(self, path): image = PSDImage.load(path) #root layers for layer in image.layers: if not isinstance(layer, Group): layerName = layer.name.encode('utf-8') if layerName == '@guide-top-face': x1, y1, x2, y2 = layer.bbox self.globalGuideTopFace = y1 for layer in image.layers: layerName = layer.name.encode('utf-8') if layerName.startswith('//'): continue if isinstance(layer, Group): mo = re.match(r'\s*([\w\-\._]+)(\s*:\s*(.*))?\s*', layerName) if mo: name, profix = mo.group( 1), mo.group(3) or self.defaultDeckProfix meta = parseMetaTag(layerName) for factory in self.deckFactories: deck = factory.build(self, layer, name, profix, meta) if deck: self.decks.append(deck)
def process(self, instance): # Check if python module `psd_tools` is installed try: global PSDImage from psd_tools import PSDImage except Exception: raise AssertionError( "BUG: Python module `psd-tools` is not installed!" ) self.allowed_group_names = [ name.lower() for name in self.allowed_group_names ] repres = instance.data.get("representations") if not repres: self.log.info("There are no representations on instance.") return for repre in tuple(repres): # Skip all files without .psd extension repre_ext = repre["ext"].lower() if repre_ext.startswith("."): repre_ext = repre_ext[1:] if repre_ext != "psd": continue # TODO add check of list of "files" value psd_filename = repre["files"] psd_folder_path = repre["stagingDir"] psd_filepath = os.path.join(psd_folder_path, psd_filename) self.log.debug(f"psd_filepath: \"{psd_filepath}\"") psd_object = PSDImage.open(psd_filepath) self.create_new_instances(instance, psd_object) # Remove the instance from context instance.context.remove(instance)
def extract( self, path, outputPath ): image = PSDImage.load( path ) #meta data bx0 , by0 , bx1 , by1 = image.bbox self.bbox = ( bx0, by0, bx1, by1 ) self.tileSize = ( bx1, by1 ) collected = [] for layer in image.layers: self.collectLayer( layer, collected ) result = [] idx = 0 for l in collected: idx += 1 name = get_layer_fullname( l ) filename = 'exported_%d' % idx filepath = outputPath + '/'+filename+'.png' img = l.as_PIL() img.save( filepath, 'PNG' ) result.append( ( name, filepath, filename ) ) return result
def handleTexture(textureFilePath): textureFilePath = str(textureFilePath) if not os.path.exists(textureFilePath): return if SOURCE_PATH not in textureFilePath: return targetPath = textureFilePath.replace(SOURCE_PATH, ASSET_PATH) targetDir = os.path.dirname(targetPath) if not os.path.exists(targetDir): os.makedirs(targetDir) # simple copy if texture is not psd file if not textureFilePath.endswith(".psd"): shutil.copy(textureFilePath, targetPath) return psd = PSDImage.load(textureFilePath) for layer in psd.layers: if not layer.name == "main": continue layer.as_PIL().save(targetPath.replace(".psd", ".png"))
def analysePsdFile(self, uiName_: str): _psdName = uiName_ _psd = PSDImage.open(self.psdFolderPath + _psdName + ".psd") _psdDict = self.psdToJson(_psd, self.targetFolderPath, _psdName) _unityDict = {} _unityDict["name"] = _psdName _unityDict["type"] = "Root" _unityDict["bbox"] = {} _unityDict["bbox"]["left"] = _psdDict["bbox"]["left"] _unityDict["bbox"]["top"] = _psdDict["bbox"]["top"] _unityDict["bbox"]["right"] = _psdDict["bbox"]["right"] _unityDict["bbox"]["bottom"] = _psdDict["bbox"]["bottom"] self.convertToUnityUIJson(_psdDict, _unityDict) writeFileWithStr( self.targetFolderPath + "jsons/" + _psdName + ".json", str( json.dumps(_unityDict, indent=4, sort_keys=False, ensure_ascii=False)))
def main(psd_path, png_org_path, png_bubble_path): bubble = list() psd_files_list, psd_name_list = list_files(psd_path) print(psd_files_list) print("-" * 40) print(psd_name_list) if not os.path.isdir(png_org_path): os.makedirs(png_org_path) if not os.path.isdir(png_bubble_path): os.makedirs(png_bubble_path) for idx, psd_file in enumerate(psd_files_list): psd = PSDImage.open(psd_file) try: if len(psd) == 0: continue image_size = psd[0].bbox for layer in psd: if layer.name == u'말칸' or layer.name == u'외침': bubble.append(layer.compose(image_size)) if len(bubble) == 0: continue if len(bubble) == 1: items = bubble.pop() if len(bubble) > 1: items = bubble[0] bubble = bubble[1:] for i in range(len(bubble)): items = Image.alpha_composite(items, bubble[i]) items.save(png_bubble_path + 'bubble' + psd_name_list[idx] + '.png') psd.compose(psd).save(png_org_path + 'org' + psd_name_list[idx] + '.png') print("PSD:(bubble {}th/total:{})".format(idx + 1, len(psd_files_list))) except Exception as ex: print(ex)
def create_psd_thumbnails(repo, file_id, path, size, thumbnail_file, file_size): try: from psd_tools import PSDImage except ImportError: logger.error("Could not find psd_tools installed. " "Please install by 'pip install psd_tools'") return (False, 500) token = seafile_api.get_fileserver_access_token( repo.id, file_id, 'view', '', use_onetime=False) if not token: return (False, 500) tmp_img_path = str(os.path.join(tempfile.gettempdir(), '%s.png' % file_id)) t1 = timeit.default_timer() inner_path = gen_inner_file_get_url(token, os.path.basename(path)) tmp_file = os.path.join(tempfile.gettempdir(), file_id) urlretrieve(inner_path, tmp_file) psd = PSDImage.load(tmp_file) merged_image = psd.as_PIL() merged_image.save(tmp_img_path) os.unlink(tmp_file) # remove origin psd file t2 = timeit.default_timer() logger.debug('Extract psd image [%s](size: %s) takes: %s' % (path, file_size, (t2 - t1))) try: ret = _create_thumbnail_common(tmp_img_path, thumbnail_file, size) os.unlink(tmp_img_path) return ret except Exception as e: logger.error(e) os.unlink(tmp_img_path) return (False, 500)
def startConverter(): # Opens all files with in directory current_path = os.getcwd() total = percentageDone() count = 0 # Naming extension added to the end of the file name naming_ext = "filler" for path, dirs, files in os.walk(current_path): for x in files: name = x.split('.') if name[1] == 'psd': merged_image = PSDImage.load(path + '/' + x).as_PIL() # Txt file is where all info comes from for image outputs file = open('info.txt', 'r') for line in file: if '#' not in line: if '!' in line: naming_ext = line.replace('!', '').replace('\n', '') print(naming_ext) else: line_split = line.split(' ') image_type = '.' + line_split[0] width_res = int(line_split[1]) imageResizer(name[0], width_res, merged_image, image_type, naming_ext) count = count + 1 print(str(count) + "/" + str(total) + " files processed") else: pass
def psd2png(abs_dir_path, file_list): """ psd文件转化为png图片 :param abs_dir_path: psd文件所在绝对路径 :param file_list: 一个包含psd文件名的列表,可以处理多个psd文件转化 :return: 成功返回True, 失败False """ if abs_dir_path and file_list: if os.path.isdir(abs_dir_path): os.chdir(abs_dir_path) for psd in file_list: str_tmp = psd + '.png' try: psd_image = PSDImage.open(psd) image = psd_image.compose() image.save(str_tmp) except Exception as e: print('Error: psd2png,', e) return False return True else: print('psd2png: 目录不存在 --', abs_dir_path) else: print('psd2png: 函数需要两个非空参数,但获取了空值')
def image(ext, w, inf, out): if ext != 'psd': img = Image.open(inf) if int(w) < 0: size = img.size width = size[0] height = size[1] else: width = int(w) height = int(w) im2 = img.resize((width, height)) im2 = im2.convert('RGB') im2.save(out) else: psd = PSDImage.load(inf) im = psd.as_PIL() if int(w) < 0: im = im.convert('RGB') im.save(out) else: size = (int(w), int(w)) im.thumbnail(size, Image.ANTIALIAS) im = im.convert('RGB') im.save(out)
def convertPsd(psdFl, tmpDir): # Конвертируем psd файлы в jpeg, сначала пересохраняем в png # тк метод не из psd_tools не умеет сразу сохранять в jpeg # загружаем png файл, конвертируем его в RGB и ресайзим # до размера 900 px baseSize = 900 for psdFlName in psdFl: psd = PSDImage.open(psdFlName) psd.compose().save(tmpDir + sep + "tmp_file.png") pngFl = Image.open(tmpDir + sep + "tmp_file.png") rgb_png = pngFl.convert("RGB") x, y = rgb_png.size if x > y: width = baseSize height = int(width / x * y) elif y > x: height = baseSize width = int(height / y * x) else: height = 590 width = 590 jpgFl = rgb_png.resize((width, height), Image.BICUBIC) jpgFl.save(tmpDir + sep + psdFlName[0:-4] + ".jpeg") os.remove(tmpDir + sep + "tmp_file.png")
def test_draw_stroke(filename): psd = PSDImage.open(full_name(filename)) preview = psd.topil().convert('RGB') rendered = psd.compose(force=True).convert('RGB') assert _calculate_hash_error(preview, rendered) <= 0.1
a = a @ model z = a[2] a[0:2] *= z b *= z 横旋转量 = 0 if not 图层数据['名字'] == '身体': 横旋转量 = math.sin(time.time() * 5) / 30 a = a @ matrix.translate(0, 0, -1) \ @ matrix.rotate_ax(横旋转量, axis=(0, 2)) \ @ matrix.translate(0, 0, 1) a = a @ matrix.perspective(999) glTexCoord4f(*b) glVertex4f(*a) glEnd() glfw.swap_buffers(window) def 添加深度信息(所有图层): with open('深度2.yaml', encoding='utf8') as f: 深度信息 = yaml.load(f) for 图层信息 in 所有图层: if 图层信息['名字'] in 深度信息: 图层信息['深度'] = 深度信息[图层信息['名字']] if __name__ == '__main__': psd = PSDImage.open('../res/莉沫酱过于简单版.psd') 所有图层, size = 提取图层(psd) 添加深度信息(所有图层) opengl循环(所有图层, size)
def test_bbox(filename, layer_index, bbox): psd = PSDImage(decode_psd(filename)) layer = psd.layers[layer_index] assert layer.bbox == bbox
def open(self): # 打开图片后根据weight重新调整大小 fileName, _ = QFileDialog.getOpenFileName(self, "Open File", QDir.currentPath()) if fileName: # 如果是webp格式用PIL # 如果是psd用PSDtool # gif格式? fileType = fileName.split('.')[-1] if fileType == 'gif': #QMessageBox.information(self, "file type", "type:%s"%(fileType)) self.movie = QMovie(fileName) self.movie.setCacheMode(QMovie.CacheAll) self.movie.setSpeed(100) self.imageLabel.setMovie(self.movie) self.movie.start() if not self.fitToWindowAct.isChecked(): self.imageLabel.adjustSize() elif fileType == 'psd': img = PSDImage.load(fileName) img = img.as_PIL() img.save('./res/temp.jpg') image = QImage('./res/temp.jpg') if image.isNull(): QMessageBox.information(self, "Image Viewer", "Cannot load %s." % (fileName)) return self.imageLabel.setPixmap(QPixmap.fromImage(image)) self.scaleFactor = 1.0 self.printAct.setEnabled(True) self.fitToWindowAct.setEnabled(True) self.updateActions() if not self.fitToWindowAct.isChecked(): self.imageLabel.adjustSize() elif fileType == 'svg': svg = QtSvg.QSvgRenderer(fileName) img = QImage(svg.defaultSize().width(), svg.defaultSize().height(), QImage.Format_ARGB32) p = QPainter(img) svg.render(p) img.save('./res/temp.png') p.end() image = QImage('./res/temp.png') if image.isNull(): QMessageBox.information(self, "Image Viewer", "Cannot load %s." % (fileName)) return self.imageLabel.setPixmap(QPixmap.fromImage(image)) self.scaleFactor = 1.0 self.printAct.setEnabled(True) self.fitToWindowAct.setEnabled(True) self.updateActions() if not self.fitToWindowAct.isChecked(): self.imageLabel.adjustSize() else: image = QImage(fileName) if image.isNull(): QMessageBox.information(self, "Image Viewer", "Cannot load %s." % (fileName)) return self.imageLabel.setPixmap(QPixmap.fromImage(image)) self.scaleFactor = 1.0 self.printAct.setEnabled(True) self.fitToWindowAct.setEnabled(True) self.updateActions() if not self.fitToWindowAct.isChecked(): self.imageLabel.adjustSize()
def convert_psd(psd_dir, output_dir, output_title): json_arr = [] try: os.mkdir(output_dir + output_title + '/') except: pass for file in os.listdir('./' + psd_dir): if fnmatch.fnmatch(file, '*.psd'): psdfile_path = psd_dir + file title = file[0:len(file) - 4] output_sub = output_title + '/' + title + '/' print('converting : ', psdfile_path) print('to : ', output_dir + output_sub) try: os.mkdir(output_dir + output_sub) except: pass # json object to build json_obj = {} json_obj['segmented'] = False json_obj['title'] = title json_obj['faces'] = {} psd = PSDImage.open(psdfile_path) for layer in psd: layer.visible = True layer_img = layer.topil() properties = layer.name.split('_') if len(properties) == 1: # save background saving_path = output_sub + 'background.png' json_obj['background_path'] = saving_path layer_img.save(output_dir + saving_path) else: # name for this layer # parse property of layer if properties[0] not in json_obj['faces']: json_obj['faces'][properties[0]] = {} json_obj['faces'][properties[0]][properties[1]] = {} # save and build json if len(properties) == 2: saving_path = output_sub + layer.name json_obj['faces'][properties[0]][ properties[1]]['path'] = saving_path + '.png' json_obj['faces'][properties[0]][ properties[1]]['mask'] = saving_path + '_mask.png' json_obj['faces'][properties[0]][ properties[1]]['bbox'] = layer.bbox json_obj['segmented'] = True layer_img.save(output_dir + saving_path + '.png') mask_img = to_mask(layer_img) plt.imsave(output_dir + saving_path + '_mask.png', mask_img, cmap='gray') if len(properties) == 3: saving_path = output_sub + properties[ 0] + '_' + properties[1] json_obj['faces'][properties[0]][ properties[1]]['kind'] = properties[2] json_obj['faces'][properties[0]][ properties[1]]['path'] = saving_path + '.png' json_obj['faces'][properties[0]][ properties[1]]['bbox'] = layer.bbox layer_img.save(output_dir + saving_path + '.png') json_arr.append(json_obj) with open(output_dir + output_title + '.json', 'w') as outfile: json.dump(json_arr, outfile, indent=4)
grant = list_parent[0].parent if not grant.parent or grant.name == root.name: for index, item in enumerate(grant.parent): if item.name.lower( ) == background or item.name == grant.name: grant.parent[index].visible = True else: grant.parent[index].visible = False set_visible(layer_parent, False, root) for item in layer_parent: item.visible = True name = item.name result.append({ "name": f"{layer.name}", "url": f"./lab1/{layer.name}.png" }) if not os.path.isfile(f'./lab1/{name}.png'): image = root.composite(ignore_preview=True) image.save(f'./lab1/{name}.png') item.visible = False set_visible(layer_parent.parent, False, root) psd = _Const( PSDImage.open( '/home/anhmeo/Desktop/Once upon a time there was a girl who loves dogs. The end..psd' )) get_object(psd.psd, psd.psd, 'background')
from psd_tools import PSDImage # from pymaging.image import LoadedImage # with open('../src/test.psd') as psd: # print(dir(psd)) psd = PSDImage.load('../src/test.psd') print(psd.header) print(psd.layers) png = psd.as_PIL() png.save('../src/test.jpg')
def __init__(self, file_name): self.file_name = file_name self.psd = PSDImage.load(file_name)
def test_draw_solid_color_fill(): psd = PSDImage.open(full_name('layers-minimal/solid-color-fill.psd')) setting = psd[0].tagged_blocks.get_data(Tag.SOLID_COLOR_SHEET_SETTING) draw_solid_color_fill(psd.size, setting)
def start(): psd = PSDImage.load(sys.argv[1]) textfile = open("offsets.txt", "w") parse_and_save(psd,textfile) textfile.close()
level=logging.INFO, format="%(asctime)s %(message)s", handlers=[ logging.FileHandler("spotifier.log"), logging.StreamHandler() ]) logging.info('file: %s ' % (str(args))) args.trim = not args.dont_align if file.endswith('.psd'): try: from psd_tools import PSDImage except: print('pip install psd-tools3') psd = PSDImage.load(file) if 1 or args.verbose: for l in psd.layers: if l.name != 'Background': i = l.as_PIL() #i.save('tmp.png') print(l) img = psd.as_PIL() ## from PIL import Image, ImageSequence ## im = Image.open(args.file) ## layers = [frame.copy() for frame in ImageSequence.Iterator(im)] ## print(layers) ## img = layers else: img = Image.open(file)
def loadPSD(self, path): image = PSDImage.load(path) #meta data ox = 0 oy = 0 bx0, by0, bx1, by1 = image.bbox mani = get_mani(image) layers = extract_leaf_layers(image) docFeatures = get_psd_features(image) if docFeatures: for entry in docFeatures.values(): self.addFeature(entry['name']) layerModifyDict = {} outputLayers = [] layerFeatures = {} #1. extract meta data: X/Y axis, output bound box for l in layers: stat = get_mlst(l) # print(stat, l.name) layerModifyDict[l] = stat name = l.name.encode('utf-8') if name == '@axis-x': x0, y0, x1, y1 = l.bbox oy = y0 elif name == '@axis-y': x0, y0, x1, y1 = l.bbox ox = x0 elif name == '@output': bx0, by0, bx1, by1 = l.bbox elif not (name and (name[0] == '@' or name == '背景')): outputLayers.append(l) #2. foreach frame: # find valid layer (visible & inside output bbox) # find in cache ( using hash/ direct comparison ) # if not in cache, add new one # for l in layers: # print 'layer count:', len( outputLayers ) anim = Anim() frameDelays = {} if mani: #single frame frameList = mani['FSts'][0]['FsFr'] activeFrame = mani['FSts'][0]['AFrm'] for data in mani['FrIn']: frameDelays[data['FrID']] = 0.1 # frameDelays[ data['FrID'] ] = data[ 'FrDl' ] else: frameList = [0] frameDelays[0] = 0.1 activeFrame = 0 index = 0 layerStates = {} outputLayers.reverse() for l in outputLayers: # print 'L:', l.name.encode('utf-8'), l.visible x0 = 0 y0 = 0 visible = True states = {} modData = layerModifyDict[l] if modData: #find initial visiblity #calculate visiblity for each frame for mod in modData['LaSt']: fid = mod['FrLs'][0] ofst = mod.get('Ofst', None) if ofst: x0 = ofst['Hrzn'] y0 = ofst['Vrtc'] visible = mod.get('enab', visible) states[fid] = (visible, x0, y0) else: states[0] = (l.visible, 0, 0) layerStates[l] = states l._featureId = 0 if docFeatures: localFeatureId = get_layer_feature(l) if localFeatureId >= 0: fname = docFeatures[localFeatureId].get('name', None) l._featureId = self.getFeature(fname) for fid in frameList: frame = AnimFrame() frame.delay = frameDelays.get(fid, 0) frame._fid = fid for l in outputLayers: #find modify state layerModify = None modData = layerModifyDict[l] if modData: for mod in modData['LaSt']: if mod['FrLs'][0] == fid: layerModify = mod break states = layerStates[l] #check enabled defaultState = (l.visible, 0, 0) fstate = states.get(fid, defaultState) visible, offx, offy = fstate name = l.name if not visible: continue #check inside bbox x0, y0, x1, y1 = l.bbox if x0 + offx < bx0: continue if y0 + offy < by0: continue if x1 + offx > bx1: continue if y1 + offy > by1: continue m = self.getModule(l) x = x0 - ox + offx y = y0 - oy + offy frame.addModule(m, x, y) anim.addFrame(frame, 0, 0) self.addFrame(frame) self.addAnim(anim) n, ext = os.path.splitext(os.path.basename(path)) anim.name = n
def returnArrayOpenPsd(arrayNamePsdInTheFolder): psds = [] for namePsd in arrayNamePsdInTheFolder: psds.append(PSDImage.open(namePsd)) return psds
#!/usr/bin/python2.7 from psd_tools import PSDImage ASSETDIR='/opt/projects/python/beaglebone/assets' psd_file_loc = "%s/assets.psd" % ASSETDIR psd = PSDImage.load(psd_file_loc) for layer in psd.layers: layer_pos_str = "%s_%s_%s_%s" % layer.bbox layer_name = layer.name layer_filename = "%s_%s.png" % (layer_name, layer_pos_str) layer_as_pil = layer.as_PIL() layer_file_loc = "%s/%s" % (ASSETDIR, layer_filename) layer_as_pil.save(layer_file_loc)
import os, sys from Tkinter import Tk from tkFileDialog import askopenfilename from tkFileDialog import askdirectory from psd_tools import PSDImage #select folder containing the photoshop documents Tk().withdraw() directory = askdirectory() path = os.listdir(directory) #loop throguh all documents / resize them and save them for filename in path: #create full path fullPath = directory + '/' + filename psd = PSDImage.load(fullPath) #get entire image (layer 0) groupOfAllLayers = psd.layers[0] groupOfAllLayers = psd.as_PIL() newImgae = groupOfAllLayers.resize( (groupOfAllLayers.size[0] / 2, groupOfAllLayers.size[1] / 2)) newImgae.save(directory + '/Link Map' + filename + '.png')
def test_dimensions_api(filename, size): psd = PSDImage(decode_psd(filename)) assert psd.header.width == size[0] assert psd.header.height == size[1]
# -*- coding: utf-8 -*- """ Created on Fri Apr 29 00:38:17 2016 @author: toranado """ from psd_tools import PSDImage im = PSDImage.load('/home/toranado/background.psd') #from PIL import Image #im = Image.load(path="/home/toranado/background.psd")
def process(self, instance): # Check if python module `psd_tools` is installed try: global PSDImage from psd_tools import PSDImage except Exception: raise AssertionError( "BUG: Python module `psd-tools` is not installed!") self.allowed_group_names = [ name.lower() for name in self.allowed_group_names ] repres = instance.data.get("representations") if not repres: self.log.info("There are no representations on instance.") return self.redo_global_plugins(instance) repres = instance.data.get("representations") if not repres: self.log.info("There are no representations on instance.") return if not instance.data.get("transfers"): instance.data["transfers"] = [] # Prepare staging dir staging_dir = self.staging_dir(instance) if not os.path.exists(staging_dir): os.makedirs(staging_dir) # Prepare publish dir for transfers publish_dir = instance.data["publishDir"] for repre in tuple(repres): # Skip all files without .psd extension if repre["ext"] != ".psd": continue # Prepare json filepath where extracted metadata are stored json_filename = "{}.json".format(instance.name) json_full_path = os.path.join(staging_dir, json_filename) self.log.debug(f"`staging_dir` is \"{staging_dir}\"") # Prepare new repre data new_repre = { "name": "json", "ext": "json", "files": json_filename, "stagingDir": staging_dir } # TODO add check of list psd_filename = repre["files"] psd_folder_path = repre["stagingDir"] psd_filepath = os.path.join(psd_folder_path, psd_filename) self.log.debug(f"psd_filepath: \"{psd_filepath}\"") psd_object = PSDImage.open(psd_filepath) json_data, transfers = self.export_compositing_images( psd_object, staging_dir, publish_dir) self.log.info("Json file path: {}".format(json_full_path)) with open(json_full_path, "w") as json_filestream: json.dump(json_data, json_filestream, indent=4) instance.data["transfers"].extend(transfers) instance.data["representations"].remove(repre) instance.data["representations"].append(new_repre)
def loadPSD( self, path ): image = PSDImage.load( path ) #meta data ox = 0 oy = 0 bx0 , by0 , bx1 , by1 = image.bbox mani = get_mani( image ) # print(mani) layers = extractLeafLayers ( image ) layerModifyDict = {} outputLayers = [] #1. extract meta data: X/Y axis, output bound box for l in layers: stat = get_mlst(l) # print(stat, l.name) layerModifyDict[ l ] = stat name = l.name.encode( 'utf-8' ) if name == '@axis-x': x0, y0, x1, y1 = l.bbox oy = y0 elif name == '@axis-y': x0, y0, x1, y1 = l.bbox ox = x0 elif name == '@output': bx0 , by0 , bx1 , by1 = l.bbox elif not ( name and name[0] == '@' ): outputLayers.append( l ) #2. foreach frame: # find valid layer (visible & inside output bbox) # find in cache ( using hash/ direct comparison ) # if not in cache, add new one # for l in layers: anim = Anim() # print(mani) frameDelays = {} for data in mani['FrIn']: frameDelays[ data['FrID'] ] = data[ 'FrDl' ] frameList = mani['FSts'][0]['FsFr'] index = 0 layerStates = {} outputLayers.reverse() for l in outputLayers: x0 = 0 y0 = 0 visible = l.visible states = {} for mod in layerModifyDict[l]['LaSt']: fid = mod['FrLs'][0] ofst = mod.get('Ofst', None) if ofst: x0 = ofst['Hrzn'] y0 = ofst['Vrtc'] visible = mod.get('enab', visible) states[ fid ] = ( visible, x0, y0 ) layerStates[ l ] = states for fid in frameList: frame = AnimFrame() frame.delay = frameDelays.get( fid, 0 ) frame._fid = fid for l in outputLayers: #find modify state layerModify = None for s in layerModifyDict[l]['LaSt']: if s['FrLs'][0] == fid: layerModify = s break # #check meta # if l.name[0] == '@' : continue states = layerStates[l] #check enabled visible, offx, offy = states[ fid ] if not visible: continue #check inside bbox x0, y0 ,x1 ,y1 = l.bbox if x0 + offx <= bx0: continue if y0 + offy <= by0: continue if x1 + offx >= bx1: continue if y1 + offy >= by1: continue m = self.getModule( l ) x = x0 - ox + offx y = y0 - oy + offy frame.addModule( m, x, y ) anim.addFrame( frame, 0, 0 ) self.addFrame( frame ) self.addAnim( anim ) n,ext = splitext( basename( path ) ) anim.name = n
def psd_image_factory(data, *args): try: return PSDImage.from_stream(data).as_PIL() except Exception: raise TypeError
resizeHeight = 928 scaler = 'BICUBIC' resample = { 'ANTIALIAS': Image.ANTIALIAS, 'BILINEAR': Image.BILINEAR, 'BICUBIC': Image.BICUBIC } def outputfile(s): return "./jpg/" + s+ "." + extension def inputfile(s): return "./psd/" + s print('-----------------------------------\n') for folderName,subfolders,filenames in os.walk('./psd'): for myfilename in filenames: if(myfilename == ".DS_Store"): continue print('input' + ':' + myfilename) fname,fext = os.path.splitext(myfilename) if(fext == ".psd"): psd = PSDImage.load(inputfile(myfilename)) merged_image = psd.as_PIL() merged_image = merged_image.resize((resizeWidth, resizeHeight),resample[scaler]) # print(merged_image) merged_image.format = extension merged_image.save(outputfile(fname),quality=100, optimize=True) print('output' + ':' + outputfile(fname) + '\n-----------------------------------')