CRect.h

Go to the documentation of this file.

/* Copyright (C) 2002 Dominic Letourneau (dominic.letourneau@usherbrooke.ca)

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
   This library 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
   Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifndef _MY_CRECT_
#define _MY_CRECT_

#include "math.h"
#include <vector>
#include <list>
#include <stdlib.h>
#include <stdio.h>
#include "Object.h"
#include "CPoint.h"
#include "Cell.h"

namespace RobotFlow {

/** CRect.

    A CRect is a rectangle defined by its upper left corner and its lower
    right corner and contains ImageCell elements of multiple lines.
        
    @author  Dominic Letourneau
    @version $Revision: 1.7 $
    \begin{verbatim}
    Creation         : 23/02/2001
    Last Modification: $Date: 2005/03/29 15:20:47 $
    \end{verbatim}
*/
class CRect : public FD::Object {
    
 public:

  /**
     Ctor default with (x1,y1,x2,y2) = (0,0,0,0)
  */
  CRect();

  /**
     Ctor with corner values
     @param x1 ulx
     @param y1 uly
     @param x2 lrx
     @param y2 lry
  */
  CRect(int x1, int y1, int x2, int y2);


  /**
     Copy ctor
     @param r The CRect to copy 
  */
  CRect(const CRect& r);

  /**
     Ctor with CPoints for ulc and lrc
     @param p1 ulc
     @param p2 lrc
  */
  CRect(CPoint& p1,CPoint& p2);

  /**
     Dtor Destructor
  */
  virtual ~CRect();

  /**
     Cleanup for unused cells
  */
  void cell_cleanup();

  /**
     Intersection between two CRect
     @param inter the CRect we are doing intersection with (destination)
     @param rect2 the Crect we are doing intersectino with (source)
  */
  void IntersectRect(CRect &inter,const CRect &rect2);
  
  /**
     Union between two CRect
     @param uni the CRect we are doing intersection with (destination)
     @param rect2 the Crect we are doing intersectino with (source)
  */
  void UnionRect(CRect &uni,const CRect &rect2);

  /**
     Sets the values of its coordinates
     @param p1 ulc
     @param p2 lrc

  */
  void SetRect(CPoint& p1,CPoint& p2);

  /**
     Verifies if the CRect is empty
     @return bool True if the CRect is empty
  */
  bool IsRectEmpty() const;

  /**
     Returns the height of the CRect
     @return int The height
  */
  int Height() const;

  /**
     Returns the width of the CRect
     @return int The width
  */
  int Width() const;

  /**
     Returns the mean of the cell width
     @return int the mean of the cell width
  */
  int MeanCellWidth(int* pCellMin, int* pCellMax, int nSize, int nWidthMax);


  /**
     Returns the mean cell width for a CRect
     @return int the mean_width
  */
  float MeanCellWidth();

  /**
     Returns the Area of the CRect. The Area is not the Area of the rectangle
     but what's contained in it. This is the area of all ImageCell put together
     that are added in the CRect.
     @return int Area
  */
  int Area () const;

  /**
     Returns the upper left corner
     @return CPoint The ulc
  */
  CPoint TopLeft();
  
  /**
     Returns the lower right corner
     @return CPoint The lrc
  */
  CPoint BottomRight();

  /**
     Verifies if two CRect are identical
     @return bool True if they are identical
  */
  bool operator==(const CRect &rect) const;

  /**
     Verifies if the area is smaller 
     @return bool True if smaller
  */
  bool operator < (const CRect & rect);
  
  /**
     Verifies if the area is larger
     @return bool True if larger
  */
  bool operator > (const CRect & rect);

  /**
     Assignation operator between two CRect
     @param  rect a CRect Instance to equals
     @return CRect& a CRect Instance
   */
  CRect& operator=(const CRect &rect);

  /**
     Adds a ImageCell to the CRect
     @param cell, The ImageCell to be added
     @param update, True if the area and the coordinates are to be updated
   */
  void add_cell(ImageCell *cell, bool update = false, bool serialized = false);
    
  /**
     Returns the list of cell in the CRect 
     @return list<ImageCell*>& The list of cells
   */
  std::list<ImageCell*>& get_cell_list();

  /**
     Sets the corner values of the CRect.
     @param x1 ulx
     @param y1 uly
     @param x2 lrx
     @param y2 lry
   */
  void set_values(int x1,int y1, int x2,int y2);

  /**
     Returns the coordinates of the upper left corner and the lower right corner
     @param x1 ulx
     @param y1 uly
     @param x2 lrx
     @param y2 lry
   */
  void get_values(int &x1,int &y1, int &x2,int &y2);
  
  /**
     Verifies if a Crect is inside another one
     @param rect The rect to verify
     @return bool true if the rect is inside
   */
  bool inside (CRect *rect);

  /**
     Calculates the center of gravity from the ImageCells
  */
  void center_of_gravity ();

  /**
     Gets the center of gravity. You must call center_of_gravity() first to calculate it.
     @param center_x the x center of gravity
     @param center_y the y center of gravity
   */
  void get_center_of_gravity(double &center_x, double &center_y);

  void printOn(std::ostream &out = std::cout) const;
  
  void readFrom(std::istream &in);

  /**
     Merge two CRect (adding cells)
     @param rect The rect to merge with
  */
  void merge(CRect *rect);

  /**
     Distance (cog to cog) of two CRect
     @return double the distance
  */
  double dist (CRect *rect);
 
  double dist (double x, double y);

 private:

  ///Center of gravity y
  double m_center_y;

  ///Center of gravity x
  double m_center_x;

  ///Area of the ImageCells
  int m_area;

  ///ulx
  int m_x1;

  ///uly
  int m_y1;

  ///lrx
  int m_x2;

  ///lry
  int m_y2;

  ///The list of cells
  std::list<ImageCell*> m_cell_list;

  ///The temp serialized cells list
  std::list<ImageCell*> m_serialized_list;
 
};
}//namespace RobotFlow
#endif

---