Merge branch 'hotfix/0.3.1'

include/flom/effector_type.hpp

@@ -22,13 +22,15 @@
 
 #include "flom/effector.hpp"
 
+#include <boost/operators.hpp>
+
 #include <optional>
 
 namespace flom {
 
 enum class CoordinateSystem { World, Local };
 
-struct EffectorType {
+struct EffectorType : boost::operators<EffectorType> {
 private:
   std::optional<CoordinateSystem> location_;
   std::optional<CoordinateSystem> rotation_;
@@ -50,6 +52,8 @@ struct EffectorType {
   bool is_compatible(const Effector &) const;
 };
 
+bool operator==(const EffectorType &, const EffectorType &);
+
 } // namespace flom
 
 #endif

include/flom/effector_weight.hpp

@@ -20,9 +20,11 @@
 #ifndef FLOM_EFFECTOR_WEIGHT_HPP
 #define FLOM_EFFECTOR_WEIGHT_HPP
 
+#include <boost/operators.hpp>
+
 namespace flom {
 
-class EffectorWeight {
+class EffectorWeight : boost::operators<EffectorWeight> {
 private:
   double location_;
   double rotation_;
@@ -41,6 +43,8 @@ class EffectorWeight {
   void set_rotation(double);
 };
 
+bool operator==(const EffectorWeight &, const EffectorWeight &);
+
 } // namespace flom
 
 #endif

include/flom/motion.hpp

@@ -94,6 +94,7 @@ class Motion {
 };
 
 bool operator==(const Motion &, const Motion &);
+bool operator!=(const Motion &, const Motion &);
 
 } // namespace flom
 

lib/effector_type.cpp

@@ -41,4 +41,8 @@ bool EffectorType::is_compatible(const Effector &e) const {
   return loc_v == loc_t && rot_v == rot_t;
 }
 
+bool operator==(const EffectorType &v1, const EffectorType &v2) {
+  return v1.location() == v2.location() && v1.rotation() == v2.rotation();
+}
+
 } // namespace flom

lib/effector_weight.cpp

@@ -27,4 +27,8 @@ double EffectorWeight::validate_weight(double weight) {
   return weight;
 }
 
+bool operator==(const EffectorWeight &v1, const EffectorWeight &v2) {
+  return v1.location() == v2.location() && v1.rotation() == v2.rotation();
+}
+
 } // namespace flom

lib/motion.cpp

@@ -246,7 +246,9 @@ KeyRange<std::string> Motion::effector_names() const {
 bool operator==(const Motion &m1, const Motion &m2) {
   return m1.impl->model_id == m2.impl->model_id &&
          m1.impl->loop == m2.impl->loop &&
-         m1.impl->raw_frames == m2.impl->raw_frames;
+         m1.impl->raw_frames == m2.impl->raw_frames &&
+         m1.impl->effector_types == m2.impl->effector_types &&
+         m1.impl->effector_weights == m2.impl->effector_weights;
 }
 
 bool operator!=(const Motion &m1, const Motion &m2) { return !(m1 == m2); }

test/generators.hpp

@@ -101,6 +101,13 @@ template <> struct Arbitrary<flom::CoordinateSystem> {
   }
 };
 
+template <> struct Arbitrary<flom::EffectorWeight> {
+  static auto arbitrary() -> decltype(auto) {
+    auto const g = gen::map(gen::inRange(0, 100), [](int i) { return static_cast<double>(i) / 100; });
+    return gen::construct<flom::EffectorWeight>(g, g);
+  }
+};
+
 template <> struct Arbitrary<flom::EffectorType> {
   static auto arbitrary() -> decltype(auto) {
     return gen::apply(
@@ -176,22 +183,30 @@ template <> struct Arbitrary<flom::Motion> {
   static auto arbitrary() -> decltype(auto) {
     return gen::apply(
         [](std::string const &model_id, flom::LoopType loop, double fps, auto const& t) {
-          auto const& [joint_names, effector_types, frames] = t;
+          auto const& [joint_names, effector_types, frames, weights] = t;
           flom::Motion m(joint_names, effector_types, model_id);
           m.set_loop(loop);
-          unsigned i = 0;
-          for (auto const& [p, e] : frames) {
-            std::unordered_map<std::string, double> positions;
-            std::unordered_map<std::string, flom::Effector> effectors;
-            for(auto const& pair : boost::combine(joint_names, p)) {
-              positions.emplace(boost::get<0>(pair), boost::get<1>(pair));
+          {
+            unsigned i = 0;
+            for (auto const& [name, type] : effector_types) {
+              m.set_effector_weight(name, weights[i++]);
             }
-            for(auto const& pair : boost::combine(effector_types, e)) {
-              auto const& [name, type] = boost::get<0>(pair);
-              auto const& eff = boost::get<1>(pair);
-              effectors.emplace(name, convert_effector(type, eff));
+          }
+          {
+            unsigned i = 0;
+            for (auto const& [p, e] : frames) {
+              std::unordered_map<std::string, double> positions;
+              std::unordered_map<std::string, flom::Effector> effectors;
+              for(auto const& pair : boost::combine(joint_names, p)) {
+                positions.emplace(boost::get<0>(pair), boost::get<1>(pair));
+              }
+              for(auto const& pair : boost::combine(effector_types, e)) {
+                auto const& [name, type] = boost::get<0>(pair);
+                auto const& eff = boost::get<1>(pair);
+                effectors.emplace(name, convert_effector(type, eff));
+              }
+              m.insert_keyframe(fps * i++, flom::Frame{positions, effectors});
             }
-            m.insert_keyframe(fps * i++, flom::Frame{positions, effectors});
           }
           return m;
         },
@@ -218,9 +233,10 @@ template <> struct Arbitrary<flom::Motion> {
 
             auto effector_gen = gen::construct<flom::Effector>(gen::arbitrary<flom::Location>(), gen::arbitrary<flom::Rotation>());
             auto effectors_gen = gen::container<std::vector<flom::Effector>>(num_effectors, effector_gen);
+            auto weights_gen = gen::container<std::vector<flom::EffectorWeight>>(num_effectors, gen::arbitrary<flom::EffectorWeight>());
 
             auto frames_gen = gen::nonEmpty(gen::container<std::vector<std::pair<std::vector<double>, std::vector<flom::Effector>>>>(gen::pair(positions_gen, effectors_gen)));
-            return gen::tuple(joint_names_gen, effector_names_gen, frames_gen);
+            return gen::tuple(joint_names_gen, effector_names_gen, frames_gen, weights_gen);
         }));
   }
 };