def save_poster(self, button):
collage = self.history[self.history_index]
enlargement = float(self.opts.out_w) / collage.page.w
collage.page.scale(enlargement)
dialog = Gtk.FileChooserDialog(_("Save image"), button.get_toplevel(),
Gtk.FileChooserAction.SAVE)
dialog.add_button(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)
dialog.add_button(Gtk.STOCK_OK, Gtk.ResponseType.OK)
if self.opts.last_output_dir is not None:
dialog.set_current_folder(self.opts.last_output_dir)
dialog.set_do_overwrite_confirmation(True)
set_save_image_filters(dialog)
if dialog.run() != Gtk.ResponseType.OK:
dialog.destroy()
return
savefile = dialog.get_filename()
base, ext = os.path.splitext(savefile)
self.opts.last_output_dir = os.path.abspath(base)
if ext == "" or not ext[1:].lower() in get_all_save_image_exts():
savefile += ".jpg"
dialog.destroy()
# Display a "please wait" dialog and do the job.
compdialog = ComputingDialog(self)
def on_update(img, fraction_complete):
compdialog.update(fraction_complete)
def on_complete(img):
compdialog.destroy()
def on_fail(exception):
dialog = ErrorDialog(
self, "%s:\n\n%s" %
(_("An error occurred while rendering image:"), exception))
compdialog.destroy()
dialog.run()
dialog.destroy()
t = render.RenderingTask(
collage.page,
output_file=savefile,
border_width=self.opts.border_w *
max(collage.page.w, collage.page.h),
quality=self.opts.quality, # for saving, use user setting
border_color=self.opts.border_c,
on_update=gtk_run_in_main_thread(on_update),
on_complete=gtk_run_in_main_thread(on_complete),
on_fail=gtk_run_in_main_thread(on_fail))
t.start()
response = compdialog.run()
if response == Gtk.ResponseType.CANCEL:
t.abort()
compdialog.destroy()
def save_poster(savefile, opts, collage):
enlargement = float(opts.out_w) / collage.page.w
collage.page.scale(enlargement)
t = render.RenderingTask(
collage.page,
output_file=savefile,
border_width=opts.border_w * max(collage.page.w, collage.page.h),
border_color=opts.border_c,
)
t.start()
def save_collage(self, savefile):
collage = self.collage
enlargement = float(self.opts.out_w) / collage.page.w
collage.page.scale(enlargement)
t = render.RenderingTask(
collage.page, output_file=savefile,
border_width=self.opts.border_w * max(collage.page.w,
collage.page.h),
border_color=self.opts.border_c)
t.start()
def render_preview(self):
collage = self.history[self.history_index]
# If the desired ratio changed in the meantime (e.g. from landscape
# to portrait), it needs to be re-updated
collage.page.target_ratio = 1.0 * self.opts.out_h / self.opts.out_w
collage.page.adjust_cols_heights()
w = self.img_preview.get_allocation().width
h = self.img_preview.get_allocation().height
collage.page.scale_to_fit(w, h)
# Display a "please wait" dialog and do the job.
compdialog = ComputingDialog(self)
def on_update(img, fraction_complete):
self.img_preview.set_collage(img, collage)
compdialog.update(fraction_complete)
def on_complete(img):
self.img_preview.set_collage(img, collage)
compdialog.destroy()
self.btn_save.set_sensitive(True)
def on_fail(exception):
dialog = ErrorDialog(
self, "%s:\n\n%s" %
(_("An error occurred while rendering image:"), exception))
compdialog.destroy()
dialog.run()
dialog.destroy()
self.btn_save.set_sensitive(False)
t = render.RenderingTask(
collage.page,
border_width=self.opts.border_w *
max(collage.page.w, collage.page.h),
border_color=self.opts.border_c,
quality=QUALITY_FAST, # for preview, use NEAREST
on_update=gtk_run_in_main_thread(on_update),
on_complete=gtk_run_in_main_thread(on_complete),
on_fail=gtk_run_in_main_thread(on_fail))
t.start()
response = compdialog.run()
if response == Gtk.ResponseType.CANCEL:
t.abort()
compdialog.destroy()
def make_collage(output_filename, photos):
# Define the output image height / width ratio
ratio = 1.0 * out_h / out_w
"""
Compute a good number of columns. It depends on the ratio, the number
of images and the average ratio of these images. According to my
calculations, the number of column should be inversely proportional
to the square root of the output image ratio, and proportional to the
square root of the average input images ratio.
"""
avg_ratio = sum(
1.0 * photo_from_list.h / photo_from_list.w for photo_from_list in
photos) / len(photos)
"""
Virtual number of images: since ~ 1 image over 3 is in a multi-cell
(i.e. takes two columns), it takes the space of 4 images.
So it's equivalent to 1/3 * 4 + 2/3 = 2 times the number of images.
"""
virtual_no_images = 2 * len(photos)
no_cols = int(round(math.sqrt(avg_ratio / ratio * virtual_no_images)))
border_w = 0.01
border_c = (0, 0, 0) # black
# border_c = render.random_color()
page = Page(1.0, ratio, no_cols)
random.shuffle(photos)
for photo_from_list in photos:
page.add_cell(photo_from_list)
page.adjust()
# If the desired ratio changed in the meantime (e.g. from landscape to
# portrait), it needs to be re-updated
page.target_ratio = 1.0 * out_h / out_w
page.adjust_cols_heights()
page.scale_to_fit(out_w, out_h)
enlargement = float(out_w) / page.w
page.scale(enlargement)
t = render.RenderingTask(
page, output_file=output_filename,
border_width=border_w * max(page.w, page.h),
border_color=border_c)
t.start()
if os.path.splitext(fn)[1].lower() in ('.jpg', '.jpeg', '.png')
]
random.shuffle(img_paths)
#####################################################################
# Options
#####################################################################
out_h = 10000
out_w = 20000
savefile = 'collage_01.jpg'
#####################################################################
# Run
#####################################################################
photolist = render.build_photolist(img_paths)
mycollage = collage.UserCollage(photolist)
mycollage.make_page(out_h, out_w)
print(mycollage.page)
enlargement = float(out_w) / mycollage.page.w
mycollage.page.scale(enlargement)
t = render.RenderingTask(mycollage.page, output_file=savefile)
t.start()
t.is_alive == True
