← Back to branch summary

~ubuntu-branches/debian/jessie/ugene/jessie

« back to all changes in this revision

Viewing changes to src/plugins_3rdparty/ball/src/include/BALL/STRUCTURE/SASEdge.h

  • Committer: Package Import Robot
  • Author(s): Steffen Moeller
  • Date: 2011-11-02 13:29:07 UTC
  • mfrom: (1.2.1) (3.1.11 natty)
  • Revision ID: package-import@ubuntu.com-20111102132907-o34gwnt0uj5g6hen
Tags: 1.9.8+repack-1
* First release to Debian
  - added README.Debian
  - increased policy version to 3.9.2
  - added URLs for version control system
* Added debug package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins_3rdparty/ball/src/include/BALL/STRUCTURE/SASEdge.h
 
1
// -*- Mode: C++; tab-width: 2; -*-
 
2
// vi: set ts=2:
 
3
//
 
4
// $Id: SASEdge.h,v 1.9 2005-12-23 17:02:01 amoll Exp $
 
5
//
 
6
 
 
7
#ifndef BALL_STRUCTURE_SASEDGE_H
 
8
#define BALL_STRUCTURE_SASEDGE_H
 
9
 
 
10
#ifndef BALL_STRUCTURE_GRAPHEDGE_H
 
11
#       include <BALL/STRUCTURE/graphEdge.h>
 
12
#endif
 
13
 
 
14
#ifndef BALL_MATHS_ANGLE_H
 
15
#       include <BALL/MATHS/angle.h>
 
16
#endif
 
17
 
 
18
#ifndef BALL_MATHS_CIRCLE3_H
 
19
#       include <BALL/MATHS/circle3.h>
 
20
#endif
 
21
 
 
22
namespace BALL
 
23
{
 
24
 
 
25
        class SolventAccessibleSurface;
 
26
        class SASFace;
 
27
        class SASVertex;
 
28
        class RSEdge;
 
29
        class TriangulatedSAS;
 
30
        class SASTriangulator;
 
31
 
 
32
        /** Generic SASEdge Class.
 
33
        \ingroup Surface                        
 
34
        */
 
35
        class BALL_EXPORT SASEdge       :       public GraphEdge< SASVertex,SASEdge,SASFace >
 
36
        {
 
37
                public:
 
38
 
 
39
                /** @name Class friends
 
40
                
 
41
                                        - class SASFace
 
42
                                        - class SASVertex
 
43
                                        - class SolventAccessibleSurface
 
44
                                        - class TriangulatedSAS
 
45
                                        - class SASTriangulator
 
46
                                
 
47
                */
 
48
                friend class SASVertex;
 
49
                friend class SASFace;
 
50
                friend class SolventAccessibleSurface;
 
51
                friend class TriangulatedSAS;
 
52
                friend class SASTriangulator;
 
53
 
 
54
                BALL_CREATE(SASEdge)
 
55
 
 
56
                /**     @name   Constructors and Destructors
 
57
                */
 
58
                //@{
 
59
 
 
60
                /**     Default constructor.
 
61
                                This method creates a new SASEdge object.
 
62
                */
 
63
                SASEdge()
 
64
                        throw();
 
65
 
 
66
                /**     Copy constructor.
 
67
                                Create a new SASEdge object from another.
 
68
                                @param  sasedge the SASEdge object to be copied
 
69
                                @param  deep            if deep = false, all pointers are set to NULL   
 
70
                                                                                                (default). Otherwise the new SASEdge object is linked   
 
71
                                                                                                to the neighbours of the old SASEdge object.
 
72
                */
 
73
                SASEdge(const SASEdge& sasedge, bool deep = false)
 
74
                        throw();
 
75
 
 
76
                /**     Detailled constructor.
 
77
                                Create a new SASEdge object from some nice objects.
 
78
                                @param  vertex0 assigned to the first vertex
 
79
                                @param  vertex1 assigned to the second vertex
 
80
                                @param  face0           assigned to the first face
 
81
                                @param  face1           assigned to the second face
 
82
                                @param  circle  assigned to the circle
 
83
                                @param  angle           assigned to the angle
 
84
                                @param  index           assigned to the index
 
85
                */
 
86
                SASEdge(SASVertex* vertex0,
 
87
                                SASVertex* vertex1,
 
88
                                SASFace* face0,
 
89
                                SASFace* face1,
 
90
                                const TCircle3<double>& circle,
 
91
                                const TAngle<double>& angle,
 
92
                                Index index)
 
93
                        throw();
 
94
 
 
95
                /**     Destructor.
 
96
                                Destructs the SASEdge object.
 
97
                */
 
98
                virtual ~SASEdge()
 
99
                        throw();
 
100
 
 
101
                //@}
 
102
                /**     @name   Assignment
 
103
                */
 
104
                //@{
 
105
 
 
106
                /**     Assign from another SASEdge object.
 
107
                                @param  sasedge the SASEdge object to assign from
 
108
                                @param  deep            if deep = false, all pointers are set to NULL   
 
109
                                                                                                (default). Otherwise the SASEdge object is linked to    
 
110
                                                                                                the neighbours of the SASEdge object to assign from.
 
111
                */
 
112
                void set(const SASEdge& sasedge, bool deep = false)
 
113
                        throw();
 
114
 
 
115
                /**     Assign from another SASEdge object.
 
116
                                The SASEdge object is linked to the neighbours of the SASEdge object    
 
117
                                to assign from.
 
118
                                @param  sasedge the SASEdge object to assign from
 
119
                */
 
120
                SASEdge& operator = (const SASEdge& sasedge)
 
121
                        throw();
 
122
 
 
123
                /**     Assign from some nice objects.
 
124
                                @param  vertex0 assigned to the first vertex
 
125
                                @param  vertex1 assigned to the second vertex
 
126
                                @param  face0           assigned to the first face
 
127
                                @param  face1           assigned to the second face
 
128
                                @param  circle  assigned to the circle
 
129
                                @param  angle           assigned to the angle
 
130
                                @param  index           assigned to the index
 
131
                */
 
132
                void set(SASVertex* vertex0,
 
133
                                SASVertex* vertex1,
 
134
                                SASFace* face0,
 
135
                                SASFace* face1,
 
136
                                const TCircle3<double>& circle,
 
137
                                const TAngle<double>& angle,
 
138
                                Index index)
 
139
                        throw();
 
140
 
 
141
                //@}
 
142
                /**     @name   Accessors
 
143
                */
 
144
                //@{
 
145
 
 
146
                /** Set the circle on which the SASEdge lies.
 
147
                                @param  center  the new circle
 
148
                */
 
149
                void setCircle(const TCircle3<double>& center)
 
150
                        throw();
 
151
 
 
152
                /** Return the circle on which the SASEdge lies.
 
153
                                @return TCircle3<double>        the circle of the SASEdge
 
154
                */
 
155
                TCircle3<double> getCircle() const
 
156
                        throw();
 
157
 
 
158
                /** Set the angle of the SASEdge.
 
159
                                @param  angle   the new angle
 
160
                */
 
161
                void setAngle(const TAngle<double>& angle)
 
162
                        throw();
 
163
 
 
164
                /** Return the angle of the SASEdge.
 
165
                                @return TAngle<double>  the angle of the SASEdge
 
166
                */
 
167
                TAngle<double> getAngle() const
 
168
                        throw();
 
169
 
 
170
                //@}
 
171
                /**     @name   Predicates
 
172
                */
 
173
                //@{
 
174
 
 
175
                /**     Equality operator.
 
176
                                @return bool    <b>true</b>
 
177
                */
 
178
                virtual bool operator == (const SASEdge&) const
 
179
                        throw();
 
180
 
 
181
                /**     Inequality operator.
 
182
                                @return bool    <b>false</b>
 
183
                */
 
184
                virtual bool operator != (const SASEdge&) const
 
185
                        throw();
 
186
 
 
187
                /**     Similarity operator.
 
188
                                @return bool    <b>true</b>
 
189
                */
 
190
                virtual bool operator *= (const SASEdge&) const
 
191
                        throw();
 
192
 
 
193
                /** isFree.
 
194
                                @return bool    <b>true</b> if the RSEdge of the SASEdge is free,       
 
195
                                                                                        <b>false</b> otherwise
 
196
                */
 
197
                bool isFree() const
 
198
                        throw();
 
199
 
 
200
                //@}
 
201
                
 
202
                protected:
 
203
                
 
204
                /*_     @name   Attributes
 
205
                */
 
206
                //@{
 
207
 
 
208
                /*_ The circle on which the SASEdge lies.
 
209
                */
 
210
                TCircle3<double> circle_;
 
211
                /*_ The angle of the SASEdge.
 
212
                */
 
213
                TAngle<double> angle_;
 
214
 
 
215
                //@}
 
216
        };
 
217
 
 
218
        /**     @name   Storers
 
219
        */
 
220
        //@{
 
221
 
 
222
        /**     Output- Operator
 
223
        */
 
224
        BALL_EXPORT std::ostream& operator << (std::ostream& s, const SASEdge& sasedge);
 
225
 
 
226
        //@}
 
227
 
 
228
 
 
229
} // namespace BALL
 
230
 
 
231
#endif // BALL_STRUCTURE_SASEDGE_H