Example #1
0
    def on_pushButton_calibrate_clicked(self):

        self._widget.pushButton_calibrate.setEnabled(False)

        status_icon = QIcon.fromTheme('stock_no')

        # Fill request information
        request = self._selected_service['service_class']._request_class()
        request.target_hue.data = self._widget.spinBox_hue.value()
        request.mult_diffs.data = self._widget.spinBox_diff.value()
        request.mult_sat.data = self._widget.spinBox_sat.value()
        try:
            # Call service
            response = self._selected_service['service_proxy'](request)
        except rospy.ServiceException as e:
            qWarning('on_pushButton_calibrate_clicked(): error calling service "%s":\n%s' % (self._selected_service['service_name'], e))
        else:
            # Get debug image and show
            img = response.image_debug
            qImage = QImage(img.data, img.width, img.height, img.step, QImage.Format_RGB888)
            qPixmap = QPixmap()
            qPixmap.convertFromImage(qImage)
            pixmapItem = QGraphicsPixmapItem(qPixmap)
            self._qGraphicsScene.clear()
            self._qGraphicsScene.addItem(pixmapItem)

            self._widget.graphicsView.fitInView(QRectF(qPixmap.rect()), Qt.KeepAspectRatio)

            if response.success.data == True:
                status_icon = QIcon.fromTheme('stock_yes')

        self._widget.label_status.setPixmap(status_icon.pixmap(status_icon.actualSize(QSize(24, 24))))

        self._widget.pushButton_calibrate.setEnabled(True)
Example #2
0
    def handle_signal(self, image, qPixmapItem, qGraphicsView):
        qImage = QImage(image.data, image.width, image.height, image.step, QImage.Format_RGB888)
        qPixmap = QPixmap()
        qPixmap.convertFromImage(qImage)

        qPixmapItem.setPixmap(qPixmap)
        qGraphicsView.fitInView(qPixmapItem, Qt.KeepAspectRatio)
Example #3
0
def rocon_icon_to_qicon(icon):
    """
    :param rocon_std_msgs.Icon icon: icon to use for the pixmap
    """
    pixmap = QPixmap()
    pixmap.loadFromData(icon.data, format=icon.format)
    return QIcon(pixmap)
Example #4
0
 def __init__(self, img):
     splash_pix = QPixmap(img)
     self.splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
     self.splash.setMask(splash_pix.mask())
     self.splash.show()
     for i in range(100):
         time.sleep(0.01)
         QApplication.processEvents()
 def __init__(self, img):
     splash_pix = QPixmap(img)
     self.splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
     self.splash.setMask(splash_pix.mask())
     self.splash.show()
     for i in range(100):
         time.sleep(0.01)
         QApplication.processEvents()
Example #6
0
    def update(self):
        """
        Updates the widget.
        """
        if not self.__deleted:
            if self.__selected_item is not None:
                data_dict = self.__selected_item.get_latest_data()
                self.__state = data_dict["state"]
                self.host_node_label.setText(
                    self.tr(self.__selected_item.get_seuid()))

                if self.__previous_state is not self.__state:
                    self.__previous_state = self.__state
                    if self.__state == "ok":
                        self.current_status_label.setText(self.tr("ok"))
                        #self.host_node_label.setText(self.tr("Current Status: Ok"))
                        pixmap = QPixmap(
                            os.path.join(
                                self.rp.get_path('rqt_arni_gui_detail'),
                                'resources/graphics', 'block_green.png'))
                    elif self.__state == "warning":
                        self.current_status_label.setText(self.tr("warning"))
                        #self.host_node_label.setText(self.tr("Current Status: Warning"))
                        pixmap = QPixmap(
                            os.path.join(
                                self.rp.get_path('rqt_arni_gui_detail'),
                                'resources/graphics', 'block_orange.png'))
                    elif self.__state == "unknown":
                        self.current_status_label.setText(self.tr("unkown"))
                        #self.host_node_label.setText(self.tr("Current Status: Unkown"))
                        pixmap = QPixmap(
                            os.path.join(
                                self.rp.get_path('rqt_arni_gui_detail'),
                                'resources/graphics', 'block_grey.png'))
                    else:  # error or offline
                        self.current_status_label.setText(self.tr(
                            self.__state))
                        pixmap = QPixmap(
                            os.path.join(
                                self.rp.get_path('rqt_arni_gui_detail'),
                                'resources/graphics', 'block_red.png'))
                    self.status_light_label.setPixmap(pixmap)
                content = self.__selected_item.get_detailed_data()

                scroll_value = self.information_tab_text_browser.verticalScrollBar(
                ).value()
                self.information_tab_text_browser.setHtml(content)
                self.information_tab_text_browser.verticalScrollBar(
                ).setSliderPosition(scroll_value)
            else:
                self.host_node_label.setText(self.tr("No item selected"))
                self.current_status_label.setText(self.tr("Offline"))
                self.information_tab_text_browser.setText(
                    self.
                    tr("Please select an item in the TreeView to get more information"
                       " about it"))
Example #7
0
    def __init__(self, context):
        """
        Constructor
        """
        super(CarlaControlPlugin, self).__init__(context)
        self.setObjectName('CARLA Control')

        self._widget = QWidget()

        self._node = CompatibleNode('rqt_carla_control_node')

        package_share_dir = roscomp.get_package_share_directory(
            'rqt_carla_control')
        ui_file = os.path.join(package_share_dir, 'resource',
                               'CarlaControl.ui')

        loadUi(ui_file, self._widget)
        self._widget.setObjectName('CarlaControl')
        if context.serial_number() > 1:
            self._widget.setWindowTitle(self._widget.windowTitle() +
                                        (' (%d)' % context.serial_number()))

        self.pause_icon = QIcon(
            QPixmap(os.path.join(package_share_dir, 'resource', 'pause.png')))
        self.play_icon = QIcon(
            QPixmap(os.path.join(package_share_dir, 'resource', 'play.png')))
        self._widget.pushButtonStepOnce.setIcon(
            QIcon(
                QPixmap(
                    os.path.join(package_share_dir, 'resource',
                                 'step_once.png'))))

        self.carla_status = None
        self.carla_status_subscriber = self._node.new_subscription(
            CarlaStatus,
            "/carla/status",
            self.carla_status_changed,
            qos_profile=10)

        self.carla_control_publisher = self._node.new_publisher(
            CarlaControl, "/carla/control", qos_profile=10)

        self._widget.pushButtonPlayPause.setDisabled(True)
        self._widget.pushButtonStepOnce.setDisabled(True)
        self._widget.pushButtonPlayPause.setIcon(self.play_icon)
        self._widget.pushButtonPlayPause.clicked.connect(
            self.toggle_play_pause)
        self._widget.pushButtonStepOnce.clicked.connect(self.step_once)

        context.add_widget(self._widget)

        if roscomp.get_ros_version() == 2:
            spin_thread = threading.Thread(target=self._node.spin, daemon=True)
            spin_thread.start()
Example #8
0
 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))
Example #9
0
 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))
Example #10
0
    def mouseMoveEvent(self, event):
        '''
        Determine if the current movement is a drag.  If it is, convert it into a QDrag.  If the
        drag ends inside the tab bar, emit an move_tab_signal.  If the drag ends outside the tab
        bar, emit an detach_tab_signal.
        '''
        # Determine if the current movement is detected as a drag
        if not self.drag_start_pos.isNull() and ((event.pos() - self.drag_start_pos).manhattanLength() > QApplication.startDragDistance()):
            self.drag_initiated = True

        # If the current movement is a drag initiated by the left button
        if ((event.buttons() & Qt.LeftButton)) and self.drag_initiated:

            # Stop the move event
            finishMoveEvent = QMouseEvent(QEvent.MouseMove, event.pos(), Qt.NoButton, Qt.NoButton, Qt.NoModifier)
            QTabBar.mouseMoveEvent(self, finishMoveEvent)

            # Convert the move event into a drag
            drag = QDrag(self)
            mime_data = QMimeData()
            mime_data.setData('action', b'application/tab-detach')
            drag.setMimeData(mime_data)

            # Create the appearance of dragging the tab content
            # tab_index = self.tabAt(self.drag_start_pos)
            pixmap = self.parentWidget().grab()
            targetPixmap = QPixmap(pixmap.size())
            targetPixmap.fill(Qt.transparent)
            painter = QPainter(targetPixmap)
            painter.setOpacity(0.85)
            painter.drawPixmap(0, 0, pixmap)
            painter.end()
            drag.setPixmap(targetPixmap)

            # Initiate the drag
            dropAction = drag.exec_(Qt.MoveAction | Qt.CopyAction)

            # If the drag completed outside of the tab bar, detach the tab and move
            # the content to the current cursor position
            if dropAction == Qt.IgnoreAction:
                event.accept()
                self.detach_tab_signal.emit(self.tabAt(self.drag_start_pos), self.mouse_cursor.pos(), False)
            elif dropAction == Qt.MoveAction:
                # else if the drag completed inside the tab bar, move the selected tab to the new position
                if not self.drag_droped_pos.isNull():
                    self.move_tab_signal.emit(self.tabAt(self.drag_start_pos), self.tabAt(self.drag_droped_pos))
                else:
                    # else if the drag completed inside the tab bar new TabBar, move the selected tab to the new TabBar
                    self.detach_tab_signal.emit(self.tabAt(self.drag_start_pos), self.mouse_cursor.pos(), False)
                event.accept()
        else:
            QTabBar.mouseMoveEvent(self, event)
Example #11
0
 def on_compressed_image_received(self, image):
     '''
     :param sensor_msgs.CompressedImage image: convert and display this in the QGraphicsView.
     '''
     if len(self.scene.items()) > 1:
         self.scene.removeItem(self.scene.items()[0])
     pixmap = QPixmap()
     pixmap.loadFromData(image.data, format=image.format)
     self.scene.addPixmap(pixmap)
     self.scene.update()
     # setting fitInvView seems sensitive to here or prior to scene update
     self.fitInView(QRectF(0, 0, self.scene.width(), self.scene.height()),
                    Qt.KeepAspectRatio)
 def __init__(self, parent=None, info=False):
     QFrame.__init__(self, parent=parent)
     self.setObjectName('MessageFrame')
     self.questionid = self.TYPE_INVALID
     self.text = ""
     self.data = MessageData(None)
     self.IMAGES = {1: QPixmap(),
                    2: QPixmap(':/icons/crystal_clear_question.png').scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
                    3: QPixmap(':/icons/crystal_clear_launch_file.png').scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
                    4: QPixmap(":/icons/default_cfg.png").scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
                    5: QPixmap(":/icons/crystal_clear_nodelet_q.png").scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
                    6: QPixmap(":/icons/crystal_clear_launch_file_transfer.png").scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
                    7: QPixmap(":/icons/crystal_clear_question.png").scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation),
                    8: QPixmap(":/icons/crystal_clear_no_io.png").scaled(self.ICON_SIZE, self.ICON_SIZE, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
                    }
     self._new_request = False
     self.frameui = QFrame()
     ui_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'MessageFrame.ui')
     loadUi(ui_file, self.frameui)
     color = QColor(255, 207, 121)
     self.frameui.setVisible(False)
     self.frameui.listLabel.setVisible(False)
     self.frameui.questionOkButton.clicked.connect(self._on_question_ok)
     self.frameui.questionCancelButton.clicked.connect(self._on_question_cancel)
     self.frameui.checkBox_dnaa.stateChanged.connect(self._on_checkbox_state_changed)
     self._ask = 'ask'
     if info:
         color = QColor(232, 104, 80)
         self.frameui.questionCancelButton.setVisible(False)
         self._ask = 'show'
     bg_style = "QFrame#questionFame { background-color: %s;}" % color.name()
     self.frameui.setStyleSheet("%s" % (bg_style))
     self._queue = MessageQueue()
     self._do_not_ask = {}
Example #13
0
    def __init__(self, context):
        super(SpeechStatusPlugin, self).__init__(context)
        self.setObjectName('SpeechStatusPlugin')

        self._widget = QWidget()
        if context.serial_number() > 1:
            self._widget.setWindowTitle(self._widget.windowTitle() +
                                        (' (%d)' % context.serial_number()))

        ui_file = os.path.join(rospkg.RosPack().get_path('rqt_speech_status'),
                               'resource', 'speech_widget.ui')
        loadUi(ui_file, self._widget)
        context.add_widget(self._widget)

        file_live = os.path.join(
            rospkg.RosPack().get_path('rqt_speech_status'), 'resource',
            'microphone.png')
        file_mute = os.path.join(
            rospkg.RosPack().get_path('rqt_speech_status'), 'resource',
            'muted.png')
        file_silency = os.path.join(
            rospkg.RosPack().get_path('rqt_speech_status'), 'resource',
            'silence-face.png')
        file_speech = os.path.join(
            rospkg.RosPack().get_path('rqt_speech_status'), 'resource',
            'surprise-face.png')

        self.img_mute = QPixmap(file_mute).scaled(160, 160)
        self.img_live = QPixmap(file_live).scaled(160, 160)
        self.img_silency = QPixmap(file_silency).scaled(160, 160)
        self.img_speech = QPixmap(file_speech).scaled(160, 160)

        self._widget.imgRecognition.setPixmap(self.img_live)
        self._widget.imgSilency.setPixmap(self.img_silency)

        self.signal_render_recog_status = SignalRender()
        self.signal_render_recog_status.renderSignal.connect(
            self.render_recog_status)

        self.signal_render_silency_status = SignalRender()
        self.signal_render_silency_status.renderSignal.connect(
            self.render_silency_status)

        rospy.Subscriber('enable_recognition', Bool,
                         self.handle_enable_recognition)
        rospy.Subscriber('start_of_speech', Empty, self.handle_start_speech)
        rospy.Subscriber('end_of_speech', Empty, self.handle_end_speech)
        rospy.Subscriber('silency_detected', Empty,
                         self.handle_silency_detection)
Example #14
0
 def _show_image(self, bin_, index):
     target_name = self.bin_contents[bin_][index]
     target_image_path = os.path.join(self.image_path, target_name,
                                      'image.jpg')
     target_pixmap = QPixmap(target_image_path).scaled(100, 100)
     self.bin_dict[bin_]['image'].setPixmap(target_pixmap)
     self.bin_dict[bin_]['image'].show()
Example #15
0
 def update(self):
     if self.mapitem:
         self.scene.removeItem(self.mapitem)
     qpix = QPixmap.fromImage(self.map)
     self.mapitem = self.scene.addPixmap(qpix)
     self.mirror(self.mapitem)
     self.show()
 def update_description(self, index, cfg, name, displayed_name, robot_type,
                        description, images):
     '''
     Sets the values of an existing item to the given items only if the current
     value is empty.
     '''
     if index < len(self._data):
         obj = self._data[index]
         if cfg not in obj['cfgs']:
             obj['cfgs'].append(cfg)
         if not obj['name']:
             obj['name'] = name
         if not obj['displayed_name']:
             obj['displayed_name'] = displayed_name
         if not obj['type']:
             obj['type'] = robot_type
         if not obj['description']:
             obj['description'] = replace_paths(description)
         if not obj['images']:
             for image_path in images:
                 img = interpret_path(image_path)
                 if img and img[0] != os.path.sep:
                     img = os.path.join(nm.settings().PACKAGE_DIR,
                                        image_path)
                 if os.path.isfile(img):
                     obj['images'].append(QPixmap(img))
Example #17
0
 def _setup_tab_view_page(self, sid, mid):
     tabContent = InnerWidget(mid, sid)
     tabContent.mesaurementLabel.setText(
         "<html><head/><body><p><span style=\" font-size:14pt; "
         "font-weight:600;\">Measurement {}</span></p></body></html>".
         format(mid + 1))
     measurement = self.last_site_data.sites[sid].measurements[
         mid]  # type: rover_science.msg.Measurement
     tabContent.latitudeLabel.setText("Latitude: {}".format(
         measurement.location.latitude))
     tabContent.longitudeLabel.setText("Longitude: {}".format(
         measurement.location.longitude))
     tabContent.altitudeLabel.setText("Altitude: {}".format(
         measurement.location.altitude))
     site = self.last_site_data.sites[sid]
     if site.has_pano & site.HAS_PANO == site.HAS_PANO:
         pmap = QPixmap(site.pano_location)
         tabContent.panorama.clear()
         tabContent.panorama.setPixmap(pmap)
         tabContent.panorama.setMaximumSize(500, 350)
     if measurement.data_completeness & measurement.HAS_PH == measurement.HAS_PH:
         tabContent.phLabel.setText("PH: {}".format(measurement.ph))
     if measurement.data_completeness & measurement.HAS_TEMP == measurement.HAS_TEMP:
         tabContent.tempLabel.setText("Temperature: {}".format(
             measurement.temp))
     if measurement.data_completeness & measurement.HAS_HUMIDITY == measurement.HAS_HUMIDITY:
         tabContent.humidityLabel.setText("Humidity: {}".format(
             measurement.humidity))
     tabContent.retake.connect(self.retake_measurement_clicked)
     self.tabWidget.addTab(tabContent, "Measurement {}".format(mid + 1))
Example #18
0
    def __init__(self, context):
        """
        Constructor
        """
        super(CarlaControlPlugin, self).__init__(context)
        self.setObjectName('CARLA Control')

        self._widget = QWidget()
        ui_file = os.path.join(rospkg.RosPack().get_path('rqt_carla_control'),
                               'resource', 'CarlaControl.ui')
        loadUi(ui_file, self._widget)
        self._widget.setObjectName('CarlaControl')
        if context.serial_number() > 1:
            self._widget.setWindowTitle(self._widget.windowTitle() +
                                        (' (%d)' % context.serial_number()))

        self.pause_icon = QIcon(
            QPixmap(
                os.path.join(rospkg.RosPack().get_path('rqt_carla_control'),
                             'resource', 'pause.png')))
        self.play_icon = QIcon(
            QPixmap(
                os.path.join(rospkg.RosPack().get_path('rqt_carla_control'),
                             'resource', 'play.png')))
        self._widget.pushButtonStepOnce.setIcon(
            QIcon(
                QPixmap(
                    os.path.join(
                        rospkg.RosPack().get_path('rqt_carla_control'),
                        'resource', 'step_once.png'))))

        self.carla_status = None
        self.carla_status_subscriber = rospy.Subscriber(
            "/carla/status", CarlaStatus, self.carla_status_changed)
        self.carla_control_publisher = rospy.Publisher("/carla/control",
                                                       CarlaControl,
                                                       queue_size=10)

        self._widget.pushButtonPlayPause.setDisabled(True)
        self._widget.pushButtonStepOnce.setDisabled(True)
        self._widget.pushButtonPlayPause.setIcon(self.play_icon)
        self._widget.pushButtonPlayPause.clicked.connect(
            self.toggle_play_pause)
        self._widget.pushButtonStepOnce.clicked.connect(self.step_once)

        context.add_widget(self._widget)
Example #19
0
    def put_image_into_scene(self):
        if self._image:
            resized_image = self._image.resize((self._image_view.size().width() - 2, self._image_view.size().height() - 2), self.quality)

            QtImage = ImageQt(resized_image)
            pixmap = QPixmap.fromImage(QtImage)
            self._scene.clear()
            self._scene.addPixmap(pixmap)
Example #20
0
    def put_image_into_scene(self):
        if self._image:
            resized_image = self._image.resize((self._image_view.size().width() - 2, self._image_view.size().height() - 2), self.quality)

            QtImage = ImageQt(resized_image)
            pixmap = QPixmap.fromImage(QtImage)
            self._scene.clear()
            self._scene.addPixmap(pixmap)
Example #21
0
 def put_image_into_scene(self):
     if self._image:
         if self.capture is None:
             resized_image = self._image.resize(
                 (self._image_view.size().width() - 2,
                  self._image_view.size().height() - 2, self.quality))
             QtImage = ImageQt(resized_image)
             pixmap = QPixmap.fromImage(QtImage)
             self._scene.clear()
             self._scene.addPixmap(pixmap)
         else:
             QtImage = ImageQt(self._image)
             pixmap = QPixmap.fromImage(QtImage)
             self.label = CaptureImage(self._timeline, self._topic,
                                       self._image_msg, self.capture)
             self.label.setPixmap(pixmap)
             self._scene.addWidget(self.label)
Example #22
0
    def __init__(self, context):
        super(MasterInfo, self).__init__(context)
        self.initialised = False
        self.setObjectName('MasterInfo')
        self._current_dotcode = None

        self._master_info = rocon_master_info.get_master_info(0.5)  # at worst a small timeout here, but perhaps should be run in a thread.

        self._widget = QWidget()
        self._widget.setObjectName('RoconMasterInfoUi')
        rospack = rospkg.RosPack()
        ui_file = os.path.join(rospack.get_path('rocon_qt_master_info'), 'ui', 'master_info.ui')
        loadUi(ui_file, self._widget)
        if context.serial_number() > 1:
            self._widget.setWindowTitle(self._widget.windowTitle() + (' (%d)' % context.serial_number()))

        pixmap = QPixmap()
        pixmap.loadFromData(self._master_info.icon.data, format=self._master_info.icon.format)
        self._widget.icon_label.setPixmap(pixmap)
        self._widget.icon_label.resize(pixmap.width(), pixmap.height())

        self._widget.info_label.resize(200, pixmap.height())
        self._widget.info_label.setText("<b>Name:</b> %s<br/><b>Rocon Version:</b> %s<br/><b>Description:</b> %s" % (self._master_info.name, self._master_info.version, self._master_info.description))
        self._widget.adjustSize()

        context.add_widget(self._widget)
Example #23
0
    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
Example #24
0
 def _load_default_image(self):
     joystick_icon = os.path.join(
         rospkg.RosPack().get_path('rocon_bubble_icons'), 'icons',
         'joystick.png')
     pixmap = QPixmap(joystick_icon, format="png")
     self.scene.addPixmap(pixmap)
     self.scene.update()
     self.fitInView(QRectF(0, 0, self.scene.width(), self.scene.height()),
                    Qt.KeepAspectRatio)
Example #25
0
    def _update(self):
        if self._map_item:
            self._scene.removeItem(self._map_item)
        pixmap = QPixmap.fromImage(self._map)

        self._map_item = self._scene.addPixmap(pixmap)

        self.centerOn(self._map_item)
        self.show()
Example #26
0
    def _update(self):
        if self._map_item:
            self._scene.removeItem(self._map_item)
        pixmap = QPixmap.fromImage(self._map)

        self._map_item = self._scene.addPixmap(pixmap)

        self.centerOn(self._map_item)
        self.show()
    def load_map(self, scenario):
        self.scenario = scenario
        map_yaml = os.path.join(rospkg.RosPack().get_path('rqt_simulation'),
                                'scenarios', scenario, 'map.yaml')
        self.loadConfig(map_yaml)
        map = 'map.png'

        map_file = os.path.join(rospkg.RosPack().get_path('rqt_simulation'),
                                'scenarios', scenario, map)
        pixmap = QPixmap(map_file)
        self.mapSize = pixmap.size()
        self.addPixmap(pixmap)

        # Add world origin
        self.worldOrigin = QPointF(
            -self.map_origin[0] / self.map_resolution,
            self.map_origin[1] / self.map_resolution + self.mapSize.height())
        self.addCoordinateSystem(self.worldOrigin, 0.0)
class ScaledLabel(QLabel):
    def __init__(self, *args, **kwargs):
        QLabel.__init__(self)
        self._pixmap = QPixmap(self.pixmap())

    def resizeEvent(self, event):
        self.setPixmap(
            self._pixmap.scaled(self.width(), self.height(),
                                QtCore.Qt.KeepAspectRatio))
Example #29
0
 def getRobotLabel(self, colorStr):
     """
     initiates the robot label
     :param colorStr: color as string
     :return:
     """
     ls = self.pool.get(colorStr)
     if ls == []:
         pxmap = QPixmap(self._getRobFile(colorStr))
         rob = QLabel(parent=self.frame)
         rob.setPixmap(pxmap)
         rob.originalPixmap = QPixmap(pxmap)
         rob.setScaledContents(True)
         rob.setFixedSize(self.size, self.size)
         rob.show()
         return rob
     else:
         rob = ls.pop()
         rob.show()
         return rob
Example #30
0
    def _update(self):
        if self._map_item:
            self._scene.removeItem(self._map_item)

        pixmap = QPixmap.fromImage(self._map)
        self._map_item = self._scene.addPixmap(pixmap)

        # Everything must be mirrored
        self._mirror(self._map_item)

        self.centerOn(self._map_item)
        self.show()
Example #31
0
 def _set_icon(self):
     pixmap = QPixmap()
     pixmap.loadFromData(
         self.qt_rapp_manager_info._get_icon().data,
         format=self.qt_rapp_manager_info._get_icon().format)
     self._widget.icon_label.setPixmap(pixmap)
     self._widget.icon_label.resize(pixmap.width(), pixmap.height())
Example #32
0
 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 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 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)
Example #35
0
 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)
Example #36
0
    def update(self):
        """
        Updates the Plugin and draws the graphs if draw_graphs is true.
        """
        data_dict = self.__model.get_root_item().get_latest_data("state")

        self.__state = data_dict["state"]

        if self.__previous_state is not self.__state:
            self.__previous_state = self.__state
            if self.__state == "ok":
                self.status_text_line_edit.setText(
                    self.tr("Current status: Ok"))
                pixmap = QPixmap(
                    os.path.join(self.rp.get_path('rqt_arni_gui_overview'),
                                 'resources/graphics', 'light_green.png'))
            elif self.__state == "warning":
                self.status_text_line_edit.setText(
                    self.tr("Current status: Warning"))
                pixmap = QPixmap(
                    os.path.join(self.rp.get_path('rqt_arni_gui_overview'),
                                 'resources/graphics', 'light_orange.png'))
            else:
                self.status_text_line_edit.setText(
                    self.tr("Current status: Error"))
                pixmap = QPixmap(
                    os.path.join(self.rp.get_path('rqt_arni_gui_overview'),
                                 'resources/graphics', 'light_red.png'))
            self.status_light_label.setPixmap(pixmap)

        if self.information_tab_text_browser:
            scroll_value = self.information_tab_text_browser.verticalScrollBar(
            ).value()
            self.information_tab_text_browser.setHtml(
                self.__model.get_overview_text())
            self.information_tab_text_browser.verticalScrollBar(
            ).setSliderPosition(scroll_value)
Example #37
0
    def _update(self):
        if self._map_item:
            self._scene.removeItem(self._map_item)

        pixmap = QPixmap.fromImage(self._map)
        self._map_item = self._scene.addPixmap(pixmap)

        # Everything must be mirrored
        self._mirror(self._map_item)

        # Add drag and drop functionality
        self.add_dragdrop(self._map_item)

        self.centerOn(self._map_item)
        self.show()
    def _update(self):
        if self._map_item:
            self._scene.removeItem(self._map_item)

        pixmap = QPixmap.fromImage(self._map)
        self._map_item = self._scene.addPixmap(pixmap)

        # Everything must be mirrored
        self._mirror(self._map_item)

        # Add drag and drop functionality
        self.add_dragdrop(self._map_item)

        self.centerOn(self._map_item)
        self.show()
 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)
Example #40
0
    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
Example #41
0
 def __init__(self, img):
     splash_pix = QPixmap(img)
     self.splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
     self.splash.setMask(splash_pix.mask())
     self.splash.show()
     QApplication.processEvents()
class ImageView2Widget(QWidget):
    """
    Qt widget to communicate with image_view2
    """
    cv_image = None
    pixmap = None
    def __init__(self):
        super(ImageView2Widget, self).__init__()
        self.left_button_clicked = False
        self.lock = Lock()
        self.event_pub = rospy.Publisher("event", MouseEvent)
        self.bridge = CvBridge()
        self.label = ScaledLabel()
        self.label.setAlignment(Qt.AlignCenter)
        self.label.setSizePolicy(QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored))
        #self.label.installEventFilter(self)
        hbox = QtGui.QHBoxLayout(self)
        hbox.addWidget(self.label)
        self.setLayout(hbox)
        self.image_sub = rospy.Subscriber("image_marked", Image, 
                                          self.imageCallback)
        self._update_plot_timer = QTimer(self)
        self._update_plot_timer.timeout.connect(self.redraw)
        self._update_plot_timer.start(40)
        self.setMouseTracking(True)
        self.show()
    def imageCallback(self, msg):
        with self.lock:
            cv_image = self.bridge.imgmsg_to_cv2(msg, msg.encoding)
            if msg.encoding == "bgr8":
                self.cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB)
            elif msg.encoding == "rgb8":
                self.cv_image = cv_image
            self.numpy_image = np.asarray(self.cv_image)
    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))
                #self.label.setPixmap(self.pixmap)
    def mousePosition(self, e):
        label_x = self.label.x()
        label_y = self.label.y()
        label_width = self.label.width()
        label_height = self.label.height()
        pixmap_width = self.label.pixmap().width()
        pixmap_height = self.label.pixmap().height()
        x_offset = (label_width - pixmap_width) / 2.0 + label_x
        y_offset = (label_height - pixmap_height) / 2.0 + label_y
        return (e.x() - x_offset, e.y()- y_offset)
    def mouseMoveEvent(self, e):
        if self.left_button_clicked:
            msg = MouseEvent()
            msg.header.stamp = rospy.Time.now()
            msg.type = MouseEvent.MOUSE_MOVE
            msg.x, msg.y = self.mousePosition(e)
            msg.width = self.label.pixmap().width()
            msg.height = self.label.pixmap().height()
            self.event_pub.publish(msg)
    def mousePressEvent(self, e):
        msg = MouseEvent()
        msg.header.stamp = rospy.Time.now()
        if e.button() == Qt.LeftButton:
            msg.type = MouseEvent.MOUSE_LEFT_DOWN
            self.left_button_clicked = True
        elif msg.type == Qt.RightButton:
            msg.type = MouseEvent.MOUSE_RIGHT_DOWN
        msg.width = self.label.pixmap().width()
        msg.height = self.label.pixmap().height()
        msg.x, msg.y = self.mousePosition(e)
        self.event_pub.publish(msg)
    def mouseReleaseEvent(self, e):
        if e.button() == Qt.LeftButton:
            self.left_button_clicked = False
            msg = MouseEvent()
            msg.header.stamp = rospy.Time.now()
            msg.width = self.label.pixmap().width()
            msg.height = self.label.pixmap().height()
            msg.type = MouseEvent.MOUSE_LEFT_UP
            msg.x, msg.y = self.mousePosition(e)
            self.event_pub.publish(msg)
    def eventFilter(self, widget, event):
        if not self.pixmap:
            return QtGui.QMainWindow.eventFilter(self, widget, event)
        if (event.type() == QtCore.QEvent.Resize and
            widget is self.label):
            self.label.setPixmap(self.pixmap.scaled(
                self.label.width(), self.label.height(),
                QtCore.Qt.KeepAspectRatio))
            return True
        return QtGui.QMainWindow.eventFilter(self, widget, event)
    def draw_timeline_segment(self, painter, topic, stamp_start, stamp_end, x, y, width, height):
        """
        draws a stream of images for the topic
        :param painter: painter object, ''QPainter''
        :param topic: topic to draw, ''str''
        :param stamp_start: stamp to start drawing, ''rospy.Time''
        :param stamp_end: stamp to end drawing, ''rospy.Time''
        :param x: x to draw images at, ''int''
        :param y: y to draw images at, ''int''
        :param width: width in pixels of the timeline area, ''int''
        :param height: height in pixels of the timeline area, ''int''
        """
        if x < self.timeline._history_left:
            width += x - self.timeline._history_left
            x = self.timeline._history_left
        max_interval_thumbnail = self.timeline.map_dx_to_dstamp(self.thumbnail_combine_px)
        max_interval_thumbnail = max(0.1, max_interval_thumbnail)
        thumbnail_gap = 6
        thumbnail_x, thumbnail_y, thumbnail_height = x + 1, y + 1, height - 2 - thumbnail_gap  # leave 1px border

        # set color to white draw rectangle over messages
        painter.setBrush(QBrush(Qt.white))
        painter.drawRect(x, y, width, height - thumbnail_gap)
        thumbnail_width = None

        while True:
            available_width = (x + width) - thumbnail_x

            # Check for enough remaining to draw thumbnail
            if width > 1 and available_width < self.min_thumbnail_width:
                break

            # Try to display the thumbnail, if its right edge is to the right of the timeline's left side
            if not thumbnail_width or thumbnail_x + thumbnail_width >= self.timeline._history_left:
                stamp = self.timeline.map_x_to_stamp(thumbnail_x, clamp_to_visible=False)
                thumbnail_bitmap = self.thumbnail_cache.get_item(topic, stamp, max_interval_thumbnail)

                # Cache miss
                if not thumbnail_bitmap:
                    thumbnail_details = (thumbnail_height,)
                    self.thumbnail_cache.enqueue((topic, stamp, max_interval_thumbnail, thumbnail_details))
                    if not thumbnail_width:
                        break
                else:
                    thumbnail_width, _ = thumbnail_bitmap.size

                    if width > 1:
                        if available_width < thumbnail_width:
                            thumbnail_width = available_width - 1
                    QtImage = ImageQt(thumbnail_bitmap)
                    pixmap = QPixmap.fromImage(QtImage)
                    painter.drawPixmap(thumbnail_x, thumbnail_y, thumbnail_width, thumbnail_height, pixmap)
            thumbnail_x += thumbnail_width

            if width == 1:
                break

        painter.setPen(QPen(QBrush(Qt.black)))
        painter.setBrush(QBrush(Qt.transparent))
        if width == 1:
            painter.drawRect(x, y, thumbnail_x - x, height - thumbnail_gap - 1)
        else:
            painter.drawRect(x, y, width, height - thumbnail_gap - 1)
        return True
Example #44
0
 def mousePressEvent(self, event):
     thing = QPixmap.grabWidget(self._layoutmanager._view)
     if thing.save(self.filename, "png", 100):
         print "Saved image to ", self.filename
class ImageView2Widget(QWidget):
    """
    Qt widget to communicate with image_view2
    """
    cv_image = None
    pixmap = None
    repaint_trigger = pyqtSignal()
    def __init__(self):
        super(ImageView2Widget, self).__init__()
        self.left_button_clicked = False
        
        self.repaint_trigger.connect(self.redraw)
        self.lock = Lock()
        self.need_to_rewrite = False
        self.bridge = CvBridge()
        self.image_sub = None
        self.event_pub = None
        self.label = ScaledLabel()
        self.label.setAlignment(Qt.AlignCenter)
        self.label.setSizePolicy(QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored))
        #self.label.installEventFilter(self)
        vbox = QtGui.QVBoxLayout(self)
        vbox.addWidget(self.label)
        self.setLayout(vbox)
        
        self._image_topics = []
        self._update_topic_thread = Thread(target=self.updateTopics)
        self._update_topic_thread.start()
        
        self._active_topic = None
        self.setMouseTracking(True)
        self.label.setMouseTracking(True)
        self._dialog = ComboBoxDialog()
        self.show()
    def trigger_configuration(self):
        self._dialog.exec_()
        self.setupSubscriber(self._image_topics[self._dialog.number])
    def setupSubscriber(self, topic):
        if self.image_sub:
            self.image_sub.unregister()
        rospy.loginfo("Subscribing %s" % (topic + "/marked"))
        self.image_sub = rospy.Subscriber(topic + "/marked",
                                          Image, 
                                          self.imageCallback)
        self.event_pub = rospy.Publisher(topic + "/event", MouseEvent)
        self._active_topic = topic
    def onActivated(self, number):
        self.setupSubscriber(self._image_topics[number])
    def imageCallback(self, msg):
        with self.lock:
            if msg.width == 0 or msg.height == 0:
                rospy.logdebug("Looks input images is invalid")
                return
            cv_image = self.bridge.imgmsg_to_cv2(msg, msg.encoding)
            if msg.encoding == "bgr8":
                self.cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB)
            elif msg.encoding == "rgb8":
                self.cv_image = cv_image
            self.numpy_image = np.asarray(self.cv_image)
            self.need_to_rewrite = True
            self.repaint_trigger.emit()
    def updateTopics(self):
        need_to_update = False
        for (topic, topic_type) in rospy.get_published_topics():
            if topic_type == "sensor_msgs/Image":
                with self.lock:
                    if not topic in self._image_topics:
                        self._image_topics.append(topic)
                        need_to_update = True
        if need_to_update:
            with self.lock:
                self._image_topics = sorted(self._image_topics)
                self._dialog.combo_box.clear()
                for topic in self._image_topics:
                    self._dialog.combo_box.addItem(topic)
                if self._active_topic:
                    self._dialog.combo_box.setCurrentIndex(self._image_topics.index(self._active_topic))
        time.sleep(1)
    @pyqtSlot()
    def redraw(self):
        with self.lock:
            if not self.need_to_rewrite:
                return
            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))
                #self.label.setPixmap(self.pixmap)
    def mousePosition(self, e):
        label_x = self.label.x()
        label_y = self.label.y()
        label_width = self.label.width()
        label_height = self.label.height()
        pixmap_width = self.label.pixmap().width()
        pixmap_height = self.label.pixmap().height()
        x_offset = (label_width - pixmap_width) / 2.0 + label_x
        y_offset = (label_height - pixmap_height) / 2.0 + label_y
        return (e.x() - x_offset, e.y()- y_offset)
    def mouseMoveEvent(self, e):
        msg = MouseEvent()
        msg.header.stamp = rospy.Time.now()
        msg.type = MouseEvent.MOUSE_MOVE
        msg.x, msg.y = self.mousePosition(e)
        msg.width = self.label.pixmap().width()
        msg.height = self.label.pixmap().height()
        if self.event_pub:
            self.event_pub.publish(msg)
    def mousePressEvent(self, e):
        msg = MouseEvent()
        msg.header.stamp = rospy.Time.now()
        if e.button() == Qt.LeftButton:
            msg.type = MouseEvent.MOUSE_LEFT_DOWN
            self.left_button_clicked = True
        elif e.button() == Qt.RightButton:
            msg.type = MouseEvent.MOUSE_RIGHT_DOWN
        msg.width = self.label.pixmap().width()
        msg.height = self.label.pixmap().height()
        msg.x, msg.y = self.mousePosition(e)
        if self.event_pub:
            self.event_pub.publish(msg)
    def mouseReleaseEvent(self, e):
        if e.button() == Qt.LeftButton:
            self.left_button_clicked = False
            msg = MouseEvent()
            msg.header.stamp = rospy.Time.now()
            msg.width = self.label.pixmap().width()
            msg.height = self.label.pixmap().height()
            msg.type = MouseEvent.MOUSE_LEFT_UP
            msg.x, msg.y = self.mousePosition(e)
            if self.event_pub:
                self.event_pub.publish(msg)
    def save_settings(self, plugin_settings, instance_settings):
        if self._active_topic:
            instance_settings.set_value("active_topic", self._active_topic)
    def restore_settings(self, plugin_settings, instance_settings):
        if instance_settings.value("active_topic"):
            topic = instance_settings.value("active_topic")
            self._dialog.combo_box.addItem(topic)
            self.setupSubscriber(topic)