interactive_marker_control.h

Go to the documentation of this file.

/*
 * Copyright (c) 2011, Willow Garage, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Willow Garage, Inc. nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef INTERACTIVE_MARKER_CONTROL_H_
#define INTERACTIVE_MARKER_CONTROL_H_
 
#ifndef Q_MOC_RUN
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
 
#include <OgreRay.h>
#include <rviz/ogre_helpers/ogre_vector.h>
#include <OgreQuaternion.h>
#include <OgreSceneManager.h>
#endif
 
#include <QCursor>
 
#include <visualization_msgs/InteractiveMarkerControl.h>
 
#include <rviz/windows_compat.h>
#include <rviz/default_plugin/markers/marker_base.h>
#include <rviz/selection/forwards.h>
#include <rviz/viewport_mouse_event.h>
#include <rviz/interactive_object.h>
 
namespace Ogre
{
class SceneNode;
}
 
namespace rviz
{
class DisplayContext;
class InteractiveMarker;
class PointsMarker;
class Line;
 
class InteractiveMarkerControl : public Ogre::SceneManager::Listener,
                                 public InteractiveObject,
                                 public boost::enable_shared_from_this<InteractiveMarkerControl>
{
public:
  InteractiveMarkerControl(DisplayContext* context,
                           Ogre::SceneNode* reference_node,
                           InteractiveMarker* parent);
 
  ~InteractiveMarkerControl() override;
 
  void processMessage(const visualization_msgs::InteractiveMarkerControl& message);
 
  // called when interactive mode is globally switched on/off
  void enableInteraction(bool enable) override;
 
  // will receive all mouse events while the handler has focus
  void handleMouseEvent(ViewportMouseEvent& event) override;
 
  virtual void handle3DCursorEvent(ViewportMouseEvent event,
                                   const Ogre::Vector3& cursor_3D_pos,
                                   const Ogre::Quaternion& cursor_3D_orientation);
 
  void interactiveMarkerPoseChanged(Ogre::Vector3 int_marker_position,
                                    Ogre::Quaternion int_marker_orientation);
 
  bool isInteractive() override
  {
    return interaction_mode_ != visualization_msgs::InteractiveMarkerControl::NONE;
  }
 
  // Called every frame by parent's update() function.
  void update();
 
  void setVisible(bool visible);
 
  bool getVisible();
 
  // Highlight types
  enum ControlHighlight
  {
    NO_HIGHLIGHT = 0,
    HOVER_HIGHLIGHT = 3,
    ACTIVE_HIGHLIGHT = 5
  };
 
  // Public access to highlight controls
  void setHighlight(const ControlHighlight& hl);
 
  InteractiveMarker* getParent()
  {
    return parent_;
  }
 
  const std::string& getName()
  {
    return name_;
  }
 
  const QString& getDescription()
  {
    return description_;
  }
 
  int getInteractionMode()
  {
    return interaction_mode_;
  }
 
  int getOrientationMode()
  {
    return orientation_mode_;
  }
 
  void setShowVisualAids(bool show)
  {
    show_visual_aids_ = show;
  }
 
protected:
  // when this is called, we will face the camera
  void preFindVisibleObjects(Ogre::SceneManager* source,
                             Ogre::SceneManager::IlluminationRenderStage irs,
                             Ogre::Viewport* v) override;
 
  void updateControlOrientationForViewFacing(Ogre::Viewport* v);
 
  Ogre::Ray getMouseRayInReferenceFrame(const ViewportMouseEvent& event, int x, int y);
 
  void beginRelativeMouseMotion(const ViewportMouseEvent& event);
 
  bool getRelativeMouseMotion(const ViewportMouseEvent& event, int& dx, int& dy);
 
  void rotateXYRelative(const ViewportMouseEvent& event);
 
  void rotateZRelative(const ViewportMouseEvent& event);
 
  void moveZAxisRelative(const ViewportMouseEvent& event);
 
  void moveZAxisWheel(const ViewportMouseEvent& event);
 
  void moveViewPlane(Ogre::Ray& mouse_ray, const ViewportMouseEvent& event);
 
  void rotate(Ogre::Ray& mouse_ray);
 
  void rotate(const Ogre::Vector3& cursor_position_in_reference_frame);
 
  void moveRotate(Ogre::Ray& mouse_ray);
 
  void moveRotate(const Ogre::Vector3& cursor_position_in_reference_frame, bool lock_axis = true);
 
  void movePlane(Ogre::Ray& mouse_ray);
 
  void movePlane(const Ogre::Vector3& cursor_position_in_reference_frame);
 
  void moveAxis(const Ogre::Ray& mouse_ray, const ViewportMouseEvent& event);
 
  void moveAxis(const Ogre::Vector3& cursor_position_in_reference_frame);
 
  void move3D(const Ogre::Vector3& cursor_position_in_reference_frame,
              const Ogre::Quaternion& cursor_orientation_in_reference_frame);
 
  void rotate3D(const Ogre::Vector3& cursor_position_in_reference_frame,
                const Ogre::Quaternion& cursor_orientation_in_reference_frame);
 
  void moveRotate3D(const Ogre::Vector3& cursor_position_in_reference_frame,
                    const Ogre::Quaternion& cursor_orientation_in_reference_frame);
 
  bool intersectYzPlane(const Ogre::Ray& mouse_ray,
                        Ogre::Vector3& intersection_3d,
                        Ogre::Vector2& intersection_2d,
                        float& ray_t);
 
  bool intersectSomeYzPlane(const Ogre::Ray& mouse_ray,
                            const Ogre::Vector3& point_in_plane,
                            const Ogre::Quaternion& plane_orientation,
                            Ogre::Vector3& intersection_3d,
                            Ogre::Vector2& intersection_2d,
                            float& ray_t);
 
  bool findClosestPoint(const Ogre::Ray& target_ray,
                        const Ogre::Ray& mouse_ray,
                        Ogre::Vector3& closest_point);
 
  void worldToScreen(const Ogre::Vector3& pos_rel_reference,
                     const Ogre::Viewport* viewport,
                     Ogre::Vector2& screen_pos);
 
  void addHighlightPass(const S_MaterialPtr& materials);
 
  // set the highlight color to (a,a,a)
  void setHighlight(float a);
 
  // Save a copy of the latest mouse event with the event type set to
  // QEvent::MouseMove, so that update() can resend the mouse event during
  // drag actions to maintain consistent behavior.
  void recordDraggingInPlaceEvent(ViewportMouseEvent& event);
 
  // Begin a new mouse motion.  Called when left button is pressed to begin a drag.
  void beginMouseMovement(ViewportMouseEvent& event, bool line_visible);
 
  // Motion part of mouse event handling.
  void handleMouseMovement(ViewportMouseEvent& event);
 
  // Mouse wheel part of mouse event handling.
  void handleMouseWheelMovement(ViewportMouseEvent& event);
 
  // Return closest point on a line to a test point.
  Ogre::Vector3 closestPointOnLineToPoint(const Ogre::Vector3& line_start,
                                          const Ogre::Vector3& line_dir,
                                          const Ogre::Vector3& test_point);
 
  void makeMarkers(const visualization_msgs::InteractiveMarkerControl& message);
 
  void stopDragging(bool force = false);
 
  const QCursor& getCursor() const override
  {
    return cursor_;
  }
 
  bool mouse_dragging_;
  Ogre::Viewport* drag_viewport_;
 
  ViewportMouseEvent dragging_in_place_event_;
 
  DisplayContext* context_;
 
  CollObjectHandle coll_object_handle_;
 
  Ogre::SceneNode* reference_node_;
 
  Ogre::SceneNode* control_frame_node_;
 
  // this is a child of scene_node, but might be oriented differently
  Ogre::SceneNode* markers_node_;
 
  // interaction mode
  int interaction_mode_;
  int orientation_mode_;
 
  // if in view facing mode, the markers should be
  // view facing as well
  // if set to false, they will follow the parent's transformations
  bool independent_marker_orientation_;
 
  Ogre::Quaternion control_orientation_;
 
  bool always_visible_;
 
  QString description_;
 
  std::string name_;
 
  typedef boost::shared_ptr<MarkerBase> MarkerBasePtr;
  std::vector<MarkerBasePtr> markers_;
 
  InteractiveMarker* parent_;
 
  std::set<Ogre::Pass*> highlight_passes_;
 
  // PointsMarkers are rendered by special shader programs, so the
  // regular highlighting method does not work for them.  Keep a
  // vector of them so we can call their setHighlightColor() function.
  typedef boost::shared_ptr<PointsMarker> PointsMarkerPtr;
  std::vector<PointsMarkerPtr> points_markers_;
 
  Ogre::Radian rotation_;
 
  Ogre::Radian rotation_at_mouse_down_;
 
  Ogre::Vector3 grab_point_in_reference_frame_;
 
  Ogre::Quaternion grab_orientation_in_reference_frame_;
 
  Ogre::Vector3 parent_to_cursor_in_cursor_frame_at_grab_;
 
  Ogre::Quaternion rotation_cursor_to_parent_at_grab_;
 
  Qt::KeyboardModifiers modifiers_at_drag_begin_;
 
  int mouse_x_at_drag_begin_;
  int mouse_y_at_drag_begin_;
 
  /* mouse ray when drag begins. */
  Ogre::Ray mouse_ray_at_drag_begin_;
 
  /* how far to move in Z when mouse moves 1 pixel. */
  double mouse_z_scale_;
 
  int mouse_relative_to_absolute_x_;
  int mouse_relative_to_absolute_y_;
 
  Ogre::Vector3 parent_to_grab_position_; // obsolete now, but left for ABI compatibility
 
  Ogre::Vector3 parent_position_at_mouse_down_;
 
  Ogre::Quaternion control_frame_orientation_at_mouse_down_;
 
  Ogre::Quaternion parent_orientation_at_mouse_down_;
 
  Ogre::Vector3 rotation_axis_;
 
  Ogre::Vector3 rotation_center_rel_control_;
 
  Ogre::Vector3 grab_point_rel_control_;
 
  bool has_focus_;
  bool interaction_enabled_;
 
  bool visible_;
  bool view_facing_;
 
  QCursor cursor_;
  QString status_msg_;
 
  bool mouse_down_;
 
  boost::shared_ptr<Line> line_;
 
  bool show_visual_aids_;
};
 
} // namespace rviz
 
#endif /* INTERACTIVE_MARKER_CONTROL_H_ */