main.cpp

#include <imgui.h>
#include <igl/colormap.h>
#include <igl/triangle_triangle_adjacency.h>
#include <string>
#include <iostream>
#include <vector>
#include <utility>
#include <optional>
#include <unordered_set>
#include <array>
#include <filesystem>
#include <igl/edge_exists_near.h>
#include <igl/serialize.h>
#include <igl/file_dialog_open.h>
#include <igl/opengl/glfw/Viewer.h>
#include <igl/opengl/glfw/imgui/ImGuiPlugin.h>
#include <igl/opengl/glfw/imgui/ImGuiMenu.h>
#include <igl/readOBJ.h>
#include <igl/readOFF.h>

#include "imgui_internal.h"
#include "src/mesh.h"
#include "src/selection.hpp"
#include "src/geometry.hpp"
#include "src/isoline_selection.h"
#include "src/app_state.h"
#include "src/user_interface.hpp"
#include "external/ImGuizmo/ImGuizmo.h"
#include "src/deformation.hpp"

// Expanding state serialization
namespace igl::serialization
{
    // optional<int>
    template<> inline void serialize(const std::optional<int>& obj, std::vector<char>& buffer)
    {
        ::igl::serialize(obj.has_value(), std::string("has_value"), buffer);
        if (obj.has_value())
        {
            ::igl::serialize(obj.value(), std::string("value"), buffer);
        }
    }

    template<> inline void deserialize(std::optional<int>& obj, const std::vector<char>& buffer)
    {
        bool has_value;
        ::igl::deserialize(has_value, std::string("has_value"), buffer);
        if (has_value)
        {
            int value;
            ::igl::deserialize(value, std::string("value"),buffer);
            obj = value;
        } else {
            obj = {};
        }
    }

    // optional<VectorXd>
    template<> inline void serialize(const std::optional<Eigen::VectorXd>& obj, std::vector<char>& buffer)
    {
        ::igl::serialize(obj.has_value(), std::string("has_value"), buffer);
        if (obj.has_value())
        {
            ::igl::serialize(obj.value(), std::string("value"), buffer);
        }
    }

    template<> inline void deserialize(std::optional<Eigen::VectorXd>& obj, const std::vector<char>& buffer)
    {
        bool has_value;
        ::igl::deserialize(has_value, std::string("has_value"), buffer);
        if (has_value)
        {
            Eigen::VectorXd value;
            ::igl::deserialize(obj, std::string("value"),buffer);
            obj = value;
        } else {
            obj = {};
        }
    }

    // optional<ContiguousSelection>
    template<> inline void serialize(const std::optional<SelectionRegion>& obj, std::vector<char>& buffer)
    {
        ::igl::serialize(obj.has_value(), std::string("has_value"), buffer);
        if (obj.has_value())
        {
            ::igl::serialize(obj.value(), std::string("value"), buffer);
        }
    }

    template<> inline void deserialize(std::optional<SelectionRegion>& obj, const std::vector<char>& buffer)
    {
        bool has_value;
        ::igl::deserialize(has_value, std::string("has_value"), buffer);
        if (has_value)
        {
            SelectionRegion value;
            ::igl::deserialize(value, std::string("value"),buffer);
            obj = value;
        } else {
            obj = {};
        }
    }
}

using Eigen::Vector2f;
using Eigen::Vector3d, Eigen::Vector3i, Eigen::Vector3f;
using Eigen::VectorXd, Eigen::VectorXi;
using Eigen::MatrixXd, Eigen::MatrixXi;

using igl::opengl::glfw::Viewer;
using igl::opengl::glfw::imgui::ImGuiMenu, igl::opengl::glfw::imgui::ImGuiPlugin;

using std::string;
using std::pair;
using std::optional;

const string TEST_MESH_ARMADILLO = "../data/armadillo0.off";
const string TEST_MESH_TEAPOT = "../data/teapot.obj";
const string TEST_MESH_COW = "../data/cow.off";

const Vector3d SELECTION_COLOR = Vector3d(0, 0, 0);
const Vector3d COLOR_RED(1, 0, 0);
const Vector3d COLOR_GREEN(0, 1, 0);
const Vector3d COLOR_BLUE(0, 0, 1);
const Vector3d COLOR_LIGHT_RED(.8, .3 , .3);
const Vector3d COLOR_LIGHT_GREEN(0.53, 0.85, 0.5);

Viewer viewer;
AppState appState;

enum ViewerData
{
    DATA_IDX_MESH = 0,
    DATA_IDX_SELECTION_ISOLINES = 1,
    DATA_IDX_BBOX = 2,
    DATA_IDX_EXPANSION_ISOLINES = 3,
};

void set_colors(MatrixXd& color_arr, const std::vector<int>& items, const Vector3d& color)
{
    for (const int idx: items) { color_arr.row(idx) = color; }
}

void set_colors(MatrixXd& color_arr, const std::unordered_set<int>& items, const Vector3d& color)
{
    for (const int idx: items) { color_arr.row(idx) = color; }
}

void set_colors(MatrixXd& color_arr, const Eigen::VectorXi& items, const Vector3d& color)
{
    for (const int idx: items) { color_arr.row(idx) = color; }
}

MatrixXd
highlight_selection(const Mesh& mesh, const MeshSelection& selection)
{
    MatrixXd colors = MatrixXd::Constant(mesh.faces.rows(), 3, 1);
    set_colors(colors, selection.faces, COLOR_RED);
    return colors;
}

void color_deform_handles(
    const SelectionRegion& fixed,
    const SelectionRegion& handle,
    MatrixXd& colors)
{
    set_colors(colors, fixed.interior.faces, COLOR_LIGHT_RED);
    set_colors(colors, fixed.boundary.faces, COLOR_RED);
    set_colors(colors, handle.interior.faces, COLOR_LIGHT_GREEN);
    set_colors(colors, handle.boundary.faces, COLOR_GREEN);
}

void show_candidate_isolines()
{
    if (!appState.initialCandidates.has_value()) return;
    const auto& isolines = appState.initialCandidates->candidates;
    viewer.data().clear_edges();
    const Eigen::RowVector3d COLOR_DEBUG_LINE(1, 0, 1);
    const Eigen::RowVector3d COLOR_SELECTED_LINE(0, 1, 0);
    for (int i = 0; i < NB_ISOLINES; i++) {
        const auto color = i == appState.initialCandidates->currCandidateIdx ? COLOR_SELECTED_LINE : COLOR_DEBUG_LINE;
        debug_draw_line(viewer, isolines[i].points, color);
    }
}


/* ====================================================================
 * =============== State (De)Serialization ============================
 * ====================================================================
 */
bool load_mesh(const string filename, Mesh& targetMesh) {
    // @TODO: Load OBJ / OFF automatically without having to worry about it
    if (filename.rfind(".off") == filename.size() - 4) {
        std::cout << "Loading OFF file: " << filename << std::endl;
        igl::readOFF(filename, targetMesh.vertices, targetMesh.faces);
    } else if (filename.rfind(".obj") == filename.size() - 4) {
        std::cout << "Loading OBJ file: " << filename << std::endl;
        igl::readOBJ(filename, targetMesh.vertices, targetMesh.faces);
    } else {
        std::cerr << "load_mesh: Unknown file extension!" << std::endl;
        return false;
    }

    std::cout << "Post loading - precomputing conformal map" << std::endl;

    igl::triangle_triangle_adjacency(targetMesh.faces, targetMesh.faceNeighbors);
    targetMesh.faceColors = MatrixXd::Constant(targetMesh.faces.rows(), 3, 1);
    targetMesh.conformalMap = compute_conformal_map(appState.mesh);
    targetMesh.boundingBox = BoundingBox::from_points(targetMesh.vertices);
    std::vector<std::vector<int>> _VFI;
    igl::vertex_triangle_adjacency(targetMesh.vertices, targetMesh.faces, targetMesh.vertexAdjacentFaces, _VFI);
    std::cout << "Loaded mesh has approximate size of " << targetMesh.approx_size_in_bytes() / (1024.f * 1024.f) << "MB" << std::endl;
    return true;
}

void serialize_state()
{
    igl::serialize(appState,"appState","stored_state",true);
}

void deserialize_state()
{
    igl::deserialize(appState, "appState", "stored_state");
    viewer.data().clear();
}

/* ===================================================================
* =============== Rendering & UI Updating ============================
* ====================================================================
*/
void color_current_selection(MatrixXd& colors)
{
    // Color reference selection & expansions
    // const auto& initialFaces = appState.initialSelection->selectedFaces;
    const auto& initialFaces = appState.initialCandidates->currSel.interior.faces;
    set_colors(colors, initialFaces, COLOR_BLUE);
    for (int i = 0; i < appState.selectionExpansionCounter; i++) {
        set_colors(colors, appState.candidateExpansions[i].interior.faces, COLOR_BLUE);
    }
}

void render_current_selection()
{
    if (!appState.initialCandidates.has_value())
        return;
    const Vector3d COLOR_SELECTED(1, 0, 0);
    const Vector3d COLOR_EXPANSION(1, 0, 0);
    // Color selected faces & reference selection
    MatrixXd colors = MatrixXd::Constant(appState.mesh.faces.rows(), 3, 1);

    // const auto& initialFaces = appState.initialSelection->selectedFaces;
    const auto& initialFaces = appState.initialCandidates->currSel.interior.faces;
    set_colors(colors, initialFaces, COLOR_SELECTED);
    for (int i = 0; i < appState.selectionExpansionCounter; i++) {
        set_colors(colors, appState.candidateExpansions[i].interior.faces, COLOR_EXPANSION);
    }
    viewer.data().set_colors(colors);
}


void update_viewer()
{
    // Render mesh
    viewer.data().set_mesh(appState.mesh.vertices, appState.mesh.faces);
    viewer.data().set_face_based(true);
    viewer.data().clear_labels();
    viewer.data().clear_points();
    MatrixXd meshColors = appState.mesh.faceColors;

    // Render selected points
    bool points_set = false;
    if (appState.showSelectionBoundaryConditions) {
        MatrixXd colorMatrix = MatrixXd::Constant(2 * appState.boundaryStrokes.size(), 3, 0);
        MatrixXd pointMatrix = MatrixXd::Constant(2 * appState.boundaryStrokes.size(), 3, 1);

        int rowCount = 0;
        for (auto const& stroke : appState.boundaryStrokes) {
            const Vector3d& pStart = appState.mesh.vertices.row(stroke.first);
            const Vector3d& pEnd = appState.mesh.vertices.row(stroke.second);
            pointMatrix.row(rowCount) = pStart.transpose();
            colorMatrix.row(rowCount) = COLOR_BLUE;
            rowCount++;
            pointMatrix.row(rowCount) = pEnd.transpose();
            colorMatrix.row(rowCount) = COLOR_RED;
            rowCount++;
        }
        if (points_set) {
            viewer.data().add_points(pointMatrix, colorMatrix);
        } else {
            viewer.data().set_points(pointMatrix, colorMatrix);
            points_set = true;
        }
    }

    if (appState.showMeshBoundingBox) {
        MatrixXd colors(8, 3);
        colors.rowwise() = COLOR_RED.transpose();
        colors.row(0) = COLOR_GREEN;
        
        bool isLocalTransfom = appState.transformMode & (TRANSFORM_TRANSLATE_LOCAL | TRANSFORM_RESIZE_LOCAL);
        const BoundingBox& bbox = (isLocalTransfom && appState.has_initial_selection()) 
            ? appState.initialCandidates->currSel.interior.box : appState.mesh.boundingBox;
        if (points_set) {
            viewer.data().add_points(bbox.vertices(), colors);
        } else {
            viewer.data().set_points(bbox.vertices(), colors);
            points_set = true;
        }
        
        if (appState.showMeshBoundingBoxLabels) {
            snprintf(appState.bboxMinString, STR_BUFFER_LEN, "(%.3f, %.3f, %.3f)", bbox.min.x(), bbox.min.y(), bbox.min.z());
            snprintf(appState.bboxMaxString, STR_BUFFER_LEN, "(%.3f, %.3f, %.3f)", bbox.max.x(), bbox.max.y(), bbox.max.z());
            viewer.data().add_label(bbox.min, appState.bboxMinString);
            viewer.data().add_label(bbox.max, appState.bboxMaxString);
        }
    }

    if (appState.has_initial_selection() && appState.showSelectionIsocontours) {
        show_candidate_isolines();
    } else {
        // TODO: Would be cleaner to separate this into a separate data(DATA_IDX_ISOLINES) "slot"
        viewer.data().clear_edges();
    }
    
    if (// appState.handleRegion.has_value() &&
        appState.handleRegion.has_value()) {
        set_colors(meshColors, appState.handleRegion->interior.faces, COLOR_LIGHT_GREEN);
        set_colors(meshColors, appState.handleRegion->boundary.faces, COLOR_GREEN);
    }
    
    if (// appState.fixedRegion.has_value() &&
        appState.fixedRegion.has_value()) {
        set_colors(meshColors, appState.fixedRegion->interior.faces, COLOR_LIGHT_RED);
        set_colors(meshColors, appState.fixedRegion->boundary.faces, COLOR_RED);
    }

    if (auto maybeDeformSel = appState.get_current_deform_selection();
        maybeDeformSel.has_value()) {
        color_deform_handles(maybeDeformSel->fixedRegion, maybeDeformSel->handleRegion, meshColors);
    }

    if (appState.has_initial_selection()) {
        color_current_selection(meshColors);
    }
    
    viewer.data().set_colors(meshColors);
}

void clean_slate()
{
    // Reset selection brush & constraints
    appState.brushStroke = {};
    appState.strokeStart = {};
    appState.strokeEnd = {};
    appState.boundaryStrokes.clear();
    
    // Reset Generated harmonic field
    appState.selectionHarmonicField = {};
    
    // Reset selection candidates & expansion counter
    appState.initialCandidates = {};
    appState.candidateExpansions.clear();
    appState.selectionExpansionCounter = 0;

    appState.deformExpansions.clear();
    appState.debugDeformExpansionIdx = 0;
    
    // reset fixed & handle regions
    appState.handleRegion = {};
    appState.fixedRegion = {};
    
    viewer.data().clear();
    update_viewer();
}

void update_gizmo_bounds(const BoundingBox& box)
{
    const Vector3f& bbmin = box.min.cast<float>();
    const Vector3f& bbmax = box.max.cast<float>();
    appState.resizeGizmoBounds = {
        bbmin.x(), bbmin.y(), bbmin.z(),
        bbmax.x(), bbmax.y(), bbmax.z()
    };
    // Reset the gizmo transform matrix
    appState.resizeGizmoTransformMatrix = MAT_4X4_IDENTITY;
}

void apply_transform(const Eigen::Matrix4d& transform, Mesh& mesh) {
    // Apply a transform to the whole mesh
    const int numVertices = mesh.vertices.rows();
    
    // Copy old vertices into temporary matrix
    MatrixXd tempVertices = MatrixXd::Constant(numVertices, 4, 1);
    tempVertices.block(0, 0, numVertices, 3) = mesh.vertices.block(0, 0, numVertices, 3);
    // Transform temporary matrix  & put back
    MatrixXd deformedShape = transform * tempVertices.transpose();
    mesh.vertices.block(0, 0, numVertices, 3) = deformedShape.transpose().block(0, 0, numVertices, 3);

    // Update bounding box
    mesh.boundingBox = BoundingBox::from_points(mesh.vertices);
}

void apply_transform(const Eigen::Matrix4d& transform, Mesh& mesh, const MeshSelection& selection) {
    // Modify vertices in selection
    for (int v : selection.vertices) {
        const Eigen::Vector4d pos = mesh.vertices.row(v).homogeneous();
        mesh.vertices.row(v) = (transform * pos).head<3>();
    }
    // Update the bounding box
    mesh.boundingBox = BoundingBox::from_points(mesh.vertices);
}

bool selection_compute_candidates()
{
    if (!appState.has_initial_selection()) {
        std::cerr << "No initial selection" << std::endl;
        return false;
    }
    if (appState.brushStroke.empty()) {
        std::cerr << "BrushStroke contains no points" << std::endl;
        return false;
    }

    // ContiguousSelection& initialSel = appState.initialSelection.value();
    auto& initialSel = appState.initialCandidates->currSel;
    std::vector<IsolineCandidate> candidateIsolines = compute_expansion_candidates(
            appState.mesh, initialSel, appState.brushStroke, appState.candidateExpansions);
    show_candidate_isolines();
    return true;
}

bool expand_and_render_selection()
{
    // Expand selection
    if (!appState.selectionHarmonicField.has_value() || !appState.has_initial_selection()) {
        std::cout << "Cannot expand: Reference selection does not exist" << std::endl;
        return false;
    }
    if (appState.candidateExpansions.size() <= appState.selectionExpansionCounter) {
        std::cout << "Cannot expand: Maximum number of expansions selected" << std::endl;
        return false;
    }
    
    appState.selectionExpansionCounter++;
    render_current_selection();
    return true;
}

void gizmo_apply_transform(MeshSelection& handle)
{
    using Eigen::Matrix4d;
    BoundingBox& bbox = handle.box;
    // Apply transform to mesh & handle bbox

    // Transform to origin, then apply transform.
    const Matrix4d gizmoTransform = ImGui_matrix_to_Eigen(appState.resizeGizmoTransformMatrix.data());
    const Matrix4d mat_t = translation_matrix(bbox.min);
    const Matrix4d mat_ti = translation_matrix(-bbox.min);
    // This looks a little weird:
    // - Since the gizmo transform is located at bbox.min, we need to undo this transformation.
    // - We need to apply transformations center-origined. This does not matter for translations, but it does for rotations/scaling.
    // For translation the outer terms cancel out. For rotations they do not.
    const Matrix4d composedTransform = mat_t * gizmoTransform * mat_ti * mat_ti;
    apply_transform(composedTransform, appState.mesh, handle);
    compute_bounding_box_from_vertex_selection(appState.mesh, handle.vertices, handle.box);
}

/* ===================================================================
 * =============== Algorithmics =======================================
 * ====================================================================
 */
void test_triangle_adjacency(Viewer& viewer, Mesh& mesh) {
    std::optional<std::tuple<int, Vector3f>> maybe_pick = pick_mouse(viewer, mesh);
    if (!maybe_pick.has_value()) {
        return;
    }
    auto [face_id, bary_coords] = maybe_pick.value();
    VectorXi neighbours = mesh.faceNeighbors.row(face_id);
    // Color current face red, and all neighbours blue
    mesh.faceColors.row(face_id) << 1, 0, 0;
    set_colors(mesh.faceColors, neighbours, COLOR_BLUE);

    viewer.data().set_colors(mesh.faceColors);
}

/* ====================================================================
* =============== Event handlers =====================================
* ====================================================================
*/
bool key_down(Viewer& viewer, unsigned char key, int modifier)
{
    std::cout << "Key press " << (int) key << std::endl;
    if (key == KEY_F1) {
        appState.showDefaultMenu = !appState.showDefaultMenu;
    } if (key == KEY_F4) { // F4 {
        std::cout << "Entering debugger" << std::endl;
    } else if (key == KEY_B) { // F5 : Brush across (pick) trigger
        std::cout << "Entering brush mode" << std::endl;
        appState.mode = MODE_BRUSH_ALONG;
    } else if (key == KEY_F6) { // F6 : Compute harmonic map (debug - Solve for laplacians)
        bool result = selection_find_initial(appState, viewer, SELECTION_COMPUTE_HARMONIC);
        if (result) {
            return true;
        }
        // render_current_selection();
        update_viewer();
    } else if (key == KEY_F7) { // F7 : Find selection (Debug)
        bool result = selection_find_initial(appState, viewer, SELECTION_COMPUTE_INITIAL_SELECTION);
        if (result) {
            return true;
        }
        // render_current_selection();
        update_viewer();
    } else if (key == KEY_F8) { // F8 : Clean selection
        clean_slate();
    } else if (key == KEY_F10) { // F10
        bool result = selection_compute_candidates();
        if (result) {
            return true;
        }
    } else if (key == KEY_1) { // key 1 : Brush mode across trigger
        appState.mode = MODE_BRUSH_ALONG;
        clean_slate();
    } else if (key == KEY_5) { // key 5
        load_mesh(TEST_MESH_TEAPOT, appState.mesh);
        clean_slate();
    } else if (key == KEY_6) {
        load_mesh(TEST_MESH_COW, appState.mesh);
    } else if (key == KEY_NUMPAD_PLUS) { // numpad +
        bool result = expand_and_render_selection();
        if (result) {
            return true;
        }
    } else if (key == 'N') {
        test_triangle_adjacency(viewer, appState.mesh);
    } else if (key == KEY_H) {
        appState.assign_handle();
        update_viewer();
    } else if (key == KEY_F) {
        appState.assign_fixed();
        update_viewer();
    }
    
    // Exit brush mode on every other keystroke
    if (key != KEY_F5 && appState.mode == MODE_BRUSH_ACROSS) {
        std::cout << "Exiting brush mode" << std::endl;
        appState.mode = MODE_NONE;
    }

    return appState.showDefaultMenu;
    // return false;
}

bool mouse_down(Viewer& viewer, int button, int modifier)
{
    if (appState.mode == MODE_BRUSH_ACROSS) {
        const optional<int> vert_select = find_selected_vertex(appState.mesh, viewer);
        if (!vert_select.has_value()) {
            return false;
        }

        if (!appState.strokeStart.has_value()) {
            appState.strokeStart = vert_select;
        } else if (!appState.strokeEnd.has_value()) {
            appState.strokeEnd = vert_select;
        }

        if (appState.strokeStart.has_value() 
            && appState.strokeEnd.has_value()) {
            appState.push_current_stroke();
        }
    
        update_viewer();
        return true;
    }
    
    if (appState.mode == MODE_BRUSH_ALONG) {
        appState.dragging = true;
    }

    if (appState.mode == MODE_TEST) {
        // Mode case for small tests & experiments
        test_triangle_adjacency(viewer, appState.mesh);
        return true;
    }
    
    if (appState.mode == MODE_PICK) {
        std::optional<std::tuple<int, Vector3f>> maybe_pick = pick_mouse(viewer, appState.mesh);
        appState.selectedTriangle = maybe_pick.has_value() ? std::optional(std::get<0>(*maybe_pick)) : std::nullopt;
        return appState.selectedTriangle.has_value();
    }
    return false;
}

bool mouse_up(Viewer& viewer, int button, int modifier)
{
    appState.dragging = false;
    if (appState.mode == MODE_BRUSH_ALONG
        && brush_select_mouse_release(appState)) {
        update_viewer();
        return true;
    }

    // if (ImGuizmo::IsUsing() && appState.transformMode == TRANSFORM_ROTATE_LOCAL) {
    //     gizmo_reset_to_point(appState, appState.handleRegion->interior.box.min);
    // }

    return false;
}

bool mouse_move(Viewer& viewer, int mouse_x, int mouse_y)
{
    if (ImGuizmo::IsUsing()){
        return true;
    }
    if (appState.dragging && appState.mode == MODE_BRUSH_ALONG) {
        brush_select_mouse_move(viewer, appState);
        return true;
    }
    return false;
}

void compute_deform_expansions()
{
    if (!appState.has_boundary_selection(BOUNDARY_TYPE_BOTH)) {
        return;
    }
    assert(appState.fixedRegion->contains(*appState.handleRegion));

    // Compute the fixed region expansions
    const Mesh& mesh = appState.mesh;
    const auto& initialFixed = appState.fixedRegion.value();
    const auto& initialHandle = appState.handleRegion.value();

    std::vector<SelectionRegion> candidateFixedExpansions;
    compute_expansion_candidates(mesh, initialFixed, {}, candidateFixedExpansions);

    std::vector<DeformSelection> expansions;
    for (const SelectionRegion& cFixedExp : candidateFixedExpansions) {
        // Find within expansion region, the region that best matches the initHandle region
        std::vector<SelectionRegion> candidateHandleExpansions;
        compute_expansion_candidates(mesh, initialHandle, {}, candidateHandleExpansions, cFixedExp.interior.faces);
        if (candidateHandleExpansions.empty()) {
            std::cout << "No handle expansion candidates found for expansion region" << std::endl;
            continue;
        }
        std::cout << "Found deformation expansion" << std::endl;
        // Add this to the set of candidates
        DeformSelection ds;
        ds.fixedRegion = cFixedExp;
        ds.handleRegion = candidateHandleExpansions[0];
        expansions.push_back(ds);
    }

    appState.deformExpansions = expansions;
}


void gui_section_expansion_deform(Viewer& viewer) {
    if (!appState.has_boundary_selection(BOUNDARY_TYPE_BOTH))
        return;
    if (!ImGui::CollapsingHeader("Handle Expansion", ImGuiTreeNodeFlags_DefaultOpen))
        return;

    float w = ImGui::GetContentRegionAvail().x;
    float p = ImGui::GetStyle().FramePadding.x;
    if (ImGui::Button("Compute expansion candidates")) {
        compute_deform_expansions();
    }
    if (appState.deformExpansions.empty()) {
        return;
    }

    constexpr auto TABLE_FLAGS = ImGuiTableFlags_Borders | ImGuiTableFlags_ScrollY | ImGuiTableFlags_RowBg; // | ImGuiTableFlags_Resizable;
    const float MIN_ROW_HEIGHT = ImGui::GetTextLineHeightWithSpacing() + 5;
    const ImVec2 TABLE_SIZE = ImVec2(-FLT_MIN, ImGui::GetTextLineHeightWithSpacing()+ 5*MIN_ROW_HEIGHT);
    if (ImGui::BeginTable("##DeformExpansionTable", 3, TABLE_FLAGS, TABLE_SIZE)) {
        ImGui::TableSetupScrollFreeze(0, 1);
        ImGui::TableSetupColumn("ID", ImGuiTableColumnFlags_WidthFixed);

        ImGui::TableSetupColumn("#F (fixed)", ImGuiTableColumnFlags_WidthFixed);
        ImGui::TableSetupColumn("#F (handle)", ImGuiTableColumnFlags_WidthFixed);
        ImGui::TableHeadersRow(); // Render the headers

        ImGuiListClipper clipper;
        clipper.Begin(appState.deformExpansions.size());
        while (clipper.Step()) {
            for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; ++i) {
                // Render rows for each Deform expansion candidate
                ImGui::PushID(i);
                DeformSelection & c = appState.deformExpansions[i];
                char label[32];
                snprintf(label, 32, "%d##selIC", i);

                ImGui::TableNextRow(ImGuiTableRowFlags_None, MIN_ROW_HEIGHT);
                ImGui::TableNextColumn();
                ImGuiSelectableFlags selectable_flags = ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_AllowItemOverlap;

                if (ImGui::Selectable(label, i == appState.debugDeformExpansionIdx, selectable_flags, ImVec2(0, MIN_ROW_HEIGHT))) {
                    appState.debugDeformExpansionIdx = i;
                    MatrixXd colors = MatrixXd::Constant(appState.mesh.faces.rows(), 3, 1);
                    color_deform_handles(c.fixedRegion, c.handleRegion, colors);
                    viewer.data().set_colors(colors);
                    // update_viewer();
                }

                ImGui::TableNextColumn();
                ImGui::Text("%zu", c.fixedRegion.interior.faces.size());
                ImGui::TableNextColumn();
                ImGui::Text("%zu", c.handleRegion.interior.faces.size());

                ImGui::PopID();
            }
        }
        ImGui::EndTable();

        if (appState.is_selected_expansion_valid() && ImGui::Button("Select Expansion")) {
            std::cout << "Moving expansion to selection " << std::endl;
            appState.move_selected_expansion_to_selection();
            update_viewer();
        }
    }
}

void gui_section_expansion(Viewer& viewer) {
    if (!appState.has_initial_selection())
        return;
    if (!ImGui::CollapsingHeader("Selection Expansion", ImGuiTreeNodeFlags_DefaultOpen))
        return;

    float w = ImGui::GetContentRegionAvail().x;
    float p = ImGui::GetStyle().FramePadding.x;
    if (ImGui::Button("Compute expansion candidates")) {
        selection_compute_candidates();
    }
    if (!appState.has_expansions())
        return;

    if (ImGui::Button("Expand Selection")) {
        expand_and_render_selection();
    }

    auto& reference = appState.initialCandidates->currSel;

    const ImVec2 GRAPH_SIZE(100, 40);
    const auto fn_access = [](void* data, int idx) { return static_cast<float>(static_cast<double *>(data)[idx]); };

    // Draw the expansion candidate table.
    constexpr auto TABLE_FLAGS = ImGuiTableFlags_Borders | ImGuiTableFlags_ScrollY | ImGuiTableFlags_RowBg; // | ImGuiTableFlags_Resizable;
    const float MIN_ROW_HEIGHT = GRAPH_SIZE.y + 5;
    const ImVec2 TABLE_SIZE = ImVec2(-FLT_MIN, ImGui::GetTextLineHeightWithSpacing()+ 5*MIN_ROW_HEIGHT);
    if (ImGui::BeginTable("##ExpansionTable", 4, TABLE_FLAGS, TABLE_SIZE)) {
        // Headers
        ImGui::TableSetupScrollFreeze(0, 2);
        ImGui::TableSetupColumn("ID", ImGuiTableColumnFlags_WidthFixed);
        char histLabel[32];
        snprintf(histLabel, 32, "Hist (#bins=%zu)", reference.descriptor.size());
        ImGui::TableSetupColumn(histLabel, ImGuiTableColumnFlags_WidthFixed);
        ImGui::TableSetupColumn("#F", ImGuiTableColumnFlags_WidthFixed);
        ImGui::TableSetupColumn("Area", ImGuiTableColumnFlags_WidthFixed);
        ImGui::TableHeadersRow(); // Render the headers

        ImGuiListClipper clipper;
        clipper.Begin(appState.candidateExpansions.size());
        // Reference selection
        ImGui::TableNextRow();
        ImGui::TableNextColumn();
        ImGui::Text("Ref");
        ImGui::TableNextColumn();
        ImGui::PlotLines("##refplot", fn_access, reference.descriptor.data(), reference.descriptor.size(),
        0, nullptr, FLT_MAX, FLT_MAX, GRAPH_SIZE);
        ImGui::TableNextColumn();
        ImGui::Text("%zu", reference.interior.faces.size());
        ImGui::TableNextColumn();
        ImGui::Text("%.3f", reference.totalArea);

        while (clipper.Step()) {
            for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; ++i) {
                ImGui::PushID(i);
                SelectionRegion& c = appState.candidateExpansions[i];
                char label[32];
                snprintf(label, 32, "%d##selIC", i);

                ImGui::TableNextRow(ImGuiTableRowFlags_None, MIN_ROW_HEIGHT);
                ImGui::TableNextColumn();
                ImGuiSelectableFlags selectable_flags = ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_AllowItemOverlap;
                if (ImGui::Selectable(label, i == appState.debugSelectionExpansionIdx, selectable_flags, ImVec2(0, MIN_ROW_HEIGHT))) {
                    appState.debugSelectionExpansionIdx = i;
                    MatrixXd colors = MatrixXd::Constant(appState.mesh.faces.rows(), 3, 1);
                    set_colors(colors, c.interior.faces, COLOR_GREEN);
                    viewer.data().set_colors(colors);
                    // update_viewer();
                }
                ImGui::TableNextColumn();
                ImGui::PlotLines("##DescHist", fn_access, c.descriptor.data(), c.descriptor.size(),
                    0, nullptr, FLT_MAX, FLT_MAX, GRAPH_SIZE);
                ImGui::TableNextColumn();
                ImGui::Text("%zu", c.interior.faces.size());
                ImGui::TableNextColumn();
                ImGui::Text("%.3f", c.totalArea);
                ImGui::PopID();
            }
        }
        ImGui::EndTable();
    }
}


void gui_section_selection(Viewer& viewer) {
    if (!ImGui::CollapsingHeader("Selection", ImGuiTreeNodeFlags_DefaultOpen))
        return;

    float w = ImGui::GetContentRegionAvail().x;
    float p = ImGui::GetStyle().FramePadding.x;
    float window_hw = (w-p)/2.f; // half width
    float window_w = w - p;

    if (ImGui::Button("Brush Select (B)", ImVec2(window_hw, 0))) {
        appState.mode = MODE_BRUSH_ALONG;
    }

    if (!appState.brushStroke.empty()) {
        ImGui::SameLine(0, p);
        if (ImGui::Button("Clear brush", ImVec2(window_hw, 0))) {
            appState.clear_selection_brush();
            update_viewer();
        }
    }

    if (appState.has_selection_stroke()
        && ImGui::Button("Compute Selection", ImVec2(window_w, 0))) {
        selection_find_initial(appState, viewer);
        update_viewer();
    }

    if (ImGui::Button("Clear all", ImVec2(window_w, 0))) {
        clean_slate();
    }

    if (appState.has_initial_selection()) {
        ImGui::Text("ARAP");
        if (ImGui::Button("-> fixed (a)", ImVec2(window_hw, 0))) {
            std::cout << "Assigned selection to fixed region" << std::endl;
            appState.assign_fixed();
            update_viewer();
        }
        ImGui::SameLine(0, p);
        if (ImGui::Button("-> handle (h)", ImVec2(window_hw, 0))) {
            std::cout << "Assigned selection to handle region" << std::endl;
            appState.assign_handle();
            update_viewer();
        }
    }

    ImGui::Separator();
    if (appState.initialCandidates.has_value()
        && ImGui::TreeNode("Isoline candidates")) {
        IsolineCandidates& c = appState.initialCandidates.value();

        constexpr auto TABLE_FLAGS = ImGuiTableFlags_Borders; // | ImGuiTableFlags_Resizable;
        const ImVec2 TABLE_SIZE = ImVec2(-FLT_MIN, 5*ImGui::GetTextLineHeightWithSpacing());
        if (ImGui::BeginTable("##ChosenIsoline", 4, TABLE_FLAGS, TABLE_SIZE)) {
            for (int i = 0; i < NB_ISOLINES; ++i) {
                char label[32];
                snprintf(label, 32, "%d##selIC", i);
                ImGui::TableNextRow();
                ImGui::TableNextColumn();
                if (ImGui::Selectable(label, i == c.currCandidateIdx, ImGuiSelectableFlags_SpanAllColumns)) {
                    c.currCandidateIdx = i;
                    appState.switch_candidate(i);
                    update_viewer();
                }
                ImGui::TableNextColumn();
                ImGui::Text("%.4f", c.candidates[i].isoValue);
                ImGui::TableNextColumn();
                ImGui::Text("%zu", c.candidates[i].faces.size());
                ImGui::TableNextColumn();

                const ImVec4 color = (i == c.bestCandidateIdx) ? ImVec4{0, 1, 0, 1} : ImVec4{1, 1, 1, 1};
                ImGui::TextColored(color, "%.3f", c.scores[i]);
            }
            ImGui::EndTable();
        }
        ImGui::TreePop();
    }
}

template<typename T>
void imgui_saveload_object(
    const std::string label,
    const std::optional<T>& data,
    const std::filesystem::path fileDir,
    std::function<void(const T&)> load_callback)
{
    namespace fs = std::filesystem;
    const bool isDirValid = fs::exists(fileDir) && fs::is_directory(fileDir);
    if (isDirValid && ImGui::TreeNode(label.c_str())) {
        if (data.has_value() && ImGui::Button("Save current")) {
            igl::serialize(*data, (fileDir / "dumped_file.bin").c_str());
        }

        for (const auto& entry : fs::directory_iterator(fileDir)) {
            bool isBinFile = entry.is_regular_file() && entry.path().extension() == ".bin";
            if (!isBinFile) { continue; }
            if (ImGui::Button(entry.path().filename().c_str())) {
                std::cout << "Loading state from file" << std::endl;
                T load_obj;
                igl::deserialize(load_obj,  entry.path().string().c_str());
                load_callback(load_obj);
            }
        }
        ImGui::TreePop();
    }
}

void gui_section_settings(Viewer& viewer) {
    if (!ImGui::CollapsingHeader("Settings"))
        return;
    const char* solverOptions[] = { "Direct", "Least Squares" };
    ImGui::ListBox("Solver", reinterpret_cast<int*>(&appState.solver), solverOptions, 2);

    if (ImGui::TreeNode("ARAP Settings")) {
        if (ImGui::BeginListBox("ARAP Mode", ImVec2(0, ImGui::GetTextLineHeightWithSpacing()*3))) {
            if (ImGui::Selectable("Spokes", appState.arapEnergyType == igl::ARAP_ENERGY_TYPE_SPOKES)) {
                appState.arapEnergyType = igl::ARAP_ENERGY_TYPE_SPOKES;
            }
            if (ImGui::Selectable("Spokes and Rims", appState.arapEnergyType == igl::ARAP_ENERGY_TYPE_SPOKES_AND_RIMS)) {
                appState.arapEnergyType = igl::ARAP_ENERGY_TYPE_SPOKES_AND_RIMS;
            }
            if (ImGui::Selectable("Elements", appState.arapEnergyType == igl::ARAP_ENERGY_TYPE_ELEMENTS)) {
                appState.arapEnergyType = igl::ARAP_ENERGY_TYPE_ELEMENTS;
            }
            ImGui::EndListBox();
        }
        ImGui::Checkbox("Use dynamics", &appState.arapUseDynamics);

        ImGui::InputFloat("Youngs modulus", &appState.arapYoungsModulus);
        ImGui::InputFloat("Dynamics timestep", &appState.arapDynamicsTimestep);
        ImGui::InputInt("Max iters", &appState.arapMaxIters);

        ImGui::TreePop();
    }

    ImGui::InputFloat("Isoline selection sigma", &appState.isoselectionSigma);
    if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip("Convolution kernel width, see section 3.1 of \"Mesh Decomposition with Cross-boundary brushes\"");
    }

    ImGui::InputFloat("Stroke offset distance", &appState.strokeOffsetDistance);
    if (ImGui::IsItemHovered()) {
        ImGui::SetTooltip("offset of placed boundary conditions for stroke points, see section 4.2 of \"SimSelect: Similarity-based selection for 3D surfaces\"");
    }
}

void gui_section_debug_options(Viewer& viewer) {
    if (!ImGui::CollapsingHeader("Debug"))
        return;
    float w = ImGui::GetContentRegionAvail().x;
    float p = ImGui::GetStyle().FramePadding.x;
    float window_hw = (w-p)/2.f; // half width

    // Debugging utilities (put in separate section?)
    if (ImGui::Checkbox("Show Selection bdry conditions", &appState.showSelectionBoundaryConditions)) {
        update_viewer();
    }

    // Load / Save state functionality
    ImGui::Text("State serialization");
    if (ImGui::Button("Load##State", ImVec2(window_hw, 0))) {
        std::cout << "Loading serialized state" << std::endl;
        deserialize_state();
        update_viewer();
    }
    ImGui::SameLine(0, p);
    if (ImGui::Button("Save##State", ImVec2(window_hw, 0))) {
        // std::cout << "Saving temporarily disabled for safety" << std::endl;
        std::cout << "Saving serialized state" << std::endl;
        serialize_state();
    }

    ImGui::Spacing();
    if (ImGui::Button("Load Mesh", ImVec2(window_hw, 0))) {
        std::string fname = igl::file_dialog_open();
        if (fname.length() == 0) {
            return;
        }
        load_mesh(fname, appState.mesh);
        clean_slate();
    }

    if (ImGui::Button("Show conformal map")) {
        std::cout << "Rendering Conformal map" << std::endl;
        MatrixXd Colors;
        igl::colormap(igl::COLOR_MAP_TYPE_JET, appState.mesh.conformalMap, true, Colors);
        viewer.data().set_colors(Colors);
    }

    if (ImGui::Button("Dbg: Compute Harmonic Field")) {
        selection_find_initial(appState, viewer, SELECTION_COMPUTE_HARMONIC);
        render_current_selection();
    }

    if (ImGui::Button("Show Conformal isolines:")) {
        // Compute the isolines
        viewer.data().clear_edges();
        std::vector<IsolineCandidate> candidateIsolines;
        find_isoline_candidates(appState.mesh, appState.mesh.conformalMap, appState.debugConformalIsovalue, candidateIsolines);
        for (IsolineCandidate& c : candidateIsolines) {
            debug_draw_line(viewer, c.points, Eigen::RowVector3d(1, 1, 0));
        }
    }
    ImGui::SameLine();
    ImGui::InputFloat("##ConformalIsoval", &appState.debugConformalIsovalue);

    ImGui::Separator();
    // Options for highlighting various sets.
    const ImVec2 BTN_SIZE(window_hw, 0);
    if (appState.has_boundary_selection(BOUNDARY_TYPE_HANDLE)) {
        if (ImGui::Button("Handle (int)", BTN_SIZE)) {
            viewer.data().set_colors(highlight_selection(appState.mesh, appState.handleRegion->interior));
        }
        ImGui::SameLine(0, p);
        if (ImGui::Button("Handle (bdry)", BTN_SIZE)) {
            viewer.data().set_colors(highlight_selection(appState.mesh, appState.handleRegion->boundary));
        }
    }


    if (appState.has_boundary_selection(BOUNDARY_TYPE_FIXED)) {
        if (ImGui::Button("Fixed (int)", BTN_SIZE)) {
            viewer.data().set_colors(highlight_selection(appState.mesh, appState.fixedRegion->interior));
        }
        ImGui::SameLine(0, p);
        if (ImGui::Button("Fixed (bdry)", BTN_SIZE)) {
            viewer.data().set_colors(highlight_selection(appState.mesh, appState.fixedRegion->boundary));
        }
    }

    if (appState.has_selections() && ImGui::Button("Show deformable faces", ImVec2(w-p, 0))) {
        std::unordered_set<int> deformable_faces = appState.get_deformable_faces_from_selection();
        MatrixXd colors = MatrixXd::Constant(appState.mesh.faces.rows(), 3, 1);
        set_colors(colors, deformable_faces, COLOR_GREEN);
        viewer.data().set_colors(colors);
    }

    if (ImGui::Button("Reset vizualization", ImVec2(w-p, 0))) {
        update_viewer();
    }

    ImGui::Separator();
    namespace fs = std::filesystem;

    if (ImGui::Button("Debug dump selection state", ImVec2(w-p, 0))) {
        const fs::path DIR_TEST_dbg = "../tests/data";
        igl::serialize(appState.initialCandidates->currSel,
            (DIR_TEST_dbg / "dumped_stroke.bin").c_str());
    }

    const fs::path DIR_TEST_STROKES = "../tests/data/strokes";
    const bool isTestDirValid = fs::exists(DIR_TEST_STROKES) && fs::is_directory(DIR_TEST_STROKES);
    if (isTestDirValid && ImGui::TreeNode("Stroke Testfiles")) {
        if (ImGui::Button("Save current stroke")) {
            std::cout << "Storing n brush strokes: " << appState.brushStroke.size() << std::endl;
            igl::serialize(appState.brushStroke,"brushStroke",
                (DIR_TEST_STROKES / "dumped_stroke.bin").c_str(),true);
        }

        for (const auto& entry : fs::directory_iterator(DIR_TEST_STROKES)) {
            bool isBinFile = entry.is_regular_file() && entry.path().extension() == ".bin";
            if (!isBinFile) { continue; }

            if (ImGui::Button(entry.path().filename().c_str())) {
                // Load the state
                std::cout << "brush stroke before: " << appState.brushStroke.size() << std::endl;
                igl::deserialize(appState.brushStroke, "brushStroke", entry.path().string().c_str());
                place_selection_boundary_constraints(appState);
                update_viewer();
                std::cout << "brush stroke after: " << appState.brushStroke.size() << std::endl;
            }
        }
        ImGui::TreePop();
    }

    const fs::path DIR_TEST_DEFORM_SELECTIONS = "../tests/data/deformselections";
    imgui_saveload_object<DeformSelection>(
        "Deform Selection Testfiles",
        appState.get_current_deform_selection(), // TODO (perf): This makes copies every frame...
        DIR_TEST_DEFORM_SELECTIONS,
        [](const DeformSelection& deformSel)
        {
            appState.fixedRegion = deformSel.fixedRegion;
            appState.handleRegion = deformSel.handleRegion;
            update_viewer();
        });
}

void make_window(Viewer& viewer, ImGuiMenu& menu)
{
    menu.callback_draw_viewer_menu = [&]()
    {
        if (appState.resizeGizmoEnable) {
            // Convert igl's viewer & projection matrices into float* arrays
            float proj[16], view[16];
            Eigen_matrix_to_ImGui(viewer.core().proj, proj);
            Eigen_matrix_to_ImGui(viewer.core().view, view);

//                float boundsSnap[] = { 0.1f, 0.1f, 0.1f };
//                float snap[3] = { 1.f, 1.f, 1.f };
//                ImGuizmo::DrawCube(view, proj, matrix);

            switch (appState.transformMode) {
                case TRANSFORM_RESIZE_LOCAL:
                case TRANSFORM_RESIZE_GLOBAL:
                    ImGuizmo::Manipulate(
                        view, proj,
                        ImGuizmo::SCALE, ImGuizmo::LOCAL,
                        appState.resizeGizmoTransformMatrix.data(),
                        appState.resizeGizmoTransformDeltaMatrix.data(), nullptr,
                        appState.resizeGizmoBounds.data(), nullptr);
                    break;
                case TRANSFORM_TRANSLATE_LOCAL:
                    ImGuizmo::Manipulate(
                        view, proj,
                        ImGuizmo::TRANSLATE, ImGuizmo::LOCAL,
                        appState.resizeGizmoTransformMatrix.data(),
                        appState.resizeGizmoTransformDeltaMatrix.data());
                    break;
                case TRANSFORM_ROTATE_LOCAL:
                    ImGuizmo::Manipulate(
                        view, proj,
                        ImGuizmo::ROTATE, ImGuizmo::LOCAL,
                        appState.resizeGizmoTransformMatrix.data(),
                        appState.resizeGizmoTransformDeltaMatrix.data());
                    break;
                default:
                    break;
            }
        }

        if (ImGuizmo::IsUsing()
            && appState.has_boundary_selection(BOUNDARY_TYPE_BOTH)
            && appState.arapState.has_value()
            && (appState.transformMode == TRANSFORM_TRANSLATE_LOCAL
                || appState.transformMode == TRANSFORM_ROTATE_LOCAL))
        {
            if (appState.transformMode == TRANSFORM_TRANSLATE_LOCAL) {
                gizmo_apply_transform(appState.handleRegion->interior);
            } else if (appState.transformMode == TRANSFORM_ROTATE_LOCAL) {
                // TODO: Properly unify transform code. (Inverse translate to local root, the apply transform, then translate back)
                // Apply the rotation directly?
                using Eigen::Matrix4d;
                MeshSelection& handle = appState.handleRegion->interior;
                BoundingBox& bbox = handle.box;
                // Apply transform to mesh & handle bbox

                // Transform to origin, then apply transform.
                const Matrix4d gizmoTransform = ImGui_matrix_to_Eigen(appState.resizeGizmoTransformDeltaMatrix.data());
                const Vector3d handleCOM = center_of_mass(appState.mesh, handle.vertices);
                const Matrix4d mat_t = translation_matrix(handleCOM);
                const Matrix4d mat_ti = translation_matrix(-handleCOM);
                // This looks a little weird:
                // - Since the gizmo transform is located at bbox.min, we need to undo this transformation.
                // - We need to apply transformations center-origined. This does not matter for translations, but it does for rotations/scaling.
                // For translation the outer terms cancel out. For rotations they do not.
                const Matrix4d composedTransform = mat_t * gizmoTransform * mat_ti;
                apply_transform(composedTransform, appState.mesh, handle);
                compute_bounding_box_from_vertex_selection(appState.mesh, handle.vertices, bbox);
            }
            arap_subset_update(
                appState.fixedRegion->boundary,
                appState.handleRegion->boundary,
                appState.mesh,
                *appState.arapState);

            viewer.data().set_vertices(appState.mesh.vertices);
        }
        
        if (appState.showDefaultMenu) {
            menu.draw_viewer_menu();
            return;
        }

        ImGui::SetNextItemWidth(300);
        if (ImGui::CollapsingHeader("Transform", ImGuiTreeNodeFlags_DefaultOpen))
        {
            ImGui::Checkbox("Enable Transform", &appState.resizeGizmoEnable);
            ImGuizmo::Enable(appState.resizeGizmoEnable);

            float translateVec[3] = {0};
            float rotateVec[3] = {0};
            float scaleVec[3] = {0};
            ImGuizmo::DecomposeMatrixToComponents(appState.resizeGizmoTransformMatrix.data(), translateVec, rotateVec, scaleVec);
            ImGui::PushItemWidth(200);
            ImGui::InputFloat3("tr", translateVec, "%.3f");
            ImGui::InputFloat3("ro", rotateVec, "%.3f");
            ImGui::InputFloat3("sc", scaleVec, "%.3f");
            ImGui::PopItemWidth();
            
            ImGui::Checkbox("Render bounding box", &appState.showMeshBoundingBox);

            if (appState.has_selections()) {
                const MeshSelection& hRegion = appState.handleRegion->interior;
                const MeshSelection& hIsoline = appState.handleRegion->boundary;
                const MeshSelection& fRegion = appState.fixedRegion->interior;
                const MeshSelection& fIsoline = appState.fixedRegion->boundary;
                if (ImGui::Button("Translate (M)")) {
                    // Center handle to the correct position
                    gizmo_reset_to_point(appState, hRegion.box.min);
                    appState.transformMode = TRANSFORM_TRANSLATE_LOCAL;

                    const std::unordered_set<int> deformableFaces = appState.get_deformable_faces_from_selection();
                    appState.arapState = arap_subset_init(
                        fIsoline, hIsoline, appState.originalMesh, deformableFaces,
                        appState.arapEnergyType, appState.arapDynamicsTimestep, appState.arapYoungsModulus,
                        appState.arapMaxIters, appState.arapUseDynamics);
                    update_viewer();
                }
                ImGui::SameLine();

                if (ImGui::Button("Rotate")) {
                    // Center handle to the correct position
                    gizmo_reset_to_point(appState, hRegion.box.min);
                    appState.transformMode = TRANSFORM_ROTATE_LOCAL;

                    const std::unordered_set<int> deformableFaces = appState.get_deformable_faces_from_selection();
                    appState.arapState = arap_subset_init(
                        fIsoline, hIsoline, appState.originalMesh, deformableFaces,
                        appState.arapEnergyType, appState.arapDynamicsTimestep, appState.arapYoungsModulus,
                        appState.arapMaxIters, appState.arapUseDynamics);
                    update_viewer();
                }

                if (false
                    && appState.has_boundary_selection(BOUNDARY_TYPE_HANDLE)
                    && ImGui::Button("Resize selection")) {
                    // @TODO: This is just the primary selection for now
                    // ContiguousSelection& selection = appState.initialSelection.value();
                    const MeshSelection& selection = appState.handleRegion->interior;
                    update_gizmo_bounds(selection.box);
                    appState.transformMode = TRANSFORM_RESIZE_LOCAL;
                    update_viewer();
                }

                if (ImGui::Button("Reset mesh")) {
                    appState.mesh = appState.originalMesh;
                    update_viewer();
                }
            }
            
            if (false && ImGui::Button("Apply scaling")) {
                // should be heavily optimized in the future (use inline manipulation instead)
                // Map coordinates from float matrix (transposed) to eigen matrix.
                const float* matrix = appState.resizeGizmoTransformMatrix.data();
                const Eigen::Matrix4d transform = ImGui_matrix_to_Eigen(matrix);
                switch (appState.transformMode) {
                    case TRANSFORM_RESIZE_GLOBAL:
                        apply_transform(transform, appState.mesh);
                        update_gizmo_bounds(appState.mesh.boundingBox);
                        break;
                    case TRANSFORM_RESIZE_LOCAL: { // @TODO: Resize locally
                        auto& sel = appState.initialCandidates->currSel.interior;
                        apply_transform(transform, appState.mesh, sel);
                        update_gizmo_bounds(sel.box);
                        break;
                    }
                    default:
                        std::cout << "Not implemented yet" << std::endl;
                        break;
                }
                update_viewer();
            }
            
            if (ImGui::Button("Resize full mesh")) {
                appState.transformMode = TRANSFORM_RESIZE_GLOBAL;
                update_viewer();
            }
        }

        gui_section_selection(viewer);
        gui_section_expansion(viewer);
        gui_section_expansion_deform(viewer);
        gui_section_debug_options(viewer);

        if (ImGui::CollapsingHeader("Mesh info"))
        {
            const Mesh& mesh = appState.mesh;
            Vector3d meshDims = mesh.boundingBox.dimensions();
            ImGui::Text("Dims: (%.2f, %.2f, %.2f)", meshDims.x(), meshDims.y(), meshDims.z());

            ImGui::Text("Num vertices: %ld", mesh.vertices.rows());
            ImGui::Text("Num faces: %ld", mesh.faces.rows());
            ImGui::Text("Max edge length: %.3f", appState.maxEdgeLength);
            ImGui::Text("Mean edge length: %.3f", appState.meanEdgeLength);

            if (ImGui::Button("Pick vertex")) {
                appState.mode = MODE_PICK;
            }
            if (appState.selectedTriangle.has_value()) {
                int triangleId = appState.selectedTriangle.value();
                Vector3i triangle = appState.mesh.faces.row(triangleId);

                ImGui::Text("Triangle: %d", triangleId);
                ImGui::Text("Vertices %d %d %d", triangle(0), triangle(1), triangle(2));
                if (appState.selectionHarmonicField.has_value()) {
                    const VectorXd& harmonicField = appState.selectionHarmonicField.value();
                    ImGui::Text("Harmonic Map");
                    ImGui::Text("v0: %.4f", harmonicField(triangle(0)));
                    ImGui::Text("v1: %.4f", harmonicField(triangle(1)));
                    ImGui::Text("v2: %.4f", harmonicField(triangle(2)));
                }

                const VectorXd& conformalMap = appState.mesh.conformalMap;
                ImGui::Text("Conformal Map");
                ImGui::Text("v0: %.4f", conformalMap(triangle(0)));
                ImGui::Text("v1: %.4f", conformalMap(triangle(1)));
                ImGui::Text("v2: %.4f", conformalMap(triangle(2)));

                Vector3d v0Pos = appState.mesh.vertices.row(triangle(0));
                ImGui::Text("v0: (%.4f, %.4f, %.4f)", v0Pos.x(), v0Pos.y(), v0Pos.z());
            } else {
                ImGui::Text("No triangle selected");
            }
        }

        gui_section_settings(viewer);
    };
}

class ImGuizmoPlugin : public igl::opengl::glfw::ViewerPlugin
{
public:
    IGL_INLINE virtual bool pre_draw()
    {
        ImGuizmo::BeginFrame();
//        ImGuizmo::Enable(true);
        ImGuiIO& io = ImGui::GetIO();
        ImGuizmo::SetRect(0, 0, io.DisplaySize.x, io.DisplaySize.y);
        
        return false;
    }
    
//    IGL_INLINE  virtual bool post_draw() override;
};

int main(int argc, char *argv[])
{
    std::string file = (argc > 1) ? argv[1] : TEST_MESH_ARMADILLO;
    if (!load_mesh(file, appState.mesh)) {
        std::cout << "Failed to load mesh at: " << file << std::endl;
        return -1;
    }
    appState.originalMesh = appState.mesh;
    appState.strokeOffsetDistance =  0.01 * appState.mesh.boundingBox.dimensions().maxCoeff();
    std::cout << "Initial stroke offset distance: " << appState.strokeOffsetDistance << std::endl;

    {
        MatrixXd edgeLengths;
        igl::edge_lengths(appState.originalMesh.vertices, appState.originalMesh.faces, edgeLengths);
        appState.maxEdgeLength = edgeLengths.maxCoeff();
        appState.meanEdgeLength = edgeLengths.mean();
    }

    // Plot the mesh
    viewer.callback_mouse_down = &mouse_down;
    viewer.callback_mouse_up = &mouse_up;
    viewer.callback_mouse_move = &mouse_move;
    viewer.callback_key_down = &key_down;

    ImGuiPlugin menuPlugin;
    ImGuiMenu menu;
    viewer.plugins.push_back(&menuPlugin);
    menuPlugin.widgets.push_back(&menu);
    ImGuizmoPlugin guizmoPlugin;
    viewer.plugins.push_back(&guizmoPlugin);
    make_window(viewer, menu);
    
    update_gizmo_bounds(appState.mesh.boundingBox);
    update_viewer();
    viewer.launch();
}