def mouseDoubleClickEvent(self, e):
x = e.x()
y = e.y()
if image.getpixel((x, y)) == (255, 255, 255, 255):
ImageDraw.floodfill(image, (x, y), (50, 205, 50, 255))
self.setPixmap(QPixmap.fromImage(ImageQt.ImageQt(image)))
curTer = self.list.currentItem().text()
if curTer not in config:
config.update(OrderedDict({curTer: [(x, y)]}))
else:
config[curTer] += [(x, y)]
item = self.list.currentItem()
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
def configScan(self):
self.dev.resolution = int(self.ui.resolutions.currentText())
self.dev.mode = self.checkScanMode()
self.dev.start()
im = self.dev.snap()
pix = ImageQt.ImageQt(im.convert('RGBA'))
#self.configWin.im = im
#self.configWin.ui.view.setPixmap(self.configWin.pixmap.fromImage(pix))
self.configWin.pixmapItem.setPixmap(QPixmap.fromImage(pix))
self.configWin.ui.view.fitInView(self.configWin.pixmapItem,
Qt.KeepAspectRatio)
self.configWin.pixmapItem.grabMouse()
self.configWin.setBufferImage()
self.configWin.enhanceImage()
def showImage(self, fname):
"""Show the masked images"""
value = self.comboBox.currentIndex()
img = Image.open(fname).convert('RGB')
self.img_original = img.resize(self.opt.loadSize)
if value < 4:
self.img = self.img_original
else:
self.img = self.img_original
sub_img = Image.fromarray(np.uint8(255 * np.ones((128, 128, 3))))
mask = Image.fromarray(np.uint8(255 * np.ones((128, 128))))
self.img.paste(sub_img, box=(64, 64), mask=mask)
self.show_image = ImageQt.ImageQt(self.img)
self.new_painter(self.show_image)
def pixelate_image(self):
grid_offset = int(self.spinBox_offset_pixel_grid.value())
pixel_size = int(self.spinBox_pixel_size.value())
x_size = floor(
(self.original_image.size[0] - grid_offset) / pixel_size)
y_size = floor(
(self.original_image.size[1] - grid_offset) / pixel_size)
self.reset_pixel_perfected_image()
img_as_array = np.array(self.pixel_perfected_image)
for y in range(y_size):
for x in range(x_size):
sub_image = self.pixel_perfected_image.crop(
(x * pixel_size + grid_offset,
y * pixel_size + grid_offset,
(x * pixel_size) + pixel_size + grid_offset,
(y * pixel_size) + pixel_size + grid_offset))
colours = sub_image.getcolors(sub_image.size[0] *
sub_image.size[1])
# Pink debugging default colour
final_colour = (255, 0, 255)
if self.radioButton_common_colour.isChecked():
final_colour = max(colours, key=lambda x: x[0])[1]
elif self.radioButton_colours_average.isChecked():
for i, colour in enumerate(colours):
colours[i] = cvtColor(
np.asarray([[colour[1]]], dtype='float32') / 255,
COLOR_RGB2Lab)
final_colour = sum(colours) / len(colours)
final_colour = cvtColor(final_colour, COLOR_Lab2RGB) * 255
img_as_array[y * pixel_size + grid_offset:(y * pixel_size) +
pixel_size + grid_offset,
x * pixel_size + grid_offset:(x * pixel_size) +
pixel_size + grid_offset] = final_colour
self.pixel_perfected_image = Image.fromarray(img_as_array, mode='RGB')
self.resized_pixel_perfected_image = resize_image(
self.pixel_perfected_image, self.label_size)
self.qimage_resized_pixel_perfected = ImageQt.ImageQt(
self.resized_pixel_perfected_image)
self.displayed_image = QtGui.QPixmap.fromImage(
self.qimage_resized_pixel_perfected)
self.label_img.setPixmap(self.displayed_image)
def load_heif(full_file_name: str, catch_pyheif_exceptions: bool=True, process_name: str=''):
"""
Load HEIF file and convert it to a QImage using Pillow
:param full_file_name: image to load
:return: ImageQt (subclass of QImage). Must keep this in memory for duration of
operations on it
"""
global _error_logged
try:
image = pyheif.read_heif(full_file_name)
except pyheif.error.HeifError:
if not _error_logged:
if process_name:
process_id = "the %s" % process_name
else:
process_id = 'this'
logging.error(
"Error using pyheif to load HEIF file %s. "
"If encountered on another file, this error message will only be repeated once "
"for %s process.", full_file_name, process_id
)
_error_logged = True
if not catch_pyheif_exceptions:
raise
return None
except FileNotFoundError:
if not _error_logged:
if process_name:
process_id = "the %s" % process_name
else:
process_id = 'this'
logging.error(
"FileNotFoundError using pyheif to load HEIF file %s ."
"If encountered on another file, this error message will only be repeated once "
"for %s process.", full_file_name, process_id
)
_error_logged = True
if not catch_pyheif_exceptions:
raise
return None
pillow_image = Image.frombytes(mode=image.mode, size=image.size, data=image.data)
if pillow_image.mode not in ('RGB', 'RGBA', '1', 'L', 'P'):
pillow_image = pillow_image.convert('RGBA')
imageqt = ImageQt.ImageQt(pillow_image)
if imageqt is not None and not imageqt.isNull():
return imageqt
return None
def get_input_image(self, file):
self.input_image = cv2.imread(file)
self.input_image = cv2.cvtColor(self.input_image, cv2.COLOR_BGR2RGB)
self.input_image = cv2.resize(
self.input_image, (self.Graphic.org_image_graphic.width(),
self.Graphic.org_image_graphic.height()),
interpolation=cv2.INTER_NEAREST)
image = Image.fromarray(self.input_image)
scene = QtWidgets.QGraphicsScene()
converted_image = QtGui.QPixmap.fromImage(
QtGui.QImage(ImageQt.ImageQt(image)))
pixmap = QtWidgets.QGraphicsPixmapItem(converted_image)
scene.addItem(pixmap)
self.Graphic.org_image_graphic.setScene(scene)
def getFrame(self, position, scale=None, asQt=True):
self._video.set(cv2.CAP_PROP_POS_FRAMES, position)
ret, frame = self._video.read()
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
image = Image.fromarray(frame)
if scale:
image.thumbnail(scale, Image.ANTIALIAS)
if asQt:
return ImageQt.ImageQt(image)
else:
return image
def Open():
src_path, _ = QFileDialog.getOpenFileName(
filter="Images (*.png *.jpg *.npy *.jpeg)")
if (src_path != "" or src_path != None):
name, exten = splitext(src_path)
image = None
if (exten == ".npy"):
data = load(src_path)
image = Image.fromarray(data)
else:
image = Image.open(src_path)
return (src_path, ImageQt.ImageQt(image), image)
else:
return
def newblend(self):
try:
morpher = Morpher(self.leftImg, self.leftTriangles, self.rightImg, self.rightTriangles)
result = morpher.getImageAtAlpha(self.alpha)
except:
morpher = ColorMorpher(self.leftImg, self.leftTriangles, self.rightImg, self.rightTriangles)
result = morpher.getImageAtAlpha(self.alpha)
# Image.fromarray(result).show()
result = ImageQt.ImageQt(Image.fromarray(result))
graph = QPixmap()
graph.convertFromImage(result)
self.blendscene.addPixmap(graph)
self.graBlend.setScene(self.blendscene)
self.graBlend.fitInView(QGraphicsScene.itemsBoundingRect(self.blendscene), Qt.KeepAspectRatio)
def __init__(self, image: Image.Image, min_height=360):
super().__init__() # Requred;
"""^^^^^^^^^^^^^^^^^^^^^^^"""
self.__image = image
self.__history = []
self.__render_image = ImageQt.ImageQt(self.__image)
self.__tool = SelectoRect()
self.__tool.init(self, ratio=3 / 3.73)
# Setup
self.setMinimumHeight(min_height)
self.setFocus(Qt.MouseFocusReason)
self.__tool.setImage(self.__render_image)
self.__tool.onDoubleClick_r.connect(self._crop) # type: ignore
self.__tool.onDoubleClick_l.connect(self._finalCrop) # type: ignore
def create_thumbnail_from(self, path):
# QImage result = img.scaled(200, 150, Qt::IgnoreAspectRatio, Qt::FastTransformation);
try:
im = Image.open(path)
imageQT = ImageQt.ImageQt(im)
imageQTRescaled = imageQT.scaled(128, 128,
QtCore.Qt.IgnoreAspectRatio,
QtCore.Qt.FastTransformation)
pixmap = QtGui.QPixmap.fromImage(imageQTRescaled)
qt_thumbnail = QtWidgets.QLabel("", self)
qt_thumbnail.setPixmap(pixmap)
except FileNotFoundError:
qt_thumbnail = QtWidgets.QLabel("Bild nicht gefunden", self)
return qt_thumbnail
def __init__(self):
super(Example, self).__init__()
img = hopper().resize((1000, 1000))
qimage = ImageQt.ImageQt(img)
pixmap1 = QtGui.QPixmap.fromImage(qimage)
QHBoxLayout(self) # hbox
lbl = QLabel(self)
# Segfault in the problem
lbl.setPixmap(pixmap1.copy())
def __readImage(self, file):
# frame=Image.open(file)
# self.image=ImageQt.ImageQt(frame).convertToFormat(QImage.Format_RGB888)
try:
frame = Image.open(file)
self.image = ImageQt.ImageQt(frame).convertToFormat(
QImage.Format_RGB888)
# self.image=QPixmap(file)
self.size = frame.size
return True
except:
self.image = None
return False
def pattern_show(self, w, image, ch_num):
a = w.findChild(
QtGui.QLabel,
str(self.LCOS_num) + "_" +
str(int(numpy.floor(ch_num / self.total_w))) + "_" + str(
(ch_num % self.total_w)))
if type(a) != None:
image = ImageQt.ImageQt(image)
a.setPixmap(QtGui.QPixmap.fromImage(image))
a.repaint()
return True
else:
print("Fail to change pattern! No such label with THIS NAME")
return False
def pil_to_pix(self, pil: Image.Image):
if not pil.mode == 'RGBA':
pil = pil.convert('RGBA')
qimage = ImageQt.ImageQt(pil)
if qimage.size().width() < self.min:
qimage = qimage.scaled(
self.min, self.min, Qt.KeepAspectRatio
)
if qimage.size().width() > self.max:
qimage = qimage.scaled(
self.max, self.max, Qt.KeepAspectRatio
)
pix = QPixmap.fromImage(qimage)
return pix
def updateData(self):
mask = self.Hr[self.count, :] # Load a mask as a row vector
img_vec = np.reshape(
self.image, (self.imgWidth * self.imgHeight, 1)) # Image vector
curr_scan = np.dot(
mask, img_vec
) # Perform a scan using dot product of mask row vec and image col vec
self.sensor_readings[
self.count] = curr_scan # Add to vector of sensor reading
if self.noise:
scan_noise = np.random.normal(0, self.noise)
self.sensor_readings[self.count] += scan_noise
curr_res = np.reshape(self.sensor_readings,
(self.imgHeight, self.imgWidth))
# Conversion to QtImage
#curr_res = (curr_res * 255).astype(np.uint8)
curr_res = (curr_res).astype(np.uint8)
res = Image.fromarray(curr_res, mode='L')
resQT = ImageQt.ImageQt(res)
QI = resQT
self.label.setPixmap(
QtGui.QPixmap.fromImage(QI).scaled(self.dispWidth,
self.dispHeight))
if self.count <= 10 or self.count % 100 == 0:
print("Count: %s \n" % self.count)
self.count += 1
if self.count >= self.numMeasurements:
"""
# Vectorize and save sensor readings
self.sensor_readings = np.reshape(self.sensor_readings, (self.numMeasurements, 1))
print("Saving data as %s.npy" % self.outfile)
np.save("%s.npy" % self.outfile, self.sensor_readings)
"""
self.timer.stop()
self.time_final = time.time()
elapsed_time = self.time_final - self.time0
print("\nScan completed")
print("Scan time: %.3f m" % ((elapsed_time // 60)),
" %.3f s" % ((elapsed_time) % 60))
time.sleep(2.0)
self.close()
def requestImage(self, qstr, size):
self._logger.debug('QR requested for %s' % qstr)
qr = qrcode.QRCode(version=1, border=2)
qr.add_data(qstr)
# calculate best box_size
pixelsize = min(self._max_size, 400)
modules = 17 + 4 * qr.best_fit()
qr.box_size = math.floor(pixelsize / (modules + 2 * 2))
qr.make(fit=True)
pimg = qr.make_image(fill_color='black', back_color='white')
self.qimg = ImageQt.ImageQt(pimg)
return self.qimg, self.qimg.size()
def plot_pic(self, dat='points', picture=None):
self.read_from_table()
width = self.plot.width()
height = self.plot.height()
if not picture:
fit_templ = self.textEdit_2.toPlainText()
picture = self.data_fit.prepare_plot(dat, width, height, fit_templ)
picture0 = QtGui.QPixmap.fromImage(ImageQt.ImageQt(picture))
picture = picture0.scaled(width, height, QtCore.Qt.KeepAspectRatio,
QtCore.Qt.SmoothTransformation)
self.plot.setPixmap(picture)
def showPicture(self):
# path, _ = QFileDialog.getOpenFileName(self, '选择图片', 'D:\Python\kears-yolov3-dev\OpenCVtest',
# 'Image files(*.jpg *.gif *.png)')
# img = Image.open(path)
# r_image = self.yolo.detect_image(img) # r_image 为 PIL 图片数据格式
image = Image.open(
'D:\Python\kears-yolov3-dev\OpenCVtest\huajuan1111.jpg')
r_image = self.yolo.detect_image(image)
qim = ImageQt(r_image) # PIL -> Pixmap 格式转换
pix = QtGui.QPixmap.fromImage(qim)
self.PhotoLabel.setPixmap(pix) # 图像更新到UI上
self.PhotoLabel.setScaledContents(True)
def extractEmbedded(self):
image = self.carrier2.extractPayload()
try:
image = Image.fromarray(image.rawData)
except:
return
imageQt = QImage(ImageQt.ImageQt(image))
pixmap = QPixmap.fromImage(imageQt)
scene = QGraphicsScene()
scene.addPixmap(pixmap)
scene.dragMoveEvent = partial(self.dragMoveEvent)
self.viewPayload2.setScene(scene)
self.viewPayload2.fitInView(scene.sceneRect(),
QtCore.Qt.KeepAspectRatio)
self.viewPayload2.show()
def execute(self, x, y):
img_qt = ImageQt.ImageQt(self.img)
pix_map = QPixmap.fromImage(img_qt)
painter = QPainter(pix_map)
painter.setFont(self.root.curr_font)
painter.setPen(QColor(self.root.curr_color))
painter.drawText(x, y, self.root.ui.text_edit.text())
painter.end()
q_img = pix_map.toImage()
buffer = QBuffer()
buffer.open(QBuffer.ReadWrite)
q_img.save(buffer, "PNG")
self.root.scene.new_layer_img = Image.open(io.BytesIO(buffer.data()))
def toQImage(self, image):
if 'Celeb' in self.dataset.name:
mode = 'RGB'
else:
mode = 'L'
img = self.dataset.transform2display(image)
pilimage = Image.fromarray(np.uint8(img * 255), mode)
imageq = ImageQt.ImageQt(pilimage)
qimage = QImage(imageq)
pix = QPixmap(qimage)
pix = pix.scaled(2 * self.image_size, 2 * self.image_size)
return pix
def show_image(self):
# show image
# im = Image.open(self.raw_imgs[self.page])
# im = im.convert("RGBA")
# im.thumbnail((450, 450), Image.ANTIALIAS)
if not self.raw_imgs:
QMessageBox.information(self, 'Fail', 'No image selected.')
return
im = self.raw_imgs[self.page]
img = ImageQt.ImageQt(im)
qimg = QPixmap.fromImage(img)
self.imgLabel_raw.setPixmap(qimg)
self.imgLabel_raw.resize(1, 1)
# show labeld image
if len(self.detect_imgs) > self.page:
self.labeled_img = self.detect_imgs[self.page]
# convert PIL to Qimage
img = ImageQt.ImageQt(self.labeled_img)
img = QPixmap.fromImage(img)
self.imgLabel_detect.setPixmap(img)
self.imgLabel_detect.resize(1, 1)
if not self.detect_imgs:
self.imgLabel_detect.clear()
def loadImage(self):
try:
image = Image.open(self.path)
except FileNotFoundError: # TODO: exception handler
pass
else:
if image.width > self.IMAGE_MAX_WIDTH:
Util.proportionalThumbnail(image, width=self.IMAGE_MAX_WIDTH)
if image.height > self.IMAGE_MAX_HEIGHT:
Util.proportionalThumbnail(image, height=self.IMAGE_MAX_HEIGHT)
self.image = ImageQt.ImageQt(image)
def showImage(self,frame,pic):
h,w = pic.shape[0],pic.shape[1]
hFrame,wFrame = frame.height(),frame.width()
img = cv2.resize(pic,(wFrame,hFrame))
if len(pic.shape) == 2:
qPix = QPixmap.fromImage(ImageQt.ImageQt(misc.toimage(img)))
else:
ch = 3
img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
qImg = QImage(img.data,wFrame,hFrame,ch*wFrame,QImage.Format_RGB888)
qPix = QPixmap(qImg)
frame.setPixmap(qPix)
def refreshImage(self):
colors = ('darkred', 'orangered', 'goldenrod',
'darkgreen', 'darkblue', 'blueviolet',
'red','orange','yellow','green','blue','violet')
if self.data_loaded:
plane = np.take(self.volume,
self.slider.value(),
axis=self.current_view)
if self.current_view == 2:
plane = plane.T
im8 = Image.fromarray(plane)
else:
im8 = Image.fromarray(np.ones((1024,1024),dtype='uint8')*255)
imQt = QImage(ImageQt.ImageQt(im8))
imQt = imQt.convertToFormat(QImage.Format_RGB16)
#print(self.current_view)
#print(self.slider.value())
if self.data_loaded:
for idx, row in self.annotations.iterrows():
if self.current_view == 0:
shouldDraw = row.AP == self.slider.value()
x = row.ML
y = row.DV
elif self.current_view == 1:
shouldDraw = row.DV == self.slider.value()
x = row.ML
y = row.AP
elif self.current_view == 2:
shouldDraw = row.ML == self.slider.value()
x = 1023 - row.AP
y = row.DV
if shouldDraw:
color = QColor(self.color_map[row.probe_name])
for j in range(x-10,x+10):
for k in range(y-10,y+10):
if pow(j-x,2) + pow(k-y,2) < 20:
imQt.setPixelColor(j,k,color)
pxmap = QPixmap.fromImage(imQt).scaledToWidth(800).scaledToHeight(800)
self.image.setPixmap(pxmap)
def display_image(self):
fps = ueye.DOUBLE()
ueye.is_GetFramesPerSecond(self.hCam, fps)
timeout = int((5 / fps) * 1000)
h_event = None
if platform.system() == 'Windows':
h_event = win32event.CreateEvent(None, False, False, None)
self.event = ueye.HANDLE(int(h_event))
ueye.is_InitEvent(self.hCam, self.event, self.frame_event_id)
ueye.is_EnableEvent(self.hCam, self.frame_event_id)
while True:
ret = None
if not self.capturing:
break
if platform.system() == 'Windows':
ret = win32event.WaitForSingleObject(h_event, timeout)
elif platform.system() == 'Linux':
ret = ueye.is_WaitEvent(self.hCam, self.frame_event_id,
timeout)
if ret == 0:
converted_image_data = self.convert_image_data()
self.image_data_copy = (
ueye.CHAR *
int(self.img_data.width * self.img_data.height * 3))()
ueye.is_CopyImageMem(
hCam=self.hCam,
pcSource=converted_image_data.memory_pointer,
nID=converted_image_data.memory_id,
pcDest=self.image_data_copy)
bytes_per_pixel = 3
self.image_data_copy = numpy.reshape(
self.image_data_copy,
(int(self.img_data.height), int(
self.img_data.width), bytes_per_pixel))
self.image_data_copy = self.image_data_copy.view(numpy.uint8)
self.pil_image = Image.fromarray(self.image_data_copy)
self.graphics_scene.clear()
self.width, self.height = self.pil_image.size
self.qt_image = ImageQt.ImageQt(self.pil_image)
self.pix_map = QPixmap.fromImage(self.qt_image)
self.graphics_scene.addPixmap(self.pix_map)
self.graphics_view.fitInView(
QRectF(0, 0, self.width, self.height), Qt.KeepAspectRatio)
self.graphics_scene.update()
app.processEvents()
def set_table_view(self, index):
from operator import itemgetter
from copy import deepcopy
self.S2_tableWidget.clearContents()
def item_make(string, flag):
_item = QtWidgets.QTableWidgetItem(string)
if flag is True:
_item.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEditable
| QtCore.Qt.ItemIsEnabled)
else:
_item.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
return _item
from PIL import ImageQt
table = self.S2_tableWidget
file = self.file_list[index]
symbols = self.Symbol_list[index]
img = file['img']
Remarks = file['path']
cnt = 0
table.setRowCount(0)
temp_list = deepcopy(symbols)
temp_list = sorted(temp_list,
key=lambda k: "".join(k['detail']),
reverse=True)
for item in temp_list:
table.insertRow(cnt)
table.setRowHeight(cnt, 50)
type = self.classes[item['type']]
if item['detail'] is not None:
detail = "".join(item['detail'])
else:
detail = "None"
croped_img = img.crop(item['coord'])
imgQ = ImageQt.ImageQt(croped_img)
imgQ = imgQ.scaled(50, 50, QtCore.Qt.KeepAspectRatio)
image = QtWidgets.QLabel()
image.setPixmap(QtGui.QPixmap.fromImage(imgQ))
table.setCellWidget(cnt, 0, image)
table.setItem(cnt, 1, item_make(type, False))
table.setItem(cnt, 2, item_make(detail, True))
table.setItem(cnt, 3, item_make(Remarks, False))
cnt += 1
def painting(self, image, x, y, w, h, color):
img = copy.deepcopy(image)
a = img.load()
b = color.name()[1:]
h1, h2, h3 = '0x' + b[0:2], '0x' + b[2:4], '0x' + b[4:6]
b = (int(h1, 16), int(h2, 16), int(h3, 16))
for i in range(x, x + w):
for j in range(y, y + h):
a[i, j] = b
pixmap = QPixmap.fromImage(ImageQt.ImageQt(img))
pixmap.detach()
del a
return (img, pixmap)
def create_order_fail(self):
im = Image.open(self.img_path)
im = im.convert('RGBA')
draw = ImageDraw.Draw(im)
font = ImageFont.truetype(self.size_font_path, size=60, index=0)
text1 = "SORRY当前订单创建失败"
text2 = "请您稍后重试"
draw.text((600, 590), text1.decode('utf-8'), fill=(0, 0, 0), font=font)
draw.text((600, 650), text2.decode('utf-8'), fill=(0, 0, 0), font=font)
# im.resize((1920, 1080))
fruit_img = ImageQt.ImageQt(im)
qimg = QtGui.QImage(fruit_img)
fruit_img = QtGui.QPixmap.fromImage(qimg)
pixmap = QtGui.QPixmap(fruit_img)
scaredPixmap = pixmap.scaled(1920, 1080, QtCore.Qt.IgnoreAspectRatio)
self.background_img.setPixmap(scaredPixmap)
