break apart logic for finding identity position; add incenter coordinates generator; also tori!?

CMakeLists.txt

@@ -18,4 +18,6 @@ add_subdirectory(cosets)
 if (NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release)
 endif ()
+
+set(CMAKE_CXX_FLAGS_DEBUG "-O2")
 set(CMAKE_CXX_FLAGS_RELEASE "-O3")

cosets/src/main.cpp

@@ -29,6 +29,13 @@ class CosetsWindow : public Window {
 
 public:
    void init() override {
+      std::cout
+         << "Graphics Information:" << std::endl
+         << "Vendor: " << glGetString(GL_VENDOR) << std::endl
+         << "Renderer: " << glGetString(GL_RENDERER) << std::endl
+         << "Version: " << glGetString(GL_VERSION) << std::endl
+         << "Shading version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
+
       auto vs = build_shader_file(
          GL_VERTEX_SHADER,
          "vertex",
@@ -45,30 +52,47 @@ public:
       u_view = glGetUniformLocation(program, "view");
       u_color = glGetUniformLocation(program, "color");
 
-      const Mults &mults = schlafli({4, 3});
+      const Mults &mults = schlafli({16, 2, 16});
-      std::cout << mults.num_gens << std::endl;
+//      const glm::vec4 ident = center(mults);
+      const glm::vec4 ident = identity(mults, {1, 1, 1, 1});
+      std::cout << "Dimension: " << mults.num_gens << std::endl;
 
       std::cout << "Generation times: " << std::endl;
 
       auto gen_start = std::chrono::high_resolution_clock::now();
 
-      vert_data = vertices(mults, {1, .1, .1, .1});
+      vert_data = vertices(mults, ident);
       auto gen_vert = std::chrono::high_resolution_clock::now();
       std::chrono::duration<double> vert_time = gen_vert - gen_start;
-      std::cout << "Vertices: " << vert_time.count() << std::endl;
+      std::cout
+         << "Vertices: "
+         << std::setw(5) << std::setprecision(3) << vert_time.count()
+         << " (" << vert_data.size() << ")"
+         << std::endl;
 
       edge_data = edges(mults);
       auto gen_edge = std::chrono::high_resolution_clock::now();
       std::chrono::duration<double> edge_time = gen_edge - gen_vert;
-      std::cout << "   Edges: " << edge_time.count() << std::endl;
+      std::cout
+         << "   Edges: "
+         << std::setw(5) << std::setprecision(3) << edge_time.count()
+         << " (" << edge_data.size() / 2 << ")"
+         << std::endl;
 
       face_data = faces(mults);
       auto gen_face = std::chrono::high_resolution_clock::now();
       std::chrono::duration<double> face_time = gen_face - gen_edge;
-      std::cout << "   Faces: " << face_time.count() << std::endl;
+      std::cout
+         << "   Faces: "
+         << std::setw(5) << std::setprecision(3) << face_time.count()
+         << " (" << face_data.size() / 3 << ")"
+         << std::endl;
 
       std::chrono::duration<double> full_time = gen_face - gen_start;
-      std::cout << "   Total: " << full_time.count() << std::endl;
+      std::cout
+         << "   Total: "
+         << std::setw(5) << std::setprecision(3) << full_time.count()
+         << std::endl;
 
       glGenBuffers(1, &verts_buf);
       glBindBuffer(GL_ARRAY_BUFFER, verts_buf);
@@ -106,11 +130,6 @@ public:
       glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, faces_buf);
 
       glBindVertexArray(0);
-
-      std::cout << "vendor: " << glGetString(GL_VENDOR) << std::endl
-         << "renderer: " << glGetString(GL_RENDERER) << std::endl
-         << "version: " << glGetString(GL_VERSION) << std::endl
-         << "shading version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
    }
 
    void render() override {
@@ -156,7 +175,7 @@ public:
       glBindVertexArray(face_vao);
       glCullFace(GL_FRONT);
       glUniform4f(u_color, 1, 1, 1, 1);
-//      glDrawElements(GL_TRIANGLES, face_data.size(), GL_UNSIGNED_INT, 0);
+      glDrawElements(GL_TRIANGLES, face_data.size(), GL_UNSIGNED_INT, 0);
 
       swapbuffers();
    }

cosets/src/util/mesh.hpp

@@ -19,13 +19,31 @@ glm::vec4 identity(const std::vector<glm::vec4> &normals, const std::vector<floa
    return glm::normalize(identity);
 }
 
+glm::vec4 identity(const Mults &mults, const std::vector<float> &coords) {
+   const std::vector<glm::vec4> normals = mirror(mults);
+   return identity(normals, coords);
+}
+
+glm::vec4 center(const Mults &mults) {
+   const std::vector<glm::vec4> normals = mirror(mults);
+   const std::vector<glm::vec4> corners = plane_intersections(normals);
+   std::vector<float> coords{};
+   for (int i = 0; i < corners.size(); ++i) {
+      const auto u = (i + 2) % corners.size();
+      const auto v = (i + 1) % corners.size();
+      const auto &d = corners[u] - corners[v];
+      coords.push_back(glm::length(d));
+   }
+   const glm::vec4 identity = barycentric(corners, coords);
+   return glm::normalize(identity);
+}
+
 std::vector<glm::vec4>
-vertices(const Mults &mults, std::vector<float> coords) {
+vertices(const Mults &mults, const glm::vec4 ident) {
    int N = mults.num_gens;
    Table *table = solve(all_gens(N), {}, mults);
 
    const std::vector<glm::vec4> normals = mirror(mults);
-   glm::vec4 ident = identity(normals, coords);
 
    std::vector<glm::vec4> verts{};
    for (const auto &word : table->words()) {
@@ -43,14 +61,16 @@ std::vector<int> edges(const Mults &mults) {
    std::vector<int> res{};
 
    int N = mults.num_gens;
-   Table *t_vert = solve(all_gens(N), {}, mults);
+   const std::vector<int> &gens = all_gens(N);
+
+   Table *t_vert = solve(gens, {}, mults);
 
    for (const auto &subgens : combinations(N, 1)) {
       Table *t_edge = solve(subgens, {}, mults);
 
       std::vector<int> edge = t_vert->apply_each(t_edge->words());
 
-      Table *c_edge = solve(all_gens(N), subgens, mults);
+      Table *c_edge = solve(gens, subgens, mults);
 
       for (const auto &coset : c_edge->words()) {
          for (const auto &e : edge) {
@@ -65,12 +85,22 @@ std::vector<int> edges(const Mults &mults) {
 std::vector<int> faces(const Mults &mults) {
    std::vector<int> res{};
    int N = mults.num_gens;
+   const std::vector<int> &gens = all_gens(N);
 
-   Table *t_vert = solve(all_gens(N), {}, mults);
+   Table *t_vert = solve(gens, {}, mults);
 
    // for each *kind* of face
    for (const auto &sg_face : combinations(N, 2)) {
-      Table *cs_face = solve(all_gens(N), sg_face, mults);
+      if (sg_face[0] == 0 and sg_face[1] == 1) continue;
+//      if (sg_face[0] == 0 and sg_face[1] == 2) continue;
+      if (sg_face[0] == 0 and sg_face[1] == 3) continue;
+
+      if (sg_face[0] == 1 and sg_face[1] == 2) continue;
+//      if (sg_face[0] == 1 and sg_face[1] == 3) continue;
+
+      if (sg_face[0] == 2 and sg_face[1] == 3) continue;
+
+      Table *cs_face = solve(gens, sg_face, mults);
 
       // for each *kind* of edge
       for (const auto &sg_edge : combinations(sg_face, 1)) {