graphiq/library/geometric/rectangle.h

   1 #ifndef RECTANGLE_CLASS
   2 #define RECTANGLE_CLASS
   3
   4 /*****************************************************************************\
   5 *                                                                             *
   6 *  Name   : rectangle                                                         *
   7 *  Author : Chris Koeritz                                                     *
   8 *                                                                             *
   9 *******************************************************************************
  10 * Copyright (c) 1992-$now By Author.  This program is free software; you can  *
  11 * redistribute it and/or modify it under the terms of the GNU General Public  *
  12 * License as published by the Free Software Foundation; either version 2 of   *
  13 * the License or (at your option) any later version.  This is online at:      *
  14 *     http://www.fsf.org/copyleft/gpl.html                                    *
  15 * Please send any updates to: fred@gruntose.com                               *
  16 \*****************************************************************************/
  17
  18 #include "point.h"
  19
  20 #include <basis/functions.h>
  21
  22 namespace geometric {
  23
  24 //! Represents a geometric rectangle.
  25
  26 template <class numeric_type>
  27 class rectangle : public basis::packable
  28 {
  29 public:
  30   rectangle(const point<numeric_type> &vertex_1,
  31           const point<numeric_type> &vertex_2);
  32   rectangle(numeric_type x_1 = 0, numeric_type y_1 = 0,
  33           numeric_type x_2 = 0, numeric_type y_2 = 0);
  34
  35   numeric_type height() const;
  36   numeric_type width() const;
  37
  38   rectangle order() const;
  39     //!< Re-orders the vertices of the line to be increasing.
  40     /*!< Orients the vertices such that the x and y coordinates of the first
  41     vertex are respectively closer to the origin than the x and y
  42     coordinates of the second vertex (or they are equidistant). */
  43
  44   point<numeric_type> top_left() const;
  45   point<numeric_type> bottom_left() const;
  46   point<numeric_type> top_right() const;
  47   point<numeric_type> bottom_right() const;
  48     //!< returns the appropriate point as represented by our rectangle.
  49     /*!< note that these are with respect to a normal cartesian coordinate
  50     system.  if you want points for a screen based coordinate system (with
  51     the origin in the top left), then bottom_left and top_right return the
  52     appropriate bounding points for that rectangle. */
  53
  54   numeric_type minimum_x() const;
  55     //!< Return the smallest x from the points in the rectangle.
  56   numeric_type minimum_y() const;
  57     //!< Return the smallest y from the points in the rectangle.
  58   numeric_type maximum_x() const;
  59     //!< Return the largest x from the points in the rectangle.
  60   numeric_type maximum_y() const;
  61     //!< Return the largest y from the points in the rectangle.
  62
  63   point<numeric_type> center() const;
  64     //!< Returns the point at the center of the rectangle.
  65
  66   bool inside(const point<numeric_type> &to_check) const;
  67     //!< Returns true if `to_check' is inside `this' rectangle.
  68
  69   bool operator == (const rectangle &to_compare) const;
  70     //!< Returns true if `to_compare' has vertices equal to `this'.
  71
  72   rectangle operator + (const point<numeric_type> &to_add) const;
  73     //!< Returns the rectangle resulting from adding a point to its vertices.
  74   rectangle operator - (const point<numeric_type> &to_subtract) const;
  75     //!< Returns the rectangle resulting from subtracting "to_subtract".
  76
  77   rectangle &operator += (const point<numeric_type> &to_add);
  78     //!< Adds the point "to_add" to our vertices.
  79   rectangle &operator -= (const point<numeric_type> &to_subtract);
  80     //!< Subtracts the point "to_add" to our vertices.
  81
  82   void encompass(const rectangle &to_adjust_to);
  83     //!< Finds the largest dimension needed to contain all rectangles passed in.
  84     /*!< The original dimension of `this' rectangle is compared with
  85     all subsequent rectangles passed to adjust_dimension, and it is
  86     modified (joined with `to_adjust_to') if the extent of `to_adjust_to'
  87     is greater or lesser than the current extent of `this' rectangle. */
  88
  89   bool intersect(const rectangle &r2) const;
  90     //!< Returns true if `this' & `r2' cover any common points.
  91
  92   bool disjoint(const rectangle &r2) const;
  93     //!< Returns true if `this' & `r2' have mutually exclusive extents.
  94
  95   bool join_intersecting(const rectangle &r2, rectangle &result);
  96     //!< Sets "result" to encompass this and "r2" if they intersect.
  97     /*!< If `this' and `r2' intersect, `result' is adjusted to their dimension
  98     and true is returned.  If not, false is returned and `result' is
  99     undefined. */
 100
 101   bool intersection(const rectangle &r2, rectangle &result);
 102     //!< Sets "result" to the intersection of this and "r2".
 103     /*!< If `this' and `r2' intersect, then `result' is set to their
 104     intersecting extent and true is returned.  If not, then false is returned
 105     and `result' is undefined. */
 106
 107   basis::astring text_form() const;
 108     //!< Prints out the contents of the rectangle.
 109
 110   bool from_text(const basis::astring &text);
 111     //!< Returns true if the "text" is parsed into this rectangle.
 112
 113   point<numeric_type> vertex_1() const;
 114   point<numeric_type> vertex_2() const;
 115
 116   void vertex_1(const point<numeric_type> &to_set);
 117   void vertex_2(const point<numeric_type> &to_set);
 118
 119   virtual int packed_size() const;
 120   virtual void pack(basis::byte_array &packed_form) const;
 121   virtual bool unpack(basis::byte_array &packed_form);
 122
 123 protected:
 124   point<numeric_type> _vertex_1;
 125   point<numeric_type> _vertex_2;
 126 };
 127
 128 //////////////
 129
 130 //!< A commonly used rectangle of integers.
 131
 132 typedef rectangle<int> int_rectangle;
 133
 134 //////////////
 135
 136 // implementations below...
 137
 138 template <class numeric_type>
 139 rectangle<numeric_type>::rectangle(const point<numeric_type> &lb, const point<numeric_type> &rt)
 140 : _vertex_1(lb), _vertex_2(rt) {}
 141
 142 template <class numeric_type>
 143 rectangle<numeric_type>::rectangle(numeric_type left, numeric_type bottom, numeric_type right, numeric_type top)
 144 : _vertex_1(point<numeric_type>(left, bottom)),
 145   _vertex_2(point<numeric_type>(right, top)) {}
 146
 147 template <class numeric_type>
 148 point<numeric_type> rectangle<numeric_type>::vertex_1() const
 149 { return _vertex_1; }
 150
 151 template <class numeric_type>
 152 point<numeric_type> rectangle<numeric_type>::vertex_2() const
 153 { return _vertex_2; }
 154
 155 template <class numeric_type>
 156 void rectangle<numeric_type>::vertex_1(const point<numeric_type> &to_set)
 157 { _vertex_1 = to_set; }
 158
 159 template <class numeric_type>
 160 void rectangle<numeric_type>::vertex_2(const point<numeric_type> &to_set)
 161 { _vertex_2 = to_set; }
 162
 163 template <class numeric_type>
 164 numeric_type rectangle<numeric_type>::height() const
 165 { return absolute_value(_vertex_2.y() - _vertex_1.y()); }
 166
 167 template <class numeric_type>
 168 numeric_type rectangle<numeric_type>::width() const
 169 { return absolute_value(_vertex_2.x() - _vertex_1.x()); }
 170
 171 template <class numeric_type>
 172 numeric_type rectangle<numeric_type>::minimum_x() const
 173 { return basis::minimum(_vertex_1.x(), _vertex_2.x()); }
 174
 175 template <class numeric_type>
 176 numeric_type rectangle<numeric_type>::minimum_y() const
 177 { return basis::minimum(_vertex_1.y(), _vertex_2.y()); }
 178
 179 template <class numeric_type>
 180 numeric_type rectangle<numeric_type>::maximum_x() const
 181 { return basis::maximum(_vertex_1.x(), _vertex_2.x()); }
 182
 183 template <class numeric_type>
 184 numeric_type rectangle<numeric_type>::maximum_y() const
 185 { return basis::maximum(_vertex_1.y(), _vertex_2.y()); }
 186
 187 template <class numeric_type>
 188 rectangle<numeric_type> rectangle<numeric_type>::order() const
 189 {
 190   numeric_type x1 = _vertex_1.x();
 191   numeric_type x2 = _vertex_2.x();
 192   numeric_type y1 = _vertex_1.y();
 193   numeric_type y2 = _vertex_2.y();
 194   basis::flip_increasing(x1, x2);
 195   basis::flip_increasing(y1, y2);
 196   return rectangle<numeric_type>(x1, y1, x2, y2);
 197 }
 198
 199 template <class numeric_type>
 200 point<numeric_type> rectangle<numeric_type>::top_left() const
 201 {
 202   rectangle temp(order());
 203   return point<numeric_type>(temp.vertex_1().x(), temp.vertex_2().y());
 204 }
 205
 206 template <class numeric_type>
 207 point<numeric_type> rectangle<numeric_type>::bottom_left() const
 208 {
 209   rectangle temp(order());
 210   return point<numeric_type>(temp.vertex_1().x(), temp.vertex_1().y());
 211 }
 212
 213 template <class numeric_type>
 214 point<numeric_type> rectangle<numeric_type>::top_right() const
 215 {
 216   rectangle temp(order());
 217   return point<numeric_type>(temp.vertex_2().x(), temp.vertex_2().y());
 218 }
 219
 220 template <class numeric_type>
 221 point<numeric_type> rectangle<numeric_type>::bottom_right() const
 222 {
 223   rectangle temp(order());
 224   return point<numeric_type>(temp.vertex_2().x(), temp.vertex_1().y());
 225 }
 226
 227 template <class numeric_type>
 228 point<numeric_type> rectangle<numeric_type>::center() const
 229 {
 230   return point<numeric_type>(numeric_type((_vertex_1.x()
 231       + _vertex_2.x()) / 2.0), numeric_type((_vertex_1.y()
 232       + _vertex_2.y()) / 2.0));
 233 }
 234
 235 template <class numeric_type>
 236 bool rectangle<numeric_type>::inside(const point<numeric_type> &to_check) const
 237 {
 238   rectangle<numeric_type> ordered_me = this->order();
 239   return bool( (to_check.x() >= ordered_me._vertex_1.x())
 240     && (to_check.x() <= ordered_me._vertex_2.x())
 241     && (to_check.y() >= ordered_me._vertex_1.y())
 242     && (to_check.y() <= ordered_me._vertex_2.y()) );
 243 }
 244
 245 template <class numeric_type>
 246 bool rectangle<numeric_type>::operator == (const rectangle &to_compare) const
 247 {
 248   point<numeric_type> min1(minimum_x(), minimum_y());
 249   point<numeric_type> max1(maximum_x(), maximum_y());
 250   point<numeric_type> min2(to_compare.minimum_x(), to_compare.minimum_y());
 251   point<numeric_type> max2(to_compare.maximum_x(), to_compare.maximum_y());
 252   if ( (min1 == min2) && (max1 == max2) ) return true;
 253   else return false;
 254 }
 255
 256 template <class numeric_type>
 257 rectangle<numeric_type> &rectangle<numeric_type>::operator += (const point<numeric_type> &p)
 258 { _vertex_1 += p; _vertex_2 += p; return *this; }
 259
 260 template <class numeric_type>
 261 rectangle<numeric_type> &rectangle<numeric_type>::operator -= (const point<numeric_type> &p)
 262 { _vertex_1 -= p; _vertex_2 -= p; return *this; }
 263
 264 template <class numeric_type>
 265 rectangle<numeric_type> rectangle<numeric_type>::operator + (const point<numeric_type> &p) const
 266 {
 267   rectangle to_return(*this);
 268   to_return += p;
 269   return to_return;
 270 }
 271
 272 template <class contents>
 273 int rectangle<contents>::packed_size() const
 274 {
 275   basis::byte_array temp;
 276 //hmmm: inefficient!
 277   pack(temp);
 278   return temp.length();
 279 }
 280
 281 template <class contents>
 282 void rectangle<contents>::pack(basis::byte_array &packed_form) const
 283 {
 284   _vertex_1.pack(packed_form);
 285   _vertex_2.pack(packed_form);
 286 }
 287
 288 template <class contents>
 289 bool rectangle<contents>::unpack(basis::byte_array &packed_form)
 290 {
 291   if (!_vertex_1.unpack(packed_form)) return false;
 292   if (!_vertex_2.unpack(packed_form)) return false;
 293   return true;
 294 }
 295
 296 template <class numeric_type>
 297 rectangle<numeric_type> rectangle<numeric_type>::operator - (const point<numeric_type> &p) const
 298 {
 299   rectangle to_return(*this);
 300   to_return -= p;
 301   return to_return;
 302 }
 303
 304 template <class numeric_type>
 305 void rectangle<numeric_type>::encompass(const rectangle &to_adjust_to)
 306 {
 307   if (to_adjust_to._vertex_1.x() < _vertex_1.x())
 308     _vertex_1.set(to_adjust_to._vertex_1.x(), _vertex_1.y());
 309   if (to_adjust_to._vertex_1.y() < _vertex_1.y())
 310     _vertex_1.set(_vertex_1.x(), to_adjust_to._vertex_1.y());
 311   if (to_adjust_to._vertex_2.x() > _vertex_2.x())
 312     _vertex_2.set(to_adjust_to._vertex_2.x(), _vertex_2.y());
 313   if (to_adjust_to._vertex_2.y() > _vertex_2.y())
 314     _vertex_2.set(_vertex_2.x(), to_adjust_to._vertex_2.y());
 315 }
 316
 317 template <class numeric_type>
 318 bool rectangle<numeric_type>::disjoint(const rectangle &r2) const
 319 {
 320   if ( (maximum_x() < r2.minimum_x())
 321       || (minimum_x() > r2.maximum_x())
 322       || (maximum_y() < r2.minimum_y())
 323       || (minimum_y() > r2.maximum_y()) ) return true;
 324   else return false;
 325 }
 326
 327 template <class numeric_type>
 328 bool rectangle<numeric_type>::intersect(const rectangle &r2) const
 329 { return bool(!disjoint(r2)); }
 330
 331 template <class numeric_type>
 332 bool rectangle<numeric_type>::join_intersecting(const rectangle &r2, rectangle &result)
 333 {
 334   if (disjoint(r2)) return false;
 335   result = *this;
 336   result.encompass(r2);
 337   return true;
 338 }
 339
 340 template <class numeric_type>
 341 bool rectangle<numeric_type>::intersection(const rectangle &r2, rectangle &result)
 342 {
 343   if (disjoint(r2)) return false;
 344   result = rectangle<numeric_type>(basis::maximum(minimum_x(), r2.minimum_x()),
 345       basis::maximum(minimum_y(), r2.minimum_y()),
 346       basis::minimum(maximum_x(), r2.maximum_x()),
 347       basis::minimum(maximum_y(), r2.maximum_y()));
 348   return true;
 349 }
 350
 351 template <class numeric_type>
 352 basis::astring rectangle<numeric_type>::text_form() const
 353 {
 354   return basis::astring("[") + _vertex_1.text_form() + basis::astring(" ")
 355       + _vertex_2.text_form() + basis::astring("]");
 356 }
 357
 358 template <class numeric_type>
 359 bool rectangle<numeric_type>::from_text(const basis::astring &_text)
 360 {
 361   numeric_type nums[4] = { 0, 0, 0, 0 };
 362   // setup the scanning specifier.
 363   basis::astring spec(numeric_specifier(nums[0]));
 364   // scan the string for values.
 365   basis::astring text(_text);
 366   for (int i = 0; i < 4; i++) {
 367     text = crop_non_numeric(text);
 368     nums[i] = text.convert(nums[i]);
 369     text = crop_numeric(text);
 370   }
 371   vertex_1(point<numeric_type>(nums[0], nums[1]));
 372   vertex_2(point<numeric_type>(nums[2], nums[3]));
 373   return true;
 374 }
 375
 376 } // namespace.
 377
 378 #endif
 379