optimization_algorithm_with_hessian.h

#pragma once
#include "optimization_algorithm.h"
#include "solver.h"
#include "optimizable_graph.h"
#include "sparse_optimizer.h"
namespace NDEVR 
{
    class Solver;

    template<class t_solver>
    class  OptimizationAlgorithmWithHessian : public OptimizationAlgorithm
    {
    public:
        t_solver solver;    
        explicit OptimizationAlgorithmWithHessian()
        {
            // solver.setAlgorithm(&optimizer);
        }

        void clear()
        {
            solver.clear();
        }

        void addVertex(HyperGraph::HGVertex& v)
        {
            solver.optimizer().addVertex(v);
        }

        void addEdge(HyperGraph::HGEdge* e)
        {
            solver.optimizer().addEdge(e);
        }

        SparseOptimizer& optimizer()
        {
            return solver.optimizer();
        }

        const SparseOptimizer& optimizer() const
        {
            return solver.optimizer();
        }

        bool init(bool online = false)
        {
            bool useSchur = false;
            for (OptimizableGraph::OGVertex* v : optimizer().activeVertices())
            {
                if (v->marginalized())
                {
                    useSchur = true;
                    break;
                }
            }
            if (useSchur)
            {
                if (solver.supportsSchur())
                    solver.setSchur(true);
            }
            else
            {
                if (solver.supportsSchur())
                    solver.setSchur(false);
            }
 
            bool initState = solver.init(online);
            return initState;
        }

        bool buildLinearStructure(IndexScratch& scratch)
        {
            return solver.buildStructure(false, scratch);
        }

        void updateLinearSystem()
        {
            solver.buildSystem();
        }

        bool updateStructure(const Buffer<HyperGraph::HGVertex*>& vset, const Set<HyperGraph::HGVertex*>& edges)
        {
            return solver.updateStructure(vset, edges);
        }
 
 
    };
 
}