Camera.hh

Go to the documentation of this file.

/*
 * Copyright 2019 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 SDF_CAMERA_HH_
#define SDF_CAMERA_HH_
 
#include <string>
#include <ignition/math/Pose3.hh>
 
#include <sdf/Error.hh>
#include <sdf/Element.hh>
#include <sdf/Noise.hh>
#include <sdf/sdf_config.h>
 
namespace sdf
{
  // Inline bracket to help doxygen filtering.
  inline namespace SDF_VERSION_NAMESPACE {
  //
  // Forward declare private data class.
  class CameraPrivate;
 
  enum class PixelFormatType
  {
    UNKNOWN_PIXEL_FORMAT = 0,
    L_INT8,
    L_INT16,
    RGB_INT8,
    RGBA_INT8,
    BGRA_INT8,
    RGB_INT16,
    RGB_INT32,
    BGR_INT8,
    BGR_INT16,
    BGR_INT32,
    R_FLOAT16,
    RGB_FLOAT16,
    R_FLOAT32,
    RGB_FLOAT32,
    BAYER_RGGB8,
    BAYER_BGGR8,
    BAYER_GBRG8,
    BAYER_GRBG8,
  };
 
  class SDFORMAT_VISIBLE Camera
  {
    public: Camera();
 
    public: Camera(const Camera &_camera);
 
    public: Camera(Camera &&_camera) noexcept;
 
    public: virtual ~Camera();
 
    public: Camera &operator=(const Camera &_camera);
 
    public: Camera &operator=(Camera &&_camera) noexcept;
 
    public: bool operator==(const Camera &_alt) const;
 
    public: bool operator!=(const Camera &_alt) const;
 
    public: Errors Load(ElementPtr _sdf);
 
    public: sdf::ElementPtr Element() const;
 
    public: std::string Name() const;
 
    public: void SetName(const std::string &_name);
 
    public: ignition::math::Angle HorizontalFov() const;
 
    public: void SetHorizontalFov(const ignition::math::Angle &_hfov);
 
    public: uint32_t ImageWidth() const;
 
    public: void SetImageWidth(uint32_t _width);
 
    public: uint32_t ImageHeight() const;
 
    public: void SetImageHeight(uint32_t _height);
 
    public: PixelFormatType PixelFormat() const;
 
    public: void SetPixelFormat(PixelFormatType _format);
 
    public: std::string PixelFormatStr() const;
 
    public: void SetPixelFormatStr(const std::string &_fmt);
 
    public: uint32_t AntiAliasingValue() const;
 
    public: void SetAntiAliasingValue(uint32_t _antiAliasingValue);
 
    public: double DepthNearClip() const;
 
    public: void SetDepthNearClip(double _near);
 
    public: double DepthFarClip() const;
 
    public: void SetDepthFarClip(double _far);
 
    public: double NearClip() const;
 
    public: void SetNearClip(double _near);
 
    public: void SetHasDepthCamera(bool _camera);
 
    public: bool HasDepthCamera() const;
 
    public: void SetHasDepthNearClip(bool _near);
 
    public: bool HasDepthNearClip() const;
 
    public: void SetHasDepthFarClip(bool _far);
 
    public: bool HasDepthFarClip() const;
 
    public: double FarClip() const;
 
    public: void SetFarClip(double _far);
 
    public: bool SaveFrames() const;
 
    public: void SetSaveFrames(bool _save);
 
    public: const std::string &SaveFramesPath() const;
 
    public: void SetSaveFramesPath(const std::string &_path);
 
    public: const Noise &ImageNoise() const;
 
    public: void SetImageNoise(const Noise &_noise);
 
    public: double DistortionK1() const;
 
    public: void SetDistortionK1(double _k1);
 
    public: double DistortionK2() const;
 
    public: void SetDistortionK2(double _k2);
 
    public: double DistortionK3() const;
 
    public: void SetDistortionK3(double _k3);
 
    public: double DistortionP1() const;
 
    public: void SetDistortionP1(double _p1);
 
    public: double DistortionP2() const;
 
    public: void SetDistortionP2(double _p2);
 
    public: const ignition::math::Vector2d &DistortionCenter() const;
 
    public: void SetDistortionCenter(
                const ignition::math::Vector2d &_center) const;
 
    public: const ignition::math::Pose3d &Pose() const
        SDF_DEPRECATED(9.0);
 
    public: void SetPose(const ignition::math::Pose3d &_pose)
        SDF_DEPRECATED(9.0);
 
    public: const ignition::math::Pose3d &RawPose() const;
 
    public: void SetRawPose(const ignition::math::Pose3d &_pose);
 
    public: const std::string &PoseRelativeTo() const;
 
    public: void SetPoseRelativeTo(const std::string &_frame);
 
    public: const std::string &PoseFrame() const
        SDF_DEPRECATED(9.0);
 
    public: void SetPoseFrame(const std::string &_frame)
        SDF_DEPRECATED(9.0);
 
    public: std::string LensType() const;
 
    public: void SetLensType(const std::string &_type);
 
    public: bool LensScaleToHfov() const;
 
    public: void SetLensScaleToHfov(bool _scale);
 
    public: double LensC1() const;
 
    public: void SetLensC1(double _c1);
 
    public: double LensC2() const;
 
    public: void SetLensC2(double _c2);
 
    public: double LensC3() const;
 
    public: void SetLensC3(double _c3);
 
    public: double LensFocalLength() const;
 
    public: void SetLensFocalLength(double _f);
 
    public: const std::string &LensFunction() const;
 
    public: void SetLensFunction(const std::string &_fun);
 
    public: ignition::math::Angle LensCutoffAngle() const;
 
    public: void SetLensCutoffAngle(const ignition::math::Angle &_angle);
 
    public: int LensEnvironmentTextureSize() const;
 
    public: void SetLensEnvironmentTextureSize(int _size);
 
    public: double LensIntrinsicsFx() const;
 
    public: void SetLensIntrinsicsFx(double _fx);
 
    public: double LensIntrinsicsFy() const;
 
    public: void SetLensIntrinsicsFy(double _fy);
 
    public: double LensIntrinsicsCx() const;
 
    public: void SetLensIntrinsicsCx(double _cx);
 
    public: double LensIntrinsicsCy() const;
 
    public: void SetLensIntrinsicsCy(double _cy);
 
    public: double LensProjectionFx() const;
 
    public: void SetLensProjectionFx(double _fx_p);
 
    public: double LensProjectionFy() const;
 
    public: void SetLensProjectionFy(double _fy_p);
 
    public: double LensProjectionCx() const;
 
    public: void SetLensProjectionCx(double _cx_p);
 
    public: double LensProjectionCy() const;
 
    public: void SetLensProjectionCy(double _cy_p);
 
    public: double LensProjectionTx() const;
 
    public: void SetLensProjectionTx(double _tx);
 
    public: double LensProjectionTy() const;
 
    public: void SetLensProjectionTy(double _ty);
 
    public: double LensIntrinsicsSkew() const;
 
    public: void SetLensIntrinsicsSkew(double _s);
 
    public: static PixelFormatType ConvertPixelFormat(
                const std::string &_format);
 
    public: static std::string ConvertPixelFormat(PixelFormatType _type);
 
    public: uint32_t VisibilityMask() const;
 
    public: void SetVisibilityMask(uint32_t _mask);
 
    private: CameraPrivate *dataPtr = nullptr;
  };
  }
}
 
#endif