rectangle.h

Go to the documentation of this file.

#ifndef RECTANGLE_CLASS
#define RECTANGLE_CLASS
 
/*****************************************************************************\
*                                                                             *
*  Name   : rectangle                                                         *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1992-$now By Author.  This program 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 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/
 
#include "point.h"
 
#include <basis/functions.h>
 
namespace geometric {
 
 
template <class numeric_type>
class rectangle : public basis::packable
{
public:
  rectangle(const point<numeric_type> &vertex_1,
          const point<numeric_type> &vertex_2);
  rectangle(numeric_type x_1 = 0, numeric_type y_1 = 0,
          numeric_type x_2 = 0, numeric_type y_2 = 0);
 
  numeric_type height() const;
  numeric_type width() const;
 
  rectangle order() const;
 
  point<numeric_type> top_left() const;
  point<numeric_type> bottom_left() const;
  point<numeric_type> top_right() const;
  point<numeric_type> bottom_right() const;
 
  numeric_type minimum_x() const;
  numeric_type minimum_y() const;
  numeric_type maximum_x() const;
  numeric_type maximum_y() const;
 
  point<numeric_type> center() const;
 
  bool inside(const point<numeric_type> &to_check) const;
 
  bool operator == (const rectangle &to_compare) const;
 
  rectangle operator + (const point<numeric_type> &to_add) const;
  rectangle operator - (const point<numeric_type> &to_subtract) const;
 
  rectangle &operator += (const point<numeric_type> &to_add);
  rectangle &operator -= (const point<numeric_type> &to_subtract);
 
  void encompass(const rectangle &to_adjust_to);
 
  bool intersect(const rectangle &r2) const;
 
  bool disjoint(const rectangle &r2) const;
 
  bool join_intersecting(const rectangle &r2, rectangle &result);
 
  bool intersection(const rectangle &r2, rectangle &result);
 
  basis::astring text_form() const;
 
  bool from_text(const basis::astring &text);
 
  point<numeric_type> vertex_1() const;
  point<numeric_type> vertex_2() const;
 
  void vertex_1(const point<numeric_type> &to_set);
  void vertex_2(const point<numeric_type> &to_set);
 
  virtual int packed_size() const;
  virtual void pack(basis::byte_array &packed_form) const;
  virtual bool unpack(basis::byte_array &packed_form);
 
protected:
  point<numeric_type> _vertex_1;
  point<numeric_type> _vertex_2;
};
 
 
 
typedef rectangle<int> int_rectangle;
 
 
// implementations below...
 
template <class numeric_type>
rectangle<numeric_type>::rectangle(const point<numeric_type> &lb, const point<numeric_type> &rt)
: _vertex_1(lb), _vertex_2(rt) {}
 
template <class numeric_type>
rectangle<numeric_type>::rectangle(numeric_type left, numeric_type bottom, numeric_type right, numeric_type top)
: _vertex_1(point<numeric_type>(left, bottom)),
  _vertex_2(point<numeric_type>(right, top)) {}
 
template <class numeric_type>
point<numeric_type> rectangle<numeric_type>::vertex_1() const
{ return _vertex_1; }
 
template <class numeric_type>
point<numeric_type> rectangle<numeric_type>::vertex_2() const
{ return _vertex_2; }
 
template <class numeric_type>
void rectangle<numeric_type>::vertex_1(const point<numeric_type> &to_set)
{ _vertex_1 = to_set; }
 
template <class numeric_type>
void rectangle<numeric_type>::vertex_2(const point<numeric_type> &to_set)
{ _vertex_2 = to_set; }
 
template <class numeric_type>
numeric_type rectangle<numeric_type>::height() const
{ return absolute_value(_vertex_2.y() - _vertex_1.y()); }
 
template <class numeric_type>
numeric_type rectangle<numeric_type>::width() const
{ return absolute_value(_vertex_2.x() - _vertex_1.x()); }
 
template <class numeric_type>
numeric_type rectangle<numeric_type>::minimum_x() const
{ return basis::minimum(_vertex_1.x(), _vertex_2.x()); }
 
template <class numeric_type>
numeric_type rectangle<numeric_type>::minimum_y() const
{ return basis::minimum(_vertex_1.y(), _vertex_2.y()); }
 
template <class numeric_type>
numeric_type rectangle<numeric_type>::maximum_x() const
{ return basis::maximum(_vertex_1.x(), _vertex_2.x()); }
 
template <class numeric_type>
numeric_type rectangle<numeric_type>::maximum_y() const
{ return basis::maximum(_vertex_1.y(), _vertex_2.y()); }
 
template <class numeric_type>
rectangle<numeric_type> rectangle<numeric_type>::order() const
{
  numeric_type x1 = _vertex_1.x();
  numeric_type x2 = _vertex_2.x();
  numeric_type y1 = _vertex_1.y();
  numeric_type y2 = _vertex_2.y();
  basis::flip_increasing(x1, x2);
  basis::flip_increasing(y1, y2);
  return rectangle<numeric_type>(x1, y1, x2, y2);
}
 
template <class numeric_type>
point<numeric_type> rectangle<numeric_type>::top_left() const
{
  rectangle temp(order());
  return point<numeric_type>(temp.vertex_1().x(), temp.vertex_2().y());
}
 
template <class numeric_type>
point<numeric_type> rectangle<numeric_type>::bottom_left() const
{
  rectangle temp(order());
  return point<numeric_type>(temp.vertex_1().x(), temp.vertex_1().y());
}
 
template <class numeric_type>
point<numeric_type> rectangle<numeric_type>::top_right() const
{
  rectangle temp(order());
  return point<numeric_type>(temp.vertex_2().x(), temp.vertex_2().y());
}
 
template <class numeric_type>
point<numeric_type> rectangle<numeric_type>::bottom_right() const
{
  rectangle temp(order());
  return point<numeric_type>(temp.vertex_2().x(), temp.vertex_1().y());
}
 
template <class numeric_type>
point<numeric_type> rectangle<numeric_type>::center() const
{
  return point<numeric_type>(numeric_type((_vertex_1.x()
      + _vertex_2.x()) / 2.0), numeric_type((_vertex_1.y()
      + _vertex_2.y()) / 2.0));
}
 
template <class numeric_type>
bool rectangle<numeric_type>::inside(const point<numeric_type> &to_check) const
{
  rectangle<numeric_type> ordered_me = this->order();
  return bool( (to_check.x() >= ordered_me._vertex_1.x())
    && (to_check.x() <= ordered_me._vertex_2.x())
    && (to_check.y() >= ordered_me._vertex_1.y())
    && (to_check.y() <= ordered_me._vertex_2.y()) );
}
 
template <class numeric_type>
bool rectangle<numeric_type>::operator == (const rectangle &to_compare) const
{
  point<numeric_type> min1(minimum_x(), minimum_y());
  point<numeric_type> max1(maximum_x(), maximum_y());
  point<numeric_type> min2(to_compare.minimum_x(), to_compare.minimum_y());
  point<numeric_type> max2(to_compare.maximum_x(), to_compare.maximum_y());
  if ( (min1 == min2) && (max1 == max2) ) return true;
  else return false;
}
 
template <class numeric_type>
rectangle<numeric_type> &rectangle<numeric_type>::operator += (const point<numeric_type> &p)
{ _vertex_1 += p; _vertex_2 += p; return *this; }
 
template <class numeric_type>
rectangle<numeric_type> &rectangle<numeric_type>::operator -= (const point<numeric_type> &p)
{ _vertex_1 -= p; _vertex_2 -= p; return *this; }
 
template <class numeric_type>
rectangle<numeric_type> rectangle<numeric_type>::operator + (const point<numeric_type> &p) const
{
  rectangle to_return(*this);
  to_return += p;
  return to_return;
}
 
template <class contents>
int rectangle<contents>::packed_size() const
{
  basis::byte_array temp;
//hmmm: inefficient!
  pack(temp);
  return temp.length();
}
 
template <class contents>
void rectangle<contents>::pack(basis::byte_array &packed_form) const
{
  _vertex_1.pack(packed_form);
  _vertex_2.pack(packed_form);
}
 
template <class contents>
bool rectangle<contents>::unpack(basis::byte_array &packed_form)
{
  if (!_vertex_1.unpack(packed_form)) return false;
  if (!_vertex_2.unpack(packed_form)) return false;
  return true;
}
 
template <class numeric_type>
rectangle<numeric_type> rectangle<numeric_type>::operator - (const point<numeric_type> &p) const
{
  rectangle to_return(*this);
  to_return -= p;
  return to_return;
}
 
template <class numeric_type>
void rectangle<numeric_type>::encompass(const rectangle &to_adjust_to)
{
  if (to_adjust_to._vertex_1.x() < _vertex_1.x())
    _vertex_1.set(to_adjust_to._vertex_1.x(), _vertex_1.y());
  if (to_adjust_to._vertex_1.y() < _vertex_1.y())
    _vertex_1.set(_vertex_1.x(), to_adjust_to._vertex_1.y());
  if (to_adjust_to._vertex_2.x() > _vertex_2.x())
    _vertex_2.set(to_adjust_to._vertex_2.x(), _vertex_2.y());
  if (to_adjust_to._vertex_2.y() > _vertex_2.y())
    _vertex_2.set(_vertex_2.x(), to_adjust_to._vertex_2.y());
}
 
template <class numeric_type>
bool rectangle<numeric_type>::disjoint(const rectangle &r2) const
{
  if ( (maximum_x() < r2.minimum_x())
      || (minimum_x() > r2.maximum_x())
      || (maximum_y() < r2.minimum_y())
      || (minimum_y() > r2.maximum_y()) ) return true;
  else return false;
}
 
template <class numeric_type>
bool rectangle<numeric_type>::intersect(const rectangle &r2) const
{ return bool(!disjoint(r2)); }
 
template <class numeric_type>
bool rectangle<numeric_type>::join_intersecting(const rectangle &r2, rectangle &result)
{
  if (disjoint(r2)) return false;
  result = *this;
  result.encompass(r2);
  return true;
}
 
template <class numeric_type>
bool rectangle<numeric_type>::intersection(const rectangle &r2, rectangle &result)
{
  if (disjoint(r2)) return false;
  result = rectangle<numeric_type>(basis::maximum(minimum_x(), r2.minimum_x()),
      basis::maximum(minimum_y(), r2.minimum_y()),
      basis::minimum(maximum_x(), r2.maximum_x()),
      basis::minimum(maximum_y(), r2.maximum_y()));
  return true;
}
 
template <class numeric_type>
basis::astring rectangle<numeric_type>::text_form() const
{
  return basis::astring("[") + _vertex_1.text_form() + basis::astring(" ")
      + _vertex_2.text_form() + basis::astring("]");
}
 
template <class numeric_type>
bool rectangle<numeric_type>::from_text(const basis::astring &_text)
{
  numeric_type nums[4] = { 0, 0, 0, 0 };
  // setup the scanning specifier.
  basis::astring spec(numeric_specifier(nums[0]));
  // scan the string for values.
  basis::astring text(_text);
  for (int i = 0; i < 4; i++) {
    text = crop_non_numeric(text);
    nums[i] = text.convert(nums[i]);
    text = crop_numeric(text);
  }
  vertex_1(point<numeric_type>(nums[0], nums[1]));
  vertex_2(point<numeric_type>(nums[2], nums[3]));
  return true;
}
 
} // namespace.
 
#endif