1 | // |
---|
2 | // ******************************************************************** |
---|
3 | // * License and Disclaimer * |
---|
4 | // * * |
---|
5 | // * The Geant4 software is copyright of the Copyright Holders of * |
---|
6 | // * the Geant4 Collaboration. It is provided under the terms and * |
---|
7 | // * conditions of the Geant4 Software License, included in the file * |
---|
8 | // * LICENSE and available at http://cern.ch/geant4/license . These * |
---|
9 | // * include a list of copyright holders. * |
---|
10 | // * * |
---|
11 | // * Neither the authors of this software system, nor their employing * |
---|
12 | // * institutes,nor the agencies providing financial support for this * |
---|
13 | // * work make any representation or warranty, express or implied, * |
---|
14 | // * regarding this software system or assume any liability for its * |
---|
15 | // * use. Please see the license in the file LICENSE and URL above * |
---|
16 | // * for the full disclaimer and the limitation of liability. * |
---|
17 | // * * |
---|
18 | // * This code implementation is the result of the scientific and * |
---|
19 | // * technical work of the GEANT4 collaboration. * |
---|
20 | // * By using, copying, modifying or distributing the software (or * |
---|
21 | // * any work based on the software) you agree to acknowledge its * |
---|
22 | // * use in resulting scientific publications, and indicate your * |
---|
23 | // * acceptance of all terms of the Geant4 Software license. * |
---|
24 | // ******************************************************************** |
---|
25 | // |
---|
26 | // |
---|
27 | // $Id: G4NURBS.hh,v 1.10 2006/06/29 19:05:28 gunter Exp $ |
---|
28 | // GEANT4 tag $Name: geant4-09-03 $ |
---|
29 | // |
---|
30 | // Olivier Crumeyrolle 12 September 1996 |
---|
31 | |
---|
32 | // G4NURBS.hh |
---|
33 | // prototype for class G4NURBS - see documentation in graphics_reps/doc. |
---|
34 | // OC 280896 |
---|
35 | |
---|
36 | // Class Description: |
---|
37 | // Base class for shapes with NURBS drawing style. |
---|
38 | // See documentation in graphics_reps/doc for details. |
---|
39 | |
---|
40 | #ifndef __C_G4NURBS__ |
---|
41 | #define __C_G4NURBS__ 1 |
---|
42 | |
---|
43 | #include "globals.hh" |
---|
44 | #include "G4Visible.hh" |
---|
45 | |
---|
46 | // The internal floating point type is G4Float, defined line 162 |
---|
47 | |
---|
48 | #include "G4ios.hh" |
---|
49 | #include "G4Point3D.hh" |
---|
50 | #include "G4Vector3D.hh" |
---|
51 | |
---|
52 | class G4NURBS : public G4Visible |
---|
53 | { |
---|
54 | public: |
---|
55 | // NO public constructor. A G4NURBS must be builded with a child class. |
---|
56 | // Pure virtual function Whoami so one can't instanciate G4NURBS at all. |
---|
57 | |
---|
58 | // Whoami return a string describing the NURBS (e.g "Box") |
---|
59 | // * this string must not contain any \n * |
---|
60 | // this string is *not* yours (const char) |
---|
61 | virtual const char* Whoami() const = 0; |
---|
62 | |
---|
63 | // the copy constructor is private. |
---|
64 | |
---|
65 | // destructor. |
---|
66 | virtual ~G4NURBS(); |
---|
67 | |
---|
68 | // direction selector defined as a type because the user will use it |
---|
69 | // and we want the user to be well-manered. |
---|
70 | // However internally this typed enum is not as easy to use as it |
---|
71 | // could be (we can't ++). "t_" means it's a kind of local type. |
---|
72 | enum t_direction |
---|
73 | { |
---|
74 | U = 0, |
---|
75 | V = 1, |
---|
76 | DMask = 1, // NofD : Number of Directions |
---|
77 | NofD = 2 // DMask : direction mask for fast range control, |
---|
78 | }; // e.g. : m[a_dir & DMask] |
---|
79 | |
---|
80 | // external representation for t_direction (just U -> 'U' V -> 'V') |
---|
81 | static char Tochar(t_direction in_dir); |
---|
82 | |
---|
83 | // mother index type (I'd like to be able to use unsigned G4int |
---|
84 | // but it's impossible) |
---|
85 | typedef unsigned int t_index; |
---|
86 | |
---|
87 | // type for knot index, derivate from t_index |
---|
88 | typedef t_index t_indKnot; |
---|
89 | |
---|
90 | // type for ctrlpt coord and ctrlpt index |
---|
91 | typedef unsigned int t_indCoord; |
---|
92 | typedef unsigned int t_indCtrlPt; // mono index |
---|
93 | typedef t_index t_inddCtrlPt; // bi dim index, derivate from t_index |
---|
94 | |
---|
95 | // why only t_inddCtrlPt and t_indKnot (and t_order further) |
---|
96 | // "derive" of t_index ? Because only these ones need |
---|
97 | // to be compatible (order + nbrctrlpts = nbrknots in a given direction) |
---|
98 | // Ok, typedefs are not true type derivation, |
---|
99 | // but this is the "spirit" of declarations with t_index. |
---|
100 | // To do true derivation we need true classes |
---|
101 | // but classes for int are wastefull with today's compilers. |
---|
102 | |
---|
103 | // Note that these index types are defined |
---|
104 | // without knowledge of the indexed items types and that's perfect. |
---|
105 | |
---|
106 | // interface data type for the rationnal control points |
---|
107 | enum { X, Y, Z, W, NofC }; // NofC : number of coordinates |
---|
108 | |
---|
109 | // not typed as t_indCoord so loops are easy |
---|
110 | // to write, but the user is less restricted |
---|
111 | typedef G4double t_doubleCtrlPt [NofC]; // with doubles |
---|
112 | typedef G4float t_floatCtrlPt [NofC]; // with floats |
---|
113 | |
---|
114 | // access functions for others (e.g. GraphicsModel) |
---|
115 | G4int GetUorder() const; |
---|
116 | G4int GetVorder() const; |
---|
117 | G4int GetUnbrKnots() const; |
---|
118 | G4int GetVnbrKnots() const; |
---|
119 | G4int GetUnbrCtrlPts() const; |
---|
120 | G4int GetVnbrCtrlPts() const; |
---|
121 | G4int GettotalnbrCtrlPts() const; |
---|
122 | |
---|
123 | G4double GetUmin() const; |
---|
124 | G4double GetUmax() const; |
---|
125 | G4double GetVmin() const; |
---|
126 | G4double GetVmax() const; |
---|
127 | void CalcPoint(G4double u, G4double v, |
---|
128 | G4Point3D &p, G4Vector3D &utan, G4Vector3D &vtan) const; |
---|
129 | |
---|
130 | // alternate access functions with G4NURBS::t_direction |
---|
131 | // e.g. mynurb.Getorder(G4NURBS::U) |
---|
132 | // these functions never fail because in_dir is masked |
---|
133 | G4int Getorder(t_direction in_dir) const; |
---|
134 | G4int GetnbrKnots(t_direction in_dir) const; |
---|
135 | G4int GetnbrCtrlPts(t_direction in_dir) const; |
---|
136 | |
---|
137 | // crude access to knots vector and control points. |
---|
138 | // float and double versions. |
---|
139 | // * one should rather use the iterators below * |
---|
140 | |
---|
141 | // get a *copy* of the value; this copy is the user's |
---|
142 | // one, so the user is intended to manage it (including delete). |
---|
143 | // in_dir is masked, in_index checked and rounded. |
---|
144 | // errors on G4cerr |
---|
145 | G4float GetfloatKnot(t_direction in_dir, t_indKnot in_index) const; |
---|
146 | G4double GetdoubleKnot(t_direction in_dir, t_indKnot in_index) const; |
---|
147 | t_floatCtrlPt* GetfloatCtrlPt(t_indCtrlPt in_onedimindex) const; |
---|
148 | t_floatCtrlPt* GetfloatCtrlPt(t_inddCtrlPt in_Uindex, |
---|
149 | t_inddCtrlPt in_Vindex) const; |
---|
150 | t_doubleCtrlPt* GetdoubleCtrlPt(t_indCtrlPt in_onedimindex) const; |
---|
151 | t_doubleCtrlPt* GetdoubleCtrlPt(t_inddCtrlPt in_Uindex, |
---|
152 | t_inddCtrlPt in_Vindex) const; |
---|
153 | |
---|
154 | // complete copy functions |
---|
155 | // the user don't control the allocation and the copy process |
---|
156 | // but he/she own the result and will have to delete it |
---|
157 | // when he/she does not need it any more. |
---|
158 | G4float* GetfloatAllKnots(t_direction in_dir) const; |
---|
159 | G4double* GetdoubleAllKnots(t_direction in_dir) const; |
---|
160 | G4float* GetfloatAllCtrlPts() const; |
---|
161 | G4double* GetdoubleAllCtrlPts() const; |
---|
162 | |
---|
163 | // the iterators need that, the user does not |
---|
164 | |
---|
165 | protected: |
---|
166 | // internal type for reel numbers |
---|
167 | // ( Float is defined in templates.hh and is |
---|
168 | // under the control of HIGH_PRECISION ) |
---|
169 | typedef Float G4Float; |
---|
170 | |
---|
171 | public: |
---|
172 | |
---|
173 | // internal type for order, derivate from t_index |
---|
174 | typedef t_index t_order; |
---|
175 | |
---|
176 | // internal type for knot |
---|
177 | typedef G4Float t_Knot; |
---|
178 | |
---|
179 | protected: |
---|
180 | |
---|
181 | // internal types for the control points |
---|
182 | typedef G4Float t_Coord; |
---|
183 | typedef t_Coord t_CtrlPt [NofC]; |
---|
184 | |
---|
185 | // (nb: templates.hh included in globals.hh) |
---|
186 | // type for ref counting |
---|
187 | //typedef unsigned int t_refcount; |
---|
188 | |
---|
189 | public: |
---|
190 | // iterators for an .... iterative access to knots and control points |
---|
191 | |
---|
192 | // errors are reported on G4cerr |
---|
193 | // they are friends, they use the protected members. |
---|
194 | // one can have as many iterators as he/she wants working in the same time. |
---|
195 | |
---|
196 | // declarations of iterators |
---|
197 | class KnotsIterator; |
---|
198 | class CtrlPtsCoordsIterator; |
---|
199 | class CtrlPtsIterator; |
---|
200 | |
---|
201 | // friendness declarations for iterators |
---|
202 | friend class KnotsIterator; |
---|
203 | friend class CtrlPtsCoordsIterator; |
---|
204 | friend class CtrlPtsIterator; |
---|
205 | |
---|
206 | // Example for the KnotsIterator |
---|
207 | // G4float * my_array, * my_float_p; |
---|
208 | // my_float_p = my_array = new float [my_nurb.GetnbrKnots(G4NURBS::U)]; |
---|
209 | // G4NURBS::KnotsIterator my_iterator(my_nurb, G4NURBS::U); |
---|
210 | // while (my_iterator.pick(my_float_p++)); |
---|
211 | // that's all! my_array contain all the U knots. |
---|
212 | |
---|
213 | class KnotsIterator |
---|
214 | { |
---|
215 | public: |
---|
216 | KnotsIterator(const G4NURBS & in_rNurb, t_direction in_dir, |
---|
217 | t_indKnot in_startIndex = 0); |
---|
218 | G4bool pick(G4double * inout_pDbl); |
---|
219 | G4bool pick(G4float * inout_pFlt); |
---|
220 | //~KnotsIterator(); |
---|
221 | |
---|
222 | protected: |
---|
223 | const t_direction kmdir; |
---|
224 | const t_Knot * const kmpMax; |
---|
225 | const t_Knot * mp; |
---|
226 | }; |
---|
227 | |
---|
228 | // the CtrlPtsCoordsIterator. Works like the knots' one : |
---|
229 | // G4float * my_array, * my_float_p; |
---|
230 | // my_float_p = my_array = |
---|
231 | // new float [my_nurb.GettotalnbrCtrlPts()*G4NURBS::NofC*sizeof(float)]; |
---|
232 | // G4NURBS::CtrlPtsCoordsIterator my_iterator(my_nurb); |
---|
233 | // while (my_iterator.pick(my_float_p++)); |
---|
234 | // after the while statement; my_float_p point just after the array |
---|
235 | // Remember ctrlpts are given U index increasing first |
---|
236 | |
---|
237 | class CtrlPtsCoordsIterator |
---|
238 | { |
---|
239 | public: |
---|
240 | CtrlPtsCoordsIterator(const G4NURBS & in_rNurb, |
---|
241 | t_indCtrlPt in_startCtrlPtIndex = 0); |
---|
242 | G4bool pick(G4double * inout_pDbl); |
---|
243 | G4bool pick(G4float * inout_pFlt); |
---|
244 | //~CtrlPtsCoordsIterator(); |
---|
245 | |
---|
246 | protected: |
---|
247 | const t_Coord * const kmpMax; |
---|
248 | const t_Coord * mp; |
---|
249 | }; |
---|
250 | |
---|
251 | // this iterator work CtrlPt by CtrlPt |
---|
252 | // see the << overload for an example |
---|
253 | class CtrlPtsIterator |
---|
254 | { |
---|
255 | public: |
---|
256 | CtrlPtsIterator(const G4NURBS & in_rNurb, t_indCtrlPt in_startIndex = 0); |
---|
257 | G4bool pick(t_doubleCtrlPt * inout_pDblCtrlPt); |
---|
258 | G4bool pick(t_floatCtrlPt * inout_pFltCtrlPt); |
---|
259 | //~CtrlPtsIterator(); |
---|
260 | |
---|
261 | protected: |
---|
262 | const t_CtrlPt * const kmpMax; |
---|
263 | const t_CtrlPt * mp; |
---|
264 | }; |
---|
265 | |
---|
266 | // Q: a directional Iterator to extract one col/row of CtrlPts ? |
---|
267 | |
---|
268 | protected: |
---|
269 | |
---|
270 | // little structure containing data for each direction |
---|
271 | struct t_Dir |
---|
272 | { |
---|
273 | t_order order; |
---|
274 | t_inddCtrlPt nbrCtrlPts; |
---|
275 | t_indKnot nbrKnots; |
---|
276 | t_Knot * pKnots; |
---|
277 | //t_refcount nbralias; |
---|
278 | }; |
---|
279 | |
---|
280 | // check flag for the constructor |
---|
281 | typedef enum { NOcheck, check } t_CheckFlag; |
---|
282 | |
---|
283 | // first constructor (see G4NURBScylinder.cc for an example) |
---|
284 | // compulsory arguments : |
---|
285 | // order of the surface in U and V direction |
---|
286 | // number of control points in U and V direction |
---|
287 | // control points array (usualy empty here, *but* allocated) |
---|
288 | // optional arguments : |
---|
289 | // U and V knots vector (can be automaticaly generated) |
---|
290 | // check flag (default is to check!) |
---|
291 | // |
---|
292 | G4NURBS (t_order in_Uorder, t_order in_Vorder, |
---|
293 | t_inddCtrlPt in_UnbrCtrlPts, t_inddCtrlPt in_VnbrCtrlPts, |
---|
294 | t_CtrlPt * in_pCtrlPts, |
---|
295 | t_Knot * in_pUKnots = 0, t_Knot * in_pVKnots = 0, |
---|
296 | t_CheckFlag in_CheckFlag = check ); |
---|
297 | |
---|
298 | // NB: the minimal NURBS is order 1, 2 knots, => 1 control points |
---|
299 | // one can actually define some curves with G4NURBS, set U as you want |
---|
300 | // set the V dir as order 1, 1 ctrlpt, 2 knots { 0 1 } |
---|
301 | // OpenGL work with this kind of data |
---|
302 | |
---|
303 | // second constructor (easier to use) (see G4NURBStube.cc for an example) |
---|
304 | // compulsory arguments : |
---|
305 | // order of the surface in U and V direction |
---|
306 | // number of control points in U and V direction |
---|
307 | // optional arguments : |
---|
308 | // U and V knots vector generation flag (automaticaly or not) |
---|
309 | // check flag (default is to check!) |
---|
310 | // Allocations are Done for the user |
---|
311 | // but he/she still have to fill some arrays |
---|
312 | // For the moment I don't see yet how to ensure |
---|
313 | // that the user correctly fill the arrays |
---|
314 | // (in particular how avoid out of range access) |
---|
315 | // without class types for arrays. |
---|
316 | |
---|
317 | public: |
---|
318 | |
---|
319 | // knots vector generation flag |
---|
320 | enum t_KnotVectorGenFlag |
---|
321 | { |
---|
322 | UserDefined, // The user will fill the array (in the child constructor |
---|
323 | // for instance). |
---|
324 | |
---|
325 | Regular, // First and last knot repeated order time |
---|
326 | // other knots regularly spaced, unrepeated. |
---|
327 | // Typically used for "linear" knots vector |
---|
328 | |
---|
329 | RegularRep // First and last knot repeated order time |
---|
330 | // other knots regularly spaced but repeated one time. |
---|
331 | // Typically used for "circular" knots vector and alikes. |
---|
332 | }; //t_KnotVectorGenFlag |
---|
333 | |
---|
334 | protected: |
---|
335 | |
---|
336 | // external representation for t_KnotVectorGenFlag |
---|
337 | // as a << overload. |
---|
338 | // (used in errors report) |
---|
339 | friend std::ostream & operator << (std::ostream & inout_OutStream, |
---|
340 | t_KnotVectorGenFlag in_KVGFlag); |
---|
341 | |
---|
342 | G4NURBS (t_order in_Uorder, t_order in_Vorder, |
---|
343 | t_inddCtrlPt in_UnbrCtrlPts, t_inddCtrlPt in_VnbrCtrlPts, |
---|
344 | t_KnotVectorGenFlag in_UKVGFlag = Regular, |
---|
345 | t_KnotVectorGenFlag in_VKVGFlag = Regular, |
---|
346 | t_CheckFlag in_CheckFlag = check ); |
---|
347 | |
---|
348 | // nurbs data |
---|
349 | t_Dir m[NofD]; // t_Dir : order nbrCtrlPts nbrKnots pKnots |
---|
350 | t_indCtrlPt mtotnbrCtrlPts; // Total number of control points |
---|
351 | t_CtrlPt * mpCtrlPts; // U increasing first, V after |
---|
352 | //t_refcount mnbralias; // ref count for mpCtrlPts |
---|
353 | |
---|
354 | // 2dim index to 1 dim conversion |
---|
355 | t_indCtrlPt To1d(t_inddCtrlPt in_Uindex, t_inddCtrlPt in_Vindex) const; |
---|
356 | |
---|
357 | // internal functions for converting the internal |
---|
358 | // data points to the interface type required |
---|
359 | // one can do some better things with class conversion |
---|
360 | // but for the moment control point data types are not class. |
---|
361 | // static functions. |
---|
362 | // if changed to member functions, one must add the const |
---|
363 | // status and rewrite calls with an instance in |
---|
364 | // some of the get functions. |
---|
365 | |
---|
366 | // return a float copy |
---|
367 | static t_floatCtrlPt* TofloatCtrlPt(const t_CtrlPt &); |
---|
368 | |
---|
369 | // return a double copy |
---|
370 | static t_doubleCtrlPt* TodoubleCtrlPt(const t_CtrlPt &); |
---|
371 | |
---|
372 | |
---|
373 | // Building functions |
---|
374 | |
---|
375 | // KnotsVector builder |
---|
376 | // static function that work on a t_Dir and its |
---|
377 | // knot vector. So we can define |
---|
378 | // some knots vector outside a nurbs |
---|
379 | // object. (This avoid the existence |
---|
380 | // of some incompletly defined nurbs object, |
---|
381 | // used just as knots vector container) |
---|
382 | // Return true if succesfull. |
---|
383 | // ALWAYS allocate the knots array. |
---|
384 | // (return false and do nothing if it already exists (ie != 0)) |
---|
385 | // Always fail if order + nbrCtrlPt != nbrKnots |
---|
386 | static G4bool MakeKnotVector(t_Dir & inout_dirdat, |
---|
387 | t_KnotVectorGenFlag in_KVGFlag); |
---|
388 | static G4bool MakeKnotVector(t_Dir * p_inoutdirdat, |
---|
389 | t_KnotVectorGenFlag in_KVGFlag); |
---|
390 | |
---|
391 | static void CP(G4NURBS::t_CtrlPt & rcp, t_Coord x, t_Coord y, |
---|
392 | t_Coord z, t_Coord w); |
---|
393 | static void CP(G4NURBS::t_CtrlPt & rcp, t_Coord x, t_Coord y, |
---|
394 | t_Coord z, t_Coord w, G4Float factor); |
---|
395 | |
---|
396 | private: |
---|
397 | // check function used internally by constructors. |
---|
398 | // no returned value because all errors reported are fatals. |
---|
399 | // (assume order + nbrCtrlPts == nbrKnots |
---|
400 | // cf constructors to understand why) |
---|
401 | void Conscheck() const; |
---|
402 | |
---|
403 | // copy constructor. |
---|
404 | // Not really necessary for geant. A warning is issued when used. |
---|
405 | G4NURBS(const G4NURBS &); |
---|
406 | |
---|
407 | }; |
---|
408 | |
---|
409 | // external representation for t_KnotVectorGenFlag |
---|
410 | std::ostream & operator << (std::ostream & inout_OutStream, |
---|
411 | G4NURBS::t_KnotVectorGenFlag in_KVGFlag); |
---|
412 | |
---|
413 | |
---|
414 | // << overload to dump a nurbs |
---|
415 | // writted with public access functions |
---|
416 | // do not depends on protected part |
---|
417 | |
---|
418 | std::ostream & operator << (std::ostream & inout_outStream, |
---|
419 | const G4NURBS & in_kNurb); |
---|
420 | |
---|
421 | /*********************************************************************** |
---|
422 | * * |
---|
423 | * Inline code for public access functions. * |
---|
424 | * depends on the protected part * |
---|
425 | * * |
---|
426 | ***********************************************************************/ |
---|
427 | |
---|
428 | inline G4int G4NURBS::GetUorder() const { return m[U].order; } |
---|
429 | inline G4int G4NURBS::GetVorder() const { return m[V].order; } |
---|
430 | inline G4int G4NURBS::GetUnbrKnots() const { return m[U].nbrKnots; } |
---|
431 | inline G4int G4NURBS::GetVnbrKnots() const { return m[V].nbrKnots; } |
---|
432 | inline G4int G4NURBS::GetUnbrCtrlPts() const { return m[U].nbrCtrlPts; } |
---|
433 | inline G4int G4NURBS::GetVnbrCtrlPts() const { return m[V].nbrCtrlPts; } |
---|
434 | inline G4int G4NURBS::GettotalnbrCtrlPts() const { return mtotnbrCtrlPts; } |
---|
435 | |
---|
436 | inline G4double G4NURBS::GetUmin() const { |
---|
437 | return (G4double) m[U].pKnots[GetUorder()-1]; |
---|
438 | } |
---|
439 | |
---|
440 | inline G4double G4NURBS::GetUmax() const { |
---|
441 | return (G4double) m[U].pKnots[GetUnbrCtrlPts()]; |
---|
442 | } |
---|
443 | |
---|
444 | inline G4double G4NURBS::GetVmin() const { |
---|
445 | return (G4double) m[V].pKnots[GetVorder()-1]; |
---|
446 | } |
---|
447 | |
---|
448 | inline G4double G4NURBS::GetVmax() const { |
---|
449 | return (G4double) m[V].pKnots[GetVnbrCtrlPts()]; |
---|
450 | } |
---|
451 | |
---|
452 | inline G4int G4NURBS::Getorder(G4NURBS::t_direction in_dir) const { |
---|
453 | return m[in_dir & DMask].order; |
---|
454 | } |
---|
455 | |
---|
456 | inline G4int G4NURBS::GetnbrKnots(G4NURBS::t_direction in_dir) const { |
---|
457 | return m[in_dir & DMask].nbrKnots; |
---|
458 | } |
---|
459 | |
---|
460 | inline G4int G4NURBS::GetnbrCtrlPts(G4NURBS::t_direction in_dir) const { |
---|
461 | return m[in_dir & DMask].nbrCtrlPts; |
---|
462 | } |
---|
463 | |
---|
464 | inline char G4NURBS::Tochar(G4NURBS::t_direction in_dir) { |
---|
465 | return (in_dir?'V':'U'); |
---|
466 | } |
---|
467 | |
---|
468 | /*********************************************************************** |
---|
469 | * * |
---|
470 | * inline code for protected functions * |
---|
471 | * * |
---|
472 | ***********************************************************************/ |
---|
473 | |
---|
474 | // convert two dim. index to one dim. |
---|
475 | //( Ctrl Pts are stored U increasing first ) |
---|
476 | // no check. |
---|
477 | inline G4NURBS::t_indCtrlPt |
---|
478 | G4NURBS::To1d(t_inddCtrlPt in_Uindex, t_inddCtrlPt in_Vindex) const |
---|
479 | { |
---|
480 | return in_Uindex + in_Vindex*m[U].nbrCtrlPts; |
---|
481 | } |
---|
482 | |
---|
483 | // return a float copy |
---|
484 | inline G4NURBS::t_floatCtrlPt* |
---|
485 | G4NURBS::TofloatCtrlPt(const t_CtrlPt & in_krcp) |
---|
486 | { |
---|
487 | G4NURBS::t_floatCtrlPt * pcopy = new G4NURBS::t_floatCtrlPt [1]; |
---|
488 | for (G4int indCoord = X; indCoord < NofC; indCoord++) |
---|
489 | (*pcopy)[indCoord] = (G4float)in_krcp[indCoord]; |
---|
490 | return pcopy; |
---|
491 | } |
---|
492 | |
---|
493 | // return a double copy |
---|
494 | inline G4NURBS::t_doubleCtrlPt* |
---|
495 | G4NURBS::TodoubleCtrlPt(const t_CtrlPt & in_krcp) |
---|
496 | { |
---|
497 | G4NURBS::t_doubleCtrlPt * pcopy = new G4NURBS::t_doubleCtrlPt [1]; |
---|
498 | for (G4int indCoord = X; indCoord < NofC; indCoord++) |
---|
499 | (*pcopy)[indCoord] = (G4double)in_krcp[indCoord]; |
---|
500 | return pcopy; |
---|
501 | } |
---|
502 | |
---|
503 | // MakeKnotVector alias |
---|
504 | inline G4bool G4NURBS::MakeKnotVector(G4NURBS::t_Dir * p_inoutdirdat, |
---|
505 | G4NURBS::t_KnotVectorGenFlag in_KVGFlag) |
---|
506 | { |
---|
507 | return MakeKnotVector(*p_inoutdirdat, in_KVGFlag); |
---|
508 | } |
---|
509 | |
---|
510 | /*********************************************************************** |
---|
511 | * * |
---|
512 | * inlines functions to simplify control points definition * |
---|
513 | * see GG4NURBSbox.cc for instance * |
---|
514 | * * |
---|
515 | ***********************************************************************/ |
---|
516 | |
---|
517 | inline void G4NURBS::CP(G4NURBS::t_CtrlPt & rcp, |
---|
518 | t_Coord x, t_Coord y, t_Coord z, t_Coord w) |
---|
519 | { |
---|
520 | rcp[G4NURBS::X]=x; |
---|
521 | rcp[G4NURBS::Y]=y; |
---|
522 | rcp[G4NURBS::Z]=z; |
---|
523 | rcp[G4NURBS::W]=w; |
---|
524 | } |
---|
525 | |
---|
526 | // with a common factor |
---|
527 | inline void G4NURBS::CP(G4NURBS::t_CtrlPt & rcp, t_Coord x, |
---|
528 | t_Coord y, t_Coord z, t_Coord w, G4Float factor) |
---|
529 | { |
---|
530 | rcp[G4NURBS::X]=factor*x; |
---|
531 | rcp[G4NURBS::Y]=factor*y; |
---|
532 | rcp[G4NURBS::Z]=factor*z; |
---|
533 | rcp[G4NURBS::W]=factor*w; |
---|
534 | } |
---|
535 | |
---|
536 | #endif /* end of __C_G4NURBS__ */ |
---|