albaTimeMapScalarWIN.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaTimeMapScalarWIN
 Authors: Paolo Quadrani
 
 Copyright (c) BIC
 All rights reserved. See Copyright.txt or
 
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef __albaTimeMapScalar_h
#define __albaTimeMapScalar_h
 
 
#define ALBA_SCALAR_MIN -1.0e+299
#define ALBA_SCALAR_MAX 1.0e+299
 
//----------------------------------------------------------------------------
// includes :
//----------------------------------------------------------------------------
#include "albaObject.h"
#include "albaTimeStamped.h"
#include "albaMTime.h"
#include "albaString.h"
#include <map>
#include <vector>
#include "albaTimeMapScalar.h"
#include "albaIndent.h"
#include <math.h>
#include <assert.h>
 
//------------------------------------------------------------------------------
// Forward declarations
//------------------------------------------------------------------------------
typedef std::vector<albaTimeStamp> mmuTimeVectorScalars;
 
template <class T>
class albaTimeMapScalar : public albaObject, public albaTimeStamped
{
public:
  typedef std::map<albaTimeStamp, T > TimeMapScalars;
  typedef std::pair<albaTimeStamp, T > mmuTimePairScalars;
 
  albaTimeMapScalar();  
  virtual ~albaTimeMapScalar();
 
  albaTimeMapScalar(const albaTimeMapScalar<T>&){};  
  void operator=(const albaTimeMapScalar<T>&){};
 
  void SetItemTypeName(const char *tname) {m_ItemTypeName = tname;}
  const char *GetItemTypeName() {return m_ItemTypeName;}
  
  virtual void AppendItem(albaTimeStamp t, T m);
 
  virtual void PrependItem(albaTimeStamp t, T m);
 
  typename albaTimeMapScalar<T>::TimeMapScalars::iterator FindItemByValue(T m);
 
  virtual void InsertItem(albaTimeStamp t, T m);
  
  virtual void RemoveItem(typename albaTimeMapScalar<T>::TimeMapScalars::iterator it);
 
  int RemoveItem(int idx);
 
  virtual void RemoveAllItems();
 
  albaTimeStamp GetItemTime(int idx);
 
  void GetTimeStamps(mmuTimeVectorScalars &kframes) const;
 
  int GetNumberOfItems() const {return m_TimeMap.size();};
  
  void GetTimeBounds(albaTimeStamp tbounds[2]);
 
  void DeepCopy(albaTimeMapScalar *vitem);
 
  bool Equals(albaTimeMapScalar *vmat);
 
  typename albaTimeMapScalar<T>::TimeMapScalars::iterator FindNearestItem(albaTimeStamp t);
 
  typename albaTimeMapScalar<T>::TimeMapScalars::iterator FindItemBefore(albaTimeStamp t);
 
  typename albaTimeMapScalar<T>::TimeMapScalars::iterator FindItem(albaTimeStamp t);
 
  typename albaTimeMapScalar<T>::TimeMapScalars::iterator FindItemByIndex(int idx);
 
  albaID FindItemIndex(albaTimeStamp t);
 
  T GetItem(albaTimeStamp t);
 
  T GetNearestItem(albaTimeStamp t);
 
  T GetItemBefore(albaTimeStamp t);
 
  T GetItemByIndex(int idx);
 
  virtual void Print(std::ostream& os, const int tabs=0) const;
 
  typename albaTimeMapScalar<T>::TimeMapScalars::iterator BeginScalarVector() {return m_TimeMap.begin();}
  typename albaTimeMapScalar<T>::TimeMapScalars::iterator EndScalarVector() {return m_TimeMap.end();}
  typename albaTimeMapScalar<T>::TimeMapScalars::iterator LastScalarVector() {return --(m_TimeMap.end());}
 
protected:
  TimeMapScalars  m_TimeMap;        
  albaString       m_ItemTypeName;   
};
 
 
 
 
//-----------------------------------------------------------------------
template <class T>
albaTimeMapScalar<T>::albaTimeMapScalar()
//-----------------------------------------------------------------------
{
}
 
//-----------------------------------------------------------------------
template <class T>
albaTimeMapScalar<T>::~albaTimeMapScalar()
//-----------------------------------------------------------------------
{
}
 
//-----------------------------------------------------------------------
template <class T>
void albaTimeMapScalar<T>::AppendItem(albaTimeStamp t, T m)
//-----------------------------------------------------------------------
{
   m_TimeMap.insert(m_TimeMap.end(), mmuTimePairScalars(t, m));
   Modified();
}
 
//-----------------------------------------------------------------------
template <class T>
void albaTimeMapScalar<T>::PrependItem(albaTimeStamp t, T m)
//-----------------------------------------------------------------------
{
  m_TimeMap.insert(m_TimeMap.begin(),mmuTimePairScalars(t, m));
  Modified();
}
//-------------------------------------------------------------------------
template <class T>
void albaTimeMapScalar<T>::InsertItem(albaTimeStamp t, T m)
//-------------------------------------------------------------------------
{
  m_TimeMap[t] = m;  
  Modified();
}
 
//-------------------------------------------------------------------------
template <class T>
void albaTimeMapScalar<T>::GetTimeBounds(albaTimeStamp tbounds[2])
//-------------------------------------------------------------------------
{
  // this is a sorted array
  if (m_TimeMap.size() > 0)
  {
     tbounds[0] = m_TimeMap.begin()->first;
     tbounds[1] = m_TimeMap.rbegin()->first;
  }
  else
  {
     tbounds[0] = -1;
     tbounds[1] = -1;
  }
}
 
//-------------------------------------------------------------------------
template <class T>
void albaTimeMapScalar<T>::GetTimeStamps(mmuTimeVectorScalars &kframes) const
//-------------------------------------------------------------------------
{
  kframes.clear();  
 
  for (albaTimeMapScalar<T>::TimeMapScalars::const_iterator it = m_TimeMap.begin(); it != m_TimeMap.end(); it++)
  {
    kframes.push_back(it->first);
  }
}
 
//-------------------------------------------------------------------------
template <class T>
void albaTimeMapScalar<T>::DeepCopy(albaTimeMapScalar *o)
//-------------------------------------------------------------------------
{
  RemoveAllItems();
  
  albaTimeMapScalar<T>::TimeMapScalars::iterator it;
  for (it = o->BeginScalarVector(); it != o->EndScalarVector(); it++)
  {
    T new_item = it->second;
    AppendItem(it->first, new_item);
  }
  Modified();
}
 
//-------------------------------------------------------------------------
template <class T>
bool albaTimeMapScalar<T>::Equals(albaTimeMapScalar *o)
//-------------------------------------------------------------------------
{
  if (o == NULL)
    return false;
 
  if (GetNumberOfItems() != o->GetNumberOfItems())
    return false;
 
  albaTimeMapScalar<T>::TimeMapScalars::iterator it;
  albaTimeMapScalar<T>::TimeMapScalars::iterator it2;
  for (it = m_TimeMap.begin(), it2 = o->m_TimeMap.begin(); it != m_TimeMap.end(); it++, it2++)
  {
    T m = it->second;
    T m2 = it2->second;
 
    if (m != m2)
      return false;
  }
 
  return true;
}
 
//-------------------------------------------------------------------------
template <class T>
void albaTimeMapScalar<T>::RemoveItem(typename albaTimeMapScalar<T>::TimeMapScalars::iterator it)
//-------------------------------------------------------------------------
{
  m_TimeMap.erase(it);
  Modified();
}
 
//-------------------------------------------------------------------------
template <class T>
int albaTimeMapScalar<T>::RemoveItem(int idx)
//-------------------------------------------------------------------------
{
  albaTimeMapScalar<T>::TimeMapScalars::iterator it = FindItemByIndex(idx);
  if (it != m_TimeMap.end())
  {
    RemoveItem(it);
    return ALBA_OK;
  }
 
  return ALBA_ERROR;
}
 
//-------------------------------------------------------------------------
template <class T>
void albaTimeMapScalar<T>::RemoveAllItems()
//-------------------------------------------------------------------------
{
  m_TimeMap.clear();
  Modified();
}
 
//-------------------------------------------------------------------------
template <class T>
typename albaTimeMapScalar<T>::TimeMapScalars::iterator albaTimeMapScalar<T>::FindNearestItem(albaTimeStamp t)
//-------------------------------------------------------------------------
{
  albaTimeMapScalar<T>::TimeMapScalars::iterator lowIt;
  albaTimeMapScalar<T>::TimeMapScalars::iterator upIt;
   
  lowIt = FindItemBefore(t); // find first item < t
  upIt = m_TimeMap.lower_bound(t); // find first item >= t
 
  if(lowIt != m_TimeMap.end())
  {
    if(upIt != m_TimeMap.end())
    {
      if(fabs(lowIt->first - t) < fabs(upIt->first - t))
      {
        return lowIt;
      }
      else
      {
        return upIt;
      }
    }
    return lowIt;
  }
  else if(upIt != m_TimeMap.end())
  {
    return upIt;
  }
  return --upIt;
}
 
//-------------------------------------------------------------------------
template <class T>
typename albaTimeMapScalar<T>::TimeMapScalars::iterator albaTimeMapScalar<T>::FindItemBefore(albaTimeStamp t)
//-------------------------------------------------------------------------
{
  if (m_TimeMap.size() > 0)
  {
    albaTimeMapScalar<T>::TimeMapScalars::iterator it = m_TimeMap.lower_bound(t); // find first item >= t
    if (it == m_TimeMap.end() || it != m_TimeMap.begin() && it->first > t) // if > t get the previous 
      --it;
 
    return it;
  }
  else
  {
    return m_TimeMap.end();
  }
}
 
//-------------------------------------------------------------------------
template <class T>
typename albaTimeMapScalar<T>::TimeMapScalars::iterator albaTimeMapScalar<T>::FindItem(albaTimeStamp t)
//-------------------------------------------------------------------------
{
  return m_TimeMap.find(t);
}
 
//-------------------------------------------------------------------------
template <class T>
typename albaTimeMapScalar<T>::TimeMapScalars::iterator albaTimeMapScalar<T>::FindItemByValue(T m)
//-------------------------------------------------------------------------
{
  for (albaTimeMapScalar<T>::TimeMapScalars::iterator it = m_TimeMap.begin(); it != m_TimeMap.end(); it++)
  {
    T m2 = it->second;
    if (m == m2)
      return it;
  }
  
  return m_TimeMap.end();
}
 
//----------------------------------------------------------------------------
template <class T>
void albaTimeMapScalar<T>::Print(std::ostream& os, const int tabs) const
//----------------------------------------------------------------------------
{
  albaIndent indent(tabs);
  os << indent << "Number of Items:" << GetNumberOfItems() << "\n";
  mmuTimeVectorScalars tvector;
  os << indent << "Time Stamps: {";
  GetTimeStamps(tvector);
  for (unsigned int i = 0; i < tvector.size(); i++)
  {
     if (i!=0)
       os << ", ";
     os << tvector[i];
  }
 
  os << "}\n";
}
 
//----------------------------------------------------------------------------
template <class T>
albaTimeStamp albaTimeMapScalar<T>::GetItemTime(int idx)
//----------------------------------------------------------------------------
{
  albaTimeMapScalar<T>::TimeMapScalars::iterator it = FindItemByIndex(idx);
  return (it != m_TimeMap.end()) ? it->first : -1;
}
 
//----------------------------------------------------------------------------
template <class T>
typename albaTimeMapScalar<T>::TimeMapScalars::iterator albaTimeMapScalar<T>::FindItemByIndex(int idx)
//----------------------------------------------------------------------------
{
  if ((unsigned int)idx < m_TimeMap.size() && idx >= 0)
  {
     albaTimeMapScalar<T>::TimeMapScalars::iterator it = m_TimeMap.begin();
     std::advance(it, idx);
     return it;
  }
  
  return m_TimeMap.end();
}
 
//----------------------------------------------------------------------------
template <class T>
albaID albaTimeMapScalar<T>::FindItemIndex(albaTimeStamp t)
//----------------------------------------------------------------------------
{
  albaTimeMapScalar<T>::TimeMapScalars::iterator it = FindItem(t);
  return it != m_TimeMap.end() ? std::distance(m_TimeMap.begin(), it) : -1;
}
 
//----------------------------------------------------------------------------
template <class T>
T albaTimeMapScalar<T>::GetItemByIndex(int idx)
//----------------------------------------------------------------------------
{
  albaTimeMapScalar<T>::TimeMapScalars::iterator it = FindItemByIndex(idx);
  return (it != m_TimeMap.end()) ? it->second : ALBA_SCALAR_MIN;
}
 
//----------------------------------------------------------------------------
template <class T>
T albaTimeMapScalar<T>::GetItem(albaTimeStamp t)
//----------------------------------------------------------------------------
{
  albaTimeMapScalar<T>::TimeMapScalars::iterator it = FindItem(t);
  return (it != m_TimeMap.end()) ? it->second : ALBA_SCALAR_MIN;
}
//----------------------------------------------------------------------------
template <class T>
T albaTimeMapScalar<T>::GetNearestItem(albaTimeStamp t)
//----------------------------------------------------------------------------
{
  albaTimeMapScalar<T>::TimeMapScalars::iterator it = FindNearestItem(t);
  return (it != m_TimeMap.end()) ? it->second : ALBA_SCALAR_MIN;
}
//----------------------------------------------------------------------------
template <class T>
T albaTimeMapScalar<T>::GetItemBefore(albaTimeStamp t)
//----------------------------------------------------------------------------
{
  albaTimeMapScalar<T>::TimeMapScalars::iterator it = FindItemBefore(t);
  return (it != m_TimeMap.end()) ? it->second : ALBA_SCALAR_MIN;
}
 
#endif