ModelCreator.hh

Go to the documentation of this file.

/*
 * Copyright 2013 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 _MODEL_CREATOR_HH_
#define _MODEL_CREATOR_HH_

#include <list>
#include <string>
#include <vector>

#include <boost/unordered/unordered_map.hpp>

#include <sdf/sdf.hh>

#include "gazebo/common/KeyEvent.hh"
#include "gazebo/physics/PhysicsTypes.hh"
#include "gazebo/math/Pose.hh"
#include "gazebo/transport/TransportTypes.hh"

#include "gazebo/gui/qt.h"
#include "gazebo/gui/model/JointMaker.hh"
#include "gazebo/util/system.hh"

namespace gazebo
{
  namespace msgs
  {
    class Visual;
  }

  namespace gui
  {
    class PartData;


    class GAZEBO_VISIBLE ModelCreator : public QObject
    {
      Q_OBJECT

      public: enum PartType
      {
        PART_NONE,
        PART_BOX,
        PART_SPHERE,
        PART_CYLINDER,
        PART_CUSTOM
      };

      public: ModelCreator();

      public: virtual ~ModelCreator();

      public: void SetModelName(const std::string &_modelName);

      public: std::string GetModelName() const;

       public: void FinishModel();

      public: std::string AddBox(
          const math::Vector3 &_size = math::Vector3::One,
          const math::Pose &_pose = math::Pose::Zero);

      public: std::string AddSphere(double _radius = 0.5,
          const math::Pose &_pose = math::Pose::Zero);

      public: std::string AddCylinder(double _radius = 0.5,
          double _length = 1.0, const math::Pose &_pose = math::Pose::Zero);

      public: std::string AddCustom(const std::string &_name,
          const math::Vector3 &_scale = math::Vector3::One,
          const math::Pose &_pose = math::Pose::Zero);

      public: void AddJoint(JointMaker::JointType _type);

      public: void RemovePart(const std::string &_partName);

      public: void SetStatic(bool _static);

      public: void SetAutoDisable(bool _auto);

      public: void SaveToSDF(const std::string &_savePath);

      public: void Reset();

      public: void Stop();

      public: JointMaker *GetJointMaker() const;

      public: void AddPart(PartType _type);

      public: void GenerateSDF();

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

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

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

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

      private: void CreatePart(const rendering::VisualPtr &_visual);

      // Documentation inherited
      private: virtual void CreateTheEntity();

      private: bool Init();

      private: std::string CreateModel();

      private: std::string GetTemplateSDFString();

      private slots: void OnDelete(const std::string &_name="");

      Q_SIGNALS: void PartAdded();

      private: sdf::SDFPtr modelSDF;

      private: sdf::SDFPtr modelTemplateSDF;

      private: std::string modelName;

      private: rendering::VisualPtr modelVisual;

      private: rendering::VisualPtr mouseVisual;

      private: math::Pose modelPose;

      private: bool isStatic;

      private: bool autoDisable;

      private: std::vector<event::ConnectionPtr> connections;

      private: int boxCounter;

      private: int cylinderCounter;

      private: int sphereCounter;

      private: int customCounter;

      private: int modelCounter;

      private: PartType addPartType;

      private: boost::unordered_map<std::string, PartData *> allParts;

      private: transport::NodePtr node;

      private: transport::PublisherPtr makerPub;

      private: transport::PublisherPtr requestPub;

      private: JointMaker *jointMaker;

      private: math::Pose origin;

      private: rendering::VisualPtr selectedVis;
    };

    class GAZEBO_VISIBLE SensorData
    {
      public: std::string name;

      public: std::string type;

      public: math::Vector3 pose;

      public: bool visualize;

      public: bool alwaysOn;

      public: std::string topicName;
    };

    class GAZEBO_VISIBLE PartData : public QObject
    {
      Q_OBJECT

      public: std::string name;

      public: std::vector<rendering::VisualPtr> visuals;

      public: bool gravity;

      public: bool selfCollide;

      public: bool kinematic;

      public: math::Pose pose;

      public: physics::Inertial *inertial;

      public: std::vector<physics::CollisionPtr> collisions;

      public: SensorData *sensorData;
    };
  }
}
#endif