mirror of https://github.com/CGAL/cgal
258 lines
8.7 KiB
C++
258 lines
8.7 KiB
C++
// Copyright (c) 2001 Utrecht University (The Netherlands),
|
|
// ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany),
|
|
// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg
|
|
// (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria),
|
|
// and Tel-Aviv University (Israel). All rights reserved.
|
|
//
|
|
// This file is part of CGAL (www.cgal.org); 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; version 2.1 of the License.
|
|
// See the file LICENSE.LGPL distributed with CGAL.
|
|
//
|
|
// Licensees holding a valid commercial license may use this file in
|
|
// accordance with the commercial license agreement provided with the software.
|
|
//
|
|
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
|
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
//
|
|
// $URL$
|
|
// $Id$
|
|
//
|
|
//
|
|
// Author(s) :
|
|
|
|
#ifndef CGAL_PS_FACET_3_H
|
|
#define CGAL_PS_FACET_3_H
|
|
|
|
#include <CGAL/basic.h>
|
|
|
|
#include <algorithm>
|
|
#include <map>
|
|
#include <utility>
|
|
#include <vector>
|
|
#include <CGAL/Cartesian.h>
|
|
#include <CGAL/Point_2.h>
|
|
#include <CGAL/Point_3.h>
|
|
#include <CGAL/IO/Color.h>
|
|
#include <CGAL/IO/PS_edge_3.h>
|
|
#include <CGAL/Plane_3.h>
|
|
#include <CGAL/Line_3.h>
|
|
#include <CGAL/Vector_3.h>
|
|
#include <CGAL/intersections.h>
|
|
#include <CGAL/Aff_transformation_3.h>
|
|
|
|
//Include for the polygon
|
|
#include <CGAL/Polygon_2.h>
|
|
|
|
//Include for the Arrangement
|
|
#include <CGAL/Arithmetic_filter.h>
|
|
#include <CGAL/leda_real.h>
|
|
#include <CGAL/double.h>
|
|
#include <CGAL/Arr_2_bases.h>
|
|
#include <CGAL/Arr_2_default_dcel.h>
|
|
#include <CGAL/Arr_segment_exact_traits.h>
|
|
#include <CGAL/Arrangement_2.h>
|
|
|
|
CGAL_BEGIN_NAMESPACE
|
|
|
|
enum FILLING{NO_FILL,WIRED_CULLBACK_FACING,UNIFORM_FILL,NORMAL_FILL};
|
|
enum PROJECTION{XY,YZ,ZX};
|
|
|
|
typedef double coord_type;
|
|
//typedef leda_real coord_type;
|
|
typedef CGAL::Cartesian< coord_type > CT;
|
|
typedef CGAL::Cartesian < leda_real > R;
|
|
typedef Point_2< CT > Point2;
|
|
typedef Point_3< CT > Point3;
|
|
typedef Plane_3< CT > Plane3;
|
|
typedef Line_3 < CT > Line3;
|
|
typedef Vector_3< CT > Vector3;
|
|
typedef Vector_2< CT > Vector2;
|
|
typedef Aff_transformation_3< CT > Transformation;
|
|
|
|
//The polygon for the xy_plan_overlap got Point in leda_real
|
|
typedef Point_2< R > Point2_Leda;
|
|
typedef Polygon_traits_2< R > Traits_poly;
|
|
typedef Traits_poly::Segment_2 Segment2;
|
|
typedef Traits_poly::Vector_2 Vector2_Leda;
|
|
typedef vector<Point2_Leda> Container_poly;
|
|
typedef Polygon_2<Traits_poly,Container_poly> Poly;
|
|
|
|
//Arrangement is in LEDA_REAL
|
|
typedef CGAL::Cartesian< leda_real > Arr_CT;
|
|
typedef Arr_CT Arr_Rep;
|
|
typedef CGAL::Arr_segment_exact_traits<Arr_Rep> Traits_arr;
|
|
typedef Traits_arr::Point Arr_Point2;
|
|
typedef Traits_arr::X_curve X_curve;
|
|
typedef Traits_arr::Curve Curve;
|
|
typedef CGAL::Arr_base_node<Curve> Base_node;
|
|
typedef CGAL::Arr_2_default_dcel<Traits_arr> Dcel;
|
|
typedef CGAL::Arrangement_2<Dcel,Traits_arr,Base_node > Arr_2;
|
|
typedef Arr_2::Curve_node Curve_node;
|
|
|
|
class PS_facet_3 {
|
|
|
|
public:
|
|
|
|
//Exception due to a bad index
|
|
class BadIndex : public std::exception {};
|
|
//Constructors
|
|
|
|
//Constructor with a list of point3
|
|
//Precondition : the list must contain the points in the
|
|
// trigonometric positive way
|
|
PS_facet_3(vector<Point3> &V,Color edge_color = RED ,Color
|
|
filling_color = BLACK, FILLING
|
|
f=NO_FILL,int number=0,bool m=false);
|
|
//Constructor with a list of PS_edge_3
|
|
//Precondition : the list must contain the edges in the
|
|
// trigonometric positive
|
|
PS_facet_3(vector<PS_edge_3> &V,Color color= BLACK,FILLING
|
|
f=NO_FILL,int number=0,bool m=false);
|
|
|
|
// Copy constructor
|
|
PS_facet_3(const PS_facet_3 &face);
|
|
|
|
//Inline functions
|
|
|
|
//Accessors
|
|
//Return the number of edge of the facet.(Visible+Invisible)
|
|
inline int number_of_edge() const {return _number_of_edge;}
|
|
//Return the facet color
|
|
inline Color color() const {return _face_color;}
|
|
//Return the gray level of the facet
|
|
inline double gray_level() const {return _grey_level;}
|
|
//Return the PS_edge_3 vector
|
|
inline vector<PS_edge_3> get_Vect_Arete() const { return Face_Arete;}
|
|
//Return the type of filling of the facet
|
|
inline FILLING filling() const {return _filling;}
|
|
//Return the type of projection of the facet
|
|
inline PROJECTION projection() const {return _projection;}
|
|
//Return the mark of the facet
|
|
inline bool mark() const {return _mark;}
|
|
//Return the map of the facet
|
|
inline map<Curve_node *,PS_edge_3 *> map() const {return mapp;}
|
|
//Return the number of the facet
|
|
inline int number_of_the_facet() const {return _number_of_the_facet;}
|
|
|
|
//Settings
|
|
//Modify the type of filling of the facet
|
|
inline void set_filling(FILLING f) {_filling=f;}
|
|
//Modify the color of the facet
|
|
inline void set_color(Color c) {_face_color=c;}
|
|
//Modify the gray level.
|
|
inline void set_gray_level(double c) {_grey_level=c;}
|
|
//Modify the type of projection of the facet
|
|
inline void set_projection(PROJECTION p) {_projection=p;}
|
|
//Modify the mark of the facet
|
|
inline void set_mark(bool m) {_mark=m;}
|
|
//Modify the number of the facet
|
|
inline void set_number_of_the_facet(int i) {_number_of_the_facet=i;}
|
|
|
|
// Operators
|
|
|
|
// Access operator for the i edge of the facet
|
|
const PS_edge_3 operator[](int i) const throw(BadIndex);
|
|
// Assignment/Access operator for the i edge of the facet
|
|
PS_edge_3 operator[](int i) throw (BadIndex);
|
|
// Assignment operator
|
|
PS_facet_3 operator= (const PS_facet_3 face);
|
|
//Assignment/Access operator according a PS_edge_3(Useful to define
|
|
//a PS_edge_3 like a facet(and also a point3 to be a facet)
|
|
PS_facet_3 operator= (const PS_edge_3 ar);
|
|
|
|
friend ostream& operator<<(ostream& os,const PS_facet_3 &face);
|
|
|
|
// Others functions
|
|
|
|
//Allows to add a new edge in the face
|
|
void add(PS_edge_3 &arete){Face_Arete.push_back(arete);_number_of_edge++;}
|
|
|
|
//Return the minimum or the maximun of the edges of the facet
|
|
//according the x,y,z
|
|
coord_type xmin(); coord_type ymin(); coord_type zmin();
|
|
coord_type xmax(); coord_type ymax(); coord_type zmax();
|
|
|
|
//Return the maximum(minimum) of the x,y,z maximum(minimum)
|
|
coord_type max(); coord_type min();
|
|
//Check if the two facet P(this) and Q overlap in x
|
|
bool is_x_overlap(PS_facet_3& Q);
|
|
//Check if the two facet P(this) and Q overlap in y
|
|
bool is_y_overlap(PS_facet_3& Q);
|
|
//Check if the two facet P(this) and Q overlap in z
|
|
bool is_z_overlap(PS_facet_3& Q);
|
|
//Check if the facet P(this) is behind the facet Q
|
|
bool is_back_side(PS_facet_3& Q);
|
|
//Check if the facet P(this) is in front of the facet Q
|
|
bool is_front_side(PS_facet_3& Q);
|
|
|
|
//Compute the second two test of the Depth Sort Algorithm
|
|
bool two_test(PS_facet_3& Q);
|
|
//Compute the first five test of the Depth Sort Algorithm
|
|
bool five_test(PS_facet_3& Q);
|
|
//test to know if there is a cycle
|
|
bool has_a_cycle(PS_facet_3& Q);
|
|
|
|
//Check the type of projection for the facet
|
|
void check_projection();
|
|
//Make the projection of a Point3 according the PROJECTION variable
|
|
Arr_Point2 projection(Point3 q);
|
|
//Give the point3 which correspond to the point2 projected
|
|
Point3 lift(Arr_Point2 p);
|
|
//Make the arrangement of the face with the Line3 l which cut the face
|
|
int make_arrangement(PS_edge_3 &l);
|
|
//To recover the facet of the arrangement
|
|
vector<PS_facet_3> create_facets(PS_edge_3 &l);
|
|
//Check if the projection of the two PS_facet_3 overlap in the plan XY
|
|
bool is_xy_plan_overlap(PS_facet_3 &Q);
|
|
//Make the transformation to z-axis view
|
|
void transformation(Transformation &t);
|
|
|
|
//Return the cross product of the two vectors
|
|
leda_real cp(Vector2_Leda p,Vector2_Leda q) {
|
|
return (p.x() * q.y() - q.x() * p.y());
|
|
}
|
|
|
|
//Return the determinant of the 3 point p,q and r
|
|
leda_real det(Point2_Leda p,Point2_Leda q,Point2_Leda r) {
|
|
return cp(p-q,p-r);
|
|
}
|
|
|
|
//Return the sign of x
|
|
int sign(double x) {
|
|
if (x>0) {return 1;}
|
|
else if (x<0) { return -1;}
|
|
else {return 0;}
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
//Vector of edge of the facet
|
|
vector<PS_edge_3> Face_Arete;
|
|
//Facet color
|
|
Color _face_color;
|
|
//Number of edge of the facet;
|
|
int _number_of_edge;
|
|
//Type of filling of the facet
|
|
//NO_FILL,UNIFORM_FILL,NORMAL_FILL
|
|
FILLING _filling;
|
|
//Gray level of the facet
|
|
double _grey_level;
|
|
//Type of projection for the facet
|
|
PROJECTION _projection;
|
|
//Arrangement of the face
|
|
Arr_2 arr;
|
|
//Map
|
|
std::map<Curve_node *,PS_edge_3 *> mapp;
|
|
//Number of the facet : use to avoid cutting two facets that comes
|
|
//from the same facet
|
|
int _number_of_the_facet;
|
|
//Mark to avoid cycle
|
|
bool _mark;
|
|
};
|
|
|
|
CGAL_END_NAMESPACE
|
|
|
|
#endif // CGAL_PS_FACET_3_H
|