CoordinateVector3.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2024 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 GZ_MATH_COORDINATE_VECTOR3_HH_
#define GZ_MATH_COORDINATE_VECTOR3_HH_
 
#include <optional>
#include <ostream>
 
#include <gz/math/Angle.hh>
#include <gz/math/Vector3.hh>
#include <gz/math/Helpers.hh>
#include <gz/math/config.hh>
#include <gz/utils/ImplPtr.hh>
 
namespace gz::math
{
  // Inline bracket to help doxygen filtering.
  inline namespace GZ_MATH_VERSION_NAMESPACE {
 
  class GZ_MATH_VISIBLE CoordinateVector3
  {
    public: CoordinateVector3();
 
    public: ~CoordinateVector3();
 
    public: CoordinateVector3(const CoordinateVector3 &_other);
 
    public: CoordinateVector3(CoordinateVector3 &&_other) noexcept;
 
    public: static CoordinateVector3 Metric(double _x, double _y, double _z);
 
    public: static CoordinateVector3 Metric(const math::Vector3d &_v);
 
    public: static CoordinateVector3 Spherical(
        const math::Angle &_lat, const math::Angle &_lon, double _z);
 
    public: bool IsMetric() const;
 
    public: bool IsSpherical() const;
 
    public: void SetMetric(double _x, double _y, double _z);
 
    public: void SetMetric(const math::Vector3d &_v);
 
    public: void SetSpherical(
      const math::Angle &_lat, const math::Angle &_lon, double _z);
 
    public: std::optional<math::Vector3d> AsMetricVector() const;
 
    public: CoordinateVector3 &operator=(const CoordinateVector3 &_other);
 
    public: CoordinateVector3 &operator=(CoordinateVector3 &&_other) noexcept;
 
    public: CoordinateVector3 operator+(const CoordinateVector3 &_v) const;
 
    public: const CoordinateVector3 &operator+=(const CoordinateVector3 &_v);
 
    public: CoordinateVector3 operator-() const;
 
    public: CoordinateVector3 operator-(const CoordinateVector3 &_pt) const;
 
    public: const CoordinateVector3 &operator-=(const CoordinateVector3 &_pt);
 
    public: bool Equal(const CoordinateVector3 &_v,
                       const double &_tol,
                       const math::Angle &_ang_tol) const;
 
    public: bool operator==(const CoordinateVector3 &_v) const;
 
    public: bool operator!=(const CoordinateVector3 &_v) const;
 
    public: bool IsFinite() const;
 
    public: bool Equal(const CoordinateVector3 &_v) const;
 
    public: std::optional<double> X() const;
 
    public: std::optional<math::Angle> Lat() const;
 
    public: std::optional<double> Y() const;
 
    public: std::optional<math::Angle> Lon() const;
 
    public: std::optional<double> Z() const;
 
    public: bool X(const double &_v);
 
    public: bool Lat(const Angle &_v);
 
    public: bool Y(const double &_v);
 
    public: bool Lon(const Angle &_v);
 
    public: bool Z(const double &_v);
 
    public: friend std::ostream &operator<<(
        std::ostream &_out, const gz::math::CoordinateVector3 &_pt)
    {
      if (_pt.IsMetric())
      {
        appendToStream(_out, *_pt.X());
      }
      else
      {
        appendToStream(_out, _pt.Lat()->Degree());
        _out << "°";
      }
      _out << " ";
 
      if (_pt.IsMetric())
      {
        appendToStream(_out, *_pt.Y());
      }
      else
      {
        appendToStream(_out, _pt.Lon()->Degree());
        _out << "°";
      }
      _out << " ";
 
      appendToStream(_out, *_pt.Z());
 
      return _out;
    }
 
    GZ_UTILS_UNIQUE_IMPL_PTR(dataPtr)
  };
 
  }  // namespace GZ_MATH_VERSION_NAMESPACE
}  // namespace gz::math
#endif  // GZ_MATH_COORDINATE_VECTOR3_HH_