Airflow/Wind Sensor

include/sdf/AirFlow.hh

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2023 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_AirFlow_HH_
+#define SDF_AirFlow_HH_
+
+#include <gz/utils/ImplPtr.hh>
+
+#include <sdf/Error.hh>
+#include <sdf/Element.hh>
+#include <sdf/Noise.hh>
+#include <sdf/sdf_config.h>
+
+namespace sdf
+{
+  // Inline bracke to help doxygen filtering.
+  inline namespace SDF_VERSION_NAMESPACE {
+  /// \brief AirFlow contains information about a general
+  /// purpose air flow sensor.
+  /// This sensor can be attached to a link.
+  class SDFORMAT_VISIBLE AirFlow
+  {
+    /// \brief Default constructor
+    public: AirFlow();
+
+    /// \brief Load the air flow based on an element pointer.
+    /// This is *not* the usual entry point. Typical usage of the SDF DOM is
+    /// through the Root object.
+    /// \param[in] _sdf The SDF Element pointer
+    /// \return Errors, which is a vector of Error objects. Each Error includes
+    /// an error code and message. An empty vector indicates no error.
+    public: Errors Load(ElementPtr _sdf);
+
+    /// \brief Get a pointer to the SDF element that was used during
+    /// load.
+    /// \return SDF element pointer. The value will be nullptr if Load has
+    /// not been called.
+    public: sdf::ElementPtr Element() const;
+
+    /// \brief Get the noise values.
+    /// \return Noise values for differential pressure data.
+    public: const Noise &SpeedNoise() const;
+
+    /// \brief Set the noise values related to the differential pressure data.
+    /// \param[in] _noise Noise values for the pressure data.
+    public: void SetSpeedNoise(const Noise &_noise);\
+
+    /// \brief Get the noise values.
+    /// \return Noise values for differential pressure data.
+    public: const Noise &DirectionNoise() const;
+
+    /// \brief Set the noise values related to the differential pressure data.
+    /// \param[in] _noise Noise values for the pressure data.
+    public: void SetDirectionNoise(const Noise &_noise);
+
+    /// \brief Return true if both AirFlow objects contain the
+    /// same values.
+    /// \param[_in] _air AirFlow value to compare.
+    /// \returen True if 'this' == _air.
+    public: bool operator==(const AirFlow &_air) const;
+
+    /// \brief Return true this AirFlow object does not contain
+    /// the same values as the passed in parameter.
+    /// \param[_in] _air AirFlow value to compare.
+    /// \returen True if 'this' != _air.
+    public: bool operator!=(const AirFlow &_air) const;
+
+    /// \brief Create and return an SDF element filled with data from this
+    /// air pressure sensor.
+    /// Note that parameter passing functionality is not captured with this
+    /// function.
+    /// \return SDF element pointer with updated sensor values.
+    public: sdf::ElementPtr ToElement() const;
+
+    /// \brief Private data pointer.
+    GZ_UTILS_IMPL_PTR(dataPtr)
+  };
+  }
+}
+#endif

include/sdf/Sensor.hh

@@ -35,6 +35,7 @@ namespace sdf
   //
 
   // Forward declarations.
+  class AirFlow;
   class AirPressure;
   class AirSpeed;
   class Altimeter;
@@ -134,6 +135,9 @@ namespace sdf
 
     /// \brief An air speed sensor.
     AIR_SPEED = 26,
+
+    /// \brief An airflow sensor.
+    AIR_FLOW = 27,
   };
 
   /// \brief Information about an SDF sensor.
@@ -341,6 +345,24 @@ namespace sdf
     /// \param[in] _air The air pressure sensor.
     public: void SetAirSpeedSensor(const AirSpeed &_air);
 
+    /// \brief Get the air flow sensor, or nullptr if this sensor type
+    /// is not an AirFlow sensor.
+    /// \return Pointer to the AirFlow sensor, or nullptr if this
+    /// Sensor is not a AirFlow sensor.
+    /// \sa SensorType Type() const
+    public: const AirFlow *AirFlowSensor() const;
+
+    /// \brief Get a mutable air flow sensor, or nullptr if this sensor type
+    /// is not an AirFlow sensor.
+    /// \return Pointer to the AirFlow sensor, or nullptr if this
+    /// Sensor is not a AirFlow sensor.
+    /// \sa SensorType Type() const
+    public: AirFlow *AirFlowSensor();
+
+    /// \brief Set the air pressure sensor.
+    /// \param[in] _air The air pressure sensor.
+    public: void SetAirFlowSensor(const AirFlow &_air);
+
     /// \brief Set the camera sensor.
     /// \param[in] _cam The camera sensor.
     public: void SetCameraSensor(const Camera &_cam);

python/CMakeLists.txt

@@ -44,6 +44,7 @@ endfunction()
 set(BINDINGS_MODULE_NAME "pysdformat${PROJECT_VERSION_MAJOR}")
 pybind11_add_module(${BINDINGS_MODULE_NAME} MODULE
   src/sdf/_gz_sdformat_pybind11.cc
+  src/sdf/pyAirFlow.cc
   src/sdf/pyAirPressure.cc
   src/sdf/pyAirSpeed.cc
   src/sdf/pyAltimeter.cc

python/src/sdf/_gz_sdformat_pybind11.cc

@@ -18,6 +18,7 @@
 #include <pybind11/stl.h>
 #include <gz/math/config.hh>
 
+#include "pyAirFlow.hh"
 #include "pyAirPressure.hh"
 #include "pyAirSpeed.hh"
 #include "pyAltimeter.hh"
@@ -74,6 +75,7 @@ PYBIND11_MODULE(BINDINGS_MODULE_NAME, m) {
       std::string("gz.math") + std::to_string(GZ_MATH_MAJOR_VERSION);
   pybind11::module::import(gzMathModule.c_str());
 
+  sdf::python::defineAirFlow(m);
   sdf::python::defineAirPressure(m);
   sdf::python::defineAirSpeed(m);
   sdf::python::defineAltimeter(m);

python/src/sdf/pyAirFlow.cc

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#include "pyAirFlow.hh"
+
+#include <pybind11/operators.h>
+#include <pybind11/pybind11.h>
+
+#include "sdf/AirFlow.hh"
+
+
+using namespace pybind11::literals;
+
+namespace sdf
+{
+// Inline bracket to help doxygen filtering.
+inline namespace SDF_VERSION_NAMESPACE {
+namespace python
+{
+/////////////////////////////////////////////////
+void defineAirFlow(pybind11::object module)
+{
+  pybind11::class_<sdf::AirFlow> geometryModule(module, "AirFlow");
+  geometryModule
+    .def(pybind11::init<>())
+    .def(pybind11::init<sdf::AirFlow>())
+    .def(pybind11::self == pybind11::self)
+    .def(pybind11::self != pybind11::self)
+    .def("speed_noise", &sdf::AirFlow::SpeedNoise,
+         "Get the speed noise values.")
+    .def("set_speed_noise",
+         &sdf::AirFlow::SetSpeedNoise,
+         "Set the noise values related to the speed data.")
+    .def("dir_noise", &sdf::AirFlow::DirectionNoise,
+         "Get the direction noise values.")
+    .def("set_direction_noise",
+         &sdf::AirFlow::SetDirectionNoise,
+         "Set the noise values related to the direction data.")
+    .def("__copy__", [](const sdf::AirFlow &self) {
+      return sdf::AirFlow(self);
+    })
+    .def("__deepcopy__", [](const sdf::AirFlow &self, pybind11::dict) {
+      return sdf::AirFlow(self);
+    }, "memo"_a);
+}
+}  // namespace python
+}  // namespace SDF_VERSION_NAMESPACE
+}  // namespace sdf

python/src/sdf/pyAirFlow.hh

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2023 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 SDFORMAT_PYTHON_AIRFLOW_HH_
+#define SDFORMAT_PYTHON_AIRFLOW_HH_
+
+#include <pybind11/pybind11.h>
+
+#include "sdf/AirFlow.hh"
+
+#include "sdf/config.hh"
+
+namespace sdf
+{
+// Inline bracket to help doxygen filtering.
+inline namespace SDF_VERSION_NAMESPACE {
+namespace python
+{
+/// Define a pybind11 wrapper for an sdf::AirFlow
+/**
+ * \param[in] module a pybind11 module to add the definition to
+ */
+void defineAirFlow(pybind11::object module);
+}  // namespace python
+}  // namespace SDF_VERSION_NAMESPACE
+}  // namespace sdf
+
+#endif  // SDFORMAT_PYTHON_AirFlow_HH_

python/test/pyAirFlow_TEST.py

@@ -0,0 +1,67 @@
+# Copyright (C) 2023 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.
+
+from gz_test_deps.sdformat import AirFlow, Noise
+import gz_test_deps.sdformat as sdf
+import unittest
+
+class AirFlowTEST(unittest.TestCase):
+
+
+    def test_default_construction(self):
+        airflow = AirFlow()
+        defaultNoise = Noise()
+        self.assertEqual(defaultNoise, airflow.direction_noise())
+        self.assertEqual(defaultNoise, airflow.speed_noise())
+
+    def test_set(self):
+        air = AirFlow()
+        defaultNoise = Noise()
+        dir_noise = Noise()
+        speed_noise = Noise()
+        self.assertEqual(defaultNoise, air.speed_noise())
+        self.assertEqual(defaultNoise, air.direction_noise())
+
+        dir_noise.set_type(sdf.NoiseType.GAUSSIAN)
+        dir_noise.set_mean(1.2)
+        dir_noise.set_std_dev(2.3)
+        dir_noise.set_bias_mean(4.5)
+        dir_noise.set_bias_std_dev(6.7)
+        dir_noise.set_precision(8.9)
+
+        speed_noise.set_type(sdf.NoiseType.GAUSSIAN)
+        speed_noise.set_mean(1.2)
+        speed_noise.set_std_dev(2.3)
+        speed_noise.set_bias_mean(4.5)
+        speed_noise.set_bias_std_dev(6.7)
+        speed_noise.set_precision(8.9)
+
+        air.set_direction_noise(dir_noise)
+        self.assertEqual(dir_noise, air.direction_noise())
+        self.assertEqual(speed_noise, air.speed_noise())
+
+        # Copy Constructor
+        air2 = AirFlow(air)
+        self.assertEqual(air, air2)
+
+        # Copy operator
+        air3 = air
+        self.assertEqual(air, air3)
+
+        air4 = AirFlow()
+        self.assertNotEqual(air3, air4);
+
+
+if __name__ == '__main__':
+    unittest.main()

sdf/1.10/CMakeLists.txt

@@ -1,5 +1,6 @@
 set (sdfs
   actor.sdf
+  air_flow.sdf
   air_pressure.sdf
   air_speed.sdf
   altimeter.sdf

sdf/1.10/air_flow.sdf

@@ -0,0 +1,18 @@
+<element name="air_flow" required="0">
+  <description>These elements are specific to an air flow sensor. This sensor emulates an ultrasonic airflow sensor which determines the airspeed and direction based on the doppler effect.</description>
+
+  <element name="speed" required="0">
+    <description>
+      Noise parameters for the speed data.
+    </description>
+    <include filename="noise.sdf" required="0"/>
+  </element>
+
+  <element name="direction" required="0">
+    <description>
+      Noise parameters for the direction data.
+    </description>
+    <include filename="noise.sdf" required="0"/>
+  </element>
+
+</element>

sdf/1.10/sensor.sdf

@@ -8,6 +8,7 @@
 
   <attribute name="type" type="string" default="__default__" required="1">
     <description>The type name of the sensor. By default, SDFormat supports types
+                  air_flow,
                   air_pressure,
                   air_speed,
                   altimeter,
@@ -61,6 +62,7 @@
 
   <include filename="pose.sdf" required="0"/>
   <include filename="plugin.sdf" required="*"/>
+  <include filename="air_flow.sdf" required="0"/>
   <include filename="air_pressure.sdf" required="0"/>
   <include filename="air_speed.sdf" required="0"/>
   <include filename="altimeter.sdf" required="0"/>