JointMaker.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2014 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/

#ifndef _GAZEBO_GUI_JOINTMAKER_HH_
#define _GAZEBO_GUI_JOINTMAKER_HH_

#include <map>
#include <memory>
#include <string>
#include <vector>

#include <ignition/math/Pose3.hh>
#include <ignition/math/Vector3.hh>

#include <sdf/sdf.hh>

#include "gazebo/gui/qt.h"

#include "gazebo/msgs/msgs.hh"

#include "gazebo/rendering/RenderTypes.hh"

#include "gazebo/util/system.hh"

namespace Ogre
{
  class BillboardSet;
}

namespace boost
{
  class recursive_mutex;
}

namespace gazebo
{
  namespace common
  {
    class KeyEvent;
    class MouseEvent;
  }

  namespace rendering
  {
    class DynamicLines;
  }

  namespace gui
  {
    class JointData;
    class JointInspector;
    class MEUserCmdManager;

    // Forward declare private data.
    class JointMakerPrivate;


    class GZ_GUI_VISIBLE JointMaker : public QObject
    {
      Q_OBJECT

      public: enum JointType
      {
        JOINT_NONE,
        JOINT_FIXED,
        JOINT_SLIDER,
        JOINT_HINGE,
        JOINT_HINGE2,
        JOINT_SCREW,
        JOINT_UNIVERSAL,
        JOINT_BALL,
        JOINT_GEARBOX
      };

      public: JointMaker();

      public: virtual ~JointMaker();

      public: void Reset();

      public: void EnableEventHandlers();

      public: void DisableEventHandlers();

      public: void AddJoint(const std::string &_type);

      public: void AddJoint(const JointType _type);

      public: JointData *CreateJoint(const rendering::VisualPtr &_parent,
          const rendering::VisualPtr &_child);

      public: std::string CreateHotSpot(JointData *_joint);

      public: void Update();

      public: void RemoveJoint(const std::string &_jointName);

      public: void RemoveJointByUser(const std::string &_jointName);

      public: void RemoveJointsByLink(const std::string &_linkName);

      public: std::vector<JointData *> JointDataByLink(
          const std::string &_linkName) const;

      public: void GenerateSDF();

      public: sdf::ElementPtr SDF() const;

      public: static unsigned int JointAxisCount(
          const JointMaker::JointType _type);

      public: static std::string TypeAsString(
          const JointMaker::JointType _type);

      public: static JointType ConvertJointType(const std::string &_type);

      public: static std::string JointMaterial(const std::string &_type);

      public: JointMaker::JointType State() const;

      public: void Stop();

      public: unsigned int JointCount();

      public: void CreateJointFromSDF(sdf::ElementPtr _jointElem,
          const std::string &_modelName = "");

      public: void AddScopedLinkName(const std::string &_name);

      public slots: void ShowJoints(const bool _show);

      public: void SetSelected(const std::string &_name, const bool selected);

      public: void SetSelected(const rendering::VisualPtr &_jointVis,
          const bool selected);

      public: std::map<std::string, std::string> LinkList() const;

      public slots: void OnType(const int _typeInt);

      public slots: void SetAxis(const std::string &_axis,
          const ignition::math::Vector3d &_value);

      public: void SetJointPose(const ignition::math::Pose3d &_pose);

      public: void SetParentLink(const std::string &_name);

      public: void SetChildLink(const std::string &_name);

      public: void SetLinksRelativePose(
          const ignition::math::Pose3d &_pose, const bool _resetAll,
          const int _resetAxis = -1);

      public: void AlignLinks(const bool _childToParent,
          const std::string &_axis, const std::string &_mode,
          const bool _reverse);

      public: void FinalizeCreation();

      public: void SetUserCmdManager(MEUserCmdManager *_manager);

      private: bool OnMousePress(const common::MouseEvent &_event);

      private: bool OnMouseRelease(const common::MouseEvent &_event);

      private: bool OnMouseMove(const common::MouseEvent &_event);

      private: bool OnMouseDoubleClick(const common::MouseEvent &_event);

      private: bool OnKeyPress(const common::KeyEvent &_event);

      private: void OpenInspector(const std::string &_name);

      private: std::string ScopedLinkName(const std::string &_name);

      private: void ShowContextMenu(const std::string &_joint);

      private: void DeselectAll();

      private: void OnSetSelectedEntity(const std::string &_name,
          const std::string &_mode);

      private: void OnSetSelectedJoint(const std::string &_name,
          const bool _selected);

      private: void OnLinkInserted(const std::string &_linkName);

      private: void OnLinkRemoved(const std::string &_linkName);

      private: JointData *CreateJointLine(const std::string &_name,
          const rendering::VisualPtr &_parent);

      private: rendering::VisualPtr LinkVisualFromName(
          const std::string &_name);

      private: bool SetParentLink(const rendering::VisualPtr &_parentLink);

      private: bool SetChildLink(const rendering::VisualPtr &_childLink);

      private: void SetVisualMoved(const rendering::VisualPtr &_vis,
          const bool _moved);

      Q_SIGNALS: void JointAdded();

      Q_SIGNALS: void EmitLinkInserted(const std::string &_linkId);

      Q_SIGNALS: void EmitLinkRemoved(const std::string &_linkId);

      private slots: void OnOpenInspector();

      private slots: void OnDelete();

      public: static std::map<JointMaker::JointType, std::string> jointTypes;

      public: static std::vector<ignition::math::Vector3d> unitVectors;

      public: static std::map<JointMaker::JointType, std::string>
          jointMaterials;

      private: std::unique_ptr<JointMakerPrivate> dataPtr;
    };


    class GZ_GUI_VISIBLE JointData : public QObject
    {
      Q_OBJECT

      public: void OpenInspector();

      public: void Update();

      public: void UpdateMsg();

      public: std::string name;

      public: rendering::VisualPtr visual;

      public: rendering::JointVisualPtr jointVisual;

      public: rendering::VisualPtr hotspot;

      public: rendering::VisualPtr parent;

      public: rendering::VisualPtr child;

      public: ignition::math::Pose3d parentPose;

      public: ignition::math::Pose3d childPose;

      public: ignition::math::Vector3d childScale;

      public: rendering::DynamicLines *line;

      public: Ogre::BillboardSet *handles;

      public: JointMaker::JointType type;

      public: std::vector<ignition::math::Vector3d> axes;

      public: bool dirty;

      public: msgs::JointPtr jointMsg;

      public: JointInspector *inspector;

      private slots: void OnOpenInspector();

      private slots: void OnApply();
    };
  }
}
#endif