source: trunk/lib/classifier/Target.cc @ 514

// $Id: Target.cc 514 2006-02-20 09:45:34Z peter $

#include <c++_tools/classifier/Target.h>
#include <c++_tools/utility/stl_utility.h>
#include <c++_tools/utility/utility.h>

#include <cassert>
#include <iostream>
#include <map>
#include <string>
#include <sstream>
#include <utility>
#include <vector>

namespace theplu {
namespace classifier {

  Target::Target(const std::vector<std::string>& label)
  {
    init(label);
  }
  
  Target::Target(const Target& t, 
                 const std::vector<size_t>& index)
    : class_map_(t.class_map_)
  {
    binary_.resize(index.size());
    classes_.resize(index.size());
    for (size_t i=0; i<index.size(); i++) {
      assert(index[i]<t.size());
      classes_[i]=t.classes_[index[i]];
      binary_[i]=t.binary_[index[i]];
    }
    labels_ = t.labels_;
  }


  Target::Target(std::istream& is, char sep) 
    throw (utility::IO_error,std::exception)
  {
    std::vector<std::string> vec;
    std::string word;
    bool ok=true;
    while(ok) {
      if(sep=='\0')
        ok=(is>>word);
      else 
        ok=getline(is, word, sep);

      // ignore empty words
      if (!word.size() || !ok )
        continue;
      
      vec.push_back(word);
    }

    // manipulate the state of the stream to be good
    is.clear(std::ios::goodbit);

    init(vec);
  }
  
  Target::~Target(void)
  {
  }

  void Target::init(const std::vector<std::string>& label) 
  {
    classes_.clear();
    classes_.reserve(label.size());
    class_map_.clear();
    labels_.clear();
    
    for (size_t i=0; i<label.size(); i++) {
      std::map<std::string,size_t>::iterator iter = 
        class_map_.lower_bound(label[i]);

      // label in map
      if (iter != class_map_.end() && 
          !(class_map_.key_comp()(label[i],iter->first)) ){

        classes_.push_back(iter->second);
      }
      // label not found in map
      else{
        classes_.push_back(class_map_.size());
        class_map_.insert(iter, std::make_pair(label[i],classes_[i])); 
        labels_.push_back(label[i]);
      }
    }
    // setting binary to false for every class
    binary_=std::vector<short>(label.size(),0);
    
    set_binary(0,true);

  }

  //  const Target& Target::operator=(const Target& other)
  //{
  //  classes_=other.classes_;    
  //  class_map_=other.class_map_;    
  //  labels_=other.labels_;
  //  return *this;
  //}

  void Target::set_binary(const size_t target, const bool b)
  {
    for (size_t i=0; i<classes_.size(); i++)
      if (classes_[i]==target)
        binary_[i]=b;
  }


  std::ostream& operator<<(std::ostream& s, const Target& a)
  {
    for (size_t j = 0; j < a.size(); ++j) {
      s << a(j);
      if ( (j+1)<a.size() )
        s << " ";
    }

    return s;
  }


}} // of namespace classifier and namespace theplu