Refactor vector3_t #1645

cmake/f3dOptions.cmake

@@ -129,6 +129,11 @@ function(_parse_json_option _top_json)
        elseif(_option_type STREQUAL "ratio")
          set(_option_actual_type "f3d::ratio_t")
          set(_option_variant_type "double")
+       elseif(_option_type STREQUAL "vector")
+         set(_option_actual_type "f3d::vector3_t")
+         set(_option_variant_type "std::vector<double>")
+         set(_option_default_value_start "{")
+         set(_option_default_value_end "}")
        endif()
 
        # Add option to struct and methods

library/options.json

@@ -4,6 +4,10 @@
       "type": "string",
       "default_value": "+Y"
     },
+    "up_direction2": {
+      "type": "vector",
+      "default_value": "0, 1, 0"
+    },
     "animation": {
       "autoplay": {
         "type": "bool",

library/private/options_tools.h.in

@@ -5,7 +5,9 @@
 #include "types.h"
 
 #include <algorithm>
+#include <cctype>
 #include <sstream>
+#include <vector>
 
 namespace f3d
 {
@@ -181,6 +183,78 @@ ratio_t parse(const std::string& str)
   }
 }
 
+//----------------------------------------------------------------------------
+/**
+ * Parse provided string into a vector3_t.
+ */
+template<>
+vector3_t parse(const std::string& str)
+{
+  auto parseCommaSeparated = [](const std::string& s) -> vector3_t
+  {
+    std::vector vec = parse<std::vector<double>>(s);
+    if (vec.size() == 2)
+    {
+      return f3d::vector3_t::fromSphericalCoordinates(vec[0], vec[1]);
+    }
+    if (vec.size() == 3)
+    {
+      return { vec[0], vec[1], vec[2] };
+    }
+    else
+    {
+      throw options::parsing_exception("cannot parse " + s + " to a vector3_t");
+    }
+  };
+  auto parseYSyntax = [](const std::string& s) -> vector3_t
+  {
+    auto ss = trim(s);
+    if (ss.size() != 2)
+    {
+      throw options::parsing_exception("cannot parse " + s + " to a vector3_t");
+    }
+    int sign = +1;
+    if (ss[0] == '-')
+    {
+      sign = -1;
+    }
+    else if (ss[0] == '+')
+    {
+      sign = +1;
+    }
+    else
+    {
+      throw options::parsing_exception("cannot parse " + s + " to a vector3_t");
+    }
+    if (ss[1] == 'X')
+    {
+      return { double(sign) * 1, 0, 0 };
+    }
+    else if (ss[1] == 'Y')
+    {
+      return { 0, double(sign) * 1, 0 };
+    }
+    else if (ss[1] == 'Z')
+    {
+      return { 0, 0, double(sign) * 1 };
+    }
+    else
+    {
+      throw options::parsing_exception("cannot parse " + s + " to a vector3_t");
+    }
+  };
+  bool isNotCommaSeparated = std::find_if(str.begin(), str.end(),
+                               [](unsigned char c) { return std::isalpha(c); }) != str.end();
+  if (!isNotCommaSeparated)
+  {
+    return parseCommaSeparated(str);
+  }
+  else
+  {
+    return parseYSyntax(str);
+  }
+}
+
 //----------------------------------------------------------------------------
 /**
  * Return provided string stripped of leading and trailing spaces.
@@ -270,6 +344,17 @@ std::string format(const std::vector<double>& var)
   return stream.str();
 }
 
+//----------------------------------------------------------------------------
+/**
+ * Format provided var into a string from provided vector3_t
+ * rely on format(double&)
+ */
+template<>
+std::string format(const vector3_t& var)
+{
+  return format(static_cast<std::vector<double>>(var));
+}
+
 //----------------------------------------------------------------------------
 /**
  * Generated method, see `options::set`

library/public/types.h

@@ -4,6 +4,9 @@
 #include "export.h"
 
 #include <array>
+#include <cmath>
+#include <initializer_list>
+#include <stdexcept>
 #include <string>
 #include <vector>
 
@@ -21,18 +24,6 @@
   }
 };
 
-/**
- * Describe a 3D vector.
- */
-struct F3D_EXPORT vector3_t : std::array<double, 3>
-{
-  template<typename... Args>
-  vector3_t(Args&&... args)
-    : array({ double(std::forward<Args>(args))... })
-  {
-  }
-};
-
 /**
  * Describe an angle in degrees.
  */
@@ -82,6 +73,133 @@
    */
   F3D_EXPORT std::pair<bool, std::string> isValid() const;
 };
+
+/**
+ * Describe a 3D vector.
+ */
+struct F3D_EXPORT vector3_t
+{
+  vector3_t() = default;
+  vector3_t(double x, double y, double z)
+    : Value{ x, y, z }
+  {
+  }
+  vector3_t(const std::vector<double>& vec)
+  {
+    if (vec.size() != 3)
+    {
+      throw std::runtime_error("cannot create a vector3_t");
+    }
+    Value[0] = vec[0];
+    Value[1] = vec[1];
+    Value[2] = vec[2];
+  }
+  vector3_t(const std::array<double, 3>& arr)
+  {
+    Value[0] = arr[0];
+    Value[1] = arr[1];
+    Value[2] = arr[2];
+  }
+  vector3_t(double* ptr)
+  {
+    Value[0] = ptr[0];
+    Value[1] = ptr[1];
+    Value[2] = ptr[2];
+  }
+  vector3_t(std::initializer_list<double> l)
+  {
+    if (l.size() != 3)
+    {
+      throw std::runtime_error("cannot create a vector3_t");
+    }
+    std::copy(l.begin(), l.end(), std::begin(Value));
+  }
+
+  double* data()
+  {
+    return Value;
+  }
+  const double* data() const
+  {
+    return Value;
+  }
+
+  double& operator[](int idx)
+  {
+    return Value[idx];
+  }
+  double operator[](int idx) const
+  {
+    return Value[idx];
+  }
+  operator std::vector<double>() const
+  {
+    return { Value[0], Value[1], Value[2] };
+  }
+  operator std::array<double, 3>() const
+  {
+    return { Value[0], Value[1], Value[2] };
+  }
+  bool operator==(const vector3_t& vec) const
+  {
+    return Value[0] == vec.Value[0] && Value[1] == vec.Value[1] && Value[2] == vec.Value[2];
+  }
+  bool operator!=(const vector3_t& vec) const
+  {
+    return !(*this == vec);
+  }
+
+  double* begin()
+  {
+    return Value;
+  }
+  const double* begin() const
+  {
+    return Value;
+  }
+  const double* cbegin() const
+  {
+    return Value;
+  }
+  double* end()
+  {
+    return Value + 3;
+  }
+  const double* end() const
+  {
+    return Value + 3;
+  }
+  const double* cend() const
+  {
+    return Value + 3;
+  }
+
+  static vector3_t fromSphericalCoordinates(double theta, double phi)
+  {
+    auto sinPhi = std::sin(phi);
+    auto cosTheta = std::cos(theta);
+    return { sinPhi * cosTheta, sinPhi * cosTheta, std::cos(phi) };
+  }
+  static vector3_t x()
+  {
+    return { 1, 0, 0 };
+  }
+  static vector3_t y()
+  {
+    return { 0, 1, 0 };
+  }
+  static vector3_t z()
+  {
+    return { 0, 0, 1 };
+  }
+  static vector3_t zero()
+  {
+    return { 0, 0, 0 };
+  }
+
+private:
+  double Value[3];
+};
 }
 
 #endif

library/src/options.cxx

@@ -4,6 +4,7 @@
 #include "export.h"
 #include "init.h"
 #include "log.h"
+#include "types.h"
 #include "utils.h"
 
 #include "vtkF3DConfigure.h"
@@ -178,6 +179,7 @@ F3D_DECL_TYPE(bool);
 F3D_DECL_TYPE(int);
 F3D_DECL_TYPE(double);
 F3D_DECL_TYPE(f3d::ratio_t);
+F3D_DECL_TYPE(f3d::vector3_t);
 F3D_DECL_TYPE(std::string);
 
 //----------------------------------------------------------------------------

library/testing/PseudoUnitTest.h

@@ -1,6 +1,7 @@
 #ifndef PseudoUnitTest_h
 #define PseudoUnitTest_h
 
+#include "types.h"
 #include <functional>
 #include <iostream>
 #include <sstream>
@@ -129,6 +130,18 @@ class PseudoUnitTest
     return ss.str();
   }
 
+  std::string toString(const f3d::vector3_t& value)
+  {
+    std::stringstream ss;
+    size_t i = 0;
+    for (const double& item : value)
+    {
+      ss << (i++ ? ", " : "{ ") << this->toString(item);
+    }
+    ss << " }";
+    return ss.str();
+  }
+
 protected:
   template<typename T1, typename T2>
   std::string comparisonMessage(const T1& actual, const T2& expected, const std::string& comp)

library/testing/TestSDKOptionsIO.cxx

@@ -2,6 +2,7 @@
 #include <options.h>
 
 #include "PseudoUnitTest.h"
+#include "types.h"
 
 #include <iostream>
 
@@ -71,5 +72,16 @@ int TestSDKOptionsIO(int argc, char* argv[])
   test.parse<std::vector<std::string>>(
     "std::vector<std::string>", "  foo, bar ,   baz ", { "foo", "bar", "baz" });
 
+  test.parse<f3d::vector3_t>("vector3_t", "1, 2, 3", { 1, 2, 3 });
+  test.parse<f3d::vector3_t>("vector3_t", " 1,    2, 3  ", { 1, 2, 3 });
+  test.parse<f3d::vector3_t>("vector3_t", "+Y", { 0, 1, 0 });
+  test.parse<f3d::vector3_t>("vector3_t", " +Y ", { 0, 1, 0 });
+  test.parse<f3d::vector3_t>("vector3_t", "-Y", { 0, -1, 0 });
+  test.parse<f3d::vector3_t>("vector3_t", "+X", { 1, 0, 0 });
+  test.parse<f3d::vector3_t>("vector3_t", "-X", { -1, 0, 0 });
+  test.parse<f3d::vector3_t>("vector3_t", "+Z", { 0, 0, 1 });
+  test.parse<f3d::vector3_t>("vector3_t", "-Z", { 0, 0, -1 });
+  test.parse<f3d::vector3_t>("vector3_t", "1, 2", f3d::vector3_t::fromSphericalCoordinates(1, 2));
+
   return test.result();
 }

python/F3DPythonBindings.cxx

@@ -15,23 +15,23 @@
 
 namespace py = pybind11;
 
-template<typename T, size_t S>
-bool load_array(const py::handle& src, bool convert, std::array<T, S>& value)
+template<typename T>
+bool load_array(const py::handle& src, bool convert, T& value)
 {
   if (!py::isinstance<py::sequence>(src))
   {
     return false;
   }
   const py::sequence l = py::reinterpret_borrow<py::sequence>(src);
-  if (l.size() != S)
+  if (l.size() != 3)
   {
     return false;
   }
 
   size_t i = 0;
   for (auto it : l)
   {
-    value[i++] = py::cast<T>(it);
+    value[i++] = py::cast<double>(it);
   }
   return true;
 }
@@ -367,8 +367,7 @@ PYBIND11_MODULE(pyf3d, module)
     .def_static("set_verbose_level", &f3d::log::setVerboseLevel, py::arg("level"),
       py::arg("force_std_err") = false)
     .def_static("set_use_coloring", &f3d::log::setUseColoring)
-    .def_static("print",
-      [](f3d::log::VerboseLevel& level, const std::string& message)
+    .def_static("print", [](f3d::log::VerboseLevel& level, const std::string& message)
       { f3d::log::print(level, message); });
 
   py::enum_<f3d::log::VerboseLevel>(log, "VerboseLevel")