AdvancedVisualizationFactory.h

Go to the documentation of this file.

 
/* This file is part of ArmarX.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* @package    ArmarXGuiPlugins::RobotTrajectoryDesigner::Visualization
* @author     Timo Birr
* @date       2018
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
#ifndef ADVANCEDVISUALIZATIONFACTORY_H
#define ADVANCEDVISUALIZATIONFACTORY_H
 
#include <memory>
 
#include <VirtualRobot/Primitive.h>
#include <VirtualRobot/Robot.h>
#include <VirtualRobot/Visualization/VisualizationFactory.h>
#include <VirtualRobot/Visualization/VisualizationNode.h>
 
#include "AbstractManipulatorVisualization.h"
#include "VirtualRobot/BoundingBox.h"
#include "VirtualRobot/MathTools.h"
#include "VirtualRobot/Trajectory.h"
#include "VirtualRobot/Visualization/TriMeshModel.h"
 
namespace armarx
{
    /**
     * @brief The AdvancedVisualizationFactory class is the abstract decorator of the Decorator-Pattern and decorates the VisualizationFactoy in Simox
     *
     * The additional Functionality is that it can also generate the Visualization for a Manipulator
     */
    class AdvancedVisualizationFactory : public VirtualRobot::VisualizationFactory
    {
 
 
    public:
        /**
         * @brief createManipulator
         * @param kc
         * @param robot
         * @return
         */
        AbstractManipulatorVisualizationPtr createManipulator(VirtualRobot::RobotNodeSetPtr kc,
                                                              VirtualRobot::RobotPtr robot);
 
        virtual void
        init(int& argc, char* argv[], const std::string& appName) override
        {
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        getVisualizationFromPrimitives(
            const std::vector<VirtualRobot::Primitive::PrimitivePtr>& primitives,
            bool boundingBox = false,
            Color color = Color::Gray()) override
        {
            return component.getVisualizationFromPrimitives(primitives, boundingBox, color);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        getVisualizationFromFile(const std::string& filename,
                                 bool boundingBox = false,
                                 float scaleX = 1.0f,
                                 float scaleY = 1.0f,
                                 float scaleZ = 1.0f) override
        {
            return component.getVisualizationFromFile(
                filename, boundingBox, scaleX, scaleY, scaleZ);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        getVisualizationFromFile(const std::ifstream& ifs,
                                 bool boundingBox = false,
                                 float scaleX = 1.0f,
                                 float scaleY = 1.0f,
                                 float scaleZ = 1.0f) override
        {
            return component.getVisualizationFromFile(ifs, boundingBox, scaleX, scaleY, scaleZ);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createBox(float width,
                  float height,
                  float depth,
                  float colorR = 0.5f,
                  float colorG = 0.5f,
                  float colorB = 0.5f) override
        {
            return component.createBox(width, height, depth, colorR, colorG, colorB);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createLine(const Eigen::Vector3f& from,
                   const Eigen::Vector3f& to,
                   float width = 1.0f,
                   float colorR = 0.5f,
                   float colorG = 0.5f,
                   float colorB = 0.5f) override
        {
            return component.createLine(from, to, width, colorR, colorG, colorB);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createLine(const Eigen::Matrix4f& from,
                   const Eigen::Matrix4f& to,
                   float width = 1.0f,
                   float colorR = 0.5f,
                   float colorG = 0.5f,
                   float colorB = 0.5f) override
        {
            return component.createLine(from, to, width, colorR, colorG, colorB);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createSphere(float radius,
                     float colorR = 0.5f,
                     float colorG = 0.5f,
                     float colorB = 0.5f) override
        {
            return component.createSphere(radius, colorR, colorG, colorB);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createCircle(float radius,
                     float circleCompletion,
                     float width,
                     float colorR = 1.0f,
                     float colorG = 0.5f,
                     float colorB = 0.5f,
                     size_t numberOfCircleParts = 30) override
        {
            return component.createCircle(
                radius, circleCompletion, width, colorR, colorG, colorB, numberOfCircleParts);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createTorus(float radius,
                    float tubeRadius,
                    float completion = 1.0f,
                    float colorR = 0.5f,
                    float colorG = 0.5f,
                    float colorB = 0.5f,
                    float transparency = 0.0f,
                    int sides = 8,
                    int rings = 30) override
        {
            return component.createTorus(
                radius, tubeRadius, completion, colorR, colorG, colorB, transparency, sides, rings);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createCircleArrow(float radius,
                          float tubeRadius,
                          float completion = 1,
                          float colorR = 0.5f,
                          float colorG = 0.5f,
                          float colorB = 0.5f,
                          float transparency = 0.0f,
                          int sides = 8,
                          int rings = 30) override
        {
            return component.createCircleArrow(
                radius, tubeRadius, completion, colorR, colorG, colorB, transparency, sides, rings);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createCylinder(float radius,
                       float height,
                       float colorR = 0.5f,
                       float colorG = 0.5f,
                       float colorB = 0.5f) override
        {
            return component.createCylinder(radius, height, colorR, colorG, colorB);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createCoordSystem(float scaling = 1.0f,
                          std::string* text = NULL,
                          float axisLength = 100.0f,
                          float axisSize = 3.0f,
                          int nrOfBlocks = 10) override
        {
            return component.createCoordSystem(scaling, text, axisLength, axisSize, nrOfBlocks);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createBoundingBox(const VirtualRobot::BoundingBox& bbox, bool wireFrame = false) override
        {
            return component.createBoundingBox(bbox, wireFrame);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createVertexVisualization(const Eigen::Vector3f& position,
                                  float radius,
                                  float transparency,
                                  float colorR = 0.5f,
                                  float colorG = 0.5f,
                                  float colorB = 0.5f) override
        {
            return component.createVertexVisualization(
                position, radius, transparency, colorR, colorG, colorB);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createTriMeshModelVisualization(VirtualRobot::TriMeshModelPtr model,
                                        Eigen::Matrix4f& pose,
                                        float scaleX = 1.0f,
                                        float scaleY = 1.0f,
                                        float scaleZ = 1.0f) override
        {
            return component.createTriMeshModelVisualization(model, pose, scaleX, scaleY, scaleZ);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createTriMeshModelVisualization(VirtualRobot::TriMeshModelPtr model,
                                        bool showNormals,
                                        Eigen::Matrix4f& pose,
                                        bool showLines = true) override
        {
            return component.createTriMeshModelVisualization(model, showNormals, pose, showLines);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createPlane(const Eigen::Vector3f& position,
                    const Eigen::Vector3f& normal,
                    float extend,
                    float transparency,
                    float colorR = 0.5f,
                    float colorG = 0.5f,
                    float colorB = 0.5f) override
        {
            return component.createPlane(
                position, normal, extend, transparency, colorR, colorG, colorB);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createPlane(const VirtualRobot::MathTools::Plane& plane,
                    float extend,
                    float transparency,
                    float colorR = 0.5f,
                    float colorG = 0.5f,
                    float colorB = 0.5f) override
        {
            return component.createPlane(plane, extend, transparency, colorR, colorG, colorB);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createArrow(const Eigen::Vector3f& n,
                    float length = 50.0f,
                    float width = 2.0f,
                    const Color& color = Color::Gray()) override
        {
            return component.createArrow(n, length, width, color);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createTrajectory(VirtualRobot::TrajectoryPtr t,
                         Color colorNode = Color::Blue(),
                         Color colorLine = Color::Gray(),
                         float nodeSize = 15.0f,
                         float lineSize = 4.0f) override
        {
            return component.createTrajectory(t, colorNode, colorLine, nodeSize, lineSize);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createText(const std::string& text,
                   bool billboard = false,
                   float scaling = 1.0f,
                   Color c = Color::Black(),
                   float offsetX = 20.0f,
                   float offsetY = 20.0f,
                   float offsetZ = 0.0f) override
        {
            return component.createText(text, billboard, scaling, c, offsetX, offsetY, offsetZ);
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createEllipse(float x,
                      float y,
                      float z,
                      bool showAxes = true,
                      float axesHeight = 4.0f,
                      float axesWidth = 8.0f) override
        {
            return component.createEllipse(x, y, z, showAxes, axesHeight, axesWidth);
        }
 
        virtual void
        applyDisplacement(VirtualRobot::VisualizationNodePtr o, Eigen::Matrix4f& m) override
        {
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createVisualization() override
        {
            return component.createVisualization();
        }
 
        virtual VirtualRobot::VisualizationNodePtr
        createUnitedVisualization(
            const std::vector<VirtualRobot::VisualizationNodePtr>& visualizations) const override
        {
            return component.createUnitedVisualization(visualizations);
        }
 
        /**
         * @brief createCurve creates the visualization of a curve that goes through the Waypoints in transition
         * @param transition the curve/transition to visualize
         * @param highligt true when the Transition should be highlighted(red) , false if not (blue)
         * @return the visualization node in the visualization method of this factory
         */
        virtual VirtualRobot::VisualizationNodePtr
        createCurve(const std::vector<PoseBasePtr> transition, bool highligt);
 
 
    protected:
        VisualizationFactory component;
    };
 
    using AdvancedVisualizationFactoryPtr = std::shared_ptr<AdvancedVisualizationFactory>;
} // namespace armarx
 
#endif