warper.h

Go to the documentation of this file.

#ifndef RECTANGLE_WARPER_CLASS
#define RECTANGLE_WARPER_CLASS
 
/*****************************************************************************\
*                                                                             *
*  Name   : rectangle_warper                                                  *
*  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 "rectangle.h"
 
#include <basis/astring.h>
 
namespace geometric {
 
template <class numeric_type>
class rectangle_warper
{
public:
 
  enum origin_vertex { BOTTOM_LEFT, TOP_LEFT, TOP_RIGHT, BOTTOM_RIGHT };
 
  rectangle_warper(const rectangle<numeric_type> &system_1,
          const rectangle<numeric_type> &system_2,
          origin_vertex system_1_origin = BOTTOM_LEFT,
          origin_vertex system_2_origin = BOTTOM_LEFT);
 
  ~rectangle_warper();
 
  point<numeric_type> to_system_1(const point<numeric_type> &in_system_2) const;
 
  point<numeric_type> to_system_2(const point<numeric_type> &in_system_1) const;
 
  rectangle<numeric_type> to_system_1
          (const rectangle<numeric_type> &in_system_2) const;
  rectangle<numeric_type> to_system_2
          (const rectangle<numeric_type> &in_system_1) const;
 
  rectangle<numeric_type> system_1() const { return _system_1; }
  rectangle<numeric_type> system_2() const { return _system_2; }
  origin_vertex origin_1() const { return _vert_1; }
  origin_vertex origin_2() const { return _vert_2; }
 
  void system_1(const rectangle<numeric_type> &to_set,
          origin_vertex origin_corner = BOTTOM_LEFT);
  void system_2(const rectangle<numeric_type> &to_set,
          origin_vertex origin_corner = BOTTOM_LEFT);
 
  basis::astring text_form() const;
 
  basis::astring vertex_name(origin_vertex v) const;
 
  enum vertical_component { RW_BOTTOM, RW_TOP };
  enum horizontal_component { RW_LEFT, RW_RIGHT };
 
  void separate_vertical(origin_vertex v, vertical_component &to_set) const;
  void separate_horizontal(origin_vertex v, horizontal_component &to_set) const;
 
private:
  rectangle<numeric_type> _system_1;
  rectangle<numeric_type> _system_2;
  origin_vertex _vert_1;
  origin_vertex _vert_2;
 
  point<numeric_type> scale_point(const rectangle<numeric_type> &source,
          const rectangle<numeric_type> &target,
          origin_vertex v1, origin_vertex v2,
          const point<numeric_type> &old) const;
  rectangle<numeric_type> scale_rectangle(const rectangle<numeric_type> &source,
          const rectangle<numeric_type> &target,
          origin_vertex v1, origin_vertex v2,
          const rectangle<numeric_type> &old) const;
  rectangle<numeric_type> flip_accordingly
          (const rectangle<numeric_type> &to_flip, origin_vertex to_flip_origin,
          origin_vertex target_origin) const;
 
};
 
 
// implementations for longer methods below...
 
template <class numeric_type>
rectangle_warper<numeric_type>::rectangle_warper
    (const rectangle<numeric_type> &system_1,
     const rectangle<numeric_type> &system_2,
     origin_vertex v1, origin_vertex v2)
: _system_1(system_1), _system_2(system_2), _vert_1(v1), _vert_2(v2)
{}
 
template <class numeric_type>
rectangle_warper<numeric_type>::~rectangle_warper() {}
 
template <class numeric_type>
void rectangle_warper<numeric_type>::system_1
    (const rectangle<numeric_type> &to_set, origin_vertex v)
{ _system_1 = to_set; _vert_1 = v; }
 
template <class numeric_type>
void rectangle_warper<numeric_type>::system_2
    (const rectangle<numeric_type> &to_set, origin_vertex v)
{ _system_2 = to_set; _vert_2 = v; }
 
template <class numeric_type>
point<numeric_type> rectangle_warper<numeric_type>::to_system_1
    (const point<numeric_type> &in_system_2) const
{ return scale_point(_system_2, _system_1, _vert_2, _vert_1, in_system_2); }
 
template <class numeric_type>
point<numeric_type> rectangle_warper<numeric_type>::to_system_2
    (const point<numeric_type> &in_system_1) const
{ return scale_point(_system_1, _system_2, _vert_1, _vert_2, in_system_1); }
 
template <class numeric_type>
rectangle<numeric_type> rectangle_warper<numeric_type>::to_system_1
    (const rectangle<numeric_type> &in_system_2) const
{ 
  return scale_rectangle(_system_2, _system_1, _vert_2, _vert_1, 
      in_system_2); 
}
 
template <class numeric_type>
rectangle<numeric_type> rectangle_warper<numeric_type>::to_system_2
    (const rectangle<numeric_type> &in_system_1) const
{
  return scale_rectangle(_system_1, _system_2, _vert_1, _vert_2,
      in_system_1); 
}
 
template <class numeric_type>
void rectangle_warper<numeric_type>::separate_vertical
    (origin_vertex v, vertical_component &to_set) const
{
  if ( (v == BOTTOM_LEFT) || (v == BOTTOM_RIGHT) ) to_set = RW_BOTTOM;
  to_set = RW_TOP;
}
 
template <class numeric_type>
void rectangle_warper<numeric_type>::separate_horizontal
    (origin_vertex v, horizontal_component &to_set) const
{
  if ( (v == BOTTOM_LEFT) || (v == TOP_LEFT) ) to_set = RW_LEFT;
  to_set = RW_RIGHT;
}
 
template <class numeric_type>
rectangle<numeric_type> rectangle_warper<numeric_type>::flip_accordingly
    (const rectangle<numeric_type> &to_flip, origin_vertex flipo,
    origin_vertex targo) const
{
//LOG(basis::astring("flipping ") + to_flip.text_form() + " from " + flipo.text_form() + " to " + targo.text_form());
  if (flipo == targo) return to_flip;
  numeric_type x1(to_flip.vertex_1().x());
  numeric_type y1(to_flip.vertex_1().y());
  numeric_type x2(to_flip.vertex_2().x());
  numeric_type y2(to_flip.vertex_2().y());
  horizontal_component horiz1;
  separate_horizontal(flipo, horiz1);
  horizontal_component horiz2;
  separate_horizontal(targo, horiz2);
  bool flip_x = bool(horiz1 != horiz2);
  vertical_component vert1;
  separate_vertical(flipo, vert1);
  vertical_component vert2;
  separate_vertical(targo, vert2);
  bool flip_y = bool(vert1 != vert2);
  if (flip_x) basis::swap_values(x1, x2);
  if (flip_y) basis::swap_values(y1, y2);
//LOG(basis::astring("it becomes ") + rectangle<numeric_type>(x1, y1, x2, y2).text_form());
  return rectangle<numeric_type>(x1, y1, x2, y2);
}
 
template <class numeric_type>
rectangle<numeric_type> rectangle_warper<numeric_type>::scale_rectangle
    (const rectangle<numeric_type> &source,
    const rectangle<numeric_type> &target, origin_vertex source_origin,
    origin_vertex target_origin, const rectangle<numeric_type> &old) const
{
  rectangle<numeric_type> s = rectangle<numeric_type>
      (flip_accordingly(source, source_origin, BOTTOM_LEFT));
  numeric_type width_source = s.vertex_2().x() - s.vertex_1().x();
  numeric_type height_source = s.vertex_2().y() - s.vertex_1().y();
  if ( !width_source || !height_source ) {
//    cerr << "degenerate rectangle in rectangle_warper::scaler: " << s
//      << endl << flush;
    return old;
  }
  rectangle<numeric_type> t(flip_accordingly(target, target_origin, BOTTOM_LEFT));
  numeric_type width_target = t.vertex_2().x() - t.vertex_1().x();
  numeric_type height_target = t.vertex_2().y() - t.vertex_1().y();
  numeric_type x_scale = width_target / width_source;
  numeric_type y_scale = height_target / height_source;
 
//LOG(basis::astring("scaler: source ") + source.text_form() + " with vert " + source_origin.text_form() + " becomes " + s + " target " + target + " with vert " + target_origin + " becomes " + t + ".");
 
  rectangle<numeric_type> o(flip_accordingly(old, source_origin, BOTTOM_LEFT));
 
  rectangle<numeric_type> to_return = flip_accordingly(rectangle<numeric_type>
     ((o.vertex_1().x() - s.vertex_1().x()) * x_scale + t.vertex_1().x(),
      (o.vertex_1().y() - s.vertex_1().y()) * y_scale + t.vertex_1().y(),
      (o.vertex_2().x() - s.vertex_1().x()) * x_scale + t.vertex_1().x(),
      (o.vertex_2().y() - s.vertex_1().y()) * y_scale + t.vertex_1().y()),
     BOTTOM_LEFT, target_origin);
 
//  LOG(basis::astring("old ") + old.text_form() + " with source vert becomes " + o.text_form() + " and then is moved into " + to_return.text_form());
 
  return to_return;
}
 
template <class numeric_type>
point<numeric_type> rectangle_warper<numeric_type>::scale_point
  (const rectangle<numeric_type> &source, const rectangle<numeric_type> &target,
   origin_vertex source_origin, origin_vertex target_origin,
   const point<numeric_type> &old) const
{
  // gross but simple.
  return scale_rectangle(source, target, source_origin, target_origin,
      rectangle<numeric_type>(old, old)).vertex_1();
}
 
template <class numeric_type>
basis::astring rectangle_warper<numeric_type>::vertex_name(origin_vertex v) const
{
  basis::astring name("unknown");
  switch (v) {
    case BOTTOM_LEFT: name = "bottom-left"; break;
    case BOTTOM_RIGHT: name = "bottom-right"; break;
    case TOP_LEFT: name = "top-left"; break;
    case TOP_RIGHT: name = "top-right"; break;
  }
  return name;
}
 
template <class numeric_type>
basis::astring rectangle_warper<numeric_type>::text_form() const
{
  return basis::astring("<warps from: ") + _system_1.text_form()
      + basis::astring(" with vertex at ") + vertex_name(_vert_1)
      + basis::astring(" into ") + _system_2.text_form()
      + basis::astring(" with vertex at ") + vertex_name(_vert_2)
      + basis::astring(">");
}
 
} // namespace.
 
#endif