ChannelPrinterHelper.h

Go to the documentation of this file.

/*
 * ChannelPrinterHelper.h
 *
 *  Created on: Mar 10, 2012
 *      Author: michael
 */

#ifndef CHANNELPRINTERHELPER_H_
#define CHANNELPRINTERHELPER_H_

#include "algorithms/geometries/Channel.h"
#include <vector>
#include "tarch/la/Vector.h"

#define DIMENSIONS 2

namespace xml {
  namespace twoD {
    class ChannelPrinterHelper;

    struct SubDomain {
      SubDomain(
          algorithms::geometries::Channel domain,
          tarch::la::Vector<2,int>    intPosition
          )
      :_domain(domain),
       _intPosition(intPosition)
       {}

      inline double getXMin() const {
        return _domain.getCenterPositionX()-_domain.getLength()/2.0;
      }

      inline double getXMax() const {
        return _domain.getCenterPositionX()+_domain.getLength()/2.0;
      }

      inline double getYMin() const {
        return _domain.getCenterPositionY()-_domain.getWidth()/2.0;
      }

      inline double getYMax() const {
        return _domain.getCenterPositionY()+_domain.getWidth()/2.0;
      }

      algorithms::geometries::Channel _domain;
      std::vector<algorithms::geometries::Channel*> _channels;
      tarch::la::Vector<2,int>    _intPosition;
    };

    struct Point{
      Point(double _x, double _y):
        x(_x),
        y(_y)
      {}

      Point():
        x(0),
        y(0)
      {}

      Point(tarch::la::Vector<2, double> point):
        x(point[0]),
        y(point[1])
      {}

      std::string toString() const {
        std::stringstream ss;
        ss << "Point (" <<x <<"/" <<x <<")";
        return ss.str();
      }

      bool operator==(const Point& rhs) const {
        return (tarch::la::equals(rhs.x, x) && tarch::la::equals(rhs.y, y) ) ? true: false;
      }

      double x, y;
    };

    inline std::ostream& operator<<(std::ostream& out, const Point& p) {
      out <<"P(" <<p.x <<"/" <<p.y <<")";
      return out;
    }

    struct Line{
      Line(double m, double t)
      :_a(m),
       _b(t){
      }

      Line()
      :_a(1.0),
       _b(0.0){
      }

      Line(Point A, Point B)
      :_a( (A.y-B.y)/(A.x-B.x) ),
       _b( B.y - _a*B.x ){
      }

      double _a, _b;

      double getY(double x) {
        return x*_a + _b;
      }

      Point getIntersectionPoint(Line lineToIntersect) {
        Point p;
        p.x = (lineToIntersect._b - _b)/(_a - lineToIntersect._a);
        p.y = getY(p.x);
        return p;
      }

      double getXPosOfPointProjected(Point p){
        assertion(_a != 0);
        double t2 = p.y + p.x/_a;
        double m2 = -1.0/_a;
        double value = (t2 - _b)/(_a - m2);
        return value;
      }
    };

  } /* namespace geometries */
} /* namespace algorithms */


class xml::twoD::ChannelPrinterHelper {
  typedef algorithms::geometries::Channel Channel;

public:
  ChannelPrinterHelper();
  virtual
  ~ChannelPrinterHelper();



  std::vector< xml::twoD::SubDomain >
  sortChannelsWithRespectToSubdomains(
      std::vector<Channel*>& channels,
      const unsigned int& subDivPerDim
  ) const;

  std::vector<xml::twoD::SubDomain>
  generateSubDomains(
      const unsigned int& subDivPerDim
  ) const;

  bool areRectanglesSeparatedAlongXOrYAxis(
      const Channel& unrotatedChannel,
      Channel& rotatedChannel
  ) const {
    /* get borders of unrotated channel */
    double leftBorderUnrotChannel  = unrotatedChannel.getCenterPositionX() - unrotatedChannel.getLength()/2.0;
    double rightBorderUnrotChannel = unrotatedChannel.getCenterPositionX() + unrotatedChannel.getLength()/2.0;
    double lowerBorderUnrotChannel = unrotatedChannel.getCenterPositionY() - unrotatedChannel.getLength()/2.0;
    double upperBorderUnrotChannel = unrotatedChannel.getCenterPositionY() + unrotatedChannel.getLength()/2.0;

    // check intersection of x-axis - return false if no intersection occurs
    tarch::la::Vector<4,double> boundingBox = rotatedChannel.getBoundingBox();
    if( !(leftBorderUnrotChannel  < boundingBox(Channel::RIGHT) ||
        rightBorderUnrotChannel < boundingBox(Channel::LEFT) ))
      return false;

    // check intersection of y-axis - return false if no intersection occurs
    if( !(lowerBorderUnrotChannel > boundingBox(Channel::TOP) ||
        upperBorderUnrotChannel < boundingBox(Channel::BOTTOM) ))
      return false;

    return true;
  }

  bool areProjectionsSeparated(
      const Channel& unrotatedChannel,
      Channel& rotatedChannel
  ) const {
    assertionEquals(unrotatedChannel.getOrientation(), 0.0);
    // test if rotation is multiple of Pi
    // if yes we can ommit this test - and don't have to worry about special cases in it :)
    double test = rotatedChannel.getOrientation()/(M_PI/2.0);

    if(!tarch::la::equals(test-(int)test,0.0)) {
      // check if the 1D projection intersects
      /* get borders of unrotated channel */
      double leftBorderUnrotChannel  = unrotatedChannel.getCenterPositionX() - unrotatedChannel.getLength()/2.0;
      double rightBorderUnrotChannel = unrotatedChannel.getCenterPositionX() + unrotatedChannel.getLength()/2.0;
      double lowerBorderUnrotChannel = unrotatedChannel.getCenterPositionY() - unrotatedChannel.getLength()/2.0;
      double upperBorderUnrotChannel = unrotatedChannel.getCenterPositionY() + unrotatedChannel.getLength()/2.0;

      std::vector<tarch::la::Vector<2, double> > positions = rotatedChannel.getSortedVertices();

      // Line on which we will project
      Line projectionLine(
          rotatedChannel._sinOrientation/rotatedChannel._cosOrientation, 0.0);

      Line
      leftBottom  = Line(Point(positions[Channel::LEFT]), Point(positions[Channel::BOTTOM])),
      rightTop    = Line(Point(positions[Channel::RIGHT]), Point(positions[Channel::TOP]));

      Point
      unrotLeftBottom  = Point(leftBorderUnrotChannel,lowerBorderUnrotChannel),
      unrotRightTop    = Point(rightBorderUnrotChannel,upperBorderUnrotChannel);

      double rotLeft = projectionLine.getIntersectionPoint(leftBottom).x;
      double rotRight= projectionLine.getIntersectionPoint(rightTop).x;

      double unrotLeft = projectionLine.getXPosOfPointProjected(unrotLeftBottom);
      double unrotRight= projectionLine.getXPosOfPointProjected(unrotRightTop);

      return areRegionsSeparated(rotLeft,rotRight,unrotLeft,unrotRight);
    }

    return true;
  }

  inline bool areRegionsSeparated(
      const double& region1LowerBound,
      const double& region1UpperBound,
      const double& region2LowerBound,
      const double& region2UpperBound) const {
    assertion(region1LowerBound < region1UpperBound);
    assertion(region2LowerBound < region2UpperBound);
    return
        !(region1LowerBound >= region2LowerBound && region1LowerBound <= region2UpperBound) &&
        !(region1UpperBound >= region2LowerBound && region1UpperBound <= region2UpperBound);
  }

  bool doChannelsIntersect(
      const Channel& unrotatedChannel,
      Channel& rotatedChannel
  ) const {
    if(areRectanglesSeparatedAlongXOrYAxis(unrotatedChannel, rotatedChannel))
      return false;

    if(areProjectionsSeparated(unrotatedChannel, rotatedChannel))
      return false;

    /* check x-axis separating axis */
    return true;
  }
};

#endif /* CHANNELPRINTERHELPER_H_ */