def run(self):
image = QImage()
image.load(str(self.filename))
mask = QImage(image.size(), QImage.Format_RGB32)
mask.fill(Qt.black)
maskfile = self.filename.parent / (self.filename.stem + ".mask")
if maskfile.exists():
bitmap = QImage(str(maskfile))
if bitmap.size() != image.size():
raise Exception("Mask %s doesn't match image size" % maskfile)
mask.fill(QColor.fromRgbF(1.0, 0.0, 1.0))
p = QPainter(mask)
p.setCompositionMode(QPainter.CompositionMode_Multiply)
p.drawImage(mask.rect(), bitmap)
p.end()
self.view.imagefile = self.filename
self.view.image = image
self.view.mask = mask
self.view.maskfile = maskfile
self.view.path = list()
self.view.changed = False
self.view.update()
class ImageViewFrame(QFrame):
def __init__(self, image, parent=None):
super(ImageViewFrame, self).__init__(parent)
self.image = image
self.qimage = None
self.lock = Lock()
@Slot()
def displayImage(self):
if self.lock.acquire(False):
if self.image[0] is not None:
image = self.image[0].copy()
cv2.cvtColor(image, cv2.COLOR_BGR2RGB, image)
height, width, _ = image.shape
self.qimage = QImage(image, width, height, image.strides[0],
QImage.Format_RGB888)
self.resizeAspectRatio(self.contentsRect().size())
self.lock.release()
self.update()
self.repaint()
else:
print('image_view_widget: acquiring lock failed')
self.update()
def resizeAspectRatio(self, size):
try:
width = self.qimage.size().width()
height = self.qimage.size().height()
ratio = height / width
if self.contentsRect().size().height() / self.contentsRect().size(
).width() > ratio:
event_width = size.width()
self.resize(event_width, event_width * ratio)
else:
event_height = size.height()
self.resize(event_height / ratio, event_height)
except ZeroDivisionError as zde:
pass
def paintEvent(self, event):
painter = QPainter(self)
painter.drawImage(self.contentsRect(), self.qimage)
def resizeEvent(self, event):
if self.qimage is not None:
self.resizeAspectRatio(event.size())
class ImageWidget(QLabel):
def __init__(self, parent=None):
super(ImageWidget, self).__init__(parent)
self.image = QImage()
def set_image(self, image):
self.image = image
self.resize(self.image.size())
pixmap = QPixmap.fromImage(self.image)
self.setPixmap(pixmap)
def openImage(self, fileName):
loadedImage = QImage()
if not loadedImage.load(fileName):
return False
newSize = loadedImage.size().expandedTo(self.size())
self.resizeImage(loadedImage, newSize)
self.image = loadedImage
self.modified = False
self.update()
return True
def _read_image(self, path: Path) -> Optional[QImage]:
data = self._read_file(path)
if data:
image = QImage()
image.loadFromData(data, path.suffix[1:])
max_size = QSize(600, 400)
image_size = image.size()
if image_size.width() > max_size.width() or image_size.height(
) > max_size.height():
image = image.scaled(max_size,
Qt.AspectRatioMode.KeepAspectRatio)
return image
class QMoon(QWidget):
"""Small widget displays today's moon."""
def __init__(self,
pos=(0, 0),
parent=None,
size=216,
web=False,
save=False,
debug=0):
super(QMoon, self).__init__(parent)
self.total_images = 8760
self.moon_domain = "https://svs.gsfc.nasa.gov"
self.moon_path_2021 = "/vis/a000000/a004800/a004874/"
# https://svs.gsfc.nasa.gov/vis/a000000/a004900/a004955/frames/216x216_1x1_30p/moon.8597.jpg
self.moon_path = "/vis/a000000/a004900/a004955/"
self.debug = debug
self.size = size
self.get_from_web = web
self.save = save
# self.setGeometry(pos[0], pos[1], self.size, self.size)
self.moon = QLabel(self)
self.moon.setGeometry(pos[0], pos[1], self.size, self.size)
self.update()
self.timer = QTimer(self)
self.timer.timeout.connect(self.update)
self.timer.start(3600 * 1000)
self.image = None
self.pixmap = None
self.moon_image_number = 1
@Slot()
def update(self):
if self.debug > 0:
print("Updating the Moon Phase pixmap.")
self.pixmap = self.get_moon_image()
self.moon.setPixmap(self.pixmap)
def get_moon_image_number(self):
#
# Conversion from the jscript.
#
now = datetime.utcnow()
janone = datetime(now.year, 1, 1, 0, 0, 0)
self.moon_image_number = round(
(datetime.utcnow() - janone).total_seconds() / 3600)
return self.moon_image_number <= self.total_images
def get_moon_image(self):
if not self.get_moon_image_number():
print("Could not get the moon. Are we in a new year?")
if self.debug:
print(f"We are using moon image number: {self.moon_image_number}")
if self.size > 500 or self.get_from_web:
if self.size > 2160:
url = self.moon_domain+self.moon_path+"/frames/5760x3240_16x9_30p/" \
f"plain/moon.{self.moon_image_number:04d}.tif"
elif self.size > 216:
url = self.moon_domain+self.moon_path+"/frames/3840x2160_16x9_30p/" \
f"plain/moon.{self.moon_image_number:04d}.tif"
else:
url = self.moon_domain + self.moon_path + "/frames/216x216_1x1_30p/" \
f"moon.{self.moon_image_number:04d}.jpg"
if self.debug:
print(f"Getting image from url: {url}")
req = requests.get(url)
self.image = QImage()
self.image.loadFromData(req.content, "tiff")
size = self.image.size()
if self.debug:
print("Image size: ", size)
if self.save:
self.image.save(f"moon/moon.{self.moon_image_number:04d}.tiff")
offset = (size.width() - size.height()) / 2
rect = QRect(offset, 0, size.height(), size.height())
self.image = self.image.copy(rect)
pix = QPixmap.fromImage(self.image)
pix = pix.scaled(self.size, self.size, Qt.IgnoreAspectRatio,
Qt.SmoothTransformation)
return pix
else:
moon_file = f"moon/moon.{self.moon_image_number:04d}.jpg"
pix = QPixmap(moon_file)
pix = pix.scaled(self.size, self.size, Qt.IgnoreAspectRatio,
Qt.SmoothTransformation)
return pix
class View(QWidget):
previous = Signal()
next = Signal()
def __init__(self, window):
super(View, self).__init__(window)
self.setFocusPolicy(Qt.StrongFocus)
self.shiftKey = False
self.ctrlKey = False
self.lastMousePos = QPoint()
self.lastTabletPos = QPoint()
self.mode = 'add'
self.maskOnly = False
self.refresh = QTimer(self)
self.refresh.setSingleShot(True)
self.refresh.timeout.connect(self.repaint)
self.addCursor = makeCursor('images/cursor-add.png',
QColor.fromRgbF(0.5, 0.5, 1.0))
self.delCursor = makeCursor('images/cursor-del.png',
QColor.fromRgbF(1.0, 0.5, 0.5))
self.setCursor(self.addCursor)
self.imagefile = None
self.maskfile = None
self.image = QImage()
self.mask = QImage(self.image.size(), QImage.Format_RGB32)
self.mask.fill(Qt.black)
self.changed = False
self.update()
self.path = list()
self.load_threads = QThreadPool()
self.load_threads.setMaxThreadCount(4)
def load(self, filename):
self.load_threads.start(LoadTask(self, filename))
def save(self):
if self.maskfile and self.changed:
self.load_threads.waitForDone()
if self.maskfile and self.changed:
bitmap = self.mask.createMaskFromColor(
QColor.fromRgbF(1.0, 0.0, 1.0).rgb())
bitmap.save(str(self.maskfile), "PNG")
self.changed = False
def update(self):
widgetRatio = self.width() / self.height()
aspectRatio = self.image.width() / max(1, self.image.height())
if aspectRatio >= widgetRatio:
width = self.width()
height = self.width() / aspectRatio
else:
width = self.height() * aspectRatio
height = self.height()
self.rc = QRectF((self.width() - width) / 2.0,
(self.height() - height) / 2.0, width, height)
self.repaint()
def resizeEvent(self, event):
self.update()
def paintEvent(self, event):
p = QPainter(self.mask)
for (mode, p1, p2, weight) in self.path:
if mode == 'add':
p.setPen(
QPen(QColor.fromRgbF(1.0, 0.0, 1.0), (weight * 10.0)**2,
Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
else:
p.setPen(
QPen(QColor.fromRgbF(0.0, 0.0, 0.0), (weight * 10.0)**2,
Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
p.drawLine(realCoords(p1, self.mask.rect()),
realCoords(p2, self.mask.rect()))
self.changed = True
self.path = list()
p.end()
p = QPainter(self)
p.setCompositionMode(QPainter.CompositionMode_SourceOver)
if not self.maskOnly:
p.drawImage(self.rc, self.image)
p.setCompositionMode(QPainter.CompositionMode_Plus)
p.drawImage(self.rc, self.mask)
p.end()
def closeEvent(self, event):
self.refresh.stop()
event.accept()
def enterEvent(self, event):
self.setFocus(Qt.OtherFocusReason)
def keyPressEvent(self, event):
k = event.key()
if k == Qt.Key_Shift:
self.shiftKey = True
if k == Qt.Key_Control:
self.ctrlKey = True
if k == Qt.Key_Space:
self.maskOnly = not self.maskOnly
self.repaint()
def keyReleaseEvent(self, event):
k = event.key()
mod = event.modifiers()
if k == Qt.Key_Shift:
self.shiftKey = False
if k == Qt.Key_Control:
self.ctrlKey = False
def mousePressEvent(self, event):
x = event.x()
y = event.y()
self.lastMousePos = event.pos()
if event.button() == Qt.ExtraButton1:
if self.mode == 'add':
self.mode = 'del'
self.setCursor(self.delCursor)
else:
self.mode = 'add'
self.setCursor(self.addCursor)
elif event.button() == Qt.ExtraButton2:
self.maskOnly = not self.maskOnly
self.repaint()
elif event.button() == Qt.ExtraButton3:
self.previous.emit()
elif event.button() == Qt.ExtraButton4:
self.next.emit()
def mouseMoveEvent(self, event):
x = event.x()
y = event.y()
dx = x - self.lastMousePos.x()
dy = y - self.lastMousePos.y()
self.lastMousePos = event.pos()
# if event.buttons() & Qt.LeftButton:
# elif event.buttons() & Qt.MiddleButton:
# elif event.buttons() & Qt.RightButton:
def wheelEvent(self, event):
dx = event.angleDelta().x() / 8
dy = event.angleDelta().y() / 8
# self.cameraZoom.emit(dy / 15)
def tabletEvent(self, event):
if event.device() == QTabletEvent.Stylus and event.pointerType(
) == QTabletEvent.Pen:
if event.type() == QEvent.TabletPress:
self.tabletPressEvent(event)
elif event.type() == QEvent.TabletRelease:
self.tabletReleaseEvent(event)
elif event.type() == QEvent.TabletMove:
if event.pressure() > 0.0:
self.tabletMoveEvent(event)
else:
print('tabletEvent', event.device(), event.type(),
event.pointerType())
else:
print('tabletEvent', event.device(), event.type(),
event.pointerType())
def tabletPressEvent(self, event):
if event.buttons() & Qt.LeftButton:
self.lastTabletPos = normalizeCoords(event.posF(), self.rc)
if event.buttons() & Qt.MiddleButton:
if self.mode == 'add':
self.mode = 'del'
self.setCursor(self.delCursor)
else:
self.mode = 'add'
self.setCursor(self.addCursor)
if event.buttons() & Qt.RightButton:
self.next.emit()
def tabletReleaseEvent(self, event):
self.lastTabletPos = normalizeCoords(event.posF(), self.rc)
def tabletMoveEvent(self, event):
self.path.append((self.mode, self.lastTabletPos,
normalizeCoords(event.posF(),
self.rc), event.pressure()))
self.lastTabletPos = normalizeCoords(event.posF(), self.rc)
if not self.refresh.isActive():
self.refresh.start(50)
class ScribbleArea(QWidget):
def __init__(self, parent=None):
super(ScribbleArea, self).__init__(parent)
self.myPenColors = [
QColor("green"),
QColor("purple"),
QColor("red"),
QColor("blue"),
QColor("yellow"),
QColor("pink"),
QColor("orange"),
QColor("brown"),
QColor("grey"),
QColor("black")
]
self.setAttribute(Qt.WA_AcceptTouchEvents)
self.setAttribute(Qt.WA_StaticContents)
self.image = QImage()
self.modified = False
def s_print(self):
pass
def clearImage(self):
self.image.fill(qRgb(255, 255, 255))
self.modified = True
self.update()
def openImage(self, fileName):
loadedImage = QImage()
if not loadedImage.load(fileName):
return False
newSize = loadedImage.size().expandedTo(self.size())
self.resizeImage(loadedImage, newSize)
self.image = loadedImage
self.modified = False
self.update()
return True
def saveImage(self, fileName, fileFormat):
visibleImage = self.image.copy()
self.resizeImage(visibleImage, self.size())
if visibleImage.save(fileName, fileFormat):
self.modified = False
return True
else:
return False
def paintEvent(self, event):
painter = QPainter(self)
rect = event.rect()
painter.drawImage(rect.topLeft(), self.image, rect)
def resizeEvent(self, event):
if self.width() > self.image.width() or self.height(
) > self.image.height():
newWidth = max(self.width() + 128, self.image.width())
newHeight = max(self.height() + 128, self.image.height())
self.resizeImage(self.image, QSize(newWidth, newHeight))
self.update()
super(ScribbleArea, self).resizeEvent(event)
def resizeImage(self, image, newSize):
if self.image.size() == newSize:
return
newImage = QImage(newSize, QImage.Format_RGB32)
newImage.fill(qRgb(255, 255, 255))
painter = QPainter(newImage)
painter.drawImage(QPoint(0, 0), self.image)
self.image = newImage
#
# def print(self, )
# {
# #ifndef QT_NO_PRINTER:
# QPrinter printer(QPrinter.HighResolution)
#
# QPrintDialog *printDialog = new QPrintDialog(&printer, this)
# if (printDialog.exec() == QDialog.Accepted) {
# QPainter painter(&printer)
# QRect rect = painter.viewport()
# QSize size = self.image.size()
# size.scale(rect.size(), Qt.KeepAspectRatio)
# painter.setViewport(rect.x(), rect.y(), size.width(), size.height())
# painter.setWindow(self.image.rect())
# painter.drawImage(0, 0, image)
# }
# #endif // QT_NO_PRINTER
# }
#
def event(self, event):
if event.type() == QEvent.TouchBegin or event.type(
) == QEvent.TouchUpdate or event.type() == QEvent.TouchEnd:
touchPoints = event.touchPoints()
for touchPoint in touchPoints:
if touchPoint.state() == Qt.TouchPointStationary:
continue
else:
rect = touchPoint.rect()
if rect.isEmpty():
diameter = 50 * touchPoint.pressure()
rect.setSize(QSizeF(diameter, diameter))
painter = QPainter(self.image)
painter.setPen(Qt.NoPen)
painter.setBrush(self.myPenColors[touchPoint.id() %
len(self.myPenColors)])
painter.drawEllipse(rect)
painter.end()
self.modified = True
rad = 2
self.update(rect.toRect().adjusted(-rad, -rad, +rad, +rad))
else:
return super(ScribbleArea, self).event(event)
return True
class DisplayWidget(QWidget):
"""
The widget actually displaying the image. It has a scale parameter for setting the scale factor of the drawn
image. The widget is created from the Filter instance. Both are QObjects and both have to run in the main (=GUI)
thread of the QApplication.
"""
def __init__(self, parent=None):
super().__init__(parent=parent)
self._img = QImage(16, 16, QImage.Format_RGB888)
self._scale = 1.0
self._mv = None
def setScale(self, scale):
"""
Set the scale factor
:param scale: a floating point (<1: size reduction)
:return:
"""
self._scale = scale
# check for size constraints
self.checkSize()
# update the displayed image
self.update()
def setData(self, data):
"""
Called when new data arrives. This function converts the numpy array to a QImage which can then be drawn
with a QT painter.
:param data: the image as a numpy array
:return:
"""
img = None
if data.dtype is np.dtype(np.uint8):
# uint8 images can either be 2 dimensional (intensity) or 3 dimensional with 3 channels (rgb)
assert len(data.shape) == 2 or (len(data.shape) == 3
and data.shape[-1] == 3)
# conversion will be performed later in this case
elif data.dtype is np.dtype(np.uint16) and len(data.shape) == 2:
# an uint16 intensity image
self._mv = memoryview(data)
# conversion is done immediately
img = QImage(self._mv, data.shape[1], data.shape[0], data.shape[1],
QImage.Format_Grayscale16)
else:
# all other cases: convert the image to a uint8 array scaling between min and max
mind = np.nanmin(data)
maxd = np.nanmax(data)
data = np.clip(
(data.astype(np.float64) - mind) / (maxd - mind) * 256, 0,
255).astype(np.uint8)
if img is None:
# if not yet done, convert the (uint8) data to a qimage
self._mv = memoryview(data)
img = QImage(
self._mv, data.shape[1], data.shape[0],
np.prod(data.shape[1:]),
QImage.Format_RGB888 if len(data.shape) == 3
and data.shape[-1] == 3 else QImage.Format_Grayscale8)
# save for later painting
self._img = img
# check for size constraints
self.checkSize()
# request QT for an update
self.update()
def checkSize(self):
"""
make sure that the minimum size is consistent with the shown image.
:return:
"""
size = self._img.size() * self._scale
if size != self.minimumSize():
logger.info("Size changed: %s", size)
self.setMinimumSize(size)
self.parent().parent().adjustSize()
def paintEvent(self, paintEvent): # pylint: disable=unused-argument
"""
The paint event actually drawing the image
:param paintEvent: a QPaintEvent instance
:return:
"""
p = QPainter(self)
p.scale(self._scale, self._scale)
p.drawImage(0, 0, self._img)
class PingIndicator(QMainWindow):
def __init__(self, address="8.8.8.8"):
super(PingIndicator, self).__init__()
self.icon = QImage(QSize(packet_amount, indicator_image_height),
QImage.Format_RGBA8888)
self.online = True
self.destination = address
self.packets = deque([], packet_amount)
self.tray_icon = QSystemTrayIcon(self)
self.tray_icon.setToolTip(address)
self.update_timer = QTimer(self)
self.update_timer.setInterval(int(timeout * 1.05))
self.update_timer.timeout.connect(self.update_indicator)
self.update_timer.start()
self.last_time_online = strftime("%H:%M:%S")
self.reset()
def update_icon(self):
self.icon.fill(QColor(0, 0, 0, 0))
painter = QPainter(self.icon)
(width, height) = self.icon.size().toTuple()
width -= 1
height -= 1
painter.fillRect(QRect(0, 0, width, height), QColor(0, 0, 0, 0))
try:
scale = min(1.0 / max(self.packets), min_scale)
except ValueError:
scale = min_scale
for index, ping in enumerate(list(reversed(self.packets))):
x = ping / float(timeout)
color = QColor(
int(-324 * x**2 + 390 * x + 138), # R
int(-480 * x**2 + 254 * x + 226), # G
int(-212 * x**2 + 160 * x + 52), # B
255,
)
scaled_height = ceil(scale * ping * height)
painter.fillRect(
QRect(width - index, height - scaled_height, 1, scaled_height),
color)
self.tray_icon.setIcon(QIcon(QPixmap(self.icon)))
self.tray_icon.show()
def update_indicator(self):
try:
new_env = dict(os.environ)
new_env['LC_ALL'] = 'C'
output = check_output(
[
"ping", "-c", "1", "-W",
str(timeout / 1000), self.destination
],
stderr=STDOUT,
env=new_env,
).decode("ascii") # man ping
for line in output.splitlines():
pos = line.find("time=")
if pos != -1:
new_label = line[pos + 5:-3].center(4)
self.packets.append(round(float(new_label), 2))
if not self.online:
self.online = True
self.tray_icon.contextMenu().actions()[0].setText(
"Last disconnect: " + self.last_time_online)
else:
self.last_time_online = strftime("%H:%M:%S")
break
else:
raise ValueError("No time could be parsed.")
except CalledProcessError as cpe:
self.packets.append(timeout)
if self.online:
self.online = False
self.tray_icon.contextMenu().actions()[0].setText(
"Offline since: " + strftime("%H:%M:%S"))
print(cpe)
except KeyboardInterrupt:
self.close()
self.update_icon()
self.update_menu()
return True
def reset(self):
self.packets.clear()
self.update_icon()
menu = QMenu()
menu.addAction("Online since: " + strftime("%H:%M:%S"))
menu.addAction("Lost: -, Avg: -")
menu.addAction("Max: -, Min: -")
menu.addSeparator()
menu.addAction("Reset").triggered.connect(self.reset)
menu.addAction("Quit").triggered.connect(self.close)
self.tray_icon.setContextMenu(menu)
def update_menu(self):
self.tray_icon.contextMenu().actions()[1].setText(
"Lost: %d, Avg: %dms" %
(self.packets.count(timeout), avg(self.packets)), )
self.tray_icon.contextMenu().actions()[2].setText(
"Max: %dms, Min: %dms" % (max(self.packets), min(self.packets)), )
class MainWindow(QMainWindow):
def __init__(self):
# load setting json file
with open('setting.json') as f:
self.app_setting = json.load(f)
# Status of window
super().__init__()
self.title = 'Image Editor'
self.left = 70
self.top = 70
self.width = 800
self.height = 700
# Status of view image
self.org_qimg = None
self.org_img_width = 0
self.org_img_height = 0
self.layer_pixmap = None
self.layer_width = 0
self.layer_height = 0
self.layer_alpha = 50.0
# Prepare color bar data
self.colormap_gain = self.app_setting["SoftwareSetting"]["process"][
"colormap"]["gain"]
self.colormap_offset_x = self.app_setting["SoftwareSetting"][
"process"]["colormap"]["offset_x"]
self.colormap_offset_green = self.app_setting["SoftwareSetting"][
"process"]["colormap"]["offset_green"]
self.colormap_data = [
colormap.colorBarRGB(x * 0.001, self.colormap_offset_x,
self.colormap_offset_green,
self.colormap_gain) for x in range(1000)
]
self.img_edit_mode = 'cursor'
self.draw_color = QColor(255, 0, 0)
self.draw_tool_size = 5
self.eraser_color = QColor(0, 0, 0, 0)
# setup user interface components
self.setup_ui()
# Setup user interface components
def setup_ui(self):
# Set main window title
self.setWindowTitle(self.title)
# Set main wiodow initial position
self.setGeometry(self.left, self.top, self.width, self.height)
# Set up mainWindow's layout
self.mainWidget = QWidget(self) # Note not to forget this code.
self.main_layout = QVBoxLayout()
# Set menu for main window
self.main_menu = self.menuBar()
self.file_menu = self.main_menu.addMenu('File')
self.edit_menu = self.main_menu.addMenu('Edit')
self.help_menu = self.main_menu.addMenu('Help')
self.main_layout.addWidget(self.main_menu)
# Set "Original Image Open" menu
self.org_img_open_button = QAction(
self.style().standardIcon(getattr(QStyle, 'SP_FileDialogStart')),
'Open Orginal Image', self)
self.org_img_open_button.setShortcut('Ctrl+O')
self.org_img_open_button.triggered.connect(self.open_org_img_dialog)
self.file_menu.addAction(self.org_img_open_button)
# Set "Save layer image" menu
self.layer_img_save_button = QAction(
self.style().standardIcon(getattr(QStyle, 'SP_FileDialogEnd')),
'Save Layer Image', self)
self.layer_img_save_button.setShortcut('Ctrl+S')
self.layer_img_save_button.triggered.connect(self.save_layer_image)
self.file_menu.addAction(self.layer_img_save_button)
# Set "Save compose image(original + layer image)" menu
self.compose_img_save_button = QAction(
self.style().standardIcon(getattr(QStyle, 'SP_FileDialogEnd')),
'Save Compose Image', self)
self.compose_img_save_button.setShortcut('Ctrl+D')
self.compose_img_save_button.triggered.connect(self.save_compose_image)
self.file_menu.addAction(self.compose_img_save_button)
# Set "exit software" menu
self.exit_button = QAction(
self.style().standardIcon(getattr(QStyle, 'SP_DialogCloseButton')),
'Exit', self)
self.exit_button.setShortcut('Ctrl-Q')
self.exit_button.setStatusTip('Exit software')
self.exit_button.triggered.connect(self.close)
self.file_menu.addAction(self.exit_button)
self.upper_layout = QHBoxLayout()
self.main_layout.addLayout(self.upper_layout)
# Set image display area
self.gview_default_size = 500
self.graphics_view = QGraphicsView()
self.graphics_view.setFixedSize(self.gview_default_size,
self.gview_default_size)
self.graphics_view.setObjectName("imageDisplayArea")
self.upper_layout.addWidget(self.graphics_view)
# image display area's contents
self.scene = GraphicsSceneForMainView(self.graphics_view, self)
self.imgs_pixmap = []
self.imgs = []
self.img_status_layout = QVBoxLayout()
self.upper_layout.addLayout(self.img_status_layout)
# Set tranparency value of layer image
self.transparency_title_label = QLabel('layer transparency value')
self.img_status_layout.addWidget(self.transparency_title_label)
transparency = round((1.0 - self.layer_alpha / 255.0) * 100)
self.img_transparency_edit = QLineEdit(str(transparency))
self.img_transparency_sld = QSlider(Qt.Horizontal)
self.img_transparency_sld.setFocusPolicy(Qt.NoFocus)
self.img_transparency_sld.setRange(0, 100)
self.img_transparency_sld.setValue(transparency)
self.transparency_layout = QFormLayout()
self.transparency_layout.addRow(self.img_transparency_sld,
self.img_transparency_edit)
self.img_status_layout.addLayout(self.transparency_layout)
# Signal of transparency value changed
self.img_transparency_sld.valueChanged.connect(
self.transparency_change_sld)
self.img_transparency_edit.textChanged.connect(
self.transparency_change_edit)
self.img_editor_layout = QVBoxLayout()
self.img_status_layout.addLayout(self.img_editor_layout)
# Set layer image editor tool
self.img_editor_tool1_layout = QHBoxLayout()
self.img_editor_layout.addLayout(self.img_editor_tool1_layout)
self.tool_button_size = 64
# Set Mouse cursor
self.mouse_cursor_button = QPushButton()
self.mouse_cursor_button.setIcon(QIcon('icon/cursor.png'))
self.mouse_cursor_button.setCheckable(True)
self.mouse_cursor_button.setIconSize(
QSize(self.tool_button_size, self.tool_button_size))
self.img_editor_tool1_layout.addWidget(self.mouse_cursor_button)
# Set Pen
self.pen_button = QPushButton()
self.pen_button.setIcon(QIcon('icon/pen.png'))
self.pen_button.setCheckable(True)
self.pen_button.setIconSize(
QSize(self.tool_button_size, self.tool_button_size))
self.img_editor_tool1_layout.addWidget(self.pen_button)
# Set Eraser
self.eraser_button = QPushButton()
self.eraser_button.setIcon(QIcon('icon/eraser.png'))
self.eraser_button.setCheckable(True)
self.eraser_button.setIconSize(
QSize(self.tool_button_size, self.tool_button_size))
self.img_editor_tool1_layout.addWidget(self.eraser_button)
# Group button of mouse cursor, pen, eraser
self.img_editor_tool1_group1 = QButtonGroup()
self.img_editor_tool1_group1.addButton(self.mouse_cursor_button, 1)
self.img_editor_tool1_group1.addButton(self.pen_button, 2)
self.img_editor_tool1_group1.addButton(self.eraser_button, 3)
# Set signal-slot of image editor button
self.mouse_cursor_button.toggled.connect(
self.mouse_cursor_button_toggled)
self.pen_button.toggled.connect(self.pen_button_toggled)
self.eraser_button.toggled.connect(self.eraser_button_toggled)
# Set color bar
self.color_bar_width = 64
self.color_bar_height = 256
self.color_bar_view = QGraphicsView()
self.color_bar_view.setFixedSize(self.color_bar_width + 3,
self.color_bar_height + 3)
self.color_bar_scene = GraphicsSceneForTools()
self.color_bar_img = QImage(self.color_bar_width,
self.color_bar_height,
QImage.Format_RGB888)
for i in range(self.color_bar_height):
# Set drawing pen for colormap
ii = round(i * (1000 / 256))
color = QColor(self.colormap_data[ii][0],
self.colormap_data[ii][1],
self.colormap_data[ii][2])
pen = QPen(color, 1, Qt.SolidLine, \
Qt.SquareCap, Qt.RoundJoin)
self.color_bar_scene.addLine(0,
self.color_bar_height - i - 1,
self.color_bar_width,
self.color_bar_height - i - 1,
pen=pen)
for j in range(self.color_bar_width):
self.color_bar_img.setPixelColor(j,
self.color_bar_height - i - 1,
color)
self.color_bar_scene.set_img_content(self.color_bar_img)
self.color_bar_view.setScene(self.color_bar_scene)
# Connect signal to slot of color_bar_scene
self.color_bar_scene.img_info.connect(self.set_selected_color)
self.img_editor_tool1_layout.addWidget(self.color_bar_view)
# Set thickness of Pen or Eraser
self.draw_status_layout = QVBoxLayout()
self.draw_thick_title_label = QLabel('thickness of pen or eraser')
self.draw_status_layout.addWidget(self.draw_thick_title_label)
self.draw_thick_edit = QLineEdit(str(self.draw_tool_size))
self.draw_thick_sld = QSlider(Qt.Horizontal)
self.draw_thick_sld.setFocusPolicy(Qt.NoFocus)
self.draw_thick_sld.setRange(1, 30)
self.draw_thick_sld.setValue(self.draw_tool_size)
self.draw_thick_layout = QFormLayout()
self.draw_thick_layout.addRow(self.draw_thick_sld,
self.draw_thick_edit)
self.draw_status_layout.addLayout(self.draw_thick_layout)
self.img_editor_layout.addLayout(self.draw_status_layout)
# Signal of draw thickness value changed
self.draw_thick_sld.valueChanged.connect(self.draw_thick_change_sld)
self.draw_thick_edit.textChanged.connect(self.draw_thick_change_edit)
# Set view area of selected color
self.select_color_view_size = 64
self.select_color_view = QGraphicsView()
self.select_color_view.setFixedSize(self.select_color_view_size + 3,
self.select_color_view_size + 3)
self.select_color_scene = QGraphicsScene()
brush = QBrush(self.draw_color)
self.select_color_rect = self.select_color_scene.addRect(QRect(0, 0, self.select_color_view_size, self.select_color_view_size), \
brush=brush)
self.select_color_view.setScene(self.select_color_scene)
self.select_color_title_label = QLabel('Selected color')
self.selected_color_layout = QFormLayout()
self.selected_color_layout.addRow(self.select_color_title_label,
self.select_color_view)
self.img_editor_layout.addLayout(self.selected_color_layout)
# Set save button
self.save_button_layout = QHBoxLayout()
self.img_status_layout.addLayout(self.save_button_layout)
self.layer_save_button = QPushButton('Save layer image')
self.layer_save_button.setIcon(QIcon('icon/layer_save.png'))
self.layer_save_button.setIconSize(
QSize(self.tool_button_size, self.tool_button_size))
self.compose_save_button = QPushButton(
'Save composed original and layer image')
self.compose_save_button.setIcon(QIcon('icon/compose_save.png'))
self.compose_save_button.setIconSize(
QSize(self.tool_button_size, self.tool_button_size))
self.save_button_layout.addWidget(self.layer_save_button)
self.save_button_layout.addWidget(self.compose_save_button)
self.layer_save_button.clicked.connect(self.save_layer_image)
self.compose_save_button.clicked.connect(self.save_compose_image)
# Set display area of selected file path
self.org_img_path_title_label = QLabel('original image file: ')
self.org_img_path_label = QLabel('')
self.file_path_layout = QFormLayout()
self.file_path_layout.addRow(self.org_img_path_title_label,
self.org_img_path_label)
self.bottom_layout = QVBoxLayout()
self.bottom_layout.addLayout(self.file_path_layout)
self.main_layout.addLayout(self.bottom_layout)
self.mainWidget.setLayout(self.main_layout)
self.setCentralWidget(self.mainWidget)
# Original image select Function
def open_org_img_dialog(self):
options = QFileDialog.Options()
org_img_default_path = self.app_setting["SoftwareSetting"][
"file_path"]["org_img_dir"]
self.org_img_file_path, selected_filter = QFileDialog.getOpenFileName(self, 'Select original image', org_img_default_path, \
'Image files(*.jpg *jpeg *.png)', options=options)
org_img_dir_path, org_img_file = os.path.split(self.org_img_file_path)
org_img_bare_name, org_img_ext = os.path.splitext(org_img_file)
self.org_img_path_label.setText(self.org_img_file_path)
self.set_image_on_viewer()
def set_image_on_viewer(self):
# Delete existing image item
if len(self.imgs_pixmap) != 0:
for item in self.imgs_pixmap:
self.scene.removeItem(item)
self.scene.clear_contents()
self.imgs_pixmap.clear()
self.imgs.clear()
# load original image
self.org_qimg = QImage(self.org_img_file_path)
self.org_pixmap = QPixmap.fromImage(self.org_qimg)
org_img_size = self.org_qimg.size()
self.org_img_width = org_img_size.width()
self.org_img_height = org_img_size.height()
# Set layer image
self.layer_qimg = QImage(self.org_img_width, self.org_img_height,
QImage.Format_RGBA8888)
self.layer_qimg.fill(QColor(0, 0, 0, self.layer_alpha))
self.layer_pixmap = QPixmap.fromImage(self.layer_qimg)
self.imgs.append(self.org_qimg)
self.imgs.append(self.layer_qimg)
# Set image to scene
self.imgs_pixmap.append(QGraphicsPixmapItem(self.org_pixmap))
self.scene.addItem(self.imgs_pixmap[-1])
self.imgs_pixmap.append(QGraphicsPixmapItem(self.layer_pixmap))
self.scene.addItem(self.imgs_pixmap[-1])
self.scene.set_img_contents(self.imgs)
# Set scene to graphics view
self.graphics_view.setScene(self.scene)
self.graphics_view.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.show()
# Slot function of transparency slider changed
def transparency_change_sld(self, value):
self.img_transparency_edit.setText(str(value))
self.layer_alpha = int(255 * (1.0 - (value / 100)))
# Change layer image's transparency(alpha value)
for y in range(self.org_img_height):
for x in range(self.org_img_width):
self.layer_qimg.setPixelColor(
QPoint(x, y), QColor(0, 0, 0, self.layer_alpha))
self.layer_pixmap = QPixmap.fromImage(self.layer_qimg)
# remove previous layer image
self.scene.removeItem(self.imgs_pixmap[-1])
self.imgs_pixmap.pop(-1)
# add new layer image to scene
self.imgs_pixmap.append(QGraphicsPixmapItem(self.layer_pixmap))
self.scene.addItem(self.imgs_pixmap[-1])
self.show()
# Slot function of transparency text edit changed
def transparency_change_edit(self, value):
if int(value) < 0 or int(value) > 100:
return
self.img_transparency_sld.setValue(int(value))
self.layer_alpha = int(255 * (1.0 - (int(value) / 100.0)))
# Change layer image's transparency(alpha value)
for y in range(self.org_img_height):
for x in range(self.org_img_width):
self.layer_qimg.setPixelColor(
QPoint(x, y), QColor(0, 0, 0, self.layer_alpha))
self.layer_pixmap = QPixmap.fromImage(self.layer_qimg)
# remove previous layer image
self.scene.removeItem(self.imgs_pixmap[-1])
self.imgs_pixmap.pop(-1)
# add new layer image to scene
self.imgs_pixmap.append(QGraphicsPixmapItem(self.layer_pixmap))
self.scene.addItem(self.imgs_pixmap[-1])
self.show()
# slot(receiver of signal) of mouse_cursor_button toggled
def mouse_cursor_button_toggled(self, checked):
if checked:
self.img_edit_mode = 'cursor'
self.scene.set_mode(self.img_edit_mode)
self.color_bar_scene.set_mode(self.img_edit_mode)
# slot(receiver of signal) of pen_button toggled
def pen_button_toggled(self, checked):
if checked:
self.img_edit_mode = 'pen'
self.scene.set_mode(self.img_edit_mode)
self.color_bar_scene.set_mode(self.img_edit_mode)
# slot(receiver of signal) of eraser_button toggled
def eraser_button_toggled(self, checked):
if checked:
self.img_edit_mode = 'eraser'
self.scene.set_mode(self.img_edit_mode)
self.color_bar_scene.set_mode(self.img_edit_mode)
self.draw_color = self.eraser_color
self.select_color_scene.removeItem(self.select_color_rect)
brush = QBrush(self.draw_color)
self.select_color_rect = self.select_color_scene.addRect(QRect(0, 0, self.select_color_view_size, self.select_color_view_size), \
brush=brush)
self.select_color_view.setScene(self.select_color_scene)
# Slot of color bar clicked for selection color
def set_selected_color(self, color):
# Delete existng image item
self.select_color_scene.removeItem(self.select_color_rect)
self.draw_color = color
brush = QBrush(self.draw_color)
self.select_color_rect = self.select_color_scene.addRect(QRect(0, 0, self.select_color_view_size, self.select_color_view_size), \
brush=brush)
self.select_color_view.setScene(self.select_color_scene)
# Slot function of draw thicikeness slider changed
def draw_thick_change_sld(self, value):
self.draw_thickness_edit.setText(str(value))
self.draw_tool_size = value
# Slot function of draw thicikeness text editor changed
def draw_thick_change_edit(self, value):
if int(value) < 1 or int(value) > 30:
return
self.draw_thickness_sld.setValue(int(value))
def make_layer_image(self):
for i, line in enumerate(self.scene.lines):
pen = self.scene.pens[i]
pen_size = int(pen.width())
pen_color = pen.color()
# start pixel of line
x1 = int(line.x1())
y1 = int(line.y1())
# end pixel of line
x2 = int(line.x2())
y2 = int(line.y2())
dx = int(line.dx())
dy = int(line.dy())
# When only 1pixl line
if dx <= 1 and dy <= 1:
draw_pix_x1_s = max(x1 - int(pen_size / 2), 0)
draw_pix_x1_e = min(x1 + int(pen_size / 2),
self.org_img_width - 1)
draw_pix_y1_s = max(y1 - int(pen_size / 2), 0)
draw_pix_y1_e = min(y1 + int(pen_size / 2),
self.org_img_height - 1)
# for Pen's size
for y in range(draw_pix_y1_s, draw_pix_y1_e):
for x in range(draw_pix_x1_s, draw_pix_x1_e):
self.layer_qimg.setPixelColor(x, y, pen_color)
draw_pix_x2_s = max(x2 - int(pen_size / 2), 0)
draw_pix_x2_e = min(x2 + int(pen_size / 2),
self.org_img_width - 1)
draw_pix_y2_s = max(y2 - int(pen_size / 2), 0)
draw_pix_y2_e = min(y2 + int(pen_size / 2),
self.org_img_height - 1)
# for Pen's size
for y in range(draw_pix_y2_s, draw_pix_y2_e):
for x in range(draw_pix_x2_s, draw_pix_x2_e):
self.layer_qimg.setPixelColor(x, y, pen_color)
else:
# For avoid devide by 0
if dx == 0:
for y in range(y1, y2 + 1):
draw_pix_y_s = y - int(pen_size / 2)
draw_pix_y_e = y + int(pen_size / 2)
# for Pen's size
for yy in range(draw_pix_y_s, draw_pix_y_e):
self.layer_qimg.setPixelColor(x1, yy, pen_color)
else:
grad = dy / dx
# Choose coordinates with small slope not to skip pixels
if grad >= 1.0:
for x in range(dx):
y = y1 + int(grad * x + 0.5)
draw_pix_x_s = max(x1 + x - int(pen_size / 2), 0)
draw_pix_x_e = min(x1 + x + int(pen_size / 2),
self.org_img_width - 1)
draw_pix_y_s = max(y - int(pen_size / 2), 0)
draw_pix_y_e = min(y + int(pen_size / 2),
self.org_img_height - 1)
# for Pen's size
for yy in range(draw_pix_y_s, draw_pix_y_e + 1):
for xx in range(draw_pix_x_s,
draw_pix_x_e + 1):
self.layer_qimg.setPixelColor(
xx, yy, pen_color)
else:
for y in range(dy):
x = x1 + int(1 / grad * y + 0.5)
draw_pix_y_s = max(y1 + y - int(pen_size / 2), 0)
draw_pix_y_e = min(y1 + y + int(pen_size / 2),
self.org_img_height - 1)
draw_pix_x_s = max(x - int(pen_size / 2), 0)
draw_pix_x_e = min(x + int(pen_size / 2),
self.org_img_width - 1)
# for Pen's size
for yy in range(draw_pix_y_s, draw_pix_y_e + 1):
for xx in range(draw_pix_x_s,
draw_pix_x_e + 1):
self.layer_qimg.setPixelColor(
xx, yy, pen_color)
# Slot function of save layer image button clicked
def save_layer_image(self):
self.make_layer_image()
layer_img_default_path = self.app_setting["SoftwareSetting"][
"file_path"]["layer_img_dir"]
options = QFileDialog.Options()
file_name, selected_filete = QFileDialog.getSaveFileName(self, 'Save layer image', layer_img_default_path, \
'image files(*.png, *jpg)', options=options)
#print('layer image save name:{file}'.format(file=file_name))
self.layer_qimg.save(file_name)
ret = QMessageBox(self, 'Success', 'layer image is saved successfully',
QMessageBox.Ok)
# Make composed orignal and layered image
def make_compose_image(self):
self.make_layer_image()
self.compose_qimg = QImage(self.org_img_width, self.org_img_height,
QImage.Format_RGBA8888)
painter = QPainter(self.compose_qimg)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.drawImage(0, 0, self.org_qimg)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.drawImage(0, 0, self.layer_qimg)
painter.end()
# Slot function of save composer original and layer image button clicked
def save_compose_image(self):
self.make_compose_image()
compose_img_default_path = self.app_setting["SoftwareSetting"][
"file_path"]["compose_img_dir"]
options = QFileDialog.Options()
file_name, selected_fileter = QFileDialog.getSaveFileName(self, 'Save composed image', compose_img_default_path, \
'image files(*.png, *jpg)', options=options)
#print('compose image save name:{file}'.format(file=file_name))
self.compose_qimg.save(file_name)
ret = QMessageBox(self, 'Success',
'compose image is saved successfully',
QMessageBox.Ok)
class ObjectIcon(QWidget):
MIN_SIZE = QSize(32, 32)
MAX_SIZE = MIN_SIZE * 2
clicked: SignalInstance = Signal()
object_placed: SignalInstance = Signal()
def __init__(self, level_object: Optional[LevelObject] = None):
super(ObjectIcon, self).__init__()
size_policy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.setSizePolicy(size_policy)
self.zoom = 1
self.object = None
self.image = QImage()
self.set_object(level_object)
self.draw_background_color = True
self.max_size = self.MIN_SIZE
def mouseMoveEvent(self, event):
if not (event.buttons() & Qt.LeftButton):
return super(ObjectIcon, self).mouseMoveEvent(event)
drag = QDrag(self)
mime_data = QMimeData()
object_bytes = bytearray()
if isinstance(self.object, LevelObject):
object_bytes.append(0)
else:
object_bytes.append(1)
object_bytes.extend(self.object.to_bytes())
mime_data.setData("application/level-object", object_bytes)
drag.setMimeData(mime_data)
if drag.exec_() == Qt.MoveAction:
self.object_placed.emit()
def set_object(self, level_object: Union[LevelObject, EnemyObject]):
if level_object is not None:
self.object = get_minimal_icon_object(level_object)
self.image = self.object.as_image()
self.setToolTip(self.object.name)
else:
self.image = QImage()
self.setToolTip("")
self.update()
def heightForWidth(self, width: int) -> int:
current_width, current_height = self.image.size().toTuple()
height = current_height / current_width * width
return height
def sizeHint(self):
if self.object is not None and self.fits_inside(
self.image.size() * 2, self.max_size):
return self.image.size() * 2
else:
return self.max_size
def paintEvent(self, event: QPaintEvent):
if self.object is not None:
painter = QPainter(self)
if self.draw_background_color:
painter.fillRect(
event.rect(),
QColor(*bg_color_for_palette(self.object.palette_group)))
scaled_image = self.image.scaled(self.size(),
aspectMode=Qt.KeepAspectRatio)
x = (self.width() - scaled_image.width()) // 2
y = (self.height() - scaled_image.height()) // 2
painter.drawImage(x, y, scaled_image)
return super(ObjectIcon, self).paintEvent(event)
def mouseReleaseEvent(self, event: QMouseEvent):
self.clicked.emit()
return super(ObjectIcon, self).mouseReleaseEvent(event)
@staticmethod
def fits_inside(size1: QSize, size2: QSize):
return size1.width() <= size2.width() and size1.height(
) <= size2.height()
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(1024, 590)
MainWindow.setMinimumSize(QtCore.QSize(1024, 590))
MainWindow.setMaximumSize(QtCore.QSize(1024, 590))
MainWindow.setStyleSheet("background-color: rgb(220, 220, 220);")
self.switch = 0
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.label = QtWidgets.QLabel(self.centralwidget)
self.label.setGeometry(QtCore.QRect(10, 10, 166, 41))
self.label.setStyleSheet(
"border-image: url(:/newPrefix/WhatsApp Image 2020-09-11 at 12.46.25 AM.jpeg);"
)
pixmap = QPixmap(r"D:\finalapp\images\applogo.jpeg")
self.label.setPixmap(pixmap)
self.label.setScaledContents(True)
self.label.setText("")
self.label.setObjectName("label")
self.pushButton = QtWidgets.QPushButton(self.centralwidget)
self.pushButton.setGeometry(QtCore.QRect(950, 10, 31, 31))
self.pushButton.setStyleSheet(
"border-image: url(:/newPrefix/help.png);")
self.pushButton.setText("")
self.pushButton.setObjectName("pushButton")
self.pushButton_2 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_2.setGeometry(QtCore.QRect(910, 10, 31, 31))
self.pushButton_2.setStyleSheet(
"border-image: url(:/newPrefix/contact.jpg);")
self.pushButton_2.setText("")
self.pushButton_2.setObjectName("pushButton_2")
self.label_2 = QtWidgets.QLabel(self.centralwidget)
self.label_2.setGeometry(QtCore.QRect(180, 50, 341, 91))
self.label_2.setStyleSheet("border: 2px solid black;\n"
"background-color: rgb(255, 255, 255);")
self.label_2.setText("")
self.label_2.setObjectName("label_2")
self.label_3 = QtWidgets.QLabel(self.centralwidget)
self.label_3.setGeometry(QtCore.QRect(540, 50, 341, 91))
self.label_3.setStyleSheet("border: 2px solid black;\n"
"background-color: rgb(255, 255, 255);")
self.label_3.setText("")
self.label_3.setObjectName("label_3")
self.label_4 = QtWidgets.QLabel(self.centralwidget)
self.label_4.setGeometry(QtCore.QRect(200, 70, 81, 16))
self.label_4.setStyleSheet("font: 87 11pt \"Arial Black\";\n"
"background-color: rgb(255, 255, 255);")
self.label_4.setScaledContents(True)
self.label_4.setIndent(-1)
self.label_4.setObjectName("label_4")
self.label_6 = QtWidgets.QLabel(self.centralwidget)
self.label_6.setGeometry(QtCore.QRect(200, 100, 91, 16))
self.label_6.setStyleSheet("font: 87 11pt \"Arial Black\";\n"
"background-color: rgb(255, 255, 255);")
self.label_6.setScaledContents(True)
self.label_6.setIndent(-1)
self.label_6.setObjectName("label_6")
self.lineEdit = QtWidgets.QLineEdit(self.centralwidget)
self.lineEdit.setGeometry(QtCore.QRect(300, 70, 161, 21))
self.lineEdit.setObjectName("lineEdit")
self.lineEdit_2 = QtWidgets.QLineEdit(self.centralwidget)
self.lineEdit_2.setGeometry(QtCore.QRect(300, 100, 161, 21))
self.lineEdit_2.setObjectName("lineEdit_2")
self.pushButton_4 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_4.setGeometry(QtCore.QRect(470, 100, 31, 21))
self.pushButton_4.setStyleSheet(
"border-image: url(:/newPrefix/submit.png);")
self.pushButton_4.setText("")
self.pushButton_4.setObjectName("pushButton_4")
self.pushButton_4.clicked.connect(self.password)
self.pushButton_3 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_3.setGeometry(QtCore.QRect(470, 70, 31, 21))
self.pushButton_3.setAutoFillBackground(False)
self.pushButton_3.setStyleSheet(
"border-image: url(:/newPrefix/file.jpg);")
self.pushButton_3.setText("")
self.pushButton_3.setIconSize(QtCore.QSize(11, 11))
self.pushButton_3.setObjectName("pushButton_3")
self.pushButton_3.clicked.connect(self.browseImage)
self.pushButton_5 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_5.setGeometry(QtCore.QRect(550, 60, 101, 31))
self.pushButton_5.setStyleSheet("font: 87 8pt \"Arial Black\";")
self.pushButton_5.setObjectName("pushButton_5")
self.pushButton_5.clicked.connect(self.open_settings)
self.pushButton_6 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_6.setGeometry(QtCore.QRect(770, 60, 101, 31))
self.pushButton_6.setStyleSheet("font: 87 8pt \"Arial Black\";")
self.pushButton_6.setObjectName("pushButton_6")
self.pushButton_6.clicked.connect(self.openFontDialog)
self.pushButton_7 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_7.setGeometry(QtCore.QRect(660, 60, 101, 31))
self.pushButton_7.setStyleSheet("font: 87 8pt \"Arial Black\";")
self.pushButton_7.setObjectName("pushButton_7")
self.pushButton_7.clicked.connect(self.printpreviewDialog)
self.pushButton_8 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_8.setGeometry(QtCore.QRect(660, 100, 101, 31))
self.pushButton_8.setStyleSheet("font: 87 8pt \"Arial Black\";")
self.pushButton_8.setObjectName("pushButton_8")
self.pushButton_8.clicked.connect(self.resizeimage)
self.pushButton_9 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_9.setGeometry(QtCore.QRect(550, 100, 101, 31))
self.pushButton_9.setStyleSheet("font: 87 8pt \"Arial Black\";")
self.pushButton_9.setObjectName("pushButton_9")
self.pushButton_9.clicked.connect(self.trouble)
self.pushButton_10 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_10.setGeometry(QtCore.QRect(770, 100, 101, 31))
self.pushButton_10.setStyleSheet("font: 87 8pt \"Arial Black\";")
self.pushButton_10.setObjectName("pushButton_10")
self.line = QtWidgets.QFrame(self.centralwidget)
self.line.setGeometry(QtCore.QRect(0, 160, 1021, 31))
self.line.setFrameShape(QtWidgets.QFrame.HLine)
self.line.setFrameShadow(QtWidgets.QFrame.Sunken)
self.line.setObjectName("line")
self.checkBox = QtWidgets.QCheckBox(self.centralwidget)
self.checkBox.setGeometry(QtCore.QRect(20, 540, 121, 21))
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(True)
font.setWeight(75)
self.checkBox.setFont(font)
self.checkBox.setObjectName("checkBox")
self.checkBox.stateChanged.connect(self.clickBox)
self.checkBox_2 = QtWidgets.QCheckBox(self.centralwidget)
self.checkBox_2.setGeometry(QtCore.QRect(880, 540, 121, 21))
self.checkBox_2.stateChanged.connect(self.clickBox2)
font = QtGui.QFont()
font.setPointSize(10)
font.setBold(True)
font.setWeight(75)
self.checkBox_2.setFont(font)
self.checkBox_2.setObjectName("checkBox_2")
self.label_5 = QtWidgets.QLabel(self.centralwidget)
self.label_5.setGeometry(QtCore.QRect(10, 210, 1001, 311))
self.label_5.setStyleSheet("background-color: rgb(239, 239, 239);")
self.label_5.setText("")
self.label_5.setObjectName("label_5")
self.groupBox = QtWidgets.QGroupBox(self.centralwidget)
self.groupBox.setGeometry(QtCore.QRect(18, 215, 490, 300))
self.groupBox.setTitle("")
self.groupBox.setObjectName("groupBox")
self.label_7 = QtWidgets.QLabel(self.groupBox)
self.label_7.setGeometry(QtCore.QRect(0, 0, 491, 53))
self.label_7.setStyleSheet("")
self.label_7.setText("")
self.label_7.setObjectName("label_7")
self.label_9 = QtWidgets.QLabel(self.groupBox)
self.label_9.setGeometry(QtCore.QRect(40, 50, 120, 152))
self.label_9.setStyleSheet("")
self.label_9.setText("")
self.label_9.setObjectName("label_9")
self.label_10 = QtWidgets.QLabel(self.groupBox)
self.label_10.setGeometry(QtCore.QRect(170, 63, 251, 25))
self.label_10.setStyleSheet("")
self.label_10.setText("")
self.label_10.setObjectName("label_10")
self.label_11 = QtWidgets.QLabel(self.groupBox)
self.label_11.setGeometry(QtCore.QRect(170, 89, 251, 25))
self.label_11.setStyleSheet("")
self.label_11.setText("")
self.label_11.setObjectName("label_11")
self.label_12 = QtWidgets.QLabel(self.groupBox)
self.label_12.setGeometry(QtCore.QRect(170, 115, 251, 25))
self.label_12.setStyleSheet("")
self.label_12.setText("")
self.label_12.setObjectName("label_12")
self.label_13 = QtWidgets.QLabel(self.groupBox)
self.label_13.setGeometry(QtCore.QRect(170, 140, 251, 21))
self.label_13.setStyleSheet("")
self.label_13.setText("")
self.label_13.setObjectName("label_13")
self.label_14 = QtWidgets.QLabel(self.groupBox)
self.label_14.setGeometry(QtCore.QRect(170, 170, 251, 25))
self.label_14.setStyleSheet("")
self.label_14.setText("")
self.label_14.setObjectName("label_14")
self.label_15 = QtWidgets.QLabel(self.groupBox)
self.label_15.setGeometry(QtCore.QRect(0, 270, 491, 32))
self.label_15.setStyleSheet("")
self.label_15.setText("")
self.label_15.setObjectName("label_15")
self.label_16 = QtWidgets.QLabel(self.groupBox)
self.label_16.setGeometry(QtCore.QRect(0, 267, 491, 5))
self.label_16.setStyleSheet("")
self.label_16.setText("")
self.label_16.setObjectName("label_16")
self.label_20 = QtWidgets.QLabel(self.groupBox)
self.label_20.setGeometry(QtCore.QRect(10, 60, 16, 141))
self.label_20.setText("")
self.label_20.setObjectName("label_20")
self.label_21 = QtWidgets.QLabel(self.groupBox)
self.label_21.setGeometry(QtCore.QRect(460, 70, 16, 171))
self.label_21.setText("")
self.label_21.setObjectName("label_21")
self.label_23 = QtWidgets.QLabel(self.groupBox)
self.label_23.setGeometry(QtCore.QRect(90, 246, 311, 23))
self.label_23.setStyleSheet("font-size:12")
self.label_23.setFont(QFont('Arial', 12, weight=QtGui.QFont.Bold))
self.label_23.setObjectName("label_23")
self.label_23.setAlignment(Qt.AlignAbsolute)
self.label_24 = QtWidgets.QLabel(self.groupBox)
self.label_24.setGeometry(QtCore.QRect(110, 222, 311, 23))
self.label_24.setStyleSheet("font-size:15")
self.label_24.setFont(QFont('Arial', 12, weight=QtGui.QFont.Bold))
self.label_24.setObjectName("label_24")
self.label_24.setAlignment(Qt.AlignBottom)
self.label_31 = QtWidgets.QLabel(self.groupBox)
self.label_31.setGeometry(QtCore.QRect(10, 60, 21, 141))
self.label_31.setStyleSheet("")
self.label_31.setText("")
self.label_31.setObjectName("label_31")
self.label_32 = QtWidgets.QLabel(self.groupBox)
self.label_32.setGeometry(QtCore.QRect(450, 70, 31, 171))
self.label_32.setStyleSheet("")
self.label_32.setText("")
self.label_32.setObjectName("label_32")
self.groupBox_2 = QtWidgets.QGroupBox(self.centralwidget)
self.groupBox_2.setGeometry(QtCore.QRect(515, 215, 490, 300))
self.groupBox_2.setTitle("")
self.groupBox_2.setObjectName("groupBox_2")
self.label_8 = QtWidgets.QLabel(self.groupBox_2)
self.label_8.setGeometry(QtCore.QRect(0, 0, 491, 51))
self.label_8.setText("")
self.label_8.setObjectName("label_8")
self.label_17 = QtWidgets.QLabel(self.groupBox_2)
self.label_17.setGeometry(QtCore.QRect(0, 0, 491, 51))
self.label_17.setStyleSheet("")
self.label_17.setText("")
self.label_17.setObjectName("label_17")
self.label_19 = QtWidgets.QLabel(self.groupBox_2)
self.label_19.setGeometry(QtCore.QRect(0, 269, 491, 31))
self.label_19.setStyleSheet("")
self.label_19.setText("")
self.label_19.setObjectName("label_19")
self.label_18 = QtWidgets.QLabel(self.groupBox_2)
self.label_18.setGeometry(QtCore.QRect(0, 262, 491, 5))
self.label_18.setStyleSheet("")
self.label_18.setText("")
self.label_18.setObjectName("label_18")
self.label_22 = QtWidgets.QLabel(self.groupBox_2)
self.label_22.setGeometry(QtCore.QRect(330, 70, 143, 143))
self.label_22.setText("")
self.label_22.setObjectName("label_22")
self.label_25 = QtWidgets.QLabel(self.groupBox_2)
self.label_25.setGeometry(QtCore.QRect(330, 60, 143, 143))
self.label_25.setStyleSheet("")
self.label_25.setText("")
self.label_25.setObjectName("label_25")
self.label_26 = QtWidgets.QLabel(self.groupBox_2)
self.label_26.setGeometry(QtCore.QRect(330, 220, 161, 21))
self.label_26.setStyleSheet("")
self.label_26.setText("")
self.label_26.setObjectName("label_26")
self.label_27 = QtWidgets.QLabel(self.groupBox_2)
self.label_27.setGeometry(QtCore.QRect(70, 220, 261, 21))
self.label_27.setStyleSheet("font-size:15")
self.label_27.setText("")
self.label_27.setFont(QFont('Arial', 12, weight=QtGui.QFont.Bold))
self.label_27.setObjectName("label_27")
self.label_27.setAlignment(Qt.AlignAbsolute)
self.label_28 = QtWidgets.QLabel(self.groupBox_2)
self.label_28.setGeometry(QtCore.QRect(30, 240, 281, 22))
self.label_28.setStyleSheet("")
self.label_28.setStyleSheet("font-size:12")
self.label_28.setText("")
self.label_28.setFont(QFont('Arial', 12, weight=QtGui.QFont.Bold))
self.label_28.setObjectName("label_28")
self.label_28.setAlignment(Qt.AlignAbsolute | Qt.AlignJustify)
self.label_29 = QtWidgets.QLabel(self.groupBox_2)
self.label_29.setGeometry(QtCore.QRect(10, 60, 321, 75))
self.label_29.setStyleSheet("")
self.label_29.setText("")
self.label_29.setObjectName("label_29")
self.label_30 = QtWidgets.QLabel(self.groupBox_2)
self.label_30.setGeometry(QtCore.QRect(10, 140, 341, 75))
self.label_30.setStyleSheet("")
self.label_30.setText("")
self.label_30.setObjectName("label_30")
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
# create temp folder
self.path = tempfile.mkdtemp()
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "Aapki Pehchaan"))
self.label_4.setText(_translate("MainWindow", "Filename:"))
self.label_6.setText(_translate("MainWindow", "Password:"******"MainWindow", "Settings"))
self.pushButton_6.setText(_translate("MainWindow", "Font"))
self.pushButton_7.setText(_translate("MainWindow", "Print"))
self.pushButton_8.setText(_translate("MainWindow", "Resize"))
self.pushButton_9.setText(_translate("MainWindow", "Report"))
self.pushButton_10.setText(_translate("MainWindow", "License"))
self.checkBox.setText(_translate("MainWindow", "PRINT FRONT"))
self.checkBox_2.setText(_translate("MainWindow", "PRINT BACK"))
def clickBox(self, state):
if state == QtCore.Qt.Checked:
print('Checked')
self.take_screenshot()
else:
print('Unchecked')
def clickBox2(self, state):
if state == QtCore.Qt.Checked:
print('Checked')
self.take_screenshot2()
else:
print('Unchecked')
def topimage(self):
pixmap = QPixmap(r'images/Ashok Stambh Front.png')
self.label_7.setPixmap(pixmap)
self.label_7.setScaledContents(True)
def nextpagebottomimage(self):
pixmap = QPixmap(r'D:\finalapp\images\Back side Symbol.png')
self.label_19.setPixmap(pixmap)
self.label_19.setScaledContents(True)
def photoextraction(self, doc):
for i in range(len(doc)):
for img in doc.getPageImageList(i):
xref = img[0]
pix = fitz.Pixmap(doc, xref)
if pix.n < 1:
pix.writePNG(
os.path.join(self.path, "p%s-%s.png" % (i, xref)))
else:
pix1 = fitz.Pixmap(fitz.csRGB, pix)
pix1.writePNG(
os.path.join(self.path, "p%s-%s.png" % (i, xref)))
try:
# HUMAN IMAGE IN ADHAR
if pix.width == float(
0.8
) * pix.height or pix.width == 0.75 * pix.height:
self.human_image = os.path.join(
self.path, "p%s-%s.png" % (i, xref))
pixmap = QPixmap(self.human_image)
self.label_9.setPixmap(pixmap)
self.label_9.setScaledContents(True)
# SCANNER CODE IN ADHAR
elif pix.width == pix.height:
pixmap = QPixmap(
os.path.join(self.path, "p%s-%s.png" % (i, xref)))
self.label_25.setPixmap(pixmap)
self.label_25.setScaledContents(True)
except Exception as e:
print(e)
print("fault in human and scanner image")
def setText_to_elements(self, a):
self.label_13.setText(self.text_ex['DOB'])
self.label_10.setText(self.text_ex['namehindi'])
self.label_11.setText(self.text_ex['englishname'])
self.label_12.setText(self.text_ex['gender string'])
self.label_29.setText(self.text_ex['hindiAddress'])
self.label_30.setText("Address: " + "\n" + self.text_ex['engAddress'])
self.label_30.adjustSize()
self.label_27.setText(self.text_ex['Adhaar no'])
if (self.text_ex['VID'] != None):
self.label_23.setText("VID: " + self.text_ex['VID'])
self.label_23.adjustSize()
self.label_23.setStyleSheet(
"border-top:0.5px solid rgb(220, 220, 220);")
self.label_28.setText("VID: " + self.text_ex['VID'])
self.label_28.adjustSize()
self.label_28.setStyleSheet(
"border-top:0.5px solid rgb(220, 220, 220);")
self.label_24.setText(self.text_ex['Adhaar no'])
def password(self):
self.switch = 1
r = self.lineEdit.text()
pwd = self.lineEdit_2.text()
if pwd != "":
try:
mypdf = pikepdf.open(r, pwd)
r = os.path.join(self.path, "/pdffile", r, "unlocked.pdf")
mypdf.save(r)
except pikepdf._qpdf.PasswordError:
print("hi")
self.showdialog()
# print('cannot decrypt %s with password %s' % (r, pwd))
else:
pikepdf.open(r)
print(r)
# Hit fast api endpoint with PDF file
doc = fitz.open(r)
# # try:
res = requests.post(BASE_URL + '/uploadfile/',
files={'pdf': open(r, 'rb')})
data = res.json()
self.text_ex = data["text"]
name = self.name_ex(doc)
self.text_ex["englishname"] = name
try:
self.groupBox.setStyleSheet("background-color:rgb(255,255,255)")
self.groupBox_2.setStyleSheet("background-color:rgb(255,255,255)")
self.photoextraction(doc)
self.setText_to_elements(self.text_ex)
self.nextpagetop()
self.topimage()
self.redline()
self.nextpagetop()
self.defaultfooter()
self.nextpagebottomimage()
self.label_26.clear()
except Exception as e:
print(e)
print("Sorry!response invalid")
def image_smoothening(self, img):
ret1, th1 = cv2.threshold(img, BINARY_THREHOLD, 255, cv2.THRESH_BINARY)
ret2, th2 = cv2.threshold(th1, 0, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
blur = cv2.GaussianBlur(th2, (1, 1), 0)
ret3, th3 = cv2.threshold(blur, 0, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
return th3
def remove_noise_and_smooth(self, file_name):
img = cv2.imread(file_name, 0)
img = cv2.resize(img, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)
gaus = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, 31, 25)
img = self.image_smoothening(gaus)
return img
def name_ex(self, doc):
page = doc.loadPage(0)
mat = fitz.Matrix(2, 2)
pix = page.getPixmap(matrix=mat)
outfile = os.path.join(self.path, "outfile.png")
output = pix.writePNG(outfile)
image_full = cv2.imread(outfile)
path = os.path.join(self.path, "image_full.png")
cv2.imwrite(path, image_full)
image_front = image_full[1140:1475, 120:500]
a = os.path.join(self.path, "image_front.png")
cv2.imwrite(a, image_front)
image_front1 = self.remove_noise_and_smooth(a)
pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'
text = pytesseract.image_to_string(image_front1, lang="eng")
try:
newlist1 = []
for xx in text.split('\n'):
newlist1.append(xx)
newlist1 = list(filter(lambda x: len(x) > 1, newlist1))
a = 0
str2 = "Government"
str1 = "of"
for no in newlist1:
if str2 in no or str1 in no:
b = a
a = a + 1
name = newlist1[b + 2]
name = name.split(" ")
print(name)
if len(name) == 2:
print(name)
name = " ".join(name)
print(name)
return name
else:
name = " ".join(name)
name = re.sub(r'[(' ')]', '', name)
name = re.sub(r'[0-9]+', '', name)
# name = re.sub(r'[;'';;!@#!@#!#!$!=()|:><~~' '__-]+','',name)
wordlist = self.text_ex['raw'].split("\n")
name = get_close_matches(name, wordlist)
print(name)
return name[0]
except Exception as e:
print(e)
pass
def showdialog(self):
msg = QMessageBox()
msg.setIcon(QMessageBox.Warning)
msg.setText("file extension not supported")
msg.setWindowTitle("ERROR!")
retval = msg.exec_()
print("value of pressed message box button:", retval)
def browseImage(self):
"""
this function opens the dialog box.
"""
foldername = QFileDialog.getOpenFileName()
ext = os.path.splitext(foldername[0])[1]
valid_extensions = '.pdf'
if ext != valid_extensions:
print(u'File not supported!')
self.showdialog()
pdffile = foldername[0]
self.lineEdit.setText(pdffile)
def printpreviewDialog(self):
printer = QPrinter(QPrinter.HighResolution)
previewDialog = QPrintPreviewDialog(printer,
parent=None,
flags=Qt.WindowFlags())
previewDialog.paintRequested.connect(self.printImage)
previewDialog.exec_()
def printImage(self, printer):
"Prints the current diagram"
self.image = QImage('test1.tif')
# # Create the printer
printerobject = QPrinter()
# Set the settings
printdialog = QPrintDialog(printerobject)
if printdialog.exec_() == QDialog.Accepted:
painter = QPainter(printer)
rect = painter.viewport()
size = self.image.size()
size.scale(rect.size(), Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(),
size.height())
painter.setWindow(self.image.rect())
painter.drawImage(0, 0, self.image)
def take_screenshot2(self):
from PySide2 import QtCore as pyqt5c
from PySide2 import QtWidgets as pyqt5w
screen = pyqt5w.QApplication.primaryScreen()
pixmap = screen.grabWindow(self.groupBox_2.winId())
ba = pyqt5c.QByteArray()
buff = pyqt5c.QBuffer(ba)
pixmap = pixmap.scaled(500, 500, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
pixmap.save('test1.tif', 'TIF')
return ba.data()
def take_screenshot(self):
from PySide2 import QtCore as pyqt5c
from PySide2 import QtWidgets as pyqt5w
screen = pyqt5w.QApplication.primaryScreen()
pixmap = screen.grabWindow(self.groupBox.winId())
ba = pyqt5c.QByteArray()
buff = pyqt5c.QBuffer(ba)
pixmap = pixmap.scaled(500, 500, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
pixmap.save('test1.tif', 'TIF')
return ba.data()
def openFontDialog(self):
ok, font = QFontDialog.getFont()
if ok:
self.label_10.setFont(font)
self.label_11.setFont(font)
self.label_12.setFont(font)
self.label_13.setFont(font)
self.label_14.setFont(font)
self.label_30.setFont(font)
self.label_29.setFont(font)
self.label_10.adjustSize()
self.label_11.adjustSize()
self.label_12.adjustSize()
self.label_13.adjustSize()
self.label_14.adjustSize()
self.label_30.adjustSize()
self.label_29.adjustSize()
def trouble(self):
self.window = QtWidgets.QMainWindow()
self.ui = Ui_MainWindow3()
self.ui.setupUi(self.window)
self.window.show()
def photoframe(self):
if self.ui.checkBox_10.isChecked() == True:
self.label_9.setStyleSheet("border: 2px solid black;")
else:
self.label_9.setStyleSheet("border: 0px solid black;")
def redline(self):
pixmap = QPixmap(r'D:\finalapp\images\redline.jpeg')
self.label_16.setPixmap(pixmap)
self.label_16.setScaledContents(True)
self.label_18.setPixmap(pixmap)
self.label_18.setScaledContents(True)
def frontpageheader(self):
if self.ui.checkBox.isChecked() == True:
self.topimage()
else:
self.label_7.clear()
def rearpagefooter(self):
if self.ui.checkBox_6.isChecked() == True:
self.nextpagebottomimage()
else:
self.label_19.clear()
def phnno(self):
if self.ui.checkBox_14.isChecked() == True:
self.label_14.setText("Mobile No:" + self.text_ex['mobile no'])
else:
self.label_14.clear()
def put_uid(self):
sentence = self.text_ex['Adhaar no']
space = sentence.replace(" ", "")
number = space
import barcode
from barcode.writer import ImageWriter
ITF = barcode.get_barcode_class('itf')
itf = ITF(number, writer=ImageWriter())
fullname = itf.save('itf_barcode', options={"write_text": False})
print(fullname)
pixmap = QPixmap('itf_barcode.png')
self.label_26.setPixmap(pixmap)
self.label_26.setScaledContents(True)
def barcode(self):
try:
if self.ui.checkBox_7.isChecked() == True:
self.put_uid()
self.label_28.clear()
self.label_27.clear()
else:
self.label_26.clear()
self.label_28.setText("VID: " + self.text_ex['VID'])
self.label_27.setText(self.text_ex['Adhaar no'])
except:
self.label_26.clear()
self.label_28.setText("VID: " + self.text_ex['VID'])
self.label_27.setText(self.text_ex['Adhaar no'])
def vid(self):
if self.ui.checkBox_15.isChecked() == True:
if (self.text_ex['VID'] != None):
self.label_23.setText("VID: " + self.text_ex['VID'])
self.label_28.setText("VID: " + self.text_ex['VID'])
# self.label_23.setAlignment(Qt.AlignCenter)
# self.label_28.setAlignment(Qt.AlignCenter)
else:
self.label_23.clear()
self.label_28.clear()
def frontpageheadermargin(self):
if self.ui.checkBox_2.isChecked() == True:
pixmap = QPixmap(r'D:\finalapp\images\redline.jpeg')
self.label_16.setPixmap(pixmap)
self.label_16.setScaledContents(True)
else:
self.label_16.clear()
def RearPageFooterMargin(self):
if self.ui.checkBox_5.isChecked() == True:
pixmap = QPixmap(r'D:\finalapp\images\redline.jpeg')
self.label_18.setPixmap(pixmap)
self.label_18.setScaledContents(True)
else:
self.label_18.clear()
def rearpageheader(self):
if self.ui.checkBox_4.isChecked() == True:
self.nextpagetop()
else:
pixmap = QPixmap(None)
self.label_17.setPixmap(pixmap)
self.label_17.setScaledContents(True)
def nextpagetop(self):
pixmap = QPixmap('images/Aadhar Back Side Top.jpg')
self.label_17.setPixmap(pixmap)
self.label_17.setScaledContents(True)
def defaultfooter(self):
pixmap1 = QPixmap('images/footertext/hinditext.jpg')
self.label_15.setPixmap(pixmap1)
self.label_15.setScaledContents(True)
# self.label_15.adjustSize()
def hindifooter(self):
if self.ui.checkBox_16.isChecked() == True:
pixmap1 = QPixmap('images/footertext/hinditext.jpg')
self.label_15.setPixmap(pixmap1)
self.label_15.setScaledContents(True)
else:
pixmap = QPixmap(None)
self.label_15.setPixmap(pixmap)
self.label_15.setScaledContents(True)
def Tamilfooter(self):
if self.ui.checkBox_17.isChecked() == True:
pixmap1 = QPixmap('images/footertext/Tamiltext.png')
self.label_15.setPixmap(pixmap1)
self.label_15.setScaledContents(True)
else:
pixmap = QPixmap(None)
self.label_15.setPixmap(pixmap)
self.label_15.setScaledContents(True)
def Marathifooter(self):
if self.ui.checkBox_19.isChecked() == True:
pixmap1 = QPixmap('images/footertext/Marathitext.png')
self.label_15.setPixmap(pixmap1)
self.label_15.setScaledContents(True)
else:
pixmap = QPixmap(None)
self.label_15.setPixmap(pixmap)
self.label_15.setScaledContents(True)
def Punjabifooter(self):
if self.ui.checkBox_18.isChecked() == True:
pixmap1 = QPixmap('images/footertext/Punjabitext.png')
self.label_15.setPixmap(pixmap1)
self.label_15.setScaledContents(True)
else:
pixmap = QPixmap(None)
self.label_15.setPixmap(pixmap)
self.label_15.setScaledContents(True)
def FrontPageFooter(self):
if self.ui.checkBox_3.isChecked() == True:
if self.ui.checkBox_16.isChecked():
self.hindifooter()
elif self.ui.checkBox_17.isChecked():
self.Tamilfooter()
elif self.ui.checkBox_19.isChecked():
self.Marathifooter()
else:
pixmap = QPixmap(None)
self.label_15.setPixmap(pixmap)
self.label_15.setScaledContents(True)
else:
pixmap = QPixmap(None)
self.label_15.setPixmap(pixmap)
self.label_15.setScaledContents(True)
def put_dd(self):
filename = os.path.join(self.path, "img01.png")
fnt = ImageFont.truetype('arial.ttf', 37)
# create new image
a = self.text_ex["Downloaddate"]
image = Image.new(mode="RGB", size=(440, 100), color="white")
draw = ImageDraw.Draw(image)
draw.text((18, 18), a, font=fnt, fill=(0, 0, 0))
image.save(filename)
# os.system(filename)
angle = 90 # What angle would you like to rotate
self.pixmap = QPixmap(filename) # image for your label
pixmap_rotated = self.pixmap.transformed(
QTransform().rotate(angle), QtCore.Qt.SmoothTransformation)
self.label_31.setPixmap(
pixmap_rotated) # set rotated pixmap into your QLabel
self.label_31.setScaledContents(True)
self.label_31.setAlignment(Qt.AlignCenter)
self.label_31.setStyleSheet("QLabel {background-color: white;}")
def put_id(self):
filename = os.path.join(self.path, "img02.png")
fnt = ImageFont.truetype('arial.ttf', 37)
# create new image
image = Image.new(mode="RGB", size=(440, 100), color="white")
draw = ImageDraw.Draw(image)
a = self.text_ex["Issuedate"]
draw.text((0, 0), a, font=fnt, fill=(0, 0, 0))
image.save(filename)
# os.system(filename)
angle = 270 + 180 # What angle would you like to rotate
self.pixmap = QPixmap(filename) # image for your label
pixmap_rotated = self.pixmap.transformed(
QTransform().rotate(angle), QtCore.Qt.SmoothTransformation)
self.label_32.setPixmap(
pixmap_rotated) # set rotated pixmap into your QLabel
self.label_32.setScaledContents(True)
self.label_32.setAlignment(Qt.AlignCenter)
def dd(self):
if self.ui.checkBox_11.isChecked() == True:
self.put_dd()
else:
pixmap = QPixmap(None)
self.label_31.setPixmap(pixmap)
self.label_31.setScaledContents(True)
def id(self):
if self.ui.checkBox_12.isChecked() == True:
self.put_id()
else:
pixmap = QPixmap(None)
self.label_32.setPixmap(pixmap)
self.label_32.setScaledContents(True)
def uid(self):
if self.ui.checkBox_8.isChecked() == True:
self.put_uid()
else:
pixmap = QPixmap(None)
self.label_26.setPixmap(pixmap)
self.label_26.setScaledContents(True)
def open_settings(self):
self.window = QtWidgets.QMainWindow()
self.ui = Ui_MainWindow1()
self.ui.setup(self.window)
self.ui.checkBox_15.setChecked(True)
self.ui.checkBox_15.toggled.connect(self.vid)
self.ui.checkBox_14.toggled.connect(self.phnno)
self.ui.checkBox_7.toggled.connect(self.barcode)
self.ui.checkBox_2.setChecked(True)
self.ui.checkBox_2.toggled.connect(self.frontpageheadermargin)
self.ui.checkBox_5.setChecked(True)
self.ui.checkBox_5.toggled.connect(self.RearPageFooterMargin)
self.ui.checkBox.setChecked(True)
self.ui.checkBox.toggled.connect(self.frontpageheader)
self.ui.checkBox_6.setChecked(True)
self.ui.checkBox_6.toggled.connect(self.rearpagefooter)
# self.ui.checkBox_10.setChecked(True)
self.ui.checkBox_10.toggled.connect(self.photoframe)
self.ui.checkBox_4.setChecked(True)
self.ui.checkBox_4.toggled.connect(self.rearpageheader)
self.ui.checkBox_16.setChecked(True)
self.ui.checkBox_16.toggled.connect(self.hindifooter)
self.ui.checkBox_17.toggled.connect(self.Tamilfooter)
self.ui.checkBox_18.toggled.connect(self.Punjabifooter)
self.ui.checkBox_19.toggled.connect(self.Marathifooter)
self.ui.checkBox_3.setChecked(True)
self.ui.checkBox_3.toggled.connect(self.FrontPageFooter)
self.ui.checkBox_11.toggled.connect(self.dd)
self.ui.checkBox_12.toggled.connect(self.id)
self.ui.checkBox_8.toggled.connect(self.uid)
self.window.show()
def resizeimage(self):
self.Resize = QtWidgets.QMainWindow()
self.ui2 = Ui_MainWindow9()
self.ui2.setupUi(self.Resize)
self.ui2.horizontalSlider_11.valueChanged[int].connect(self.height)
self.ui2.horizontalSlider_10.valueChanged[int].connect(self.Width)
self.ui2.horizontalSlider_9.valueChanged[int].connect(self.side)
self.Resize.show()
def side(self, value):
w = self.ui2.horizontalSlider_9.value()
self.label_25.resize(w, w)
def height(self, value):
w = self.ui2.horizontalSlider_10.value()
self.label_9.resize(w, value)
def Width(self, value):
h = self.ui2.horizontalSlider_11.value()
self.label_9.resize(value, h)
class IconEditor(QWidget):
def __init__(self):
super(IconEditor, self).__init__()
self.setAttribute(Qt.WA_StaticContents)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.curColor = Qt.black
self.zoom = 8 * 1
self.image = QImage(16, 16, QImage.Format_ARGB32)
self.image.fill(qRgba(0, 0, 0, 0))
def penColor(self):
return self.curColor
def setPenColor(self, newColor):
self.curColor = newColor
def zoomFactor(self):
return self.zoom
def setZoomFactor(self, newZoom):
if newZoom < 1:
newZoom = 1
if newZoom != self.zoom:
self.zoom = newZoom
self.update()
self.updateGeometry()
def iconImage(self):
return self.image
def setIconImage(self, newImage):
if newImage != self.image:
print('updating image')
self.image = newImage.convertToFormat(QImage.Format_ARGB32)
self.update()
self.updateGeometry()
def sizeHint(self):
size = self.zoom * self.image.size()
if self.zoom >= 3:
size += QSize(1, 1)
return size
def pixelRect(self, i, j):
if self.zoom >= 3:
return QRect(self.zoom * i + 1, self.zoom * j + 1, self.zoom - 1,
self.zoom - 1)
else:
return QRect(self.zoom * i, self.zoom * j, self.zoom, self.zoom)
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.setImagePixel(event.pos(), True)
print('mouse left press')
elif event.button() == Qt.RightButton:
self.setImagePixel(event.pos(), False)
print('mouse right press')
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
self.setImagePixel(event.pos(), True)
elif event.buttons() & Qt.RightButton:
self.setImagePixel(event.pos(), False)
def setImagePixel(self, pos, opaque):
i = pos.x() // self.zoom
j = pos.y() // self.zoom
print(f'setting pixel ({i}, {j})')
if self.image.rect().contains(i, j):
if opaque:
penC = QColor('black')
self.image.setPixel(i, j, penC.rgba())
# self.image.setPixel(i, j, QColor(255, i*2.56, j*2.56, 255).rgb())
else:
print('#' * 10)
self.image.setPixel(QPoint(i, j), qRgba(0, 0, 0, 0))
print(f'Pixel Rect: {self.pixelRect(i,j)}')
self.update(self.pixelRect(i, j))
def paintEvent(self, event):
painter = QPainter(self)
if self.zoom >= 3:
painter.setPen(self.palette().foreground().color())
# painter.setPen(QPen('red'))
for i in range(0, self.image.width()):
painter.drawLine(self.zoom * i, 0, self.zoom * i,
self.zoom * self.image.height())
for j in range(0, self.image.height()):
painter.drawLine(0, self.zoom * j,
self.zoom * self.image.width(), self.zoom * j)
for i in range(0, self.image.width()):
for j in range(0, self.image.height()):
rect = self.pixelRect(i, j)
if event.region().intersected(rect):
color = QColor.fromRgba(self.image.pixel(i, j))
if color.alpha() < 255:
painter.fillRect(rect, Qt.white)
painter.fillRect(rect, color)
penColorProperty = property(QColor, penColor, setPenColor)
iconImageProperty = property(QImage, iconImage, setIconImage)
zoomFactorProperty = property(int, zoomFactor, setZoomFactor)
