EllipseCollisionTest Class Reference

Collaboration diagram for EllipseCollisionTest:

Public Member Functions
bool	collide (double x0, double y0, double w, double h, double x1, double y1, double r) const
	EllipseCollisionTest (int maxIterations)

Private Member Functions
bool	iterate (double x, double y, double c0x, double c0y, double c2x, double c2y, double rr) const

Private Attributes
int	m_maxIterations

Detailed Description

Definition at line 20 of file AnnulusBounds.cxx.

Constructor & Destructor Documentation

EllipseCollisionTest()

EllipseCollisionTest::EllipseCollisionTest ( int  maxIterations )

inlineexplicit

Definition at line 118 of file AnnulusBounds.cxx.

    : m_maxIterations(maxIterations)
  {
  }

Member Function Documentation

collide()

bool EllipseCollisionTest::collide ( double  x0, double  y0, double  w, double  h, double  x1, double  y1, double  r  ) const

inline

Definition at line 92 of file AnnulusBounds.cxx.

  {
    double x = std::abs(x1 - x0);
    double y = std::abs(y1 - y0);
 
    //      return iterate(x, y, w, 0, 0, h, r*r);
 
    if (r > 0) {
      if (x * x + (h - y) * (h - y) <= r * r || (w - x) * (w - x) + y * y <= r * r ||
          x * h + y * w <= w * h // collision with (0, h)
          || ((x * h + y * w - w * h) * (x * h + y * w - w * h) <= r * r * (w * w + h * h) && x * w - y * h >= -h * h &&
              x * w - y * h <= w * w)) { // collision with (0, h)---(w, 0)
        return true;
      }
        if ((x - w) * (x - w) + (y - h) * (y - h) <= r * r || (x <= w && y - r <= h) || (y <= h && x - r <= w)) {
          return iterate(x, y, w, 0, 0, h, r * r); // collision within triangle (0, h) (w, h) (0, 0) is possible
        }
        return false;
 
    }
      double R = -r;
      double localCos = x / R;
      double deltaR = std::sqrt(h * h + (w * w - h * h) * localCos * localCos);
      return deltaR >= R - std::sqrt(x * x + y * y);
 
  }

iterate()

bool EllipseCollisionTest::iterate ( double  x, double  y, double  c0x, double  c0y, double  c2x, double  c2y, double  rr  ) const

inlineprivate

Definition at line 24 of file AnnulusBounds.cxx.

  {
    std::vector<double> innerPolygonCoef(m_maxIterations + 1);
    std::vector<double> outerPolygonCoef(m_maxIterations + 1);
 
    for (int t = 1; t <= m_maxIterations; t++) {
      int numNodes = 4 << t;
      // innerPolygonCoef[t] = 0.5/std::cos(4*std::acos(0.0)/numNodes);
      innerPolygonCoef[t] = 0.5 / std::cos(2.0*M_PI / numNodes);
      double c1x = (c0x + c2x) * innerPolygonCoef[t];
      double c1y = (c0y + c2y) * innerPolygonCoef[t];
      double tx = x - c1x; // t indicates a translated coordinate
      double ty = y - c1y;
      if (tx * tx + ty * ty <= rr) {
        return true; // collision with t1
      }
      double t2x = c2x - c1x;
      double t2y = c2y - c1y;
      if (tx * t2x + ty * t2y >= 0 && tx * t2x + ty * t2y <= t2x * t2x + t2y * t2y &&
          (ty * t2x - tx * t2y >= 0 || rr * (t2x * t2x + t2y * t2y) >= (ty * t2x - tx * t2y) * (ty * t2x - tx * t2y))) {
        return true; // collision with t1---t2
      }
      double t0x = c0x - c1x;
      double t0y = c0y - c1y;
      if (tx * t0x + ty * t0y >= 0 && tx * t0x + ty * t0y <= t0x * t0x + t0y * t0y &&
          (ty * t0x - tx * t0y <= 0 || rr * (t0x * t0x + t0y * t0y) >= (ty * t0x - tx * t0y) * (ty * t0x - tx * t0y))) {
        return true; // collision with t1---t0
      }
      outerPolygonCoef[t] = 0.5 / (std::cos(M_PI / numNodes) * std::cos(M_PI / numNodes));
      double c3x = (c0x + c1x) * outerPolygonCoef[t];
      double c3y = (c0y + c1y) * outerPolygonCoef[t];
      if ((c3x - x) * (c3x - x) + (c3y - y) * (c3y - y) < rr) {
        c2x = c1x;
        c2y = c1y;
        continue; // t3 is inside circle
      }
      double c4x = c1x - c3x + c1x;
      double c4y = c1y - c3y + c1y;
      if ((c4x - x) * (c4x - x) + (c4y - y) * (c4y - y) < rr) {
        c0x = c1x;
        c0y = c1y;
        continue; // t4 is inside circle
      }
      double t3x = c3x - c1x;
      double t3y = c3y - c1y;
      if (ty * t3x - tx * t3y <= 0 || rr * (t3x * t3x + t3y * t3y) > (ty * t3x - tx * t3y) * (ty * t3x - tx * t3y)) {
        if (tx * t3x + ty * t3y > 0) {
          if (std::abs(tx * t3x + ty * t3y) <= t3x * t3x + t3y * t3y ||
              (x - c3x) * (c0x - c3x) + (y - c3y) * (c0y - c3y) >= 0) {
            c2x = c1x;
            c2y = c1y;
            continue; // circle center is inside t0---t1---t3
          }
        } else if (-(tx * t3x + ty * t3y) <= t3x * t3x + t3y * t3y ||
                   (x - c4x) * (c2x - c4x) + (y - c4y) * (c2y - c4y) >= 0) {
          c0x = c1x;
          c0y = c1y;
          continue; // circle center is inside t1---t2---t4
        }
      }
      return false; // no collision possible
    }
    return false; // out of iterations so it is unsure if there was a collision. But have to return something.
  }

Member Data Documentation

m_maxIterations

int EllipseCollisionTest::m_maxIterations

private

Definition at line 23 of file AnnulusBounds.cxx.

---

The documentation for this class was generated from the following file:

• AnnulusBounds.cxx