rectangle.cpp

Go to the documentation of this file.

#ifndef RECTANGLE_IMPLEMENTATION
#define RECTANGLE_IMPLEMENTATION

/*****************************************************************************\
*                                                                             *
*  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.cpp"
#include "rectangle.h"

#include <basis/function.h>

namespace geometric {

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 minimum(_vertex_1.x(), _vertex_2.x()); }

template <class numeric_type>
numeric_type rectangle<numeric_type>::minimum_y() const
{ return minimum(_vertex_1.y(), _vertex_2.y()); }

template <class numeric_type>
numeric_type rectangle<numeric_type>::maximum_x() const
{ return maximum(_vertex_1.x(), _vertex_2.x()); }

template <class numeric_type>
numeric_type rectangle<numeric_type>::maximum_y() const
{ return 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();
  flip_increasing(x1, x2);
  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>
bool rectangle<numeric_type>::operator != (const rectangle &to_compare) const
{ return (bool)!(*this == to_compare); }

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>
void rectangle<contents>::pack(byte_array &packed_form) const
{
  _vertex_1.pack(packed_form);
  _vertex_2.pack(packed_form);
}

template <class contents>
bool rectangle<contents>::unpack(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>(maximum(minimum_x(), r2.minimum_x()),
      maximum(minimum_y(), r2.minimum_y()),
      minimum(maximum_x(), r2.maximum_x()),
      minimum(maximum_y(), r2.maximum_y()));
  return true;
}

template <class numeric_type>
istring rectangle<numeric_type>::text_form() const
{
  return istring("[") + _vertex_1.text_form() + istring(" ")
      + _vertex_2.text_form() + istring("]");
}

template <class numeric_type>
bool rectangle<numeric_type>::from_text(const istring &_text)
{
  numeric_type nums[4] = { 0, 0, 0, 0 };
  // setup the scanning specifier.
  istring spec(numeric_specifier(nums[0]));
  // scan the string for values.
  istring 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

---