Heightmap.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012 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_RENDERING_HEIGHTMAP_HH_
#define GAZEBO_RENDERING_HEIGHTMAP_HH_

#include <vector>
#include <string>

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

#include "gazebo/msgs/MessageTypes.hh"
#include "gazebo/rendering/RenderTypes.hh"
#include "gazebo/rendering/ogre_gazebo.h"
#include "gazebo/util/system.hh"

namespace boost
{
  namespace filesystem
  {
    class path;
  }
}

namespace Ogre
{
  class TerrainGroup;
  class Terrain;
}

namespace gazebo
{
  namespace common
  {
    class Image;
  }

  namespace rendering
  {
    // Forward declare private data.
    class HeightmapPrivate;


    class GZ_RENDERING_VISIBLE Heightmap
    {
      public: explicit Heightmap(ScenePtr _scene);

      public: virtual ~Heightmap();

      public: void Load();

      public: void LoadFromMsg(ConstVisualPtr &_msg);

      public: double Height(const double _x, const double _y,
          const double _z = 1000) const;

      public: bool Flatten(CameraPtr _camera,
                          const ignition::math::Vector2i &_mousePos,
                          const double _outsideRadius,
                          const double _insideRadius,
                          const double _weight = 0.1);

      public: bool Smooth(CameraPtr _camera,
                          const ignition::math::Vector2i &_mousePos,
                          const double _outsideRadius,
                          const double _insideRadius,
                          const double _weight = 0.1);

      public: bool Raise(CameraPtr _camera,
                         const ignition::math::Vector2i &_mousePos,
                         const double _outsideRadius,
                         const double _insideRadius,
                         const double _weight = 0.1);

      public: bool Lower(CameraPtr _camera,
                         const ignition::math::Vector2i &_mousePos,
                         const double _outsideRadius,
                         const double _insideRadius,
                         const double _weight = 0.1);

      public: double AvgHeight(const ignition::math::Vector3d &_pos,
          const double _brushSize) const;

      public: void SetWireframe(const bool _show);

      public: Ogre::TerrainGroup *OgreTerrain() const;

      public: common::Image Image() const;

      public: Ogre::TerrainGroup::RayResult MouseHit(CameraPtr _camera,
                  const ignition::math::Vector2i &_mousePos) const;

      public: void SplitHeights(const std::vector<float> &_heightmap,
                  const int _n, std::vector<std::vector<float> > &_v);

      public: unsigned int TerrainSubdivisionCount() const;

      public: void SetMaterial(const std::string &_materialName);

      public: std::string MaterialName() const;

      public: void SetLOD(const unsigned int _value);

      public: unsigned int LOD() const;

      private: void CreateMaterial();

      private: void ModifyTerrain(Ogre::Vector3 _pos,
                    const double _outsideRadius, const double _insideRadius,
                    const double _weight, const std::string &_op);

      private: bool InitBlendMaps(Ogre::Terrain *_terrain);

      private: void ConfigureTerrainDefaults();

      private: void DefineTerrain(const int _x, const int _y);

      private: void SetupShadows(const bool _enabled);

      private: void UpdateTerrainHash(const std::string &_hash,
          const boost::filesystem::path &_terrainDir);

      private: bool PrepareTerrain(
          const boost::filesystem::path &_terrainDirPath);

      private: void SaveHeightmap();

      private: std::unique_ptr<HeightmapPrivate> dataPtr;
    };
  }
}
#endif