text: /*****************************************************************/
  /*    NAME: Michael Benjamin                                     */
  /*    ORGN: Dept of Mechanical Eng / CSAIL, MIT Cambridge MA     */
  /*    FILE: FV_Model.cpp                                         */
  /*    DATE: Sep 24th 2006                                        */
  /*                                                               */
  /* This file is part of MOOS-IvP                                 */
  /*                                                               */
  /* MOOS-IvP is free software: you can redistribute it and/or     */
  /* modify it under the terms of the GNU General Public License   */
  /* as published by the Free Software Foundation, either version  */
  /* 3 of the License, or (at your option) any later version.      */
  /*                                                               */
  /* MOOS-IvP is distributed in the hope that it will be useful,   */
  /* but WITHOUT ANY WARRANTY; without even the implied warranty   */
  /* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See  */
  /* the GNU General Public License for more details.              */
  /*                                                               */
  /* You should have received a copy of the GNU General Public     */
  /* License along with MOOS-IvP.  If not, see                     */
  /* <http://www.gnu.org/licenses/>.                               */
  /*****************************************************************/
  
  #include <iostream>
  #include "MBUtils.h"
  #include "FV_Model.h"
  #include "ColorParse.h"
  #include "BuildUtils.h"
  
  #define GL_PI 3.1415926f
  
  using namespace std;
  
  //-------------------------------------------------------------
  // Constructor
  
  FV_Model::FV_Model()
  {
    m_lock_ipf   = false;
    m_curr_iter  = 0;
  
    m_bundle_series_maxlen = 50;
    m_verbose    = true;
  
    m_nav_heading = 0;
  }
  
  //-------------------------------------------------------------
  // Procedure: addIPF()
  
  void FV_Model::addIPF(const string& ipf_str, const string& platform)
  {
    m_ipf_mutex.Lock();
  
    if(!m_lock_ipf) {
    
      m_bundle_series.addIPF(ipf_str);
      m_bundle_series_platform = platform;
  
      unsigned int bs_size = m_bundle_series.size();
      if(bs_size > m_bundle_series_maxlen)
        m_bundle_series.popFront(1);
  
      if(m_curr_source == "") {
        vector<string> sources = m_bundle_series.getAllSources();
        if(sources.size() > 0)
  	m_curr_source = sources[0];
      }
  
      m_curr_iter = m_bundle_series.getMaxIteration();
      
      if(m_curr_source == "") 
        m_curr_source = m_bundle_series.getFirstSource();
    }
    m_ipf_mutex.UnLock();
  }
  
  //-------------------------------------------------------------
  // Procedure: modColorMap
  
  void FV_Model::modColorMap(string str)
  {
    m_ipf_mutex.Lock();
    m_color_map.setType(str);
    m_ipf_mutex.UnLock();
  }
  
  //-------------------------------------------------------------
  // Procedure: modSource()
  
  void FV_Model::modSource(std::string bhv_source)
  {
    vector<string> sources = m_bundle_series.getAllSources();
    if(vectorContains(sources, bhv_source))
      m_curr_source = bhv_source;
  }
  
  //-------------------------------------------------------------
  // Procedure: getCurrSource()
  
  string FV_Model::getCurrSource()
  {
    if(m_collective != "")
      return("Collective Function");
    else {
      if(m_curr_source != "")
        return(m_curr_source);
      else
        return("no source detected");
    }
  }
  
  //-------------------------------------------------------------
  // Procedure: getCurrPieces()
  
  string FV_Model::getCurrPieces()
  {
    if(m_collective != "")
      return("n/a");
    else {
      unsigned int pcs;
      pcs = m_bundle_series.getPieces(m_curr_iter, m_curr_source);
      return(uintToString(pcs));
    }
  }
  
  //-------------------------------------------------------------
  // Procedure: getCurrPriority()
  
  string FV_Model::getCurrPriority()
  {
    if(m_collective != "")
      return("n/a");
    else {
      double pwt;
      pwt = m_bundle_series.getPriority(m_curr_iter, m_curr_source);
      return(dstringCompact(doubleToString(pwt)));
    }
  }
  
  //-------------------------------------------------------------
  // Procedure: getCurrDomain()
  
  string FV_Model::getCurrDomain()
  {
    if(m_collective != "")
      return("n/a");
    else {
      IvPDomain ivp_domain;
      ivp_domain = m_bundle_series.getDomain(m_curr_iter, m_curr_source);
      return(domainToString(ivp_domain, false));
    }
  }
  
  //-------------------------------------------------------------
  // Procedure: getCurrPlatform()
  
  string FV_Model::getCurrPlatform()
  {
    return(m_bundle_series_platform);
  }
  
  //-------------------------------------------------------------
  // Procedure: getQuadSet()
  
  QuadSet FV_Model::getQuadSet(bool dense)
  {
    m_ipf_mutex.Lock();
  
    QuadSet quadset;
    if(m_collective != "")
      quadset = m_bundle_series.getCollectiveQuadSet(m_curr_iter, m_collective);
    else
      quadset = m_bundle_series.getQuadSet(m_curr_iter, m_curr_source, dense);
    
    m_ipf_mutex.UnLock();
  
    quadset.normalize(0,200);
    quadset.applyColorMap(m_color_map);
    return(quadset);
  }
  
  
  
  
  
  