def addImage(self):
try:
self.image_name = fd.askopenfilename()
save_image = ImageEditor()
new_photopath = save_image.copyPhoto(self.image_name)
self.text.insert(END, "\n\nimage*" + new_photopath)
except Exception as e:
print("caught in addImage: %s" % e)
def save_post(self, post):
self.minified_posts.append(post)
if post.is_image():
image_name = ImageGetter(post).get_image()
ie = ImageEditor(image_name)
ie.add_text_to_image(post.title)
ie.save(image_name)
self.snapchatter.send(image_name)
else:
print("isn't image: " + post.title)
def __init__(self, path, w, h, mode="Image", cascade=""):
self.CAM = CameraMan(w, h)
self.IE = ImageEditor()
self.mode = mode
if not mode == "norecord":
self.IS = ImageStore(path, mode)
if mode == "Movie":
self.IS.movie_settings(w, h)
self.CS = CsvStore(path)
self.fps = FPS()
self.cascade_path = cascade
def scale(self):
if os.path.isfile(self.currentImage):
items = ('0.5', '0.7', '1.5')
item, okPressed = QInputDialog.getItem(self, 'Resize image',
'Scale factor:', items, 0,
False)
if okPressed and item:
print(item)
self.pixmap = ImageEditor(self.currentImage).resize(item)
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
def addMainImage(self):
try:
self.image_name = fd.askopenfilename()
save_image = ImageEditor()
if self.currFile == '':
self.saveAsF()
new_photopath = save_image.addMainPhoto(self.image_name,
self.currFile)
print("successfully saved %s." % new_photopath)
except Exception as e:
print("caught in addMainImage: %s" % e)
def brighten_and_upload(self, source_image):
image_name = source_image.split(".")[-2]
target_file_path = source_image + "-bright.png"
try:
ImageEditor.brighten_image(source_image, target_file_path)
self._upload_file(target_file_path, self.s3_bucket_name,
BW_FOLDER + image_name + "-bright-" + str(int(round(time.time() * 1000))) + ".png")
except Exception:
raise
finally:
delete_file(target_file_path)
def dialog_open(self):
fname = QFileDialog.getOpenFileName(
self, 'Open file', os.path.expanduser(''),
'Images (*.png *.xpm *.jpg);;All files (*.*)')[0]
if fname:
print(fname)
if os.path.isfile(fname):
self.pixmap = QPixmap(fname)
self.currentImage = fname
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
self.enable_actions(True)
def __init__(self):
super(MainWindow, self).__init__()
self.np_img = None
self.image_actions = []
self._init_ui()
self.view = self.ui.imageLabel
self.image_opener = ImageOpener(self)
self.image_saver = ImageSaver(self)
self.image_editor = ImageEditor()
self.image_history = History()
self.user_settings_dump_n_loader = UserSettingsDumpNLoader()
self.diff_images_dir = self.user_settings_dump_n_loader.get_diff_images_dir()
self.golden_images_dir = self.user_settings_dump_n_loader.get_golden_images_dir()
self._init_file_actions()
self._init_M2_actions()
self._init_M3_actions()
self._init_M4_actions()
self._init_M5_actions()
self._init_M6_actions()
self._enable_menu_items(False)
def create_menu(self, img):
padding = 5
img_orig = img
img = img.copy()
img.thumbnail((OptionsFrame.frame_width // 2 - padding * 3 - 10,
OptionsFrame.frame_width // 2 - padding * 3 - 10))
image_editor_model = ImageEditor()
image_editor_model.load_image(img)
def on_effect_click(effect_fun):
self.master.load_image_preview(effect_fun(img_orig))
self.master.crop_params = None
def on_index(ind, event):
on_effect_click(image_editor_model.get_effect(ind)[0])
accept_btn = tk.Button(self.scrollable_frame, text="Apply")
accept_btn.grid(row=0,
column=0,
padx=padding,
pady=padding,
sticky="nesw")
def on_apply():
if self.master.crop_params != None:
print("cropping!")
self.master.img = self.master.img.crop(self.master.crop_params)
self.master.crop_params = None
self.master.load_image(self.master.img)
accept_btn['command'] = on_apply
cancel_btn = tk.Button(self.scrollable_frame, text="Revert")
cancel_btn.grid(row=0,
column=1,
padx=padding,
pady=padding,
sticky="nesw")
def on_cancel():
self.master.load_options_prev(self.master.img_orig)
self.master.load_image_preview(self.master.img_orig)
cancel_btn['command'] = on_cancel
for i, image_with_effect in enumerate(
image_editor_model.get_images_with_effects()):
thumbn_frame = tk.Frame(self.scrollable_frame, bg="black")
thumbn_frame.grid(row=((i + 2) // 2),
column=(i % 2),
pady=padding,
padx=padding,
sticky="W")
thumbn_frame.bind("<Button-1>", partial(on_index, i))
#image_with_effect[0].thumbnail((OptionsFrame.frame_width//2, OptionsFrame.frame_width//2))
img_tk = ImageTk.PhotoImage(image=image_with_effect[0])
thumbn_photo = tk.Label(thumbn_frame,
text='image_here',
image=img_tk)
thumbn_photo.image = img_tk
thumbn_photo.pack(side=tk.TOP)
thumbn_photo.bind("<Button-1>", partial(on_index, i))
thumbn_name = tk.Label(thumbn_frame, text=image_with_effect[1])
thumbn_name.pack(side=tk.TOP)
thumbn_name.bind("<Button-1>", partial(on_index, i))
class Gui(Frame):
def __init__(self, parent):
self.parent = parent
Frame.__init__(self, parent)
self.__initUi()
self.image_editor = ImageEditor()
def __initUi(self):
"""updates the window and creates view of the board
"""
#create menu bar
self.parent.title("Simple Image Editor")
menu = Menu(self.parent)
self.parent.config(menu=menu)
#add file menu
file_menu = Menu(menu)
menu.add_cascade(label="File", menu=file_menu)
file_menu.add_command(label="Open...", command=self.__OpenFile)
file_menu.add_separator()
file_menu.add_command(label="Exit", command=self.parent.quit)
#add saveAs menu
save_menu = Menu(file_menu)
file_menu.add_cascade(label="Save as", menu=save_menu)
save_menu.add_command(label="JPG", command=self.__saveAsJpg)
save_menu.add_command(label="BMP", command=self.__saveAsBmp)
save_menu.add_command(label="PNG", command=self.__saveAsPng)
save_menu.add_command(label="TIFF", command=self.__saveAsTiff)
#add edit menu
edit_menu = Menu(menu)
menu.add_cascade(label="Edit", menu=edit_menu)
edit_menu.add_command(label="invert", command=self.__invertImage)
edit_menu.add_command(label="to greyscale", command=self.__greyscale)
edit_menu.add_command(label="fourier transformation", command=self.__fourierTransformImage)
#add flip submenu
flip_menu = Menu(edit_menu)
edit_menu.add_cascade(label="flip", menu=flip_menu)
flip_menu.add_command(label="left -> right", command=self.__flipImageLr)
flip_menu.add_command(label="top -> bottom", command=self.__flipImageTb)
#create label that contains the image
self.image_label = Label(self.parent)
def __OpenFile(self):
self.file_path = filedialog.askopenfilename()
self.image_editor.image = deepcopy(Image.open(self.file_path))
img = ImageTk.PhotoImage(self.image_editor.image)
self.image_label = Label(self.parent, image=img)
self.image_label.place(x=0, y=0, width=img.width(), height=img.height())
#self.image_label.pack(side = "top", fill = "both", expand = "yes")
self.image_label.image = img
self.image_editor.original_image = deepcopy(self.image_editor.image)
def __askSaveFilePath(self, extension):
file_path = filedialog.asksaveasfile(mode="w", defaultextension=extension)
#check if user cancelled saveFileDialog
if file_path is None:
return
#self.image_editor.image.write(file_path, format=extension)
self.image_editor.image.save(str(file_path.name))
def __saveAsJpg(self):
self.__askSaveFilePath("jpg")
def __saveAsBmp(self):
self.__askSaveFilePath("bmp")
def __saveAsPng(self):
self.__askSaveFilePath("png")
def __saveAsTiff(self):
self.__askSaveFilePath("tiff")
def __invertImage(self):
self.image_editor.invertImage()
self.__updateImage()
def __greyscale(self):
self.image_editor.greyscale()
self.__updateImage()
def __fourierTransformImage(self):
self.image_editor.fourierTransformImage()
self.__updateImage()
def __flipImageLr(self):
self.image_editor.flipImage("l2r")
self.__updateImage()
def __flipImageTb(self):
self.image_editor.flipImage("t2b")
self.__updateImage()
def __updateImage(self):
self.image_label = Label(self.parent, image=self.image_editor.image)
self.image_label.place(x=0, y=0, width=self.image_editor.image.width(),\
height=self.image_editor.image.height())
#//TODO: delete next line
#self.image_label.pack(side = "top", fill = "both", expand = "yes")
self.image_label.image = self.image_editor.image
def __init__(self, parent):
self.parent = parent
Frame.__init__(self, parent)
self.__initUi()
self.image_editor = ImageEditor()
import requests
from image_editor import ImageEditor
from post import Post
from image_getter import ImageGetter
headers = {"User-Agent" : "Snaphat by ImOffTheRails"}
r = requests.get('http://www.reddit.com/r/pics.json', headers=headers)
if r.status_code == 200:
for post in r.json()['data']['children']:
post = Post(post['data'])
if post.is_image():
image_name = ImageGetter(post).get_image()
ie = ImageEditor(image_name)
ie.add_text_to_image(post.title)
ie.save(image_name)
else:
print "Not a 200 :("
def decode_from_file(filename):
img = ImageEditor(filename)
msg = img.extract_message()
return msg
class SideFaceStreaming(Streaming):
def __init__(self, path, w, h, mode="Image", cascade=""):
self.CAM = CameraMan(w, h)
self.IE = ImageEditor()
self.mode = mode
if not mode == "norecord":
self.IS = ImageStore(path, mode)
if mode == "Movie":
self.IS.movie_settings(w, h)
self.CS = CsvStore(path)
self.fps = FPS()
self.cascade_path = cascade
def stream(self):
AKA = FeatureRecognizer("AKAZE")
CAS = CascadeRecognizer(self.cascade_path)
store_list = []
starttime = time.perf_counter()
self.fps.start()
while True:
ret, img = self.CAM.capture()
if not ret:
continue
store_list.append(time.perf_counter() - starttime)
grayimg = self.IE.get_gray_image(img)
areas = CAS.recognize(grayimg)
if len(areas):
CAS.areas_buffer(areas)
else:
areas = CAS.get_areas()
if len(areas):
crop_img = self.IE.get_crop_image(img, areas)
store_list.append(areas)
grayimg = self.IE.get_gray_image(crop_img)
kp, des = AKA.detect_keypoint(grayimg)
if kp and AKA.kp:
match_point, _ = AKA.recognize(kp, des)
store_list.append(match_point)
#正規化
norm_point = AKA.norm_matchpoint(kp, match_point)
store_list.append(norm_point)
else:
store_list.extend([[], 0])
AKA.feature_buffer(kp, des)
else:
store_list.extend([["null", "null", "null", "null"], [], 0])
if not self.mode == "norecord":
self.IS.store(img)
self.CS.store(store_list)
store_list = []
self.fps.update()
def main(self):
try:
self.stream()
except:
traceback.print_exc()
finally:
self.fps.stop()
try:
fps_ave = self.fps.fps()
except ZeroDivisionError as e:
print("{0}".format(e))
frame_list = list(range(self.fps._numFrames))
self.CS.write(frame_list, round(fps_ave, 2))
class MainWindow(QtGui.QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.np_img = None
self.image_actions = []
self._init_ui()
self.view = self.ui.imageLabel
self.image_opener = ImageOpener(self)
self.image_saver = ImageSaver(self)
self.image_editor = ImageEditor()
self.image_history = History()
self.user_settings_dump_n_loader = UserSettingsDumpNLoader()
self.diff_images_dir = self.user_settings_dump_n_loader.get_diff_images_dir()
self.golden_images_dir = self.user_settings_dump_n_loader.get_golden_images_dir()
self._init_file_actions()
self._init_M2_actions()
self._init_M3_actions()
self._init_M4_actions()
self._init_M5_actions()
self._init_M6_actions()
self._enable_menu_items(False)
def _init_ui(self):
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.imageLabel.setAlignment(QtCore.Qt.AlignCenter)
self.setCentralWidget(self.ui.imageLabel)
def _init_file_actions(self):
self.ui.actionExit.triggered.connect(QtGui.qApp.quit)
self.ui.actionOpen.triggered.connect(self._open_file)
self.ui.actionSave.triggered.connect(self._save_file)
self.ui.actionSave_As.triggered.connect(self.image_saver.save_as_file)
self.ui.actionUndo.triggered.connect(self._undo)
self.ui.actionRedo.triggered.connect(self._redo)
self.image_actions.append(self.ui.actionSave)
self.ui.actionSave_As.setEnabled(False)
self._enable_undo_redo()
def _init_M2_actions(self):
self.ui.actionErosion.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.erosion))
self.ui.actionDilatation.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.dilatation))
self.ui.actionInversion.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.inversion))
self.image_actions.extend([self.ui.actionErosion, self.ui.actionDilatation, self.ui.actionInversion])
def _init_M3_actions(self):
self.ui.actionIntegrating_filter.triggered.connect(
lambda: self._image_editor_wrapper(self.image_editor.linear_filter, ImageEditor.integration_filter_matrix,
ImageEditor.integration_filter_divisor)
)
self.ui.actionBlur.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.linear_filter,
ImageEditor.blur_matrix, ImageEditor.blur_divisor))
self.ui.actionSharpen.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.linear_filter,
ImageEditor.sharpen_matrix, ImageEditor.sharpen_divisor))
self.ui.actionMake_new_custom_filter.triggered.connect(self._make_new_custom_filter)
for filter_name, (matrix, divisor) in self.user_settings_dump_n_loader.get_filters().iteritems():
action = QtGui.QAction(self)
action.setText(filter_name)
action.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.linear_filter,
matrix, divisor))
self.ui.menuCustom_filters.addAction(action)
self.image_actions.extend([self.ui.actionIntegrating_filter, self.ui.actionBlur,
self.ui.actionSharpen, self.ui.actionMake_new_custom_filter])
def _init_M4_actions(self):
self.ui.actionWhite_noise.triggered.connect(lambda: self._get_two_params_and_edit("Probability (%)", "Range",
self.image_editor.white_noise))
self.ui.actionDust.triggered.connect(lambda: self._get_two_params_and_edit("Probability (%)", "Min value",
self.image_editor.dust))
self.ui.actionGrid.triggered.connect(lambda: self._get_two_params_and_edit("Width", "Height",
self.image_editor.grid))
self.image_actions.extend([self.ui.actionWhite_noise, self.ui.actionDust, self.ui.actionGrid])
def _init_M5_actions(self):
self.ui.actionDifference.triggered.connect(lambda: self._diff_images())
self.ui.actionSet_diff_images_path.triggered.connect(lambda: self._set_diff_images_dir(self._choose_directory()))
self.ui.actionSet_golden_images_path.triggered.connect(lambda: self._set_golden_images_dir(self._choose_directory()))
self.image_actions.extend([self.ui.actionDifference,
self.ui.actionSet_diff_images_path, self.ui.actionSet_golden_images_path])
def _init_M6_actions(self):
self.ui.actionMedian_filter_r_1.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.median_filter, 1))
self.ui.actionMedian_filter_r_2.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.median_filter, 2))
self.ui.actionMedian_filter_r_3.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.median_filter, 3))
self.image_actions.extend([self.ui.actionMedian_filter_r_1, self.ui.actionMedian_filter_r_2,
self.ui.actionMedian_filter_r_3])
def _enable_menu_items(self, mode):
for action in self.image_actions:
action.setEnabled(mode)
def _image_editor_wrapper(self, editor_func, *args):
self.image_history.add_new_state(self.np_img)
self.image_editor.update_image(self.np_img)
self.np_img = editor_func(*args)
self._show_np_image()
self._enable_undo_redo()
self._enable_menu_items(True)
def _make_new_custom_filter(self):
dialog = MakeNewCustomLinearFilterDialog(self.user_settings_dump_n_loader.get_filters().keys())
if dialog.exec_():
matrix, divisor, name = dialog.get_values()
self._image_editor_wrapper(self.image_editor.linear_filter, matrix, divisor)
self.user_settings_dump_n_loader.save_filter(matrix, divisor, name)
action = QtGui.QAction(self)
action.setText(name)
self.ui.menuCustom_filters.addAction(action)
action.triggered.connect(lambda: self._image_editor_wrapper(self.image_editor.linear_filter,
matrix, divisor))
def _get_two_params_and_edit(self, param1, param2, editor_func):
dialog = BaseTwoParamsDialog(param1, param2)
if dialog.exec_():
param1_value, param2_value = dialog.get_values()
self._image_editor_wrapper(editor_func, param1_value, param2_value)
@staticmethod
def _choose_directory():
return str(QtGui.QFileDialog.getExistingDirectory(None, 'Choose directory', '.', QtGui.QFileDialog.ShowDirsOnly))
def _set_golden_images_dir(self, dirname):
if dirname:
self.golden_images_dir = dirname
self.user_settings_dump_n_loader.set_golden_images_dir(dirname)
def _set_diff_images_dir(self, dirname):
if dirname:
self.golden_images_dir = dirname
self.user_settings_dump_n_loader.set_diff_images_dir(dirname)
def _diff_images(self):
self.image_editor.update_image(self.np_img)
basename = os.path.basename(str(self.image_saver.filename))
try:
golden_np_img = scipy.misc.imread(os.path.join(str(self.golden_images_dir), basename))
is_ok, diff_img, percentage = self.image_editor.diff_images(golden_np_img)
if not is_ok:
QtGui.QMessageBox.about(self, 'Error', 'Images have different size.s')
else:
QtGui.QMessageBox.about(self, 'Diff percentage', 'diff: %.1f %%' % percentage)
diff_filename = os.path.join(str(self.diff_images_dir), basename)
if percentage:
self.image_saver.save_any(diff_img, diff_filename)
except IOError:
QtGui.QMessageBox.about(self, 'Error', 'There is no golden image with corresponding name.')
def _open_file(self):
self.np_img = self.image_opener.open_file()
self.image_history.reset()
self.image_history.add_new_state(self.np_img)
self.image_saver.filename = self.image_opener.filename
# in case of png files swap channels
if self.np_img.shape[2] == 4:
self.np_img = utils.bgra2rgba(self.np_img)
self._show_np_image()
self._enable_menu_items(True)
self._enable_undo_redo()
self.ui.actionSave_As.setEnabled(True)
def _save_file(self):
self.image_saver.np_img = self.np_img
self.image_saver.save_file()
self.ui.actionSave.setEnabled(False)
def _undo(self):
if self.image_history.can_undo():
self.np_img = self.image_history.undo()
self._show_np_image()
self._enable_undo_redo()
def _redo(self):
if self.image_history.can_redo():
self.np_img = self.image_history.redo()
self._show_np_image()
self._enable_undo_redo()
def _enable_undo_redo(self):
undo_state, redo_state = True, True
if not self.image_history.can_redo():
redo_state = False
if not self.image_history.can_undo():
undo_state = False
self.ui.actionRedo.setEnabled(redo_state)
self.ui.actionUndo.setEnabled(undo_state)
def _show_np_image(self):
img = utils.np_to_qimage(self.np_img)
self._show_image(img)
def _show_image(self, img):
pixmap = QtGui.QPixmap.fromImage(img)
pixmap = self.scale_pixmap(pixmap)
self.view.setPixmap(pixmap)
def scale_pixmap(self, pixmap):
dest_height, dest_width = self.view.size().height(), self.view.size().width()
if dest_height < pixmap.size().height():
pixmap = pixmap.scaledToHeight(self.view.size().height())
elif dest_width < pixmap.size().width():
pixmap = pixmap.scaledToWidth(self.view.size().width())
return pixmap
def show_window(self):
self.show()
def set_original(self):
if os.path.isfile(self.currentImage):
self.pixmap = QPixmap(self.currentImage)
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
def get_editor(self, **kwargs):
""" Opens a new empty window
"""
editor = ImageEditor()
return editor
def encode_to_file(old_filename, png_filename, message):
"""Use ImageEditor to write message to image and save locally"""
img = ImageEditor(old_filename)
img.encode(message)
os.remove(old_filename)
img.save_changes(filename=png_filename)
class ProfileWindow(QDialog):
NumGridRows = 3
NumButtons = 4
def __init__(self):
super().__init__()
self.currentImage = ''
self.init_ui()
def init_ui(self):
self.formGroupBox = QGroupBox()
layout = QFormLayout()
self.username_edit = QLineEdit()
self.password_edit = QLineEdit()
load_button = QPushButton('Load image')
load_button.clicked.connect(self.dialog_open)
layout.addRow(QLabel('Name:'), self.username_edit)
layout.addRow(QLabel('Password:'******'Profile picture:'), load_button)
self.formGroupBox.setLayout(layout)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
self.image_label = QLabel()
group_image_buttons = self.init_image_buttons()
self.image_label.setBackgroundRole(QPalette.Dark)
self.image_label.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.image_label.setScaledContents(True)
self.scroll_area = QScrollArea()
self.scroll_area.setBackgroundRole(QPalette.Dark)
self.scroll_area.setWidget(self.image_label)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.formGroupBox)
mainLayout.addWidget(group_image_buttons)
mainLayout.addWidget(self.scroll_area)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.init_image_buttons()
app_icon = QIcon(os.path.join(IMAGES_PATH, 'id-card-4.png'))
self.setWindowTitle('Profile')
self.setWindowIcon(app_icon)
self.move(300, 200)
def init_image_buttons(self):
groupBox = QGroupBox('Image tools')
push_bw = QPushButton('Black and White')
push_inv = QPushButton('Inverted')
push_gray = QPushButton('Grayscale')
push_scale = QPushButton('Resize')
gray_icon = QIcon(os.path.join(IMAGES_PATH, 'picture-gray.png'))
bw_icon = QIcon(os.path.join(IMAGES_PATH, 'picture_bw.png'))
inv_icon = QIcon(os.path.join(IMAGES_PATH, 'picture_inv.png'))
scale_icon = QIcon(os.path.join(IMAGES_PATH, '020 - scale.png'))
push_bw.setIcon(bw_icon)
push_gray.setIcon(gray_icon)
push_inv.setIcon(inv_icon)
push_scale.setIcon(scale_icon)
vbox = QHBoxLayout()
vbox.addWidget(push_bw)
vbox.addWidget(push_inv)
vbox.addWidget(push_gray)
vbox.addWidget(push_scale)
vbox.addStretch(1)
groupBox.setLayout(vbox)
push_bw.clicked.connect(self.set_bw)
push_inv.clicked.connect(self.set_inverted)
push_gray.clicked.connect(self.set_gray)
push_scale.clicked.connect(self.scale)
return groupBox
def enable_actions(self, state):
pass
# for action in self.toolbar.actions():
# action.setEnabled(state)
def dialog_open(self):
fname = QFileDialog.getOpenFileName(
self, 'Open file', os.path.expanduser(''),
'Images (*.png *.xpm *.jpg);;All files (*.*)')[0]
if fname:
print(fname)
if os.path.isfile(fname):
self.pixmap = QPixmap(fname)
self.currentImage = fname
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
self.enable_actions(True)
def dialog_save(self):
fname = QFileDialog.getSaveFileName(
self, 'Save as', os.path.expanduser(''),
'Images (*.png *.xpm *.jpg);;All files (*.*)')[0]
if fname:
self.statusBar().showMessage('Saved file as: {}'.format(fname))
print(fname)
self.pixmap.save(fname)
self.currentImage = fname
def adjust_size(self):
self.image_label.adjustSize()
self.resize(self.image_label.width() + 30,
self.image_label.height() + 210)
def crop(self):
if os.path.isfile(self.currentImage):
self.pixmap = ImageEditor(self.currentImage).crop()
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
def scale(self):
if os.path.isfile(self.currentImage):
items = ('0.5', '0.7', '1.5')
item, okPressed = QInputDialog.getItem(self, 'Resize image',
'Scale factor:', items, 0,
False)
if okPressed and item:
print(item)
self.pixmap = ImageEditor(self.currentImage).resize(item)
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
def set_bw(self):
if os.path.isfile(self.currentImage):
self.pixmap = ImageEditor(self.currentImage).bw()
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
def set_bw2(self):
if os.path.isfile(self.currentImage):
self.pixmap = ImageEditor(self.currentImage).bw2()
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
def set_inverted(self):
if os.path.isfile(self.currentImage):
self.pixmap = ImageEditor(self.currentImage).inverted()
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
def set_sepia(self):
if os.path.isfile(self.currentImage):
self.pixmap = ImageEditor(self.currentImage).sepia()
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
def set_original(self):
if os.path.isfile(self.currentImage):
self.pixmap = QPixmap(self.currentImage)
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
def set_gray(self):
if os.path.isfile(self.currentImage):
self.pixmap = ImageEditor(self.currentImage).gray()
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
def set_gray(self):
if os.path.isfile(self.currentImage):
self.pixmap = ImageEditor(self.currentImage).gray()
self.image_label.setPixmap(self.pixmap)
self.adjust_size()
