/Users/jab/Documents/Teaching/02585/GEL2_and_demos/GEL/src/HMesh/mesh_optimization.h

/* ----------------------------------------------------------------------- *
 * This file is part of GEL, www.imm.dtu.dk/GEL
 * Copyright (C) the authors (see AUTHORS.txt) and DTU Informatics
 *
 * Principal authors:
 *  Christian Thode Larsen (thode2d@gmail.com)
 *  J. Andreas Baerentzen (jab@imm.dtu.dk)
 *
 * See LICENSE.txt for licensing information
 * ----------------------------------------------------------------------- */

#ifndef __HMESH_MESH_OPTIMIZATION_H
#define __HMESH_MESH_OPTIMIZATION_H

#include "Manifold.h"
#include <CGLA/Vec3d.h>
namespace HMesh
{
    // forward declarations
    //class Manifold;
    //class HalfEdgeID;

    class EnergyFun
    {
    public:
        virtual double delta_energy(const Manifold& m, HalfEdgeID h) const = 0;
        virtual double energy(const Manifold& m, HalfEdgeID h) const {return 0;}
    };
        
        class MinAngleEnergy: public EnergyFun
        {
                double min_angle(const CGLA::Vec3d& v0, const CGLA::Vec3d& v1, const CGLA::Vec3d& v2) const;
                double thresh;
                
        public:
                
                MinAngleEnergy(double _thresh): thresh(_thresh) {}
                
                double delta_energy(const HMesh::Manifold& m, HMesh::HalfEdgeID h) const;
        };
        
        class DihedralEnergy: public EnergyFun
        {
                const double gamma;
                const bool use_alpha;
                
                double cos_ang(const CGLA::Vec3d& n1, const CGLA::Vec3d& n2) const
                {
                        return CGLA::s_max(-1.0, CGLA::s_min(1.0, CGLA::dot(n1, n2)));
                }
                
                double edge_alpha_energy(CGLA::Vec3d v1, CGLA::Vec3d v2, double ca) const
                {
                        return pow(CGLA::length(v1-v2)*(acos(ca)), 1.0f/gamma); 
                }
                
                double edge_c_energy(CGLA::Vec3d v1, CGLA::Vec3d v2, double ca) const
                {
                        return pow(length(v1-v2)*(1-ca), 1.0f/gamma); 
                }

                void compute_angles(const HMesh::Manifold & m, HMesh::HalfEdgeID h) const;
                


                mutable double ab_12;
                mutable double ab_a1;
                mutable double ab_b1;
                mutable double ab_2c;
                mutable double ab_2d;
                
                mutable double aa_12;
                mutable double aa_b1;
                mutable double aa_c1;
                mutable double aa_2a;
                mutable double aa_2d;
                
        public:
                
                DihedralEnergy(double _gamma = 4.0, bool _use_alpha=false): 
                gamma(_gamma), use_alpha(_use_alpha) {}
                
                double energy(const HMesh::Manifold& m, HMesh::HalfEdgeID h) const;
                
                double delta_energy(const HMesh::Manifold& m, HMesh::HalfEdgeID h) const;
        
                double min_angle(const HMesh::Manifold& m, HMesh::HalfEdgeID h) const
                {
                        compute_angles(m, h);
                        return CGLA::s_min(CGLA::s_min(CGLA::s_min(CGLA::s_min(aa_12, aa_b1), aa_c1), aa_2a), aa_2d);
                }               
        };
        
        class CurvatureEnergy: public EnergyFun
        {
                double abs_mean_curv(const CGLA::Vec3d& v, const std::vector<CGLA::Vec3d>& ring) const;
        public:
                double delta_energy(const HMesh::Manifold& m, HMesh::HalfEdgeID h) const;
        };              

    void priority_queue_optimization(Manifold& m, const EnergyFun& efun);

    void simulated_annealing_optimization(Manifold& m, const EnergyFun& efun, int max_iter=10000);

    void minimize_dihedral_angle(Manifold& m, int max_iter=10000, bool anneal=false, bool alpha=false, double gamma=4.0);

    void minimize_curvature(Manifold& m, bool anneal=false);

    void minimize_gauss_curvature(Manifold& m, bool anneal=false);

    void maximize_min_angle(Manifold& m, float thresh, bool anneal=false);

    void optimize_valency(Manifold& m, bool anneal=false);

    void randomize_mesh(Manifold& m, int max_iter);

}


#endif