geometry.cpp

Go to the documentation of this file.

#include "wit.h"
#include "geometry.h"
#include <vector>

namespace wit {

Point::Point() : x(0), y(0)
{
    // initializers only
}

Point::Point(const Point& other) : x(other.x), y(other.y)
{
    // initializers only
}

Point::Point(float x, float y) : x(x), y(y)
{
    // initializers only
}

Point& Point::operator=(const Point& other)
{
    x = other.x;
    y = other.y;
    return *this;
}

Rect::Rect() : x1(0), y1(0), x2(0), y2(0)
{
    // initializers only
}

Rect::Rect(const Rect& other) : x1(other.x1), y1(other.y1), x2(other.x2), y2(other.y2)
{
    // initializers only
}

Rect::Rect(float x1, float y1, float x2, float y2) : x1(x1), y1(y1), x2(x2), y2(y2)
{
    // initializers only
}

Rect& Rect::operator=(const Rect& other)
{
    x1 = other.x1;
    y1 = other.y1;
    x2 = other.x2;
    y2 = other.y2;
    return *this;
}

bool Rect::contains(float x, float y)
{
    return (x1 <= x && x2 >= x) && (y1 <= y && y2 >= y);
}

bool Rect::intersects(const Rect& other)
{
    return (x2 >= other.x1 && x1 <= other.x2) && (y2 >= other.y1 && y1 <= other.y2);
}

float Rect::width() const
{
    return x2 - x1;
}

float Rect::height() const
{
    return y2 - y1;
}

struct PolygonPrivate {
    std::vector<Point> points;
    Rect bb;
};

Polygon::Polygon() : d(new PolygonPrivate)
{
    // initializers only
}

Polygon::Polygon(const Polygon& other) : d(new PolygonPrivate)
{
    this->operator=(other);
}

Polygon::~Polygon()
{
    delete d;
}

Polygon& Polygon::operator=(const Polygon& other)
{
    d->points = other.d->points;
    d->bb = other.d->bb;
    return *this;
}

void Polygon::addPoint(const Point& p)
{
    d->points.push_back(p);
    if(d->points.size() == 1) {
        d->bb.x1 = d->bb.x2 = p.x;
        d->bb.y1 = d->bb.y2 = p.y;
    } else {
        if(d->bb.x1 > p.x) d->bb.x1 = p.x;
        if(d->bb.x2 < p.x) d->bb.x2 = p.x;
        if(d->bb.y1 > p.y) d->bb.y1 = p.y;
        if(d->bb.y2 < p.y) d->bb.y2 = p.y;
    }
}

void Polygon::addPoint(float x, float y)
{
    addPoint(Point(x, y));
}

int Polygon::count() const
{
    return d->points.size();
}

Point* Polygon::points() const
{
    return &(d->points.front());
}

Rect Polygon::boundingBox() const
{
    return d->bb;
}

bool Polygon::contains(float x, float y) const
{
    bool inside = false;
    Point* p = points();

    for(int i = count() - 2; i >= -1; --i) {
        Point p1 = p[i+1];
        Point p2 = (i == -1 ? p[count() - 1] : p[i]);

        if((p2.x < x) != (x <= p1.x))
            continue;

        if(p1.x < p2.x) {
            p2 = p1;
            p1 = (i == -1 ? p[count() - 1] : p[i]);
        }

        if((y - p1.y) * (p2.x - p1.x) < (p2.y - p1.y) * (x - p1.x))
            inside = !inside;
    }
    return inside;
}

}