triangle_2d.h

Go to the documentation of this file.

// -*-c++-*-

 
/*
 *Copyright:
 
 Copyright (C) Hidehisa Akiyama, Hiroki Shimora
 
 This code is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 *EndCopyright:
 */

 
#ifndef RCSC_GEOM_TRIANGLE2D_H
#define RCSC_GEOM_TRIANGLE2D_H
 
#include <geom/region_2d.h>
#include <geom/vector_2d.h>
#include <geom/segment_2d.h>
 
namespace rcsc {
 
class Line2D;
class Ray2D;

class Triangle2D
    : public Region2D {
private:
    Vector2D M_a; 
    Vector2D M_b; 
    Vector2D M_c; 

    Triangle2D();
public:
    Triangle2D( const Vector2D & v1,
                const Vector2D & v2,
                const Vector2D & v3 )
        : M_a( v1 )
        , M_b( v2 )
        , M_c( v3 )
      { }

    Triangle2D( const Segment2D & seg,
                const Vector2D & v )
        : M_a( seg.origin() )
        , M_b( seg.terminal() )
        , M_c( v )
      { }

    const
    Triangle2D & assign( const Vector2D & v1,
                         const Vector2D & v2,
                         const Vector2D & v3 )
      {
          M_a = v1;
          M_b = v2;
          M_c = v3;
          return *this;
      }

    bool isValid() const
      {
          return M_a.isValid()
              && M_b.isValid()
              && M_c.isValid()
              && M_a != M_b
              && M_b != M_c
              && M_a != M_a;
      }

    const
    Triangle2D & assign( const Segment2D & seg,
                         const Vector2D & v )
      {
          M_a = seg.origin();
          M_b = seg.terminal();
          M_c = v;
          return *this;
      }

    const
    Vector2D & a() const
      {
          return M_a;
      }

    const
    Vector2D & b() const
      {
          return M_b;
      }

    const
    Vector2D & c() const
      {
          return M_c;
      }

    virtual
    double area() const
      {
          // outer product == area of parallelogram(Heikou Shihenkei)
          // triangle area is a half of parallelogram area
          return std::fabs( ( b() - a() ).outerProduct( c() - a() ) ) * 0.5;
      }

    double signedArea() const
      {
          //return doubleSignedArea() / 2.0;
          return signed_area( a(), b(), c() );
      }

    double doubleSignedArea() const
      {
          //return ( ( a().x - c().x ) * ( b().y - c().y )
          //         + ( b().x - c().x ) * ( c().y - a().y ) );
          return double_signed_area( a(), b(), c() );
      }

    bool ccw() const
      {
          return ccw( a(), b(), c() );
      }

    virtual
    bool contains( const Vector2D & point ) const;

    Vector2D centroid() const
      {
          return centroid( a(), b(), c() );
      }

    Vector2D incenter() const
      {
          return incenter( a(), b(), c() );
      }

    Vector2D circumcenter() const
      {
          return circumcenter( a(), b(), c() );
      }

    Vector2D orthocenter() const
      {
          return orthocenter( a(), b(), c() );
      }
 
    //brief get the excenter coordinates(BOU-SIN)
    //return coordinates of excenter
    //Vector2D excenter() const;

    int intersection( const Line2D & line,
                      Vector2D * sol1,
                      Vector2D * sol2 ) const;

    int intersection( const Ray2D & ray,
                      Vector2D * sol1,
                      Vector2D * sol2 ) const;

    int intersection( const Segment2D & segment,
                      Vector2D * sol1,
                      Vector2D * sol2 ) const;
 
 
    //
    // static methods
    //

    static
    double double_signed_area( const Vector2D & a,
                               const Vector2D & b,
                               const Vector2D & c )
      {
          return ( ( a.x - c.x ) * ( b.y - c.y )
                   + ( b.x - c.x ) * ( c.y - a.y ) );
      }

    static
    double signed_area( const Vector2D & a,
                        const Vector2D & b,
                        const Vector2D & c )
      {
          return double_signed_area( a, b, c ) * 0.5;
      }

    static
    bool ccw( const Vector2D & a,
              const Vector2D & b,
              const Vector2D & c )
      {
          return double_signed_area( a, b, c ) > 0.0;
      }

    static
    Vector2D centroid( const Vector2D & a,
                       const Vector2D & b,
                       const Vector2D & c )
      {
          //Vector2D g( a );
          //g += b;
          //g += c;
          //g /= 3.0;
          //return g;
          return Vector2D( a ).add( b ).add( c ) /= 3.0;
      }

    static
    Vector2D incenter( const Vector2D & a,
                       const Vector2D & b,
                       const Vector2D & c );

    static
    Vector2D circumcenter( const Vector2D & a,
                           const Vector2D & b,
                           const Vector2D & c );

    static
    Vector2D orthocenter( const Vector2D & a,
                          const Vector2D & b,
                          const Vector2D & c );

    static
    bool contains( const Vector2D & a,
                   const Vector2D & b,
                   const Vector2D & c,
                   const Vector2D & point );
 
};
 
}
 
#endif