def _save_image(self):
file_name, _ = QFileDialog.getSaveFileName(self._widget, self.tr('Save as image'), 'rospackgraph.png', self.tr('Image (*.bmp *.jpg *.png *.tiff)'))
if file_name is None or file_name == '':
return
img = QImage((self._scene.sceneRect().size() * 2.0).toSize(), QImage.Format_ARGB32_Premultiplied)
painter = QPainter(img)
painter.setRenderHint(QPainter.Antialiasing)
self._scene.render(painter)
painter.end()
img.save(file_name)
def _save_image(self):
file_name, _ = QFileDialog.getSaveFileName(self._widget, self.tr('Save as image'), 'rosgraph.png', self.tr('Image (*.bmp *.jpg *.png *.tiff)'))
if file_name is None or file_name == '':
return
img = QImage((self._scene.sceneRect().size() * 2.0).toSize(), QImage.Format_ARGB32_Premultiplied)
painter = QPainter(img)
painter.setRenderHint(QPainter.Antialiasing)
self._scene.render(painter)
painter.end()
img.save(file_name)
def fome_raw(self, data):
try:
cvImage = self.bridge.imgmsg_to_cv2(data, "bgr8")
except CvBridgeError as e:
print(e)
height, width, byteValue = cvImage.shape
byteValue = byteValue * width
cv2.cvtColor(cvImage, cv2.COLOR_BGR2RGB, cvImage)
r_image = QImage(cvImage, width, height, byteValue,
QImage.Format_RGB888)
r_image = QPixmap.fromImage(r_image)
r_image = r_image.scaledToHeight(300)
self.r_label.setPixmap(r_image)
def map_cb(self, msg):
map_hash = hash(msg.data)
if map_hash == self._map_hash:
rospy.logdebug("Skipping map cb, because the map is the same")
return
self._map_hash = map_hash
self.map_resolution = msg.info.resolution
self.map_width = msg.info.width
self.map_height = msg.info.height
self.map_origin = msg.info.origin
self.frame_id = msg.header.frame_id
a = numpy.array(msg.data, dtype=numpy.uint8, copy=False, order='C')
a = a.reshape((self.map_height, self.map_width))
if self.map_width % 4:
e = numpy.empty((self.map_height, 4 - self.map_width % 4),
dtype=a.dtype,
order='C')
a = numpy.append(a, e, axis=1)
image = QImage(a.reshape((a.shape[0] * a.shape[1])), self.map_width,
self.map_height, QImage.Format_Indexed8)
for i in reversed(range(101)):
image.setColor(100 - i, qRgb(i * 2.55, i * 2.55, i * 2.55))
image.setColor(101, qRgb(255, 0, 0)) # not used indices
image.setColor(255, qRgb(200, 200, 200)) # color for unknown value -1
self._map = image
self.setSceneRect(0, 0, self.map_width, self.map_height)
self.map_changed.emit()
def make_icon(self, image_list, mode=QIcon.Normal, state=QIcon.On):
"""
Helper function to create QIcons from lists of image files
Warning: svg files interleaved with other files will not render correctly
:param image_list: list of image paths to layer into an icon.
:type image: list of str
:param mode: The mode of the QIcon to be created.
:type mode: int
:param state: the state of the QIcon to be created.
:type state: int
"""
if type(image_list) is not list:
image_list = [image_list]
if len(image_list) <= 0:
raise TypeError('The list of images is empty.')
num_svg = 0
for item in image_list:
if item[-4:].lower() == '.svg':
num_svg = num_svg + 1
if num_svg != len(image_list):
# Legacy support for non-svg images
icon_pixmap = QPixmap()
icon_pixmap.load(image_list[0])
painter = QPainter(icon_pixmap)
for item in image_list[1:]:
painter.drawPixmap(0, 0, QPixmap(item))
icon = QIcon()
icon.addPixmap(icon_pixmap, mode, state)
painter.end()
return icon
else:
# rendering SVG files into a QImage
renderer = QSvgRenderer(image_list[0])
icon_image = QImage(renderer.defaultSize(), QImage.Format_ARGB32)
icon_image.fill(0)
painter = QPainter(icon_image)
renderer.render(painter)
if len(image_list) > 1:
for item in image_list[1:]:
renderer.load(item)
renderer.render(painter)
painter.end()
# Convert QImage into a pixmap to create the icon
icon_pixmap = QPixmap()
icon_pixmap.convertFromImage(icon_image)
icon = QIcon(icon_pixmap)
return icon
def make_icon(self, image_list, mode=QIcon.Normal, state=QIcon.On):
"""
Helper function to create QIcons from lists of image files
Warning: svg files interleaved with other files will not render correctly
:param image_list: list of image paths to layer into an icon.
:type image: list of str
:param mode: The mode of the QIcon to be created.
:type mode: int
:param state: the state of the QIcon to be created.
:type state: int
"""
if type(image_list) is not list:
image_list = [image_list]
if len(image_list) <= 0:
raise TypeError('The list of images is empty.')
num_svg = 0
for item in image_list:
if item[-4:].lower() == '.svg':
num_svg = num_svg + 1
if num_svg != len(image_list):
# Legacy support for non-svg images
icon_pixmap = QPixmap()
icon_pixmap.load(image_list[0])
painter = QPainter(icon_pixmap)
for item in image_list[1:]:
painter.drawPixmap(0, 0, QPixmap(item))
icon = QIcon()
icon.addPixmap(icon_pixmap, mode, state)
painter.end()
return icon
else:
# rendering SVG files into a QImage
renderer = QSvgRenderer(image_list[0])
icon_image = QImage(renderer.defaultSize(), QImage.Format_ARGB32)
icon_image.fill(0)
painter = QPainter(icon_image)
renderer.render(painter)
if len(image_list) > 1:
for item in image_list[1:]:
renderer.load(item)
renderer.render(painter)
painter.end()
# Convert QImage into a pixmap to create the icon
icon_pixmap = QPixmap()
icon_pixmap.convertFromImage(icon_image)
icon = QIcon(icon_pixmap)
return icon
def _export(self):
file_name, _ = QFileDialog.getSaveFileName(
self, self.tr("Save as image"), "graph.png", self.tr("Image (*.bmp *.jpg *.png *.tiff)")
)
if file_name is None or file_name == "":
return
img = QImage((self._scene.sceneRect().size() * 2.0).toSize(), QImage.Format_ARGB32_Premultiplied)
painter = QPainter(img)
painter.setRenderHint(QPainter.Antialiasing)
self._scene.render(painter)
painter.end()
img.save(file_name)
def _load_images(self):
images_path = os.path.join(rospkg.RosPack().get_path('rqt_vviz'),
'resource', 'img')
self.images = {}
for img_file in os.listdir(images_path):
self.images[img_file.split('.')[0]] = QImage(
os.path.join(images_path, img_file))
def callback(self, msg):
self.w = msg.width
self.h = msg.height
a = self.bridge.imgmsg_to_cv(msg, "rgb8")
a = numpy.array(a)
image = QImage(a, self.w, self.h, QImage.Format_RGB888)
self._map = image
self._scene.setSceneRect(0, 0, self.w, self.h)
self.image_changed.emit()
def image_callback(self, ros_data):
np_arr = np.fromstring(ros_data.data, np.uint8)
image = cv.imdecode(np_arr, cv.IMREAD_COLOR)
height, width, _ = image.shape
bytes_per_line = 3 * width
qImage = QImage(image.data, width, height, bytes_per_line,
QImage.Format_RGB888).rgbSwapped()
pix = QPixmap(qImage)
h_label = self._widget.videoDisplay.height()
w_label = self._widget.videoDisplay.width()
self._widget.videoDisplay.setPixmap(
pix.scaled(w_label, h_label, Qt.KeepAspectRatio))
def redraw(self):
with self.lock:
if self.cv_image != None:
size = self.cv_image.shape
img = QImage(self.cv_image.data, size[1], size[0],
size[2] * size[1], QImage.Format_RGB888)
# convert to QPixmap
self.pixmap = QPixmap(size[1], size[0])
self.pixmap.convertFromImage(img)
self.label.setPixmap(
self.pixmap.scaled(self.label.width(), self.label.height(),
QtCore.Qt.KeepAspectRatio))
def __init__(self, map_image_location, parent=None):
super(MapImage, self).__init__(parent)
# Image
self.setFixedHeight(700)
self.setFixedWidth(1300)
self.setObjectName("map_image")
# Set defaults to handle mouse events, as if these are not setup and a user clicks on the image, then all future
# mouse events are ignored.
self.enableDefaultMouseHooks()
map_image = QImage(map_image_location)
self.map_image = map_image.scaled(1300, 700, Qt.KeepAspectRatio)
# Create a pixmap for the overlay. This will be modified by functions to change what is being displayed
# on the screen.
self.overlay_image = QImage(self.map_image.size(), QImage.Format_ARGB32_Premultiplied)
self.overlay_image.fill(Qt.transparent)
self.update()
def msg_to_pixmap(self, msg):
cv_img = self.bridge.imgmsg_to_cv2(msg)
shape = cv_img.shape
if len(shape) == 3 and shape[2] == 3: # RGB888
h, w, _ = shape
bytesPerLine = 3 * w
img_format = QImage.Format_RGB888
else: # Grayscale8
h, w = shape[0], shape[1]
bytesPerLine = 1 * w
img_format = QImage.Format_Grayscale8
q_img = QImage(cv_img.data, w, h, bytesPerLine, img_format)
return QPixmap.fromImage(q_img).scaled(320, 240)
def glview_paintGL(self):
self._glview.paintGL_original()
self.draw_basic_objects()
if self.cnt == 0:
print 'DRAW!'
self.qimage = QImage('/home/matsunolab/Pictures/testimage_big.jpg',
'JPEG') # GL_TEXTURE_2D
self.texture = self._glview.get_texture(self.qimage)
my_glfuncs.map_texture_on_sphere2(self.texture, 1500, 30, 30)
self.cnt += 1
class MapImage(QLabel):
def __init__(self, map_image_location, parent=None):
super(MapImage, self).__init__(parent)
# Image
self.setFixedHeight(700)
self.setFixedWidth(1300)
self.setObjectName("map_image")
# Set defaults to handle mouse events, as if these are not setup and a user clicks on the image, then all future
# mouse events are ignored.
self.enableDefaultMouseHooks()
map_image = QImage(map_image_location)
self.map_image = map_image.scaled(1300, 700, Qt.KeepAspectRatio)
# Create a pixmap for the overlay. This will be modified by functions to change what is being displayed
# on the screen.
self.overlay_image = QImage(self.map_image.size(),
QImage.Format_ARGB32_Premultiplied)
self.overlay_image.fill(Qt.transparent)
self.update()
def defaultMouseHandler(self, event):
# Do nothing.
pass
def enableDefaultMouseHooks(self):
self.mousePressEvent = self.defaultMouseHandler
self.mouseMoveEvent = self.defaultMouseHandler
self.mouseReleaseEvent = self.defaultMouseHandler
def paintEvent(self, event):
painter = QPainter(self)
painter.drawImage(event.rect(), self.map_image, event.rect())
painter.drawImage(event.rect(), self.overlay_image, event.rect())
painter.end()
class MapImage(QLabel):
def __init__(self, map_image_location, parent=None):
super(MapImage, self).__init__(parent)
# Image
self.setFixedHeight(700)
self.setFixedWidth(1300)
self.setObjectName("map_image")
# Set defaults to handle mouse events, as if these are not setup and a user clicks on the image, then all future
# mouse events are ignored.
self.enableDefaultMouseHooks()
map_image = QImage(map_image_location)
self.map_image = map_image.scaled(1300, 700, Qt.KeepAspectRatio)
# Create a pixmap for the overlay. This will be modified by functions to change what is being displayed
# on the screen.
self.overlay_image = QImage(self.map_image.size(), QImage.Format_ARGB32_Premultiplied)
self.overlay_image.fill(Qt.transparent)
self.update()
def defaultMouseHandler(self, event):
# Do nothing.
pass
def enableDefaultMouseHooks(self):
self.mousePressEvent = self.defaultMouseHandler
self.mouseMoveEvent = self.defaultMouseHandler
self.mouseReleaseEvent = self.defaultMouseHandler
def paintEvent(self, event):
painter = QPainter(self)
painter.drawImage(event.rect(), self.map_image, event.rect())
painter.drawImage(event.rect(), self.overlay_image, event.rect())
painter.end()
def updateCupMask(self, img):
try:
image = self.__cvBridge.imgmsg_to_cv2(img) # Convert ROS' sensor_msgs/Image to cv2 image
image = cv2.merge((image, image, image)) # QImage only supports colour images or 1-bit mono (which opencv does not)
height, width = image.shape[:2]
frame = QImage(image.data, width, height, QImage.Format_RGB888)
self.__cupImageScene.clear()
self.__cupImageScene.addPixmap(QPixmap.fromImage(frame))
self.__cupImageScene.update()
self._widget.cupGraphicsView.setScene(self.__cupImageScene)
self._widget.cupGraphicsView.ensureVisible(self.__cupImageScene.sceneRect());
self._widget.cupGraphicsView.fitInView(self.__cupImageScene.sceneRect(), Qt.KeepAspectRatio);
except Exception as e:
rospy.logerr("update updatecupMask: %s", e)
def shutter_clicked_event(self):
try:
theta_capture = rospy.ServiceProxy('theta_capture',
ThetaCaptureService)
print 'request!'
res = theta_capture(GRAB_CURRENT_IMAGE)
print 'grabbed!'
self.parent.jpeg_data = res.image_msg.data
f = open('.temp', 'wb')
f.write(self.parent.jpeg_data)
f.close()
self.parent.qimage = QImage('.temp', 'JPEG')
except rospy.ServiceException, e:
print "Service call failed: %s" % e
def draw_hist_lab(self, histRGB):
# histRGB = np.log2(histRGB)
new_h = cv2.resize(histRGB.astype('uint8'),
dsize=(400, 400),
interpolation=cv2.INTER_CUBIC)
# new_h = histRGB.copy().astype('uint8')
# cv2.imshow("to draw", new_h)
# cv2.waitKey(1)
rospy.loginfo('new_h shape {}'.format(new_h.shape))
h, w, c = new_h.shape
total = new_h.nbytes
perLine = int(total / h)
if c == 3:
q_img = QImage(new_h.data, w, h, perLine, QImage.Format_RGB888)
elif c == 4:
q_img = QImage(new_h.data, w, h, perLine, QImage.Format_RGBA8888)
q = QPixmap.fromImage(q_img)
self.inner_luv_hist.setFixedWidth(400)
self.inner_luv_hist.setFixedHeight(400)
self.inner_luv_hist.setPixmap(q)
def writeLocationsToFile(self):
out_dict = {}
out_dict["locations"] = self.locations.keys()
out_dict["polygons"] = []
for index, location in enumerate(self.locations):
out_dict["polygons"].append([])
for i in range(self.locations[location].size()):
pt = self.locations[location].point(i)
scaled_pt = scalePoint(pt, self.image_size, self.map_size)
out_dict["polygons"][index].append(scaled_pt.x())
out_dict["polygons"][index].append(scaled_pt.y())
data_directory = os.path.dirname(os.path.realpath(self.location_file))
image_file = getLocationsImageFileLocationFromDataDirectory(data_directory)
# Create an image with the location data, so that C++ programs don't need to rely on determining regions using polygons.
out_dict["data"] = 'locations.pgm'
location_image = QImage(self.map_size, QImage.Format_RGB32)
location_image.fill(Qt.white)
painter = QPainter(location_image)
for index, location in enumerate(self.locations):
if index > 254:
rospy.logerr("You have more than 254 locations, which is unsupported by the bwi_planning_common C++ code!")
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(index, index, index))
scaled_polygon = scalePolygon(self.locations[location], self.image_size, self.map_size)
painter.drawPolygon(scaled_polygon)
painter.end()
location_image.save(image_file)
stream = open(self.location_file, 'w')
yaml.dump(out_dict, stream)
stream.close()
self.is_modified = False
def updateImage(self, img):
try:
img.encoding = "bgr8" # no, it's not but cv_bridge can't handle hsv
image = self.__cvBridge.imgmsg_to_cv2(img) # Convert ROS' sensor_msgs/Image to cv2 image
self.__lastHSVimage = image.copy()
image = cv2.cvtColor(image, cv2.COLOR_HSV2RGB)
height, width = image.shape[:2]
frame = QImage(image.data, width, height, QImage.Format_RGB888)
self.__colorImageScene.clear()
self.__colorImageScene.addPixmap(QPixmap.fromImage(frame))
self.__colorImageScene.update()
self._widget.lightCorrectedGraphicsView.setScene(self.__colorImageScene)
self._widget.lightCorrectedGraphicsView.ensureVisible(self.__colorImageScene.sceneRect());
self._widget.lightCorrectedGraphicsView.fitInView(self.__colorImageScene.sceneRect(), Qt.KeepAspectRatio);
except Exception as e:
rospy.logerr("update image: %s", e)
def rgb_msg_to_pixmap(self, msg):
# print("before",msg.msg.encoding)
msg.encoding = "bgr8"
# print("after",msg.encoding)
cv_img = self.bridge.imgmsg_to_cv2(msg, "rgb8")
shape = cv_img.shape
if len(shape) == 3 and shape[2] == 3: # RGB888
h, w, _ = shape
bytesPerLine = 3 * w
img_format = QImage.Format_RGB888
else: # Grayscale8
h, w = shape[0], shape[1]
bytesPerLine = 1 * w
img_format = QImage.Format_Grayscale8
q_img = QImage(cv_img.data, w, h, bytesPerLine, img_format)
return QPixmap.fromImage(q_img).scaled(320, 240)
def obj_det_callback(self, data):
if self.view != OBD:
return
if self.frozen:
return
img = self.brd.imgmsg_to_cv2(data, 'rgb8')
# cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, dsize=(1280, 720), interpolation=cv2.INTER_CUBIC)
h, w, c = img.shape
q_img = QImage(img.data, w, h, 3 * w, QImage.Format_RGB888)
q = QPixmap.fromImage(q_img)
self.wdg_img.setFixedWidth(w)
self.wdg_img.setFixedHeight(h)
self.wdg_img.setPixmap(q)
def luv_callback(self, data):
if self.view != LUV:
return
img = self.brd.imgmsg_to_cv2(data, 'rgb8')
# cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, dsize=(1280, 720), interpolation=cv2.INTER_CUBIC)
h, w, c = img.shape
# rospy.loginfo('shape {}'.format(img.shape))
q_img = QImage(img.data, w, h, 3 * w, QImage.Format_RGB888)
q = QPixmap.fromImage(q_img)
# self.wdg_img.setFixedWidth(w)
# self.wdg_img.setFixedHeight(h)
self.wdg_img.setPixmap(q)
def map_cb(self, msg):
self.resolution = msg.info.resolution
self.w = msg.info.width
self.h = msg.info.height
a = numpy.array(msg.data, dtype=numpy.uint8, copy=False, order='C')
a = a.reshape((self.h, self.w))
if self.w % 4:
e = numpy.empty((self.h, 4 - self.w % 4), dtype=a.dtype, order='C')
a = numpy.append(a, e, axis=1)
image = QImage(a.reshape((a.shape[0] * a.shape[1])), self.w, self.h, QImage.Format_Indexed8)
for i in reversed(range(101)):
image.setColor(100 - i, qRgb(i* 2.55, i * 2.55, i * 2.55))
image.setColor(101, qRgb(255, 0, 0)) # not used indices
image.setColor(255, qRgb(200, 200, 200)) # color for unknown value -1
self._map = image
self.setSceneRect(0, 0, self.w, self.h)
self.map_changed.emit()
def img_callback(self, data):
if self.view != RGB:
return
img = self.brd.imgmsg_to_cv2(data, 'rgb8')
h, w, c = img.shape
self.orig_h = h
self.orig_w = w
# rospy.loginfo('h {} w {}'.format(h,w))
# cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, dsize=(1280, 720), interpolation=cv2.INTER_CUBIC)
h, w, c = img.shape
q_img = QImage(img.data, w, h, 3 * w, QImage.Format_RGB888)
q = QPixmap.fromImage(q_img)
self.wdg_img.setFixedWidth(1280)
self.wdg_img.setFixedHeight(720)
self.wdg_img.setPixmap(q)
def callback(self, msg):
self.w = msg.info.width
self.h = msg.info.height
self.resolution = msg.info.resolution
self.origin = (msg.info.origin.position.x, msg.info.origin.position.y)
arr = np.array(msg.data, dtype=np.uint8, copy=False, order='C')
arr = arr.reshape((self.h, self.w))
img = QImage(arr.reshape((arr.shape[0] * arr.shape[1])), self.w, self.h, QImage.Format_Indexed8)
#need to invert some colors :)
for z in reversed(range(101)):
img.setColor(100 - z, qRgb(z*2.55, z*2.55, z*2.55))
img.setColor(101, qRgb(255, 0, 0))
img.setColor(255, qRgb(100, 100, 100))
self.map = img
self.setSceneRect(0, 0, self.w, self.h)
self.map_change.emit()
# Explorer laser callback
self.parent.taskplanner.explorer.laser_callback(msg)
def _update_map(self):
"""
Method used in the rqt_nav_view plugin to read the image from the map server.
"""
a = numpy.array(self.map.data,
dtype=numpy.uint8,
copy=False,
order='C')
a = a.reshape((self.map.info.height, self.map.info.width))
if self.map.info.width % 4:
e = numpy.empty(
(self.map.info.height, 4 - self.map.info.width % 4),
dtype=a.dtype,
order='C')
a = numpy.append(a, e, axis=1)
image = QImage(a.reshape(
(a.shape[0] * a.shape[1])), self.map.info.width,
self.map.info.height, QImage.Format_Indexed8)
for i in reversed(range(101)):
image.setColor(100 - i, qRgb(i * 2.55, i * 2.55, i * 2.55))
image.setColor(101, qRgb(255, 0, 0)) # not used indices
image.setColor(255, qRgb(200, 200, 200)) # color for unknown value -1
self._map = image
self.graphics_view.setSceneRect(0, 0, self.map.info.width,
self.map.info.height)
pixmap = QPixmap.fromImage(self._map)
self._map_item = self._scene.addPixmap(pixmap)
# Everything must be mirrored
self._map_item.scale(-1, 1)
self._map_item.translate(-1 * self.map.info.width, 0)
# Add drag and drop functionality
# self.add_dragdrop(self._map_item)
self.graphics_view.centerOn(self._map_item)
self.graphics_view.show()
def map_cb(self, msg):
self.resolution = msg.info.resolution
self.w = msg.info.width
self.h = msg.info.height
a = numpy.array(msg.data, dtype=numpy.uint8, copy=False, order='C')
a = a.reshape((self.h, self.w))
if self.w % 4:
e = numpy.empty((self.h, 4 - self.w % 4), dtype=a.dtype, order='C')
a = numpy.append(a, e, axis=1)
image = QImage(a.reshape((a.shape[0] * a.shape[1])), self.w, self.h, QImage.Format_Indexed8)
for i in reversed(range(101)):
image.setColor(100 - i, qRgb(i* 2.55, i * 2.55, i * 2.55))
image.setColor(101, qRgb(255, 0, 0)) # not used indices
image.setColor(255, qRgb(200, 200, 200)) # color for unknown value -1
self._map = image
self.setSceneRect(0, 0, self.w, self.h)
self.map_changed.emit()
def initialize_glview(self):
# create GL view
self._glview = MyGLWidget()
self._glview.setAcceptDrops(True)
# backup and replace original paint method
# self.glView.paintGL is callbacked from QGLWidget
self._glview.paintGL_original = self._glview.paintGL
self._glview.paintGL = self.glview_paintGL
# backup and replace original mouse release method
self._glview.mouseReleaseEvent_original = self._glview.mouseReleaseEvent
self._glview.mouseReleaseEvent = self.glview_mouseReleaseEvent
# backup and replace original mouse release method
self._glview.wheelEvent_original = self._glview.wheelEvent
self._glview.wheelEvent = self.glview_wheelEvent
# add GL view to widget layout
# http://doc.qt.io/qt-4.8/qgridlayout.html
self.layout().addWidget(self._glview, 1, 0, 1, 4)
self.qimage = QImage(self.filename, 'JPEG') # GL_TEXTURE_2D
def _set_image(self):
print("_set_image")
self._scene.clear()
img = cv2.imread("/home/gachiemchiep/Pictures/aaa.png", 1)
img_rz = cv2.resize(img, (640, 480))
# https://stackoverflow.com/questions/34232632/convert-python-opencv-image-numpy-array-to-pyqt-qpixmap-image
height, width, channel = img_rz.shape
print(img_rz.shape)
bytesPerLine = 3 * width
img_q = QImage(img_rz.data, width, height, bytesPerLine,
QImage.Format_RGB888).rgbSwapped()
# painter : this does not work
# painter = QPainter(img_q)
# painter.setRenderHint(QPainter.Antialiasing)
# self._scene.render(painter)
# painter.end()
# pixmap : this work
pixmap = QPixmap.fromImage(img_q)
self._scene.addPixmap(pixmap)
self._scene.setSceneRect(0, 0, 640, 480)
def both_callback(self, luv, hsv):
if self.view != BOTH:
self.label_hsv.hide()
self.label_lab.hide()
return
img_luv = self.brd.imgmsg_to_cv2(luv)
img_hsv = self.brd.imgmsg_to_cv2(hsv)
# cv2.cvtColor(img_luv, cv2.COLOR_BGR2RGB)
# cv2.cvtColor(img_hsv, cv2.COLOR_BGR2RGB)
h, w, c = img_luv.shape
img = np.zeros([h, w, c])
luv_2 = cv2.resize(img_luv, (0, 0), fx=0.5, fy=0.5)
hsv_2 = cv2.resize(img_hsv, (0, 0), fx=0.5, fy=0.5)
both = np.hstack((hsv_2, luv_2))
dif = (img.shape[0] - both.shape[0]) // 2
img[dif:img.shape[0] - dif, 0:img.shape[1]] = both
q_img = QImage(both.data, both.shape[1], both.shape[0],
3 * both.shape[1], QImage.Format_RGB888)
q = QPixmap.fromImage(q_img)
self.wdg_img.setFixedWidth(both.shape[1])
self.wdg_img.setFixedHeight(both.shape[0])
self.wdg_img.setPixmap(q)
def writeLocationsToFile(self):
out_dict = {}
out_dict["locations"] = self.locations.keys()
out_dict["locations"] = sorted(out_dict["locations"])
out_dict["polygons"] = []
for index, key in enumerate(sorted(self.locations)):
out_dict["polygons"].append([])
polygon = self.locations[key]
for i in range(polygon.size()):
pt = polygon.point(i)
scaled_pt = scalePoint(pt, self.image_size, self.map_size)
out_dict["polygons"][index].append(scaled_pt.x())
out_dict["polygons"][index].append(scaled_pt.y())
data_directory = os.path.dirname(os.path.realpath(self.location_file))
image_file = getLocationsImageFileLocationFromDataDirectory(
data_directory)
# Create an image with the location data, so that C++ programs don't need to rely on determining regions using polygons.
out_dict["data"] = 'locations.pgm'
location_image = QImage(self.map_size, QImage.Format_RGB32)
location_image.fill(Qt.white)
painter = QPainter(location_image)
for index, key in enumerate(self.locations):
if index > 254:
rospy.logerr(
"You have more than 254 locations, which is unsupported by the bwi_planning_common C++ code!"
)
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(index, index, index))
scaled_polygon = scalePolygon(self.locations[key], self.image_size,
self.map_size)
painter.drawPolygon(scaled_polygon)
painter.end()
location_image.save(image_file)
stream = open(self.location_file, 'w')
yaml.dump(out_dict, stream)
stream.close()
self.is_modified = False
def image(self, name):
return QImage(self.icon_path(name))
def __init__(self,
icon,
title,
text,
detailed_text="",
buttons=Cancel | Ok,
parent=None):
QDialog.__init__(self, parent=parent)
self.setWindowFlags(self.windowFlags() & ~Qt.WindowTitleHint)
self.setWindowFlags(self.windowFlags()
& ~Qt.WindowContextHelpButtonHint
& ~Qt.WindowMinimizeButtonHint)
self.setObjectName('MessageBox')
self._use_checkbox = True
self.text = text
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setObjectName("verticalLayout")
self.verticalLayout.setContentsMargins(1, 1, 1, 1)
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.horizontalLayout.setContentsMargins(1, 1, 1, 1)
# create icon
pixmap = None
if icon == self.NoIcon:
pass
elif icon == self.Question:
pixmap = QPixmap(
QImage(":icons/question.png").scaled(56, 56,
Qt.IgnoreAspectRatio,
Qt.SmoothTransformation))
elif icon == self.Information:
pixmap = QPixmap(
QImage(":icons/info.png").scaled(56, 56, Qt.IgnoreAspectRatio,
Qt.SmoothTransformation))
elif icon == self.Warning:
pixmap = QPixmap(
QImage(":icons/warning.png").scaled(56, 56,
Qt.IgnoreAspectRatio,
Qt.SmoothTransformation))
elif icon == self.Critical:
pixmap = QPixmap(
QImage(":icons/critical.png").scaled(56, 56,
Qt.IgnoreAspectRatio,
Qt.SmoothTransformation))
spacerItem = QSpacerItem(10, 60, QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
self.icon_label = QLabel()
if pixmap is not None:
self.icon_label.setPixmap(pixmap)
self.icon_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.horizontalLayout.addWidget(self.icon_label)
spacerItem = QSpacerItem(10, 60, QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
# add message
self.message_label = QLabel(text)
self.message_label.setWordWrap(True)
self.message_label.setScaledContents(True)
self.message_label.setOpenExternalLinks(True)
self.horizontalLayout.addWidget(self.message_label)
self.verticalLayout.addLayout(self.horizontalLayout)
# create buttons
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setObjectName("buttonBox")
self.buttonBox.setOrientation(Qt.Horizontal)
self._accept_button = None
self._reject_button = None
self._buttons = buttons
self._create_buttons(buttons)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.verticalLayout.addWidget(self.buttonBox)
if detailed_text:
self.btn_show_details = QPushButton(self.tr('Details...'))
self.btn_show_details.setCheckable(True)
self.btn_show_details.setChecked(True)
self.btn_show_details.toggled.connect(self.on_toggled_details)
self.buttonBox.addButton(self.btn_show_details,
QDialogButtonBox.ActionRole)
# create area for detailed text
self.textEdit = textEdit = QTextEdit(self)
textEdit.setObjectName("textEdit")
textEdit.setReadOnly(True)
textEdit.setText(detailed_text)
# textEdit.setVisible(False)
self.verticalLayout.addWidget(self.textEdit)
self.resize(480, self.verticalLayout.totalSizeHint().height())
buttons_in_box = self.buttonBox.buttons()
if buttons_in_box:
self.buttonBox.buttons()[0].setFocus()
def __init__(self, context):
super(MyPlugin, self).__init__(context)
Black = np.zeros((300, 400, 3), np.uint8)
self.is_decay_auto = 0
self.is_frame_auto = 0
self.is_segsz_auto = 0
self.bridge = CvBridge()
self.d_image_sub = rospy.Subscriber("/fome/direction", Image,
self.fome_dir)
self.m_image_sub = rospy.Subscriber("/fome/magnitude", Image,
self.fome_mag)
self.c_image_sub = rospy.Subscriber("/fome/cluster", Image,
self.fome_cls)
# self.r_image_sub = rospy.Subscriber("/dvs_rendering",Image,self.fome_raw)
self.r_image_sub = rospy.Subscriber("/dvs/image_raw", Image,
self.fome_raw)
self.decay_pub = rospy.Publisher("/fome/decay_rate",
String,
queue_size=1)
self.frame_pub = rospy.Publisher("/fome/frame_rate",
String,
queue_size=1)
self.segsz_pub = rospy.Publisher("/fome/segment_size",
String,
queue_size=1)
self.setObjectName('fome_gui')
rp = rospkg.RosPack()
self._widget = QWidget()
ui_file = os.path.join(rp.get_path('fome_gui'), 'resource',
'MyPlugin.ui')
loadUi(ui_file, self._widget)
self._widget.setObjectName('fome_gui')
height, width, byteValue = Black.shape
byteValue = byteValue * width
self.d_image = QImage(Black, width, height, byteValue,
QImage.Format_RGB888)
self.m_image = QImage(Black, width, height, byteValue,
QImage.Format_RGB888)
self.r_image = QImage(Black, width, height, byteValue,
QImage.Format_RGB888)
self.c_image = QImage(Black, width, height, byteValue,
QImage.Format_RGB888)
self.d_label = QLabel(self._widget.graphicsView_1)
d_image = QPixmap.fromImage(self.d_image)
self.d_label.setPixmap(d_image)
self.m_label = QLabel(self._widget.graphicsView_2)
m_image = QPixmap.fromImage(self.m_image)
self.m_label.setPixmap(m_image)
self.r_label = QLabel(self._widget.graphicsView_3)
r_image = QPixmap.fromImage(self.r_image)
self.r_label.setPixmap(r_image)
self.c_label = QLabel(self._widget.graphicsView_4)
c_image = QPixmap.fromImage(self.c_image)
self.c_label.setPixmap(c_image)
@QtCore.Slot(int)
def decay_moved(r):
if self.is_decay_auto == 0:
self.decay_pub.publish(str(r))
self.decay_rate = SliderWithValue(QtCore.Qt.Horizontal, 1)
self.decay_rate.slidervalue.connect(decay_moved)
self.decay_rate.setMinimum(-20)
self.decay_rate.setMaximum(30)
self.decay_rate.setTickInterval(1)
self.decay_rate.setSingleStep(1)
self.decay_rate.setPageStep(1)
self.decay_rate.setTickPosition(QSlider.TicksBelow)
self.decay_rate.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
self.decay_rate.setValue(-10)
self.decay_pub.publish(str(self.decay_rate.slidervalue))
self._widget.decay_rate.addWidget(self.decay_rate)
@QtCore.Slot(int)
def decay_auto(args):
self.is_decay_auto = args
if args == 2:
self.decay_pub.publish("auto")
self.decay_pub.unregister
del self.decay_pub
if args == 0:
self.decay_pub = rospy.Publisher("/fome/decay_rate",
String,
queue_size=1)
self._widget.decay_auto.stateChanged.connect(decay_auto)
@QtCore.Slot(int)
def frame_moved(r):
if self.is_frame_auto == 0:
self.frame_pub.publish(str(r))
self.frame_rate = SliderWithValue(QtCore.Qt.Horizontal, 1)
self.frame_rate.slidervalue.connect(frame_moved)
self.frame_rate.setMinimum(10)
self.frame_rate.setMaximum(2000)
self.frame_rate.setTickInterval(1)
self.frame_rate.setSingleStep(1)
self.frame_rate.setPageStep(1)
self.frame_rate.setTickPosition(QSlider.TicksBelow)
self.frame_rate.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
self.frame_rate.setValue(100)
self._widget.frame_rate.addWidget(self.frame_rate)
@QtCore.Slot(int)
def frame_auto(args):
self.is_frame_auto = args
if args == 2:
self.frame_pub.publish("auto")
self.frame_pub.unregister
del self.frame_pub
if args == 0:
self.frame_pub = rospy.Publisher("/fome/frame_rate",
String,
queue_size=1)
self._widget.frame_auto.stateChanged.connect(frame_auto)
@QtCore.Slot(int)
def segsz_moved(r):
if self.is_segsz_auto == 0:
self.segsz_pub.publish(str(r))
self.segsz_rate = SliderWithValue(QtCore.Qt.Horizontal, 1)
self.segsz_rate.slidervalue.connect(segsz_moved)
self.segsz_rate.setMinimum(100)
self.segsz_rate.setMaximum(10000)
self.segsz_rate.setTickInterval(10)
self.segsz_rate.setSingleStep(10)
self.segsz_rate.setPageStep(10)
self.segsz_rate.setTickPosition(QSlider.TicksBelow)
self.segsz_rate.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
self.segsz_rate.setValue(4320)
self._widget.segsz_rate.addWidget(self.segsz_rate)
@QtCore.Slot(int)
def segsz_auto(args):
self.is_segsz_auto = args
if args == 2:
self.segsz_pub.publish("auto")
self.segsz_pub.unregister
del self.segsz_pub
if args == 0:
self.segsz_pub = rospy.Publisher("/fome/segsz_rate",
String,
queue_size=1)
self._widget.segsz_auto.stateChanged.connect(segsz_auto)
if context.serial_number() > 1:
self._widget.setWindowTitle('Estimated direction from events')
context.add_widget(self._widget)
def msg_to_pixmap(self, msg): cv_img = self.bridge.imgmsg_to_cv2(msg) h, w, _ = cv_img.shape bytesPerLine = 3 * w q_img = QImage(cv_img.data, w, h, bytesPerLine, QImage.Format_RGB888) return QPixmap.fromImage(q_img).scaled(320, 240)
