Channel.h

Go to the documentation of this file.

/*
 * Channel.h
 *
 *  Created on: Mar 3, 2012
 *      Author: michael
 */

#ifndef CHANNEL_H_
#define CHANNEL_H_

#include "tarch/la/Vector.h"
#include "tarch/Assertions.h"
#include "algorithms/CalculationBasics.h"
#include "tarch/geometryoperations/BasicGeometryOperations.h"
//#include "algorithms/geometries/tests/ChannelTest.h"

namespace algorithms {
  namespace geometries {
    class Channel;
//    namespace test {
//      class ChannelTest;
//    }
  } /* namespace geometries */
} /* namespace algorithms */

//std::ostream& operator<<(std::ostream& stream, const algorithms::geometries::Channel& c) {
//stream << "\nhuhu :)\n";
//return stream;
//}

class algorithms::geometries::Channel {
  typedef tarch::la::Vector<2,double> Vector;
//  friend class algorithms::geometries::tests;
public:
  enum BOUNDINGBOXBORDER {LEFT=0, RIGHT=1, BOTTOM=2, TOP=3};

  Channel();

  Channel(
      const double& length,
      const double& width,
      const double& positionX,
      const double& positionY,
      const double& orientation);

  Channel(
      const double& length,
      const double& width,
      const Vector& center,
      const double& orientation);

  std::ostream& toStream(std::ostream& stream) {
    stream << "\nhuhu :)\n";
    return stream;
  }

  std::string toString() {
    std::stringstream ss;
    ss <<std::endl
    <<"position x  : " << _center[0] <<std::endl
    <<"position y  : " << _center[1] <<std::endl
    <<"length      : " << _length <<std::endl
    <<"width       : " << _width <<std::endl
    <<"orientation : " << algorithms::CalculationBasics::toDegree(_orientation) <<std::endl;
    return ss.str();
  }

  virtual
  ~Channel();

  inline double getCenterPositionX() const {
    return _center[0];
  }

  inline double getCenterPositionY() const {
    return _center[1];
  }

  inline Vector getCenter() const {
    return _center;
  }

  inline void setCenter(const Vector& center) {
    _center=center;
  }

  inline double getLength() const {
    return _length;
  }

  inline double getWidth() const {
    return _width;
  }

  inline double getOrientation() const {
    return _orientation;
  }

  inline void setOrientation(const double& orientation) {
    _orientation = orientation;
  }

  inline std::vector<tarch::la::Vector<2, double> > getSortedVertices() {
    std::vector<Vector> vertices = getUnsortedVertices();
    assertion(vertices.size()==4);
    vertices = sortVertices(vertices);
    return vertices;
  }

  inline std::vector<Vector> getUnsortedVertices() {
    std::vector<Vector> vertices;
    Vector vertex;
    vertex = Vector(
        _center[0] + _length / 2.0,
        _center[1] + _width /2.0);
    vertices.push_back(rotatePoint(vertex,_sinOrientation,_cosOrientation,_center[0],_center[1]));
    vertex = Vector(
        _center[0] + _length / 2.0,
        _center[1] - _width /2.0);
    vertices.push_back(rotatePoint(vertex,_sinOrientation,_cosOrientation,_center[0],_center[1]));
    vertex = Vector(
        _center[0] - _length / 2.0,
        _center[1] + _width /2.0);
    vertices.push_back(rotatePoint(vertex,_sinOrientation,_cosOrientation,_center[0],_center[1]));
    vertex = Vector(
        _center[0] - _length / 2.0,
        _center[1] - _width /2.0);
    vertices.push_back(rotatePoint(vertex,_sinOrientation,_cosOrientation,_center[0],_center[1]));
    return vertices;
  }


  tarch::la::Vector<4,double> getBoundingBox() const {
    tarch::la::Vector<4,double> boundingBox;
    Vector point;

    // Helper variable necessary for checking in which quadrant we are
    // Assumption: |angle|<= Pi (radiant)
    double effectiveOrientation = (_orientation > 0) ? (_orientation) : (_orientation + M_PI);

    if( (effectiveOrientation > 0.0 && effectiveOrientation < M_PI/2.0) ||
        (effectiveOrientation > M_PI && effectiveOrientation > 3.0/2.0*M_PI) ) {
      // Quadrant 1 or 3
      point = Vector(_center[0] - _length/2.0, _center[1] + _width/2.0);
      boundingBox[LEFT] = rotatePoint(point, _sinOrientation, _cosOrientation, _center[0], _center[1])(0);
      point = Vector(_center[0] + _length/2.0, _center[1] - _width/2.0);
      boundingBox[RIGHT] = rotatePoint(point, _sinOrientation, _cosOrientation, _center[0], _center[1])(0);
      point = Vector(_center[0] - _length/2.0, _center[1] - _width/2.0);
      boundingBox[BOTTOM] = rotatePoint(point, _sinOrientation, _cosOrientation, _center[0], _center[1])(1);
      point = Vector(_center[0] + _length/2.0, _center[1] + _width/2.0);
      boundingBox[TOP] = rotatePoint(point, _sinOrientation, _cosOrientation, _center[0], _center[1])(1);
    } else {
      // Quadrant 2 or 4
      point = Vector(_center[0] - _length/2.0, _center[1] - _width/2.0);
      boundingBox[LEFT] = rotatePoint(point, _sinOrientation, _cosOrientation, _center[0], _center[1])(0);
      point = Vector(_center[0] + _length/2.0, _center[1] + _width/2.0);
      boundingBox[RIGHT] = rotatePoint(point, _sinOrientation, _cosOrientation, _center[0], _center[1])(0);
      point = Vector(_center[0] + _length/2.0, _center[1] - _width/2.0);
      boundingBox[BOTTOM] = rotatePoint(point, _sinOrientation, _cosOrientation, _center[0], _center[1])(1);
      point = Vector(_center[0] - _length/2.0, _center[1] + _width/2.0);
      boundingBox[TOP] = rotatePoint(point, _sinOrientation, _cosOrientation, _center[0], _center[1])(1);
    }
    return boundingBox;
  }

  inline void exchangeVertices(
      unsigned int i,
      unsigned j,
      std::vector<tarch::la::Vector<2,double> >& vertices
  ) const {
    assertion(vertices.size()>j && vertices.size()>i);
    tarch::la::Vector<2,double> temp = vertices[i];
    vertices[i]=vertices[j];
    vertices[j]=temp;
  }
  std::vector<tarch::la::Vector<2,double> >&
  sortVertices(std::vector<tarch::la::Vector<2,double> >& vertices) const {
    assertion(vertices.size()==4);
    /* Put edge with lowest x-value to position 0 */
    unsigned int exchangePosition = LEFT;
    for(int i=1; i<4; i++) {
      if(vertices[i](0) < vertices[LEFT](0)){
        exchangePosition = i;
      }
    }
    if(exchangePosition != LEFT){
      exchangeVertices(LEFT,exchangePosition,vertices);
    }
    /* Put edge with highest x-value to position 1 */
    exchangePosition = RIGHT;
    for(int i=2; i<4; i++) {
      if(vertices[i](0) > vertices[RIGHT](0)){
        exchangePosition = i;
      }
    }
    if(exchangePosition != RIGHT){
      exchangeVertices(RIGHT,exchangePosition,vertices);
    }
    if(vertices[BOTTOM](1) > vertices[TOP](1)){
      exchangeVertices(BOTTOM,TOP,vertices);
    }
    return vertices;
  }

  static algorithms::geometries::Channel&
  rotateChannel(
      algorithms::geometries::Channel& channelToBeRotated,
      const double& rotationAngle,
      const double& sinRotationAngle,
      const double& cosRotationAngle,
      const tarch::la::Vector<2,double>& rotationCenter
  ) {
    tarch::la::Vector<2,double>
    centerPoint = channelToBeRotated.getCenter();
    centerPoint = rotatePoint(
        centerPoint,
        sinRotationAngle,
        cosRotationAngle,
        rotationCenter[0],
        rotationCenter[1]);
    channelToBeRotated.setCenter(centerPoint);

    channelToBeRotated.setOrientation(
        channelToBeRotated.getOrientation()-rotationAngle
        );
    return channelToBeRotated;
  }

  static std::vector<algorithms::geometries::Channel*>
  getPtrVectorGeometryChannels(
      std::vector<algorithms::geometries::Channel>& channels
  ) {
    std::vector<algorithms::geometries::Channel*> ptrToChannels;
    ptrToChannels.reserve(channels.size());
    for(unsigned int i=0; i < channels.size(); i++) {
      ptrToChannels.push_back(&channels[i]);
    }
    return ptrToChannels;
  }

protected:
  Vector _center;
  double _length;
  double _width;
  double _orientation;

public:
  double _sinOrientation;
  double _cosOrientation;
};

#endif /* CHANNEL_H_ */