AtlasFunctionalValues.h

/***************************************************************************************
*                                                                                      *
*                                     Deformetrica                                     *
*                                                                                      *
*    Copyright Inria and the University of Utah.  All rights reserved. This file is    *
*    distributed under the terms of the Inria Non-Commercial License Agreement.        *
*                                                                                      *
*                                                                                      *
****************************************************************************************/

#ifndef _AtlasFunctionalValues_h
#define _AtlasFunctionalValues_h

#include <vector>
#include <vnl/vnl_vector.h>


template <class TScalar>
class AtlasFunctionalValues
{

public:

      // typedef :

      typedef std::vector<TScalar> VectorType;



      // Constructor(s) / Destructor :

      AtlasFunctionalValues(int nobj, int nsubj)
      {
            m_NumberOfObjects = nobj;
            m_NumberOfSubjects = nsubj;

            m_DataTerm.resize(m_NumberOfSubjects);
            for (int s = 0; s < m_NumberOfSubjects; s++)
                  m_DataTerm[s].resize(m_NumberOfObjects,0.0);

            m_Regularity.resize(m_NumberOfSubjects, 0.0);
            m_Sparsity.resize(m_NumberOfSubjects, 0.0);

            m_DataTermPerObject.resize(m_NumberOfObjects, vnl_huge_val(1.0));
            m_TotalDataTerm = vnl_huge_val(1.0);
            m_TotalRegularity = vnl_huge_val(1.0);
            m_TotalSparsity = vnl_huge_val(1.0);
            m_TotalValue = vnl_huge_val(1.0);
            m_TotalL2Value = vnl_huge_val(1.0);

            m_OutOfBox = false;
      }

      AtlasFunctionalValues(const AtlasFunctionalValues& other)
      {
            m_NumberOfObjects = other.m_NumberOfObjects;
            m_NumberOfSubjects = other.m_NumberOfSubjects;

            m_DataTerm = other.m_DataTerm;
            m_Regularity = other.m_Regularity;
            m_Sparsity = other.m_Sparsity;

            m_OutOfBox = other.m_OutOfBox;

            m_DataTermPerObject = other.m_DataTermPerObject;
            m_TotalDataTerm = other.m_TotalDataTerm;
            m_TotalRegularity = other.m_TotalRegularity;
            m_TotalSparsity = other.m_TotalSparsity;
            m_TotalValue = other.m_TotalValue;
            m_TotalL2Value = other.m_TotalL2Value;
      }

      AtlasFunctionalValues* Clone() { return new AtlasFunctionalValues(*this); }

      ~AtlasFunctionalValues() {}



      // Encapsulation method(s) :

      inline std::vector< VectorType > GetDataTerm() { return m_DataTerm; }
      inline void SetDataTerm(VectorType dt, int s) { m_DataTerm[s] = dt; }
      inline void SetDataTerm(TScalar r, int s, int i) { m_DataTerm[s][i] = r; }

      inline void SetRegularity(TScalar r, int s) { m_Regularity[s] = r; }

      inline void SetSparsity(TScalar r, int s) { m_Sparsity[s] = r; }

      inline bool IsOutOfBox() { return m_OutOfBox; }
      inline void SetOutOfBox() { m_OutOfBox = true; }

      inline VectorType GetDataTermPerObject() { return m_DataTermPerObject; }
      inline TScalar GetTotalDataTerm() { return m_TotalDataTerm; }

      inline TScalar GetTotalRegularity() { return m_TotalRegularity; }

      inline TScalar GetTotalSparsity() { return m_TotalSparsity; }

      inline TScalar GetTotalValue() { return m_TotalValue; }

      inline TScalar GetTotalL2Value() { return m_TotalL2Value; }



      // Other method(s) :

      void Update()
      {
            if (m_OutOfBox)
                  return;


            m_DataTermPerObject.resize(m_NumberOfObjects,0.0);
            m_TotalDataTerm = 0.0;
            for (int i = 0; i < m_NumberOfObjects; i++)
            {
                  TScalar val = 0.0;
                  for (int s = 0; s < m_NumberOfSubjects; s++)
                        val += m_DataTerm[s][i];

                  val /= m_NumberOfSubjects;
                  m_DataTermPerObject[i] = val;
                  m_TotalDataTerm += val;
            }

            m_TotalRegularity = 0.0;
            m_TotalSparsity = 0.0;
            for (int s = 0; s < m_NumberOfSubjects; s++)
            {
                  m_TotalRegularity += m_Regularity[s];
                  m_TotalSparsity += m_Sparsity[s];
            }
            m_TotalRegularity /= m_NumberOfSubjects;
            m_TotalSparsity /= m_NumberOfSubjects;

            m_TotalValue = m_TotalDataTerm + m_TotalRegularity + m_TotalSparsity;
            m_TotalL2Value = m_TotalDataTerm + m_TotalRegularity;
      }

      void PrintIter(const int iter)
      {
            std::cout << "Iter " << iter << "  >> Objective = " << m_TotalValue <<
                        "\t(Data Term = " << m_TotalDataTerm <<
                        "\tRegularity = " << m_TotalRegularity <<
                        "\tSparsityPrior = " << m_TotalSparsity <<
                        ")" << std::endl;
      }



protected:

      // Attribute(s)

      int m_NumberOfObjects;

      int m_NumberOfSubjects;

      bool m_OutOfBox;

      std::vector< VectorType > m_DataTerm;

      VectorType m_Regularity;

      VectorType m_Sparsity;

      VectorType m_DataTermPerObject;

      TScalar m_TotalDataTerm;

      TScalar m_TotalRegularity;

      TScalar m_TotalSparsity;

      TScalar m_TotalValue;

      TScalar m_TotalL2Value;



}; /* class AtlasFunctionalValues */


#endif /* _AtlasFunctionalValues_h */