/home/rex/ebltrunk/core/libeblearn/include/bbox.h

/***************************************************************************
 *   Copyright (C) 2010 by Pierre Sermanet *
 *   pierre.sermanet@gmail.com *
 *   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Redistribution under a license not approved by the Open Source
 *       Initiative (http://www.opensource.org) must display the
 *       following acknowledgement in all advertising material:
 *        This product includes software developed at the Courant
 *        Institute of Mathematical Sciences (http://cims.nyu.edu).
 *     * The names of the authors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ThE AUTHORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ***************************************************************************/

#ifndef BBOX_H_
#define BBOX_H_

#include "libidx.h"

namespace ebl {

  enum t_bbox_saving { bbox_none = 0, bbox_all = 1,
                       bbox_eblearn = 2, bbox_caltech = 3,
                       bbox_class = 4};

  // bbox //////////////////////////////////////////////////////////////////////

  class EXPORT bbox : public rect<float>, public smart_pointer {
  public:
    bbox();
    bbox(float h0, float w0, float height, float width);
    bbox(const bbox &other);
    virtual ~bbox();

    static void init_instance_id();
    void new_instance_id();
    void accumulate(bbox &b);
    void mul(float d);

    // printing ////////////////////////////////////////////////////////////////

    string pretty(vector<string> *labels = NULL);

    // member variables ////////////////////////////////////////////////////////
  public:
    int         class_id;       
    float       confidence;     
    uint        nacc;           
    // original map //////////////////////////////////////////////
    using rect<float>::h0;      
    using rect<float>::w0;      
    using rect<float>::height;  
    using rect<float>::width;   
    // scale /////////////////////////////////////////////////
    double      scaleh;         
    double      scalew;         
    int         iscale_index;   
    int         oscale_index;   
    // input map /////////////////////////////////////////////////
    rect<float> i;        
    vector<rect<float> > mi;        
    rect<float> i0;        
    int iheight;        
    int iwidth;         
    // output map ////////////////////////////////////////////////
    rect<int> o;        
    int oheight;        
    int owidth;         
    svector<bbox> children; 

  protected:
    uint instance_id;    //<! A unique id for this bbox.
    static uint iid_cnt;    //<! A unique id for this bbox.
  };

  class EXPORT bbox_parts : public bbox {
  public:
    bbox_parts();
    bbox_parts(const bbox &other);
    bbox_parts(const bbox_parts &other);
    virtual ~bbox_parts();
    void add_part(const bbox &p);
    void add_part(const bbox_parts &p);
    bool share_parts(bbox_parts &bbp);
    vector<bbox_parts>& get_parts();
  protected:
    vector<bbox_parts> parts;
  };

  EXPORT bbox mean_bbox(vector<bbox*> &boxes, float bonus_per_bbox,
                        int classid);

  EXPORT std::ostream& operator<<(std::ostream& out, const bbox& b);
  EXPORT string& operator<<(string& s, const bbox& b);

  // bboxes ////////////////////////////////////////////////////////////////////

  class EXPORT bboxes : public svector<bbox> {
  public:
    bboxes(t_bbox_saving saving_type = bbox_all, string *outdir_ = NULL,
           std::ostream &out = std::cout, std::ostream &err = std::cerr);
    virtual ~bboxes();

    void new_group(idxdim &dims, string *name = NULL,
                          int index = -1);

    bboxes* get_group(const string &name);

    idxdim get_group_dims(const string &name);

    void add(bbox *b, idxdim &dims, string *name = NULL, int index = -1);
    void add(bbox &b, idxdim &dims, string *name = NULL, int index = -1);
    void add(bboxes &bbs, idxdim &dims, string *name = NULL, int index = -1);
    void add(vector<bbox> &bbs, idxdim &dims, string *name = NULL,
             int index = -1);
    bboxes exclude(bboxes &other);

    // loading /////////////////////////////////////////////////////////////////

    void load_eblearn(const string &filename);

    // saving //////////////////////////////////////////////////////////////////

    void save(string *dir = NULL);
    void save_eblearn(string *dir = NULL);
    void save_caltech(string *dir = NULL);
    void save_class(string *dir = NULL);

    // sorting /////////////////////////////////////////////////////////////////

    void sort_by_confidence();
    template <typename T>
      void sort_by_difference(svector<midx<T> >& inputs);
    bbox *get_most_confident();
    bboxes get_most_confidents();

    // scaling /////////////////////////////////////////////////////////////////

    void normalize_widths(float woverh);
    void scale_centered(float hfact, float wfact);

    // thresholding ////////////////////////////////////////////////////////////

    void threshold(float threshold);

    // printing ////////////////////////////////////////////////////////////////

    string describe();
    void print();
    void print_saving_type();
    string pretty(vector<string> *labels = NULL);
    string pretty_short(vector<string> &labels);
    string str();

    // member variables ////////////////////////////////////////////////////////
  private:
    std::ostream                *mout;  
    std::ostream                *merr;  
    vector<svector<bbox>*>       grouped_boxes;
    vector<string>               group_names;
    vector<idxdim>               group_dims;
    string                       outdir;
    t_bbox_saving                saving_type;
  };

} // end namespace ebl

#include "bbox.hpp"

#endif /* BBOX_H_ */