/*
----
This file is part of SECONDO.

Copyright (C) 2008, University in Hagen, Department of Computer Science,
Database Systems for New Applications.

SECONDO is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

SECONDO 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with SECONDO; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
----

//paragraph [1] Title: [{\Large \bf \begin {center}] [\end {center}}]
//[TOC] [\tableofcontents]
//[ue] [\"u]
//[ae] [\"a]
//[oe] [\"o]
//[x] [$\times $]
//[->] [$\rightarrow $]

[1] Headerfile of the Segment classes

April - November 2008, M. H[oe]ger for bachelor thesis.

[TOC]

1 Introduction

This file contains the definitions of the classes Segment2D and Segment3D.

2 Defines and Includes

*/


#ifndef SEGMENT_H_
#define SEGMENT_H_

#include "PointVector.h"

namespace temporalalgebra{

namespace mregionops {

/*
3 Class Segment3D

This class provides an oriented segment in the euclidian space.
It's start- and endpoint is represented by a Point3D each.

*/
class Segment3D {

public:
    
/*
3.1 Constructors

*/   

    inline Segment3D() {
        
    }

    inline Segment3D(const Point3D& _start, const Point3D& _end) :
        start(_start), end(_end) {

    }
    
/*
3.2 Getter methods.

*/

    inline const Point3D& GetStart() const {

        return start;
    }
    inline const Point3D& GetEnd() const {

        return end;
    }
    
/*
3.3 Operators and Predicates
        
3.3.1 IsOrthogonalToTAxis

Returns ~true~, if this is parallel to the xy-plane.

*/   

    inline const bool IsOrthogonalToTAxis() const {
        
        return NumericUtil::NearlyEqual(start.GetT(), end.GetT());
    }
    
/*
3.3.2 Length
        
Returns the length of this segment.

*/    
    
    inline double Length() const {

        return (end - start).Length();
    }
    
/*
3.3.3 Length2
            
Returns the quadratic length of this segment.

*/       
    
    inline double Length2() const {

        return (end - start).Length2();
    }

private:

    Point3D start, end;
};

/*
4 Class Segment2D

This class provides an oriented segment in the euclidian plane.
It's start- and endpoint is represented by a Point2D each.

*/
class Segment2D {

public:
    
/*
4.1 Constructors

*/   
    
    inline Segment2D() {
        
    }

    inline Segment2D(const Point2D& p1, 
                     const Point2D& p2,
                     const bool sort = false) {

        if (sort && p2 < p1) {
            
            start = p2;
            end = p1;
            
        } else { // !sort || p1 <= p2
            
            start = p1;
            end = p2;
        }
    }
    
    inline Segment2D(const Segment3D& s) {
        
        start = Point2D(s.GetStart());
        end = Point2D(s.GetEnd());
    }
    
/*
4.2 Getter methods.

*/    
                         
    inline const Point2D& GetStart() const {

        return start;
    }

    inline const Point2D& GetEnd() const {

        return end;
    }
    
/*
4.3 Operators and Predicates
            
4.3.1 IsParallel

Returns ~true~, if this is parallel to s.

*/       

    inline bool IsParallel(const Segment2D& s) const {

        Vector2D v1 = end - start;
        Vector2D v2 = s.end - s.start;

        v1.Normalize();
        v2.Normalize();
        const double d = v1 | v2;

        return NumericUtil::NearlyEqual(d, 0.0);
    }
    
/*
4.3.2 IsColinear

Returns ~true~, if this is colinear to s.

*/  
    
    inline bool IsColinear(const Segment2D& s) const {
        
        return start.IsColinear(s) && end.IsColinear(s);
    }

/*
4.3.3 IsVertical

Returns ~true~, if start.x equals end.x

*/  
    
    inline bool IsVertical() const {

        return NumericUtil::NearlyEqual(start.GetX(), end.GetX());
    }

/*
4.3.4 IsHorizontal

Returns ~true~, if start.y equals end.y

*/ 
    
    inline bool IsHorizontal() const {

        return NumericUtil::NearlyEqual(start.GetY(), end.GetY());
    }

/*
3.3.5 Length
        
Returns the length of this segment.

*/    
    
    inline double Length() const {

        return (end - start).Length();
    }

/*
3.3.6 Length2
        
Returns the quadratic length of this segment.

*/   

    inline double Length2() const {

        return (end - start).Length2();
    }

/*
3.3.7 Flip
        
Swaps the start- and endpoint of this segment.

*/   
    
    inline void Flip() {
        
        Point2D temp = start;
        
        start = end;
        end = temp;
    }

private:

    Point2D start, end;
};

/*
4 Overloaded output operators
    
*/ 

std::ostream& operator <<(std::ostream& o, const Segment2D& s);
std::ostream& operator <<(std::ostream& o, const Segment3D& s);

} // end of namespace mregionops

} // end of namespace temporalalgebra

#endif /*SEGMENT_H_*/