ENH: More type deduction

Project, Reflect, Stereo, Ortho

vis/include/mirror.hpp

@@ -28,44 +28,41 @@ Eigen::Matrix<float, N, N> mirror(const tc::Group<> &group) {
     return res;
 }
 
-template<unsigned N>
+struct Stereo {
-vec<N> stereo(const vec<N + 1> &v) {
+    template<class U>
-    vec<N> r;
+    auto operator()(U &&mat) const {
-    for (int i = 0; i < N; ++i) {
+        const auto Rows = std::remove_reference<U>::type::RowsAtCompileTime;
-        r[i] = v[i] / (1 - v[N]);
+        return std::forward<U>(mat).template topRows<Rows - 1>().rowwise() / (1 - mat.template bottomRows<1>());
     }
-    return r;
+};
-}
 
-template<unsigned N>
+struct Ortho {
-vec<N> ortho(const vec<N + 1> &v) {
+    template<class U>
-    vec<N> r;
+    auto operator()(U &&mat) const {
-    for (int i = 0; i < N; ++i) {
+        const auto Rows = std::remove_reference<U>::type::RowsAtCompileTime;
-        r[i] = v[i];
+        return std::forward<U>(mat).template topRows<Rows - 1>();
     }
-    return r;
+};
-}
 
-template<class V>
+struct Project {
-V project(const V &vec, const V &target) {
+    template<class U, class V>
-    return vec.dot(target) / target.dot(target) * target;
+    auto operator()(U &&point, V &&axis) const {
-}
+        return point.dot(axis) / axis.dot(axis) * std::forward<V>(axis);
+    }
+};
 
-template<class V>
+struct Reflect {
-V reflect(const V &a, const V &axis) {
+    template<class U, class V>
-    return a - 2.f * project(a, axis);
+    auto operator()(U &&point, V &&axis) const {
-}
+        return std::forward<U>(point) - 2 * Project()(point, axis);
-
+    }
-template<class Point, class Axis>
+};
-auto project_(const Point &point, const Axis &axis) {
-    return axis.dot(point) / axis.dot(axis) * axis;
-}
 
 template<class Mat>
 Mat gram_schmidt(Mat mat) {
     for (int i = 0; i < mat.cols(); ++i) {
         for (int j = i + 1; j < mat.cols(); ++j) {
-            mat.col(j) -= project_(mat.col(j), mat.col(i));
+            mat.col(j) -= Project()(mat.col(j), mat.col(i));
         }
     }
     return mat;

vis/src/main.cpp

@@ -43,7 +43,7 @@ struct State {
     int dimension;
 };
 
-Matrices build(GLFWwindow *window, State &state) {
+Matrices build(GLFWwindow* window, State &state) {
     int width, height;
     glfwGetFramebufferSize(window, &width, &height);
 
@@ -90,13 +90,18 @@ std::vector<vec4> points(const tc::Group<> &group, const C &coords) {
 
     tc::Path<vec5> path(cosets, mirrors.colwise());
 
-    std::vector<vec5> higher(path.order());
+    Eigen::Array<float, 5, Eigen::Dynamic> higher(5, path.order());
-    path.walk(start, reflect<vec5>, higher.begin());
+    path.walk(start, Reflect(), higher.matrix().colwise().begin());
+//    std::vector<vec5> higher(path.order());
+//    path.walk(start, Reflect(), higher.begin());
 
-    std::vector<vec4> lower(higher.size());
+//    Eigen::Array4Xf lower = higher.topRows<4>().rowwise() / (1 - higher.bottomRows<1>());
-    std::transform(higher.begin(), higher.end(), lower.begin(), stereo<4>);
+    Eigen::Array4Xf lower = Stereo()(higher);
 
-    return lower;
+    std::vector<vec4> vec(lower.cols());
+    std::copy(lower.colwise().begin(), lower.colwise().end(), vec.begin());
+
+    return vec;
 }
 
 template<unsigned N>
@@ -120,7 +125,7 @@ struct Renderer {
 
     void render() const {
         bound([&]() {
-            for (const auto &prop : props) {
+            for (const auto &prop: props) {
                 _draw(prop);
             }
         });
@@ -219,7 +224,7 @@ struct DirectRenderer : public Renderer<N> {
 
 struct WireframeProp : public Prop<2> {
 
-    WireframeProp(vec3 color) : Prop<2>(){
+    WireframeProp(vec3 color) : Prop<2>() {
         this->color = color;
     }
 
@@ -229,12 +234,12 @@ struct WireframeProp : public Prop<2> {
 
     template<class T, class C>
     static WireframeProp build(const tc::Group<> &g,
-        const C &coords,
+                               const C &coords,
-        bool curve,
+                               bool curve,
-        bool ortho,
+                               bool ortho,
-        vec3 color,
+                               vec3 color,
-        T all_sg_gens,
+                               T all_sg_gens,
-        const std::vector<std::vector<size_t>> &exclude
+                               const std::vector<std::vector<size_t>> &exclude
     ) {
         WireframeProp res(color);
 
@@ -245,7 +250,7 @@ struct WireframeProp : public Prop<2> {
     }
 };
 
-void run(const std::string &config_file, GLFWwindow *window) {
+void run(const std::string &config_file, GLFWwindow* window) {
     glEnable(GL_DEPTH_TEST);
 
     glEnable(GL_BLEND);
@@ -279,13 +284,13 @@ void run(const std::string &config_file, GLFWwindow *window) {
 
     state.dimension = scene["dimension"].as<size_t>();
 
-    for (const auto &group_info : scene["groups"]) {
+    for (const auto &group_info: scene["groups"]) {
         auto symbol = group_info["symbol"].as<std::vector<unsigned int>>();
         auto group = tc::schlafli(symbol);
         auto gens = generators(group);
 
         if (group_info["slices"].IsDefined()) {
-            for (const auto &slice_info : group_info["slices"]) {
+            for (const auto &slice_info: group_info["slices"]) {
                 auto root_arr = slice_info["root"].as<std::array<float, 5>>();
                 auto color_arr = slice_info["color"].as<std::array<float, 3>>();
 
@@ -315,7 +320,7 @@ void run(const std::string &config_file, GLFWwindow *window) {
         }
 
         if (group_info["wires"].IsDefined()) {
-            for (const auto &wire_info : group_info["wires"]) {
+            for (const auto &wire_info: group_info["wires"]) {
                 auto root_arr = wire_info["root"].as<std::array<float, 5>>();
                 auto color_arr = wire_info["color"].as<std::array<float, 3>>();
 
@@ -411,7 +416,7 @@ void run(const std::string &config_file, GLFWwindow *window) {
     }
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
     if (!glfwInit()) {
         std::cerr << "Failed to initialize GLFW" << std::endl;
         return EXIT_FAILURE;