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 load_psd():
home_path = os.environ['HOME'] + '/'
# set load_path
work_path = 'test_psd' # set work_path
title = 't1' # set title
episode = 'e2' # set episode
load_path = home_path + work_path + '/' + title + '/' + episode + '/'
name_error_list = [] # list of mis-spelled layers
visible_not_activated_list = [] # list of non-visible layers
for file in os.listdir(load_path):
if file.endswith('.psd'):
print ('-------------------------------------------------------------')
print (load_path+file+' is processing')
result_dir = load_path+'/'+file[0:3]+'/'
os.mkdir(result_dir)
psd = PSDImage.load(load_path+file)
backcolor_idx, frame_idx, line_drawing_idx, backcolor_visible, frame_visible, line_drawing_visible = layer_index_and_check_names(psd)
if (backcolor_idx == 100) or (frame_idx == 100) or (line_drawing_idx == 100) :
name_error_list.append(load_path+file)
continue
if (backcolor_visible == False) or (frame_visible == False) or (line_drawing_visible == False):
visible_not_activated_list.append(load_path+file)
continue
backcolor_frame_saved_img = save_backcolor_frame(psd, frame_idx, backcolor_idx, result_dir)
del psd # delete changed psd_file
img = cv2.imread(backcolor_frame_saved_img)[:,:,::-1]
detected_backcolor_frame = result_dir + 'detected_backcolor_frame.png'
cut_point_list = ds.detect_frames(img, detected_backcolor_frame)
psd = PSDImage.load(load_path+file) # re-load original psd_file
save_picture(psd, result_dir)
input_picture_img = save_input_picture(psd, line_drawing_idx, backcolor_idx, result_dir)
xy_coordinate_list = cropped_scenes(input_picture_img, cut_point_list, result_dir)
with open(result_dir+'xy_coordinate.txt', 'wb') as f:
pickle.dump(xy_coordinate_list, f)
print (load_path+file+' is over')
print ('everything is done')
with open(load_path+'name_error_psd.txt','wb') as f :
pickle.dump(name_error_list, f )
with open(load_path+'invisible_psd.txt','wb') as f:
pickle.dump(visible_not_activated_list, f)
print ('---------------------------- name error list ---------------------------------')
print (name_error_list)
print ('------------------------visible is not activated list ------------------------')
print (visible_not_activated_list)
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 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__, version=__version__)
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 main():
"""
psd-tools
Usage:
psd-tools convert <psd_filename> <out_filename> [options]
psd-tools export_layer <psd_filename> <layer_index> <out_filename> \
[options]
psd-tools debug <filename> [options]
psd-tools -h | --help
psd-tools --version
Options:
-v --verbose Be more verbose.
--encoding <encoding> Text encoding [default: utf8].
"""
args = docopt.docopt(main.__doc__, version=__version__)
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']:
psd = PSDImage.load(args['<filename>'], encoding=encoding)
print("\nHeader\n------")
print(psd.decoded_data.header)
print("\nDecoded data\n-----------")
pprint(psd.decoded_data)
print("\nLayers\n------")
psd.print_tree()
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 loadPSD( self, path ): image = PSDImage.load( path ) for processor in self.processors: processor.onLoadImage( image ) self.processGroup( image.layers ) self.dirty = True
def writeJSON(filenameIn, outFilename):
psd = PSDImage.load(filenameIn)
canvasWidth = psd.header.width
canvasHeight = psd.header.height
header = {}
header["canvasWidth"] = canvasWidth
header["canvasHeight"] = canvasHeight
regions = []
i = 0
for curLayer in psd.layers:
regionData = {}
regionData["width"] = curLayer.bbox.width
regionData["height"] = curLayer.bbox.height
regionData["x"] = curLayer.bbox.x1
regionData["y"] = curLayer.bbox.y1
regionData["name"] = curLayer.name
regions.append(regionData)
i += 1
print "Writing out region: %s" % curLayer.name
finalData = {}
finalData["header"] = header
finalData["regions"] = regions
writeStr = json.dumps(finalData, ensure_ascii=True, sort_keys=True)
text_file = open(outFilename, "w")
text_file.write(writeStr)
text_file.close()
def test_001():
mkdir_if("images")
psd = PSDImage.load('../psd/006.psd')
merged_image = psd.as_pymaging()
merged_image.save_to_path('images/006.png')
exportPsdLayers(psd.layers, "images/006")
searchJsonFileAndCreateImgInDir("images/006")
def psd2png(psd_path, save_dir):
psd = PSDImage.load(psd_path)
psd = psd.as_PIL()
psd_name = os.path.basename(psd_path)
psd_name_without_extension = os.path.splitext(psd_name)[0]
save_path = path.join(save_dir, psd_name_without_extension + '.png')
psd.save(save_path)
def getAllMipMaps(self, imgfilepath, imgfilename):
print(imgfilepath)
fname, ext = os.path.splitext(imgfilepath)
if ext == '.psd':
img = PSDImage.load(imgfilepath).as_PIL()
img = img.convert('RGB')
else:
try:
img = Image.open(imgfilepath)
except:
img = Image.new('RGB', (256, 256), (200, 200, 200))
ImageFile.LOAD_TRUNCATED_IMAGES = True
#else:
if ext == '.gif' or ext == '.GIF':
img = img.convert('RGB')
img = img.filter(ImageFilter.BLUR)
pix = img.load()
self.imgToPixel[imgfilename] = []
self.imgToPixel[imgfilename].append({
"w": img.width,
"h": img.height,
"pix": pix
})
width = img.width // 2
height = img.height // 2
self.imgToPixel[imgfilename] = self.createMipMap(
img, imgfilename, width, height)
def main(argv):
logger = logging.getLogger(__name__)
fileName = ""
outputFileName = ""
size = 96
try:
opts, args = getopt.getopt(argv, "f:o:s:")
except getopt.GetoptError:
print("Invalid parameters.")
sys.exit(1)
for opt, arg in opts:
if opt == '-f':
fileName = unicode(arg, "UTF-8")
elif opt == '-o':
outputFileName = arg
elif opt == '-s':
size = int(arg)
if fileName == "":
print("Need a Photoshop file to convert.")
sys.exit(1)
if outputFileName == "":
name, extension = os.path.splitext(fileName)
outputFileName = name + ".png"
psd = PSDImage.load(fileName)
image = buildClockImage(psd, size)
image.save(outputFileName)
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 __init__(self, psd_file, pdf_width, pdf_height):
self.psd = PSDImage.load(psd_file)
self.width = pdf_width
self.height = pdf_height
if not self.check_scale():
raise ValueError('PSD is not the right size.')
self.name_dummy_layer = 'FIRSTNAME SURNAME'
self.qr_dummy_layer = 'qr code example'
self.ga_layer_name = 'GENERAL ADMISSION'
self.qj_layer_name = 'QUEUE JUMP'
self.ga_text_layer_name = 'general admission text'
self.qj_text_layer_name = 'que jump ext'
self.ignore_layers = [
'Background', self.name_dummy_layer, self.qr_dummy_layer
]
self.buf = io.BytesIO()
self.pdf = canvas.Canvas(
self.buf,
pagesize=(self.width * mm, self.height * mm),
)
self.pdf.setAuthor("King's Affair")
self.pdf.setCreator("King's Affair")
self.pdf.setTitle("Tickets")
self.pdf.setSubject("King's Affair Tickets 2017")
self.layers = OrderedDict(
(layer.name, (layer, ImageReader(layer.as_PIL())))
for layer in self.psd.layers)
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 gsp_import_psd(gsp, *psds):
'''
Import psd layer as img into a GSP. Only import the layer startswith
gsp.prefix. This will just place the layer as same as in the psd file.
And the width and height of gsp will just be set to the max value
of sprites.
:param gsp: a GSP instance to process
:param psds: a filename list of psd files
'''
def f(psd, prefix, buf):
for r in psd.layers:
if not r.visible:
continue
if isgroup(r):
f(r, prefix, buf)
elif islayer(r) and r.bbox.width > 0 and\
r.bbox.height > 0 :
if not prefix or r.name.startswith(prefix):
buf.append([
r.name, [r.bbox.width, r.bbox.height],
[r.bbox.x1, r.bbox.y1],
r.as_PIL()
])
for fn in psds:
psd = PSDImage.load(fn)
gsp.width = max(gsp.width, psd.header.width)
gsp.height = max(gsp.height, psd.header.height)
f(psd, gsp.prefix, gsp.img)
def 拆包(文件名, 目標文件夾):
try:
os.mkdir(目標文件夾)
except:
None
前名 = os.path.basename(os.path.splitext(文件名)[0])
圖片文件夾 = os.path.join(目標文件夾, 前名)
psd = PSDImage.load(文件名)
d = {}
def 記錄(層, path=''):
print(path)
try:
os.mkdir(os.path.join(圖片文件夾, path))
except:
None
if hasattr(層, 'layers'):
for i in 層.layers:
記錄(i, path + 層.name + '/')
else:
名 = path + 層.name
d[名] = {'x': 層.bbox.x1, 'y': 層.bbox.y1}
layer_image = 層.as_PIL()
layer_image.save(os.path.join(圖片文件夾, f'{名}.png'))
for i in psd.layers:
記錄(i)
with open(os.path.join(圖片文件夾, '位置.yaml'), 'w', encoding='utf8') as f:
yaml.dump(d, f, default_flow_style=False, allow_unicode=1)
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 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 parse_psd(path):
psd_name = os.path.basename(path)
psd_name_without_extension = os.path.splitext(psd_name)[0]
dir_path = os.path.dirname(path)
layer_save_path = os.path.join(dir_path, psd_name_without_extension)
pathlib.Path(layer_save_path).mkdir(parents=True, exist_ok=True)
psd = PSDImage.load(path)
header = psd.header
layers = psd.layers
layer_infos = []
for layer in layers:
save_path = os.path.join(layer_save_path, layer.name + '.png')
m_x1 = 0
m_y1 = 0
layer_info = PsdLayer(layer.bbox.width, layer.bbox.height,
layer.bbox.x1 + m_x1, layer.bbox.y1 + m_y1,
layer.bbox.x2, layer.bbox.y2, layer.name,
save_path)
layer_infos.append(layer_info)
psd_info = PsdModel(header.width, header.height, layer_infos, psd_name,
path)
return psd_info
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 unpack(path):
_, filename = os.path.split(path)
name = filename[:filename.rfind('.')]
psd = PSDImage.load(path)
info = layers_to_dir(psd.layers, name)
with open('%s/info.json' % name, 'w') as io:
json.dump(info, io, ensure_ascii=False)
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 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 psd_file_to_svg(psd_path):
"""
converts a psd file path to an svg
:param psd_path: the path to the psd
:returns: the svg string
"""
psd = PSDImage.load(psd_path)
return psd_to_svg(psd)
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 psd_to_jpg(file_path):
try:
psd=PSDImage.load(file_path)
pil_image=psd.as_PIL()
pil_image.save(jpg_path(file_path))
os.remove(file_path)
except :
pass
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 converPng():
while not q.empty():
file = q.get()
if file.endswith('.psd'):
psd = PSDImage.load(file)
merged_image = psd.as_PIL()
png = file[:-3] + 'png'
merged_image.save(png)
print('>> ' + png + ' done!')
def export(self):
parts = self.format.split('.')
type = parts[-1].lower()
max_size = [int(x) for x in parts[0].split('x')] if len(parts) == 2 else None
self.metrics.merge({
'type': type,
'max_size_w': max_size[0],
'max_size_h': max_size[1],
})
try:
if self.ext in ['.psd']:
# silence warnings from psd-tools
# Warnings warn of outdated depedency that is a pain to install
# and about colors being possibly wrong
with warnings.catch_warnings():
warnings.simplefilter("ignore")
image = PSDImage.load(self.source_file_path).as_PIL()
else:
image = Image.open(self.source_file_path)
if max_size:
# resize the image to the w/h maximum specified
ratio = min(max_size[0] / image.size[0], max_size[1] / image.size[1])
self.metrics.add('ratio', ratio)
if ratio < 1:
image = image.resize((round(image.size[0] * ratio),
round(image.size[1] * ratio)), Image.ANTIALIAS)
# Mode 'P' is for paletted images. They must be converted to RGB before exporting to
# jpeg, otherwise Pillow will throw an error. This is a temporary workaround, as the
# conversion is imprecise and can be ugly.
# See: https://stackoverflow.com/q/21669657
if image.mode == 'P':
image = image.convert('RGB')
# handle transparency
# from https://github.com/python-pillow/Pillow/issues/2609
if image.mode in ('RGBA', 'RGBa', 'LA') and type in ['jpeg', 'jpg']:
# JPEG has no transparency, so anything that was transparent gets changed to
# EXPORT_BACKGROUND_COLOR. Default is white.
background = Image.new(image.mode[:-1], image.size, EXPORT_BACKGROUND_COLOR)
background.paste(image, image.split()[-1])
image = background
image.save(self.output_file_path, type)
image.close()
except (UnicodeDecodeError, IOError, FileNotFoundError, OSError) as err:
name, extension = os.path.splitext(os.path.split(self.source_file_path)[-1])
raise exceptions.PillowImageError(
'Unable to export the file as a {}, please check that the '
'file is a valid image.'.format(type),
export_format=type,
detected_format=imghdr.what(self.source_file_path),
original_exception=err,
code=400,
)
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 slice(self, prefix, psd_filename, images_output_folder, source_output_folder, images_path_from_source, images_scale_factor = 1.0, scene_scale_factor = 1.0, ignored_layers = set(), enable_cache = True, atlas_packing = False):
self.entities = []
self.sprites = []
self.texts = []
self.textures = []
self.slice9 = []
self.idents = set()
self.images_cache = {} if enable_cache else None
self.images_output_folder = images_output_folder
self.images_scale_factor = images_scale_factor
self.scene_scale_factor = scene_scale_factor
self.ignored_layers = ignored_layers
try:
os.mkdir(images_output_folder)
except:
pass
try:
os.mkdir(source_output_folder)
except:
pass
plane = PSDImage.load(psd_filename)
if not plane:
raise ValueError("failed to load %s" % psd_filename)
self._export(plane)
if atlas_packing:
self._pack_test() # experimental atlas support
self._save_images()
data = {
"prefix": prefix,
"location": images_path_from_source,
}
if len(self.entities):
data["entities"] = {"items": self.entities, "count": len(self.entities)}
if len(self.textures):
data["textures"] = {"items": self.textures, "count": len(self.textures)}
if len(self.slice9):
data["slice9"] = {"items": self.slice9, "count": len(self.slice9)}
if len(self.sprites):
data["sprites"] = {"items": self.sprites, "count": len(self.sprites)}
if len(self.texts):
data["texts"] = {"items": self.texts, "count": len(self.texts)}
with codecs.open(os.path.join(source_output_folder, "%s.h" % prefix), "w", "utf-8") as f:
pystache_renderer = pystache.Renderer(escape = lambda x: x)
f.write(pystache_renderer.render(c_template, data))
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 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 openImage(srcImgPath):
extendName = srcImgPath.split(".")[-1].lower()
changeSubStatus("extendName =", extendName)
if extendName in ("jpg", "png", "psd"):
changeSubStatus("opening file...")
if extendName == "psd":
im = PSDImage.load(srcImgPath).as_PIL()
else:
im = Image.open(srcImgPath)
return im
def test():
im = PSDImage.load("D:\\a.psd")
print dir(im)
print im.layers
for layer in im.layers:
#print dir(layer)
if type(layer) is Group:
printgroup(layer)
else:
print layer.name.encode("gb2312")
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 loadSingleImage(path, **option):
img = None
name, ext = os.path.splitext(path)
if ext.lower() == '.psd':
from psd_tools import PSDImage
pimage = PSDImage.load(path)
if pimage: img = pimage.as_PIL()
else:
img = Image.open(path)
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 compress_textures(name=''):
import os
try:
from PIL import Image
except Exception as e:
return e
if not application.compressed_textures_folder.exists():
application.compressed_textures_folder.mkdir()
file_type = '.*'
if '.' in name:
file_type = ''
# print('searching for texture:', name + file_type)
for f in application.asset_folder.glob('**/' + name + file_type):
if '\\textures_compressed\\' in str(f) or f.suffix not in (
'.psd', '.png', '.jpg', '.jpeg', '.gif'):
continue
# print(' found:', f)
image = None
if f.suffix == '.psd':
try:
from psd_tools import PSDImage
except (ModuleNotFoundError, ImportError) as e:
print('info: psd-tools3 not installed')
return None
image = PSDImage.load(f)
image = image.as_PIL()
# elif f.suffix == '.png':
# image = Image.open(f)
if not image:
return False
# print(max(image.size))
# print('............', image.mode)
if image and image.mode != 'RGBA' and max(image.size) > 512:
image.save(application.compressed_textures_folder /
(Path(f).stem + '.jpg'),
'JPEG',
quality=80,
optimize=True,
progressive=True)
print(' compressing to jpg:',
application.compressed_textures_folder / (f.stem + '.jpg'))
continue
else:
image.save(
application.compressed_textures_folder / (f.stem + '.png'),
'PNG')
print(' compressing to png:',
application.compressed_textures_folder / (f.stem + '.png'))
def update_image_from_file(self):
"""update image from psd file"""
image = self.image
psd = PSDImage.load(image.filepath)
image.generated_height = psd.header.height
image.generated_width = psd.header.width
image.layers_data.layers.clear()
ImportLayersImage.get_layers_from_psd(psd.decoded_data, psd.layers, image.layers_data)
image.layers_data.import_time = os.path.getmtime(image.filepath)
self.layers_mix()
image.pack(as_png=True)
return 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 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 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 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 start():
psd = PSDImage.load(sys.argv[1])
textfile = open("offsets.txt", "w")
parse_and_save(psd,textfile)
textfile.close()
# -*- 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")
#!/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)
def __init__(self, file_name):
self.file_name = file_name
self.psd = PSDImage.load(file_name)
def list(request):
# Handle file upload!
if request.method == 'POST':
form = DocumentForm(request.POST, request.FILES)
if form.is_valid():
newdoc = Document(docfile = request.FILES['docfile'])
newdoc.save()
# Redirect to the document list after POST!
return HttpResponseRedirect(reverse('myproject.myapp.views.list'))
else:
form = DocumentForm() # A empty, unbound form!
# Load documents for the list page!
documents = Document.objects.all()
if documents:
for document in documents:
print ( document.docfile.url)
psd =PSDImage.load(os.path.join(os.path.dirname(__file__), "/myproject" + document.docfile.url))
layer_details = psd.layers
items = []
psd_header = psd.header
try:
os.makedirs(os.path.join(os.path.dirname(__file__), "/myproject/" + 'media/' + str(document.docfile.name).rsplit('.', 1)[0]))
except OSError:
pass
filename = str(document.docfile.name).rsplit('.', 1)[0] + '.json'
f = open(filename, 'a')
# save the flatened image in png format in a directory!
merged_image = psd.as_PIL()
merged_image_filename = str(document.docfile.name).rsplit('.', 1)[0] + '.png'
merged_image.save(os.path.join(os.path.dirname(__file__), "/myproject/" + 'media/' + str(document.docfile.name).rsplit('.', 1)[0] + '/' + merged_image_filename))
# for loop to extract layer and its information from the psd uploaded
for layer_count in layer_details:
# empty dict for storing layer information
item = {}
# psd header details viz falana and dekana are extracted here!
item['psdheader_details'] = psd_header
# layer names
item['layer_name'] = layer_count.name
# convert layer as an image for further processing in future.
layer_image = layer_count.as_PIL()
layer_image_filename = str(layer_count.name) + '.png'
# save layer in a paricular directory.
layer_image.save(os.path.join(os.path.dirname(__file__), "/myproject/" + 'media/' + str(document.docfile.name).rsplit('.', 1)[0] + '/' + layer_image_filename))
# write layer informations to a jason file.
f.write(str(items) + '\n')
f.close()
#json_data = str(items)
#return HttpResponse(json.dumps(json_data), content_type="text/json")
# Render list page with the documents and the form.
return render_to_response(
'list.html',
{'documents': documents, 'form': form},
context_instance=RequestContext(request)
)
from psd_tools import PSDImage
import sys
import os
def isfilepath(path):
print(path)
return os.path.isfile(os.path.abspath(os.path.expanduser(path)))
def ispsd(path):
if path[-3:] == 'psd':
return True
return False
def pngpath(path):
return path[:-3] + 'png'
file_paths = [file_path for file_path in sys.argv if isfilepath(file_path) and ispsd(file_path)]
for file_path in file_paths:
psd = PSDImage.load(file_path)
merged_image = psd.as_PIL()
merged_image.save(pngpath(file_path))
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 convert_image(src_dir, dest_dir, format, filename, format_dict, rename_dict,
extensions, size, resize_filter, maintain_ratio):
try:
name, ext = os.path.splitext(filename)
ext = ext.lower()
filepath = os.path.join(src_dir, filename)
if ext == '.psd':
psd = PSDImage.load(filepath)
im = psd.as_PIL()
else:
im = Image.open(filepath)
if format == 'Smart':
if is_grayscale(im):
format = 'PNG'
else:
format = 'JPEG'
options = format_dict.get(format, {}).copy()
bands = list(im.getbands())
colormode = options.get('colormode')
if options.get('transparent') and colormode in ('RGB', 'L'):
colormode += 'A'
elif not options.get('transparent') and 'A' in bands:
back_color = tuple(options.get('background',
(255, 255, 255)))
back_im = Image.new('RGBA', im.size, back_color)
alpha = im.split()[bands.index('A')]
new_im = Image.composite(im, back_im, alpha)
im = new_im.convert('RGB')
if colormode is not None and im.mode != colormode:
im.draft(colormode, im.size)
if (im.mode == 'RGBA' and colormode == 'P' and
options.get('transparent')):
if format != 'PNG':
im = RGBA_to_P(im, options)
else:
im = im.convert('RGB')
im = im.convert('P', palette=Image.ADAPTIVE,
colors=options.get('colors', 256))
elif colormode == 'P':
convert_options = {
'dither': options.get('dither',
Image.FLOYDSTEINBERG),
'palette': options.get('palette', Image.WEB),
'colors': options.get('colors', 256),
}
im = im.convert(colormode, **convert_options)
for key in convert_options:
try:
del options[key]
except KeyError:
pass
else:
im = im.convert(colormode)
if format:
#im.info = {}
if size:
if maintain_ratio:
im.thumbnail(size, resize_filter)
else:
im = im.resize(size, resize_filter)
if rename_dict:
name = rename_dict.get(filename)
dest_path = os.path.join(dest_dir, name)
if (rename_dict is None) or extensions:
new_ext = shared.extension_dict.get(format,
'.' + format.lower())
dest_path += new_ext
if (options.get('interlace') or options.get('bits', 8) != 8
or options.get('optimize')):
save_as_PNG(im, dest_path, options)
else:
im.save(dest_path, format, **options)
except BaseException as e:
return filename, e
return filename, None
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-----------------------------------')
