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