class ImageViewer(QGraphicsView):
click = pyqtSignal(QPoint)
def __init__(self, parent):
super(ImageViewer, self).__init__(parent)
self.zoom = 0
self.empty = True
self.scene = QGraphicsScene(self)
self.photo = QGraphicsPixmapItem()
self.scale_factor = 0
self.scene.addItem(self.photo)
self.setScene(self.scene)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QGraphicsView.AnchorUnderMouse)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setBackgroundBrush(QBrush(QColor(30, 30, 30)))
self.setFrameShape(QFrame.NoFrame)
def set_photo(self, img_fp=None):
pix_map = QPixmap(img_fp)
self.zoom = 0
if pix_map and not pix_map.isNull():
self.empty = False
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.photo.setPixmap(pix_map)
else:
self.empty = True
self.setDragMode(QGraphicsView.NoDrag)
self.photo.setPixmap(QPixmap())
self.fitInView()
def set_drag_mode(self, drag_mode):
if not self.photo.pixmap().isNull():
if drag_mode == 0:
self.setDragMode(QGraphicsView.NoDrag)
elif drag_mode == 1:
self.setDragMode(QGraphicsView.ScrollHandDrag)
else:
raise ValueError(drag_mode + ' is not a valid drag_mode')
def fitInView(self, scale=True):
rect = QRectF(self.photo.pixmap().rect())
if not rect.isNull():
self.setSceneRect(rect)
if not self.empty:
unity = self.transform().mapRect(QRectF(0, 0, 1, 1))
self.scale(1 / unity.width(), 1 / unity.height())
view_rect = self.viewport().rect()
scene_rect = self.transform().mapRect(rect)
self.scale_factor = min(
view_rect.width() / scene_rect.width(),
view_rect.height() / scene_rect.height())
self.scale(self.scale_factor, self.scale_factor)
self.zoom = 0
def wheelEvent(self, event):
if not self.empty:
if event.angleDelta().y() > 0:
self.scale_factor = 1.25
self.zoom += 1
else:
self.scale_factor = 0.8
self.zoom -= 1
if self.zoom > 0:
self.scale(self.scale_factor, self.scale_factor)
elif self.zoom == 0:
self.fitInView()
else:
self.zoom = 0
def mousePressEvent(self, event):
if self.photo.isUnderMouse():
self.click.emit(QPoint(event.pos()))
super(ImageViewer, self).mousePressEvent(event)
class ImageViewer(QGraphicsView):
image_clicked = pyqtSignal(QPointF)
def __init__(self):
super(ImageViewer, self).__init__()
self._zoom = 0
self._empty = True
self.scene = QGraphicsScene(self)
self._image = QGraphicsPixmapItem()
self._mouse_button = None
self.view_holder = None
self.scene.addItem(self._image)
self.setScene(self.scene)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QGraphicsView.AnchorUnderMouse)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setBackgroundBrush(QBrush(QColor(30, 30, 30)))
self.setFrameShape(QFrame.NoFrame)
def has_image(self):
return not self._empty
def fitInView(self, scale=True, **kwargs):
rect = QRectF(self._image.pixmap().rect())
if not rect.isNull():
self.setSceneRect(rect)
if self.has_image():
unity = self.transform().mapRect(QRectF(0, 0, 1, 1))
self.scale(1 / unity.width(), 1 / unity.height())
view_rect = self.viewport().rect()
scene_rect = self.transform().mapRect(rect)
factor = min(view_rect.width() / scene_rect.width(),
view_rect.height() / scene_rect.height())
self.scale(factor, factor)
# Reset the view holder to None
self.view_holder = None
self._zoom = 0
def set_image(self, pixmap=None):
if pixmap and not pixmap.isNull():
self._empty = False
self._image.setPixmap(pixmap)
else:
self._empty = True
self.setDragMode(QGraphicsView.NoDrag)
self._image.setPixmap(QPixmap())
if not self.view_holder:
self.fitInView()
else:
view_rect = self.viewport().rect()
scene_rect = self.transform().mapRect(self.view_holder)
factor = min(view_rect.width() / scene_rect.width(),
view_rect.height() / scene_rect.height())
self.scale(factor, factor)
def wheelEvent(self, event: QWheelEvent):
if self.has_image():
if event.angleDelta().y() > 0:
factor = 1.25
self._zoom += 1
else:
factor = 0.8
self._zoom -= 1
if self._zoom > 0:
self.scale(factor, factor)
elif self._zoom == 0:
self.fitInView()
else:
self._zoom = 0
self.view_holder = QRectF(self.mapToScene(0, 0),
self.mapToScene(self.width(), self.height()))
def toggle_drag(self):
if self.dragMode() == QGraphicsView.ScrollHandDrag:
self.setDragMode(QGraphicsView.NoDrag)
elif not self._image.pixmap().isNull():
self.setDragMode(QGraphicsView.ScrollHandDrag)
def mousePressEvent(self, event: QMouseEvent):
# 1 -> Left-click
# 2 -> Right-click
# 4 -> Wheel-click
self._mouse_button = event.button()
if event.button() == Qt.RightButton:
self.toggle_drag()
if self._image.isUnderMouse() and event.button() == Qt.LeftButton \
and self.dragMode() == QGraphicsView.NoDrag:
point = self.mapToScene(event.pos())
log.debug("point %s" % str(point))
self.image_clicked.emit(QPointF(point))
super(ImageViewer, self).mousePressEvent(event)
def mouseReleaseEvent(self, event: QMouseEvent):
# self.setDragMode(QtWidgets.QGraphicsView.NoDrag)
super(ImageViewer, self).mouseReleaseEvent(event)
class ImageViewer(QGraphicsView):
photoClicked = pyqtSignal(QPoint)
def __init__(self, parent):
super(ImageViewer, self).__init__(parent)
self._zoom = 0
self._empty = True
self._scene = QGraphicsScene(self)
self._photo = QGraphicsPixmapItem()
self._scene.addItem(self._photo)
self.setScene(self._scene)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QGraphicsView.AnchorUnderMouse)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setBackgroundBrush(QBrush(QColor(30, 30, 30)))
self.setFrameShape(QFrame.NoFrame)
def hasPhoto(self):
return not self._empty
def fitInView(self, scale=True):
rect = QRectF(self._photo.pixmap().rect())
if not rect.isNull():
self.setSceneRect(rect)
if self.hasPhoto():
unity = self.transform().mapRect(QRectF(0, 0, 1, 1))
self.scale(1 / unity.width(), 1 / unity.height())
viewrect = self.viewport().rect()
scenerect = self.transform().mapRect(rect)
factor = min(viewrect.width() / scenerect.width(),
viewrect.height() / scenerect.height())
self.scale(factor, factor)
self._zoom = 0
else:
print('RECT IS NULL')
def setPhoto(self, pixmap=None):
self._zoom = 0
if pixmap and not pixmap.isNull():
self._empty = False
self.setDragMode(QGraphicsView.ScrollHandDrag)
self._photo.setPixmap(pixmap)
else:
self._empty = True
self.setDragMode(QGraphicsView.NoDrag)
self._photo.setPixmap(QPixmap())
self.fitInView()
##### TODO what is this?
def paintOverlayImage(self, pixmap=None):
painter = QPainter()
painter.begin(image)
painter.drawImage(0, 0, overlay)
painter.end()
def wheelEvent(self, event):
if self.hasPhoto():
if event.delta() > 0:
factor = 1.25
self._zoom += 1
else:
factor = 0.8
self._zoom -= 1
if self._zoom > 0:
self.scale(factor, factor)
elif self._zoom == 0:
self.fitInView()
else:
self._zoom = 0
def toggleDragMode(self):
if self.dragMode() == QGraphicsView.ScrollHandDrag:
self.setDragMode(QGraphicsView.NoDrag)
elif not self._photo.pixmap().isNull():
self.setDragMode(QGraphicsView.ScrollHandDrag)
def mousePressEvent(self, event):
if self._photo.isUnderMouse():
self.photoClicked.emit(QPoint(event.pos()))
super(ImageViewer, self).mousePressEvent(event)
class HomographyStimulusWindowWidget(QWidget):
closed = pyqtSignal()
def __init__(self,
camera,
homography_transform,
stimulus_widget,
parent=None):
super().__init__(parent)
self._camera = camera
self._homography_transform = homography_transform
self.homography_points = []
self.stimulus_widget = stimulus_widget
current_directory = os.path.dirname(__file__)
relative_location = '../views/StimulusWindowHomographySetup.ui'
path = os.path.join(current_directory, relative_location)
uic.loadUi(path, self)
self.exposureDoubleSpinBox.device = camera
self.gainDoubleSpinBox.device = camera
self.cameraFrameGraphicsView.setViewport(QOpenGLWidget())
self.camera_scene = self.cameraFrameGraphicsView.scene()
self.camera_display = QGraphicsPixmapItem()
self.camera_scene.addItem(self.camera_display)
self.camera_display.setPos(0, 0)
self.camera_scene.installEventFilter(ClickCapture(self))
self.first_shown = True
# self.setMouseTracking(True)
# self.stimulusWindowRepresentation.cursorScenePositionChanged.connect(self.on_stimulusWindowRepresentation_cursorScenePositionChanged)
#self.cameraFrameGraphicsView.cursorScenePositionChanged.connect(self.on_cameraFrameGraphicsView_cursorScenePositionChanged)
def create_points(self, x, y):
point = StimulusWindowHomographyPoint()
self.camera_scene.addItem(point.camera_square)
point.camera_square.setPos(x, y)
point.stimulus_window_square.setPos(x, y)
self.homography_points.append(point)
self.stimulus_widget.scene().addItem(point.stimulus_window_square)
return point
@pyqtSlot()
def on_clearAllPointsButton_pressed(self):
for point in self.homography_points:
self.camera_scene.removeItem(point.camera_square)
self.stimulus_widget.scene().removeItem(
point.stimulus_window_square)
self.homography_points = []
def closeEvent(self, event):
self._camera.newFrameReceived.disconnect(
self.on_camera_newFrameReceived)
self._camera.stop_acquisition()
self.closed.emit()
@property
def frame_display(self):
return self.cameraFrameDisplayWidget.frameDisplayWidget
# @mock_image('development/image-2018-01-31_15-40-12.PNG')
# @mock_image('development/homography_fix_cam.PNG')
@pyqtSlot(np.ndarray)
def on_camera_newFrameReceived(self, frame):
frame = (frame / 256.0).astype(
np.uint8
) # Note this is for uint16, might have problems for other camera bits
self.camera_display.setPixmap(QPixmap.fromImage(gray2qimage(frame)))
self.update()
@pyqtSlot()
def on_calculateHomographyMatrixButton_pressed(self):
source_centres = []
destination_centres = []
# todo swap below?
for point in self.homography_points:
source_centres.append(
(point.camera_square.pos().x(), point.camera_square.pos().y()))
destination_centres.append(
(point.stimulus_window_square.pos().x(),
point.stimulus_window_square.pos().y()))
log.debug("Source centres: {}".format(source_centres))
log.debug("Destination centres: {}".format(destination_centres))
if len(source_centres) < 3 and len(destination_centres) < 3:
return
# matrix, err = cv2.findHomography(np.array(source_centres),
# np.array(destination_centres))
#log.debug("Stimulus window homography matrix: {}, err: {}".format(matrix, err))
# log.debug("Perspective matrix: {}".format(cv2.getPerspectiveTransform(np.array(destination_centres[:4]),
# np.array(source_centres[:4]))))
matrix = cv2.getAffineTransform(
np.array(source_centres[:3], dtype=np.float32),
np.array(destination_centres[:3], dtype=np.float32))
#log.debug("Affine matrix: {}".format())
self._homography_transform.matrix = matrix
@pyqtSlot(int, int)
def on_cameraFrameGraphicsView_cursorScenePositionChanged(self, x, y):
self.cameraWindowSceneCursorXLabel.setText("{}".format(int(x)))
self.cameraWindowSceneCursorYLabel.setText("{}".format(int(y)))
def on_frame_display_double_click(self, event):
if not self.camera_display.isUnderMouse():
return
point = StimulusWindowHomographyPoint()
self.camera_scene.addItem(point.camera_square)
point.camera_square.setPos(event.scenePos().x(), event.scenePos().y())
point.stimulus_window_square.setPos(event.scenePos().x(),
event.scenePos().y())
self.homography_points.append(point)
self.stimulus_widget.scene().addItem(point.stimulus_window_square)
@pyqtSlot(int, int)
def on_stimulusWindowRepresentation_cursorScenePositionChanged(self, x, y):
self.stimulusWindowSceneCursorXLabel.setText("{}".format(int(x)))
self.stimulusWindowSceneCursorYLabel.setText("{}".format(int(y)))
def showEvent(self, event):
self._camera.newFrameReceived.connect(self.on_camera_newFrameReceived)
self._camera.start_acquisition()
self.stimulusWindowRepresentation.setScene(
self.stimulus_widget.scene())
if self.first_shown:
#self.bug_fix()
self.first_shown = False
def bug_fix(self):
# BUG FIX STUFF
# [[0.00000000e+00 6.66666667e-01 6.16666667e+02]
# [-6.66666667e-01 0.00000000e+00 9.93333333e+02]
# [0.00000000e+00 0.00000000e+00 1.00000000e+00]]
# (791, 922) goes
# to(1231.3333333333335, 466.0000000000001)
# (1063, 365)
# goes
# to(860.0, 284.66666666666663)
# (85, 320)
# goes
# to(830.0, 936.666666666667)
# (696, 950)
# goes
# to(1250.0, 529.3333333333335)
#
# source = (980, 218), (980, 818), (380, 818), (380, 818), (380, 218)
# destination = (760, 340), (1160, 340), (1160, 740), (760, 740)
cam_width = 1360 #self.camera_scene.width()
cam_height = 1036 #self.camera_scene.height()
mid = (cam_width / 2, cam_height / 2)
source_centres = [(mid[0] + 300, mid[1] - 300),
(mid[0] + 300, mid[1] + 300),
(mid[0] - 300, mid[1] + 300),
(mid[0] - 300, mid[1] - 300)]
stimulus_screen_mid = (self.stimulus_widget.width() / 2,
self.stimulus_widget.height() / 2)
destination_centres = [
(stimulus_screen_mid[0] - 200, stimulus_screen_mid[1] - 200),
(stimulus_screen_mid[0] + 200, stimulus_screen_mid[1] - 200),
(stimulus_screen_mid[0] + 200, stimulus_screen_mid[1] + 200),
(stimulus_screen_mid[0] - 200, stimulus_screen_mid[1] + 200)
]
for i, p in enumerate(source_centres):
stimulus_window_homography_point = self.create_points(x=p[0],
y=p[1])
stimulus_window_homography_point.stimulus_window_square.setPos(
destination_centres[i][0], destination_centres[i][1])
class PhotoViewer(QGraphicsView):
# 分别传递鼠标点击，移动，松开信号
mouse_clicked = pyqtSignal(QPoint)
mouse_moved = pyqtSignal(QPoint)
mouse_released = pyqtSignal(QPoint)
def __init__(self, parent):
super(PhotoViewer, self).__init__(parent)
self.init_UI()
def init_UI(self):
self._zoom = 0 # 定义图片的放大级别
self._empty = True # 定义是否含有图片（点击模式和拖动模式切换）
self._contour = False # 定义轮廓拖动模式 0
self._ocr = False # 定义文字识别模式
self._scene = QGraphicsScene(self) # 新建一个场景
self._photo = QGraphicsPixmapItem() # 新建一个图像图元
self._scene.addItem(self._photo) # 图像图元添加到场景中
self.setScene(self._scene) # 场景添加到视图中
self.setTransformationAnchor(
QGraphicsView.AnchorUnderMouse) # 坐标转换时以鼠标所在位置为中心
self.setResizeAnchor(
QGraphicsView.AnchorUnderMouse) # 视图大小调整时该如何定位其中的场景
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) # 垂直滚动条关闭
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) # 平行滚动条关闭
self.setBackgroundBrush(QBrush(QColor(30, 30, 30))) # 背景色
self.setFrameShape(QFrame.NoFrame) # 设置QFrame在它的内容周围画一个框
def hasPhoto(self):
# 是否加载图片
return not self._empty
def fitInView(self, scale=True):
# 图片自适应函数，缩放模式开启
rect = QRectF(self._photo.pixmap().rect()) # 绘制图元大小的矩形
if not rect.isNull():
self.setSceneRect(rect) # 这个矩形限定了场景的范围
if self.hasPhoto():
unity = self.transform().mapRect(QRectF(0, 0, 1, 1))
self.scale(1 / unity.width(), 1 / unity.height())
viewrect = self.viewport().rect()
scenerect = self.transform().mapRect(rect)
factor = min(viewrect.width() / scenerect.width(),
viewrect.height() / scenerect.height())
self.scale(factor, factor)
self._zoom = 0
def setPhoto(self, pixmap=None):
# 加载和重新渲染图元
# self._zoom = 0 # 重新渲染的时候保持放大比例，并不初始化为_zoom为0
if pixmap and not pixmap.isNull():
self._empty = False
self.setDragMode(QGraphicsView.ScrollHandDrag)
self._photo.setPixmap(pixmap)
else:
self._empty = True
self.setDragMode(QGraphicsView.NoDrag)
self._photo.setPixmap(QPixmap())
# 是否从新适应
# self.fitInView()
def wheelEvent(self, event):
# 鼠标滚轮控制放大缩小
if self.hasPhoto():
if event.angleDelta().y() > 0:
factor = 1.25
self._zoom += 1
else:
factor = 0.8
self._zoom -= 1
if self._zoom > 0:
self.scale(factor, factor)
elif self._zoom == 0:
self.fitInView()
else:
self._zoom = 0
def toggleDragMode(self):
# 鼠标拖动和点击及切换函数
if self._contour or self._ocr:
self.setDragMode(QGraphicsView.NoDrag)
else:
if self.dragMode() == QGraphicsView.ScrollHandDrag:
self.setDragMode(QGraphicsView.NoDrag)
elif not self._photo.pixmap().isNull():
self.setDragMode(QGraphicsView.ScrollHandDrag)
def mousePressEvent(self, event):
# 鼠标点击返回鼠标所在的图片坐标
if self._photo.isUnderMouse():
# 注意坐标系转换 详解http://blog.51cto.com/9291927/1879128
p = self._photo.mapToItem(self._photo,
self.mapToScene(event.pos()))
self.mouse_clicked.emit(p.toPoint())
super(PhotoViewer, self).mousePressEvent(event)
def mouseMoveEvent(self, event):
if self._ocr == True: # 只有当文字识别的时候实时返回拖动的鼠标的坐标
if self._photo.isUnderMouse():
p = self._photo.mapToItem(self._photo,
self.mapToScene(event.pos()))
self.mouse_moved.emit(p.toPoint())
super(PhotoViewer, self).mouseMoveEvent(event)
def mouseReleaseEvent(self, event):
# 获取鼠标松开的坐标点
if self._photo.isUnderMouse():
p = self._photo.mapToItem(self._photo,
self.mapToScene(event.pos()))
self.mouse_released.emit(p.toPoint())
super(PhotoViewer, self).mouseReleaseEvent(event)
class ConfigWindow(QWidget):
def __init__(self, parent=None):
super().__init__()
self.ui = uic.loadUi("configform.ui", self)
#self.ui = Ui_Form()
#self.ui.setupUi(self)
self.parent = parent
self.ui.brigthnesSlider.valueChanged.connect(self.brigthnesSlot)
self.ui.contrastSlider.valueChanged.connect(self.contrastSlot)
self.ui.brigthnessLcd.valueChanged.connect(self.setBrightSlider)
self.ui.contrastLcd.valueChanged.connect(self.setContastSlider)
self.ui.colorSlider.valueChanged.connect(self.colorSlot)
self.ui.sharpnessSlider.valueChanged.connect(self.sharpnessSlot)
self.ui.colorLcd.valueChanged.connect(self.setColorSlider)
self.ui.sharpnessLcd.valueChanged.connect(self.setSharpnessSlider)
self.ui.checkCrop.stateChanged.connect(self.setCrop)
self.rubberBand = RubberBand(self.ui.view)
#self.rubberBand.setMaximumSize(QSize(397,552))
self.ui.view.setRubberBandSelectionMode(Qt.IntersectsItemBoundingRect)
self.ui.view.rubberBandChanged.connect(self.getCropRect)
self.rubberBand.cropSignal.connect(self.crop)
self.rubberBand.sizeSignal.connect(self.setSize)
self.rubberBand.hide()
self.scene = GraphicsScene(self)
self.pixmap = QPixmap()
self.pixmapItem = QGraphicsPixmapItem()
self.scene.addItem(self.pixmapItem)
self.ui.view.setScene(self.scene)
#self.ui.view.fitInView(self.pixmapItem,Qt.KeepAspectRatio)
#self.pixmap.load("Calibrate_Test_1.png")
#self.buffer = QBuffer()
self.pilBufferPath = "/tmp/scan2foldertempimg.png"
self.pilBufferImg = Image.new('RGBA', (1, 1))
self.bright = self.ui.brigthnesSlider.maximum() / 2
self.contast = self.ui.contrastSlider.maximum() / 2
self.imageTypes = ['png', 'jpg', 'tiff', 'tif']
@pyqtSlot(int)
def colorSlot(self, value):
val = value / 10
self.ui.colorLcd.blockSignals(True)
self.ui.colorLcd.setValue(val)
self.ui.colorLcd.blockSignals(False)
color = self.ui.colorSlider.value() / 10
#self.enhanceImage(None, None,color,None)
self.enhanceImage()
@pyqtSlot(int)
def sharpnessSlot(self, value):
val = value / 10
self.ui.sharpnessLcd.blockSignals(True)
self.ui.sharpnessLcd.setValue(val)
self.ui.sharpnessLcd.blockSignals(False)
sharp = self.ui.sharpnessSlider.value() / 10
#self.enhanceImage(None, None,None,sharp)
self.enhanceImage()
@pyqtSlot(float)
def setSharpnessSlider(self, val):
value = val * 10
self.ui.sharpnessSlider.blockSignals(True)
self.ui.sharpnessSlider.setValue(int(value))
self.ui.sharpnessSlider.blockSignals(False)
self.ui.sharpnessSlider.valueChanged.emit(int(value))
@pyqtSlot(float)
def setColorSlider(self, val):
value = val * 10
self.ui.colorSlider.blockSignals(True)
self.ui.colorSlider.setValue(int(value))
self.ui.colorSlider.blockSignals(False)
self.ui.colorSlider.valueChanged.emit(int(value))
@pyqtSlot(int)
def brigthnesSlot(self, int):
val = int / 10
self.ui.brigthnessLcd.blockSignals(True)
self.ui.brigthnessLcd.setValue(val)
self.ui.brigthnessLcd.blockSignals(False)
contrast = self.ui.contrastSlider.value() / 10
#self.enhanceImage(None,contrast,None,None)
self.enhanceImage()
@pyqtSlot(int)
def contrastSlot(self, int):
val = int / 10
self.ui.contrastLcd.blockSignals(True)
self.ui.contrastLcd.setValue(val)
self.ui.contrastLcd.blockSignals(False)
bright = self.ui.brigthnesSlider.value() / 10
#self.enhanceImage(bright,None,None,None)
self.enhanceImage()
@pyqtSlot(float)
def setBrightSlider(self, val):
value = val * 10
self.ui.brigthnesSlider.blockSignals(True)
self.ui.brigthnesSlider.setValue(int(value))
self.ui.brigthnesSlider.blockSignals(False)
self.ui.brigthnesSlider.valueChanged.emit(int(value))
@pyqtSlot(float)
def setContastSlider(self, val):
value = val * 10
self.ui.contrastSlider.blockSignals(True)
self.ui.contrastSlider.setValue(int(value))
self.ui.contrastSlider.blockSignals(False)
self.ui.contrastSlider.valueChanged.emit(int(value))
@pyqtSlot(QRect, QPointF, QPointF)
def getCropRect(self, rect, start, end):
pass
if self.ui.checkCrop.isChecked():
self.rubberBand.show()
srect = self.ui.view.mapToScene(rect).boundingRect().toRect()
#print(srect)
if rect.isEmpty():
self.rubberBand.show()
else:
self.rubberBand.setGeometry(rect)
@pyqtSlot()
def crop(self):
pass
self.parent.cropSize["left"] = self.ui.cropX.value()
self.parent.cropSize["top"] = self.ui.cropY.value()
self.parent.cropSize["width"] = self.ui.cropW.value()
self.parent.cropSize["height"] = self.ui.cropH.value()
self.rubberBand.hide()
@pyqtSlot()
def setCrop(self):
pass
## ensure that RubberBandDrag dragmode is set
## if not rubberBand will not work correctly
self.ui.view.setDragMode(QGraphicsView.RubberBandDrag)
@pyqtSlot(QRect)
def setSize(self, rect):
## this the offset to subtract from srect
offset = 13
srect = self.ui.view.mapToScene(rect).boundingRect().toRect()
self.ui.cropX.setValue(srect.x() - offset)
self.ui.cropY.setValue(srect.y() - offset)
self.ui.cropH.setValue(srect.height() + -(offset * 2))
self.ui.cropW.setValue(srect.width() - (offset * 2))
pass
def enhanceImage(self):
cont = self.ui.contrastSlider.value() / 10
sharp = self.ui.sharpnessSlider.value() / 10
bright = self.ui.brigthnesSlider.value() / 10
color = self.ui.colorSlider.value() / 10
pilImg = self.pilBufferImg
brightness = ImageEnhance.Brightness(pilImg)
pilImg = brightness.enhance(bright)
contrast = ImageEnhance.Contrast(pilImg)
pilImg = contrast.enhance(cont)
colour = ImageEnhance.Color(pilImg)
pilImg = colour.enhance(color)
sharpness = ImageEnhance.Sharpness(pilImg)
pilImg = sharpness.enhance(sharp)
self.pixmapItem.setPixmap(
self.pixmap.fromImage(ImageQt.ImageQt(pilImg.convert('RGBA'))))
def setBufferImage(self):
img = self.pixmapItem.pixmap()
#self.buffer.open(QBuffer.ReadWrite)
#img.save(self.buffer,"PNG")
img.save(self.pilBufferPath, "PNG")
self.pilBufferImg = Image.open(self.pilBufferPath)
#self.buffer.close()
def wheelEvent(self, event):
point = event.position()
degrees = event.angleDelta() / 8
self.pixmapItemScale = self.pixmapItem.scale()
if self.pixmapItem.isUnderMouse():
if degrees.y() / 15 > 0:
#self.ui.view.scale(1.25, 1.25)
self.pixmapItem.setScale(self.pixmapItemScale + 0.01)
else:
#self.ui.view.scale(0.8, 0.8)
if self.pixmapItemScale > 0.15:
self.pixmapItem.setScale(self.pixmapItemScale - 0.01)
def closeEvent(self, event):
self.scene.clear()
event.accept()
