kicad/polygon/poly2tri/common/shapes.cc

/*
 * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
 * http://code.google.com/p/poly2tri/
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * * Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * * Neither the name of Poly2Tri nor the names of its contributors may be
 *   used to endorse or promote products derived from this software without specific
 *   prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "shapes.h"
#include <iostream>

namespace p2t {
Triangle::Triangle( Point& a, Point& b, Point& c )
{
    points_[0]      = &a; points_[1] = &b; points_[2] = &c;
    neighbors_[0]   = NULL; neighbors_[1] = NULL; neighbors_[2] = NULL;
    constrained_edge[0] = constrained_edge[1] = constrained_edge[2] = false;
    delaunay_edge[0]    = delaunay_edge[1] = delaunay_edge[2] = false;
    interior_ = false;
}


// Update neighbor pointers
void Triangle::MarkNeighbor( Point* p1, Point* p2, Triangle* t )
{
    if( (p1 == points_[2] && p2 == points_[1]) || (p1 == points_[1] && p2 == points_[2]) )
        neighbors_[0] = t;
    else if( (p1 == points_[0] && p2 == points_[2]) || (p1 == points_[2] && p2 == points_[0]) )
        neighbors_[1] = t;
    else if( (p1 == points_[0] && p2 == points_[1]) || (p1 == points_[1] && p2 == points_[0]) )
        neighbors_[2] = t;
    else
        assert( 0 );
}


// Exhaustive search to update neighbor pointers
void Triangle::MarkNeighbor( Triangle& t )
{
    if( t.Contains( points_[1], points_[2] ) )
    {
        neighbors_[0] = &t;
        t.MarkNeighbor( points_[1], points_[2], this );
    }
    else if( t.Contains( points_[0], points_[2] ) )
    {
        neighbors_[1] = &t;
        t.MarkNeighbor( points_[0], points_[2], this );
    }
    else if( t.Contains( points_[0], points_[1] ) )
    {
        neighbors_[2] = &t;
        t.MarkNeighbor( points_[0], points_[1], this );
    }
}


/**
 * Clears all references to all other triangles and points
 */
void Triangle::Clear()
{
    Triangle* t;

    for( int i = 0; i<3; i++ )
    {
        t = neighbors_[i];

        if( t != NULL )
        {
            t->ClearNeighbor( this );
        }
    }

    ClearNeighbors();
    points_[0] = points_[1] = points_[2] = NULL;
}


void Triangle::ClearNeighbor( Triangle* triangle )
{
    if( neighbors_[0] == triangle )
    {
        neighbors_[0] = NULL;
    }
    else if( neighbors_[1] == triangle )
    {
        neighbors_[1] = NULL;
    }
    else
    {
        neighbors_[2] = NULL;
    }
}


void Triangle::ClearNeighbors()
{
    neighbors_[0]   = NULL;
    neighbors_[1]   = NULL;
    neighbors_[2]   = NULL;
}


void Triangle::ClearDelunayEdges()
{
    delaunay_edge[0] = delaunay_edge[1] = delaunay_edge[2] = false;
}


Point* Triangle::OppositePoint( Triangle& t, Point& p )
{
    Point*  cw  = t.PointCW( p );

    /*
    double  x   = cw->x;
    double  y   = cw->y;

    x   = p.x;
    y   = p.y;
    */

    return PointCW( *cw );
}


// Legalized triangle by rotating clockwise around point(0)
void Triangle::Legalize( Point& point )
{
    points_[1]  = points_[0];
    points_[0]  = points_[2];
    points_[2]  = &point;
}


// Legalize triagnle by rotating clockwise around oPoint
void Triangle::Legalize( Point& opoint, Point& npoint )
{
    if( &opoint == points_[0] )
    {
        points_[1]  = points_[0];
        points_[0]  = points_[2];
        points_[2]  = &npoint;
    }
    else if( &opoint == points_[1] )
    {
        points_[2]  = points_[1];
        points_[1]  = points_[0];
        points_[0]  = &npoint;
    }
    else if( &opoint == points_[2] )
    {
        points_[0]  = points_[2];
        points_[2]  = points_[1];
        points_[1]  = &npoint;
    }
    else
    {
        assert( 0 );
    }
}


int Triangle::Index( const Point* p )
{
    if( p == points_[0] )
    {
        return 0;
    }
    else if( p == points_[1] )
    {
        return 1;
    }
    else if( p == points_[2] )
    {
        return 2;
    }

    assert( 0 );
    return 0;           // you better hope its a Debug build.
}


int Triangle::EdgeIndex( const Point* p1, const Point* p2 )
{
    if( points_[0] == p1 )
    {
        if( points_[1] == p2 )
        {
            return 2;
        }
        else if( points_[2] == p2 )
        {
            return 1;
        }
    }
    else if( points_[1] == p1 )
    {
        if( points_[2] == p2 )
        {
            return 0;
        }
        else if( points_[0] == p2 )
        {
            return 2;
        }
    }
    else if( points_[2] == p1 )
    {
        if( points_[0] == p2 )
        {
            return 1;
        }
        else if( points_[1] == p2 )
        {
            return 0;
        }
    }

    return -1;
}


void Triangle::MarkConstrainedEdge( const int index )
{
    constrained_edge[index] = true;
}


void Triangle::MarkConstrainedEdge( Edge& edge )
{
    MarkConstrainedEdge( edge.p, edge.q );
}


// Mark edge as constrained
void Triangle::MarkConstrainedEdge( Point* p, Point* q )
{
    if( (q == points_[0] && p == points_[1]) || (q == points_[1] && p == points_[0]) )
    {
        constrained_edge[2] = true;
    }
    else if( (q == points_[0] && p == points_[2]) || (q == points_[2] && p == points_[0]) )
    {
        constrained_edge[1] = true;
    }
    else if( (q == points_[1] && p == points_[2]) || (q == points_[2] && p == points_[1]) )
    {
        constrained_edge[0] = true;
    }
}


// The point counter-clockwise to given point
Point* Triangle::PointCW( Point& point )
{
    if( &point == points_[0] )
    {
        return points_[2];
    }
    else if( &point == points_[1] )
    {
        return points_[0];
    }
    else if( &point == points_[2] )
    {
        return points_[1];
    }

    assert( 0 );
    return NULL;    // you better hope its a Debug build.
}


// The point counter-clockwise to given point
Point* Triangle::PointCCW( Point& point )
{
    if( &point == points_[0] )
    {
        return points_[1];
    }
    else if( &point == points_[1] )
    {
        return points_[2];
    }
    else if( &point == points_[2] )
    {
        return points_[0];
    }

    assert( 0 );
    return NULL;    // you better hope its a Debug build.
}


// The neighbor clockwise to given point
Triangle* Triangle::NeighborCW( Point& point )
{
    if( &point == points_[0] )
    {
        return neighbors_[1];
    }
    else if( &point == points_[1] )
    {
        return neighbors_[2];
    }

    return neighbors_[0];
}


// The neighbor counter-clockwise to given point
Triangle* Triangle::NeighborCCW( Point& point )
{
    if( &point == points_[0] )
    {
        return neighbors_[2];
    }
    else if( &point == points_[1] )
    {
        return neighbors_[0];
    }

    return neighbors_[1];
}


bool Triangle::GetConstrainedEdgeCCW( Point& p )
{
    if( &p == points_[0] )
    {
        return constrained_edge[2];
    }
    else if( &p == points_[1] )
    {
        return constrained_edge[0];
    }

    return constrained_edge[1];
}


bool Triangle::GetConstrainedEdgeCW( Point& p )
{
    if( &p == points_[0] )
    {
        return constrained_edge[1];
    }
    else if( &p == points_[1] )
    {
        return constrained_edge[2];
    }

    return constrained_edge[0];
}


void Triangle::SetConstrainedEdgeCCW( Point& p, bool ce )
{
    if( &p == points_[0] )
    {
        constrained_edge[2] = ce;
    }
    else if( &p == points_[1] )
    {
        constrained_edge[0] = ce;
    }
    else
    {
        constrained_edge[1] = ce;
    }
}


void Triangle::SetConstrainedEdgeCW( Point& p, bool ce )
{
    if( &p == points_[0] )
    {
        constrained_edge[1] = ce;
    }
    else if( &p == points_[1] )
    {
        constrained_edge[2] = ce;
    }
    else
    {
        constrained_edge[0] = ce;
    }
}


bool Triangle::GetDelunayEdgeCCW( Point& p )
{
    if( &p == points_[0] )
    {
        return delaunay_edge[2];
    }
    else if( &p == points_[1] )
    {
        return delaunay_edge[0];
    }

    return delaunay_edge[1];
}


bool Triangle::GetDelunayEdgeCW( Point& p )
{
    if( &p == points_[0] )
    {
        return delaunay_edge[1];
    }
    else if( &p == points_[1] )
    {
        return delaunay_edge[2];
    }

    return delaunay_edge[0];
}


void Triangle::SetDelunayEdgeCCW( Point& p, bool e )
{
    if( &p == points_[0] )
    {
        delaunay_edge[2] = e;
    }
    else if( &p == points_[1] )
    {
        delaunay_edge[0] = e;
    }
    else
    {
        delaunay_edge[1] = e;
    }
}


void Triangle::SetDelunayEdgeCW( Point& p, bool e )
{
    if( &p == points_[0] )
    {
        delaunay_edge[1] = e;
    }
    else if( &p == points_[1] )
    {
        delaunay_edge[2] = e;
    }
    else
    {
        delaunay_edge[0] = e;
    }
}


// The neighbor across to given point
Triangle& Triangle::NeighborAcross( Point& opoint )
{
    if( &opoint == points_[0] )
    {
        return *neighbors_[0];
    }
    else if( &opoint == points_[1] )
    {
        return *neighbors_[1];
    }

    return *neighbors_[2];
}


void Triangle::DebugPrint()
{
    std::cout << points_[0]->x << "," << points_[0]->y << " ";
    std::cout << points_[1]->x << "," << points_[1]->y << " ";
    std::cout << points_[2]->x << "," << points_[2]->y << "\n";
}
}