?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updating the changelog in the VERSION file, and version_sync.
[shapes.git] / source / computeelementarypath.cc
blobfb54e98e5e54114cb06ba156f017e1e67f8e1971
1 /* This file is part of Shapes.
2 *
3 * Shapes is free software: you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation, either version 3 of the License, or
6 * any later version.
7 *
8 * Shapes is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with Shapes. If not, see <http://www.gnu.org/licenses/>.
15 *
16 * Copyright 2008 Henrik Tidefelt
17 */
18
19 #include <cmath>
20
21 #include "shapestypes.h"
22 #include "shapesexceptions.h"
23 #include "consts.h"
24 #include "angleselect.h"
25
26 #include <stack>
27
28 using namespace Shapes;
29 using namespace std;
30
31
32 void
33 Lang::CompositePath2D::computeElementaryPath( ) const
34 {
35 if( elementaryPath_ != NullPtr< const Lang::ElementaryPath2D >( ) )
36 {
37 return;
38 }
39 Lang::ElementaryPath2D * pth = new Lang::ElementaryPath2D;
40
41 const double GAMMA_ANGLE = 0.5;
42
43 Concrete::Coords2D basePoint( 0, 0 );
44
45 std::stack< const Lang::Value * > nodeStack;
46 nodeStack.push( this );
47 while( ! nodeStack.empty( ) )
48 {
49 const Lang::Value * node = nodeStack.top( );
50 nodeStack.pop( );
51 switch( node->getTypeID( ) )
52 {
53 SINGLELOOP1( CLASSTREE1_Coords2D, QUICKTYPECASE )
54 {
55 const Lang::Coords2D * coords = dynamic_cast< const Lang::Coords2D * >( node );
56 /* We don't care if the point has an angle since there are no handles.
57 * Perhaps it should be an error.
58 */
59 /*
60 const Lang::CornerCoords2D * tmp = dynamic_cast< const Lang::CornerCoords2D * >( coords );
61 if( tmp != 0 )
62 {
63 newPoint->defaultAngle = tmp->a_;
64 }
65 */
66 Concrete::Coords2D * newMid = new Concrete::Coords2D( basePoint, *coords );
67 basePoint = *newMid;
68 pth->push_back( new Concrete::PathPoint2D( newMid ) );
69 }
70 break;
71 SINGLELOOP1( CLASSTREE1_PathPoint2D, QUICKTYPECASE )
72 {
73 const Lang::PathPoint2D * pathPoint = reinterpret_cast< const Lang::PathPoint2D * >( node );
74 Concrete::Coords2D * newMid = new Concrete::Coords2D( basePoint, *(pathPoint->mid_) );
75 basePoint = *newMid;
76 Concrete::PathPoint2D * newPoint = new Concrete::PathPoint2D( newMid );
77
78 {
79 const Lang::CornerCoords2D * tmp = dynamic_cast< const Lang::CornerCoords2D * >( pathPoint->mid_.getPtr( ) );
80 if( tmp != 0 )
81 {
82 newPoint->defaultAngle_ = tmp->a_;
83 }
84 }
85
86 if( pathPoint->rear_ != NullPtr< const Lang::Value >( ) )
87 {
88 newPoint->rear_ = new Concrete::Coords2D( 0, 0 );
89 {
90 typedef const Lang::Coords2D * VariableHandle;
91 VariableHandle typedHandle = dynamic_cast< VariableHandle >( pathPoint->rear_.getPtr( ) );
92 if( typedHandle != 0 )
93 {
94 *(newPoint->rear_) = Concrete::Coords2D( basePoint, *typedHandle );
95 Concrete::Length dx = newPoint->rear_->x_ - newPoint->mid_->x_;
96 Concrete::Length dy = newPoint->rear_->y_ - newPoint->mid_->y_;
97 newPoint->rearAngle_ = atan2( dy.offtype< 1, 0 >( ), dx.offtype< 1, 0 >( ) );
98 newPoint->rearModulus_ = hypotPhysical( dx, dy );
99 newPoint->rearState_ = Concrete::PathPoint2D::COMPLETE;
100 goto doneRear;
101 }
102 }
103 newPoint->rearState_ = Concrete::PathPoint2D::UNFORCED_M; // This is the normal case, the only exception being rectangular handles
104 pth->allComplete_ = false;
105 {
106 typedef const Lang::PolarHandle2D * VariableHandle;
107 VariableHandle typedHandle = dynamic_cast< VariableHandle >( pathPoint->rear_.getPtr( ) );
108 if( typedHandle != 0 )
109 {
110 newPoint->rearModulusPromise_ = typedHandle->rPromise_;
111 newPoint->rearAngle_ = typedHandle->a_;
112 newPoint->rearState_ |= Concrete::PathPoint2D::COMPLETE; // This is just a no-op way of saying "keep it UNFORCED_M"
113 goto doneRear;
114 }
115 }
116 {
117 typedef const Lang::PolarHandle2DFree_a * VariableHandle;
118 VariableHandle typedHandle = dynamic_cast< VariableHandle >( pathPoint->rear_.getPtr( ) );
119 if( typedHandle != 0 )
120 {
121 newPoint->rearModulusPromise_ = typedHandle->rPromise_;
122 newPoint->rearState_ |= Concrete::PathPoint2D::FREE_ANGLE;
123 goto doneRear;
124 }
125 }
126 {
127 typedef const Lang::PolarHandle2DFree_r * VariableHandle;
128 VariableHandle typedHandle = dynamic_cast< VariableHandle >( pathPoint->rear_.getPtr( ) );
129 if( typedHandle != 0 )
130 {
131 newPoint->rearModulusPromise_ = typedHandle->defaultModulus_;
132 newPoint->rearAngle_ = typedHandle->a_;
133 newPoint->rearState_ |= Concrete::PathPoint2D::FREE_MODULUS;
134 goto doneRear;
135 }
136 }
137 {
138 typedef const Lang::PolarHandle2DFree_ra * VariableHandle;
139 VariableHandle typedHandle = dynamic_cast< VariableHandle >( pathPoint->rear_.getPtr( ) );
140 if( typedHandle != 0 )
141 {
142 newPoint->rearModulusPromise_ = typedHandle->defaultModulus_;
143 newPoint->rearState_ |= Concrete::PathPoint2D::FREE;
144 goto doneRear;
145 }
146 }
147 {
148 std::ostringstream msg;
149 msg << "Unexpected type found in handle point: " << pathPoint->rear_->getTypeName( ) ;
150 throw Exceptions::InternalError( msg );
151 }
152 }
153 doneRear:
154
155 if( pathPoint->front_ != NullPtr< const Lang::Value >( ) )
156 {
157 newPoint->front_ = new Concrete::Coords2D( 0, 0 );
158 {
159 typedef const Lang::Coords2D * VariableHandle;
160 VariableHandle typedHandle = dynamic_cast< VariableHandle >( pathPoint->front_.getPtr( ) );
161 if( typedHandle != 0 )
162 {
163 *(newPoint->front_) = Concrete::Coords2D( basePoint, *typedHandle );
164 Concrete::Length dx = newPoint->front_->x_ - newPoint->mid_->x_;
165 Concrete::Length dy = newPoint->front_->y_ - newPoint->mid_->y_;
166 newPoint->frontAngle_ = atan2( dy.offtype< 1, 0 >( ), dx.offtype< 1, 0 >( ) );
167 newPoint->frontModulus_ = hypotPhysical( dx, dy );
168 newPoint->frontState_ = Concrete::PathPoint2D::COMPLETE;
169 goto doneFront;
170 }
171 }
172 newPoint->frontState_ = Concrete::PathPoint2D::UNFORCED_M;
173 pth->allComplete_ = false;
174 {
175 typedef const Lang::PolarHandle2D * VariableHandle;
176 VariableHandle typedHandle = dynamic_cast< VariableHandle >( pathPoint->front_.getPtr( ) );
177 if( typedHandle != 0 )
178 {
179 newPoint->frontModulusPromise_ = typedHandle->rPromise_;
180 newPoint->frontAngle_ = typedHandle->a_;
181 newPoint->frontState_ |= Concrete::PathPoint2D::COMPLETE; // This is just a no-op way of saying "keep it UNFORCED_M"
182 goto doneFront;
183 }
184 }
185 {
186 typedef const Lang::PolarHandle2DFree_a * VariableHandle;
187 VariableHandle typedHandle = dynamic_cast< VariableHandle >( pathPoint->front_.getPtr( ) );
188 if( typedHandle != 0 )
189 {
190 newPoint->frontModulusPromise_ = typedHandle->rPromise_;
191 newPoint->frontState_ |= Concrete::PathPoint2D::FREE_ANGLE;
192 goto doneFront;
193 }
194 }
195 {
196 typedef const Lang::PolarHandle2DFree_r * VariableHandle;
197 VariableHandle typedHandle = dynamic_cast< VariableHandle >( pathPoint->front_.getPtr( ) );
198 if( typedHandle != 0 )
199 {
200 newPoint->frontModulusPromise_ = typedHandle->defaultModulus_;
201 newPoint->frontAngle_ = typedHandle->a_;
202 newPoint->frontState_ |= Concrete::PathPoint2D::FREE_MODULUS;
203 goto doneFront;
204 }
205 }
206 {
207 typedef const Lang::PolarHandle2DFree_ra * VariableHandle;
208 VariableHandle typedHandle = dynamic_cast< VariableHandle >( pathPoint->front_.getPtr( ) );
209 if( typedHandle != 0 )
210 {
211 newPoint->frontModulusPromise_ = typedHandle->defaultModulus_;
212 newPoint->frontState_ |= Concrete::PathPoint2D::FREE;
213 goto doneFront;
214 }
215 }
216 {
217 std::ostringstream msg;
218 msg << "Unexpected type found in handle point: " << pathPoint->front_->getTypeName( ) ;
219 throw Exceptions::InternalError( msg );
220 }
221 }
222 doneFront:
223
224 pth->push_back( newPoint );
225 }
226 break;
227 SINGLELOOP1( CLASSTREE1_Path2D, QUICKTYPECASE )
228 {
229 const Lang::Path2D * subPath = reinterpret_cast< const Lang::Path2D * >( node );
230 subPath->elementaryJob( & nodeStack, pth, & basePoint );
231 }
232 break;
233 default:
234 {
235 std::ostringstream msg;
236 msg << "Unexpected type found in subpath: " << node->getTypeName( ) ;
237 throw Exceptions::InternalError( msg );
238 }
239 }
240 }
241
242 if( pth->allComplete_ )
243 {
244 goto allComplete;
245 }
246
247
248 /* Now, fill in all the missing angles.
249 */
250
251 {
252 Lang::ElementaryPath2D::iterator the_rend = pth->begin( );
253 --the_rend;
254 Lang::ElementaryPath2D::iterator the_rbegin = pth->end( );
255 --the_rbegin;
256
257
258 pth->allComplete_ = true;
259 for( Lang::ElementaryPath2D::iterator i = pth->begin( );
260 i != pth->end( );
261 ++i )
262 {
263 if( ( (*i)->rear_ == (*i)->mid_ &&
264 (*i)->front_ == (*i)->mid_ ) ||
265 isnan( (*i)->defaultAngle_ ) )
266 {
267 /* There are no handles at this point.
268 * Set angles in direction to neighboring coordinates
269 */
270 if( (*i)->rearState_ & Concrete::PathPoint2D::FREE_ANGLE )
271 {
272 Lang::ElementaryPath2D::iterator prev = i;
273 --prev;
274 if( prev == the_rend )
275 {
276 prev = the_rbegin;
277 }
278 Concrete::Length dxRear = (*prev)->mid_->x_ - (*i)->mid_->x_;
279 Concrete::Length dyRear = (*prev)->mid_->y_ - (*i)->mid_->y_;
280 (*i)->rearAngle_ = atan2( dyRear.offtype< 1, 0 >( ), dxRear.offtype< 1, 0 >( ) );
281 (*i)->rearState_ &= ~Concrete::PathPoint2D::FREE_ANGLE;
282 }
283 if( (*i)->frontState_ & Concrete::PathPoint2D::FREE_ANGLE )
284 {
285 Lang::ElementaryPath2D::iterator next = i;
286 ++next;
287 if( next == pth->end( ) )
288 {
289 next = pth->begin( );
290 }
291 Concrete::Length dxFront = (*next)->mid_->x_ - (*i)->mid_->x_;
292 Concrete::Length dyFront = (*next)->mid_->y_ - (*i)->mid_->y_;
293 (*i)->frontAngle_ = atan2( dyFront.offtype< 1, 0 >( ), dxFront.offtype< 1, 0 >( ) );
294 (*i)->frontState_ &= ~Concrete::PathPoint2D::FREE_ANGLE;
295 }
296 continue;
297 }
298
299 if( (*i)->front_ == (*i)->mid_ )
300 {
301 /* There is only a rear handle at this point */
302 if( (*i)->rearState_ & Concrete::PathPoint2D::UNFORCED_A )
303 {
304 /* Put code for forcing the angle here
305 * ...
306 */
307 }
308
309 if( (*i)->rearState_ & ( Concrete::PathPoint2D::FREE_MODULUS | Concrete::PathPoint2D::UNFORCED_M ) )
310 {
311 pth->allComplete_ = false;
312 }
313
314 if( ! ( (*i)->rearState_ & Concrete::PathPoint2D::FREE_ANGLE ) )
315 {
316 continue;
317 }
318 (*i)->rearState_ &= ~Concrete::PathPoint2D::FREE_ANGLE;
319
320 Lang::ElementaryPath2D::iterator next = i;
321 ++next;
322 if( next == pth->end( ) )
323 {
324 if( closed_ )
325 {
326 next = pth->begin( );
327 }
328 else
329 {
330 /* In this case we do something completely different.
331 */
332 Lang::ElementaryPath2D::iterator prev = i;
333 --prev;
334 if( prev == the_rend )
335 {
336 throw Exceptions::MiscellaneousRequirement( "The angles of a singleton pathpoint cannot be determined." );
337 }
338 Concrete::Length dxRear = (*prev)->mid_->x_ - (*i)->mid_->x_;
339 Concrete::Length dyRear = (*prev)->mid_->y_ - (*i)->mid_->y_;
340 (*i)->rearAngle_ = atan2( dyRear.offtype< 1, 0 >( ), dxRear.offtype< 1, 0 >( ) );
341 (*i)->frontAngle_ = (*i)->rearAngle_ + M_PI + (*i)->defaultAngle_; /* Both angles must always be set, even where there is no handle. */
342 if( ! ( (*i)->rearState_ & ( Concrete::PathPoint2D::FREE_MODULUS | Concrete::PathPoint2D::UNFORCED_M ) ) )
343 {
344 (*i)->rear_->x_ = (*i)->mid_->x_ + (*i)->rearModulus_ * cos( (*i)->rearAngle_ );
345 (*i)->rear_->y_ = (*i)->mid_->y_ + (*i)->rearModulus_ * sin( (*i)->rearAngle_ );
346 (*i)->rearState_ = Concrete::PathPoint2D::COMPLETE;
347 }
348 continue;
349 }
350 }
351 Concrete::Length dxFront = (*next)->mid_->x_ - (*i)->mid_->x_;
352 Concrete::Length dyFront = (*next)->mid_->y_ - (*i)->mid_->y_;
353 (*i)->frontAngle_ = atan2( dyFront.offtype< 1, 0 >( ), dxFront.offtype< 1, 0 >( ) ); /* Both angles must always be set, even where there is no handle. */
354 (*i)->rearAngle_ = (*i)->frontAngle_ + M_PI - (*i)->defaultAngle_;
355 if( ! ( (*i)->rearState_ & ( Concrete::PathPoint2D::FREE_MODULUS | Concrete::PathPoint2D::UNFORCED_M ) ) )
356 {
357 (*i)->rear_->x_ = (*i)->mid_->x_ + (*i)->rearModulus_ * cos( (*i)->rearAngle_ );
358 (*i)->rear_->y_ = (*i)->mid_->y_ + (*i)->rearModulus_ * sin( (*i)->rearAngle_ );
359 (*i)->rearState_ = Concrete::PathPoint2D::COMPLETE;
360 }
361 continue;
362 }
363 if( (*i)->rear_ == (*i)->mid_ )
364 {
365 /* There is only a front handle at this point */
366
367 if( (*i)->frontState_ & Concrete::PathPoint2D::UNFORCED_A )
368 {
369 /* Put code for forcing the angle here
370 * ...
371 */
372 }
373
374 if( (*i)->frontState_ & ( Concrete::PathPoint2D::FREE_MODULUS | Concrete::PathPoint2D::UNFORCED_M ) )
375 {
376 pth->allComplete_ = false;
377 }
378
379 if( ! ( (*i)->frontState_ & Concrete::PathPoint2D::FREE_ANGLE ) )
380 {
381 continue;
382 }
383 (*i)->frontState_ &= ~Concrete::PathPoint2D::FREE_ANGLE;
384
385 Lang::ElementaryPath2D::iterator prev = i;
386 --prev;
387 if( prev == the_rend )
388 {
389 if( closed_ )
390 {
391 prev = the_rbegin;
392 }
393 else
394 {
395 /* In this case we do something completely different.
396 */
397 Lang::ElementaryPath2D::iterator next = i;
398 ++next;
399 if( next == pth->end( ) )
400 {
401 throw Exceptions::MiscellaneousRequirement( "The angles of a singleton pathpoint cannot be determined." );
402 }
403 Concrete::Length dxFront = (*next)->mid_->x_ - (*i)->mid_->x_;
404 Concrete::Length dyFront = (*next)->mid_->y_ - (*i)->mid_->y_;
405 (*i)->frontAngle_ = atan2( dyFront.offtype< 1, 0 >( ), dxFront.offtype< 1, 0 >( ) );
406 (*i)->rearAngle_ = (*i)->frontAngle_ + M_PI - (*i)->defaultAngle_; /* Both angles must always be set, even where there is no handle. */
407 if( ! ( (*i)->frontState_ & ( Concrete::PathPoint2D::FREE_MODULUS | Concrete::PathPoint2D::UNFORCED_M ) ) )
408 {
409 (*i)->front_->x_ = (*i)->mid_->x_ + (*i)->frontModulus_ * cos( (*i)->frontAngle_ );
410 (*i)->front_->y_ = (*i)->mid_->y_ + (*i)->frontModulus_ * sin( (*i)->frontAngle_ );
411 (*i)->frontState_ = Concrete::PathPoint2D::COMPLETE;
412 }
413 continue;
414 }
415 }
416 Concrete::Length dxRear = (*prev)->mid_->x_ - (*i)->mid_->x_;
417 Concrete::Length dyRear = (*prev)->mid_->y_ - (*i)->mid_->y_;
418 (*i)->rearAngle_ = atan2( dyRear.offtype< 1, 0 >( ), dxRear.offtype< 1, 0 >( ) ); /* Both angles must always be set, even where there is no handle. */
419 (*i)->frontAngle_ = (*i)->rearAngle_ + M_PI + (*i)->defaultAngle_;
420 if( ! ( (*i)->frontState_ & ( Concrete::PathPoint2D::FREE_MODULUS | Concrete::PathPoint2D::UNFORCED_M ) ) )
421 {
422 (*i)->front_->x_ = (*i)->mid_->x_ + (*i)->frontModulus_ * cos( (*i)->frontAngle_ );
423 (*i)->front_->y_ = (*i)->mid_->y_ + (*i)->frontModulus_ * sin( (*i)->frontAngle_ );
424 (*i)->frontState_ = Concrete::PathPoint2D::COMPLETE;
425 }
426 continue;
427 }
428
429
430 /* We reach here if there are two handles at the point */
431
432 if( (*i)->rearState_ & Concrete::PathPoint2D::UNFORCED_A )
433 {
434 /* Put code for forcing the angle here
435 * ...
436 */
437 }
438
439 if( (*i)->frontState_ & Concrete::PathPoint2D::UNFORCED_A )
440 {
441 /* Put code for forcing the angle here
442 * ...
443 */
444 }
445
446 if( ( (*i)->rearState_ | (*i)->frontState_ ) & ( Concrete::PathPoint2D::FREE_MODULUS | Concrete::PathPoint2D::UNFORCED_M ) )
447 {
448 pth->allComplete_ = false;
449 }
450
451 if( ! ( (*i)->rearState_ & Concrete::PathPoint2D::FREE_ANGLE ) &&
452 ! ( (*i)->frontState_ & Concrete::PathPoint2D::FREE_ANGLE ) )
453 {
454 /* Both handles have specified angles */
455 continue;
456 }
457 if( ! ( (*i)->rearState_ & Concrete::PathPoint2D::FREE_ANGLE ) )
458 {
459 /* The rear handle has a specified angle, that may propagate to the front handle */
460 if( (*i)->frontState_ & Concrete::PathPoint2D::FREE_ANGLE )
461 {
462 (*i)->frontAngle_ = (*i)->rearAngle_ + M_PI + (*i)->defaultAngle_;
463 (*i)->frontState_ &= ~Concrete::PathPoint2D::FREE_ANGLE;
464 }
465 continue;
466 }
467 if( ! ( (*i)->frontState_ & Concrete::PathPoint2D::FREE_ANGLE ) )
468 {
469 /* Analogous to above */
470 if( (*i)->rearState_ & Concrete::PathPoint2D::FREE_ANGLE )
471 {
472 (*i)->rearAngle_ = (*i)->frontAngle_ + M_PI - (*i)->defaultAngle_;
473 (*i)->rearState_ &= ~Concrete::PathPoint2D::FREE_ANGLE;
474 }
475 continue;
476 }
477
478 /* None of the handles have specified angles */
479
480 Lang::ElementaryPath2D::iterator prev = i;
481 --prev;
482 if( prev == the_rend )
483 {
484 prev = the_rbegin;
485 }
486 Lang::ElementaryPath2D::iterator next = i;
487 ++next;
488 if( next == pth->end( ) )
489 {
490 next = pth->begin( );
491 }
492
493 Concrete::Length dxRear = (*prev)->mid_->x_ - (*i)->mid_->x_;
494 Concrete::Length dyRear = (*prev)->mid_->y_ - (*i)->mid_->y_;
495 Concrete::Length dxFront = (*next)->mid_->x_ - (*i)->mid_->x_;
496 Concrete::Length dyFront = (*next)->mid_->y_ - (*i)->mid_->y_;
497 double angleRear = atan2( dyRear.offtype< 1, 0 >( ), dxRear.offtype< 1, 0 >( ) );
498 double angleFront = atan2( dyFront.offtype< 1, 0 >( ), dxFront.offtype< 1, 0 >( ) );
499 double weightRear = pow( hypot( dxFront.offtype< 1, 0 >( ), dyFront.offtype< 1, 0 >( ) ), GAMMA_ANGLE );
500 double weightFront = pow( hypot( dxRear.offtype< 1, 0 >( ), dyRear.offtype< 1, 0 >( ) ), GAMMA_ANGLE );
501 double a = angleSelectNorm2( angleRear, angleFront - ( M_PI + (*i)->defaultAngle_ ), weightRear, weightFront );
502 (*i)->rearAngle_ = a;
503 (*i)->frontAngle_ = a + M_PI + (*i)->defaultAngle_;
504
505 (*i)->frontState_ &= ~Concrete::PathPoint2D::FREE_ANGLE;
506 (*i)->rearState_ &= ~Concrete::PathPoint2D::FREE_ANGLE;
507
508 }
509
510 } // Done filling in angles.
511
512
513 /* Now, complete the path by filling in all the handle radii.
514 */
515
516 {
517 Lang::ElementaryPath2D::iterator the_rend = pth->begin( );
518 --the_rend;
519 Lang::ElementaryPath2D::iterator the_rbegin = pth->end( );
520 --the_rbegin;
521
522 pth->allComplete_ = true;
523 for( Lang::ElementaryPath2D::iterator i = pth->begin( );
524 i != pth->end( );
525 ++i )
526 {
527 if( (*i)->rear_ == (*i)->mid_ &&
528 (*i)->front_ == (*i)->mid_ )
529 {
530 /* There are no handles at this point */
531
532 continue;
533 }
534
535 Lang::ElementaryPath2D::iterator prev = i;
536 --prev;
537 if( prev == the_rend )
538 {
539 prev = the_rbegin;
540 }
541 Lang::ElementaryPath2D::iterator next = i;
542 ++next;
543 if( next == pth->end( ) )
544 {
545 next = pth->begin( );
546 }
547
548 if( (*i)->front_ == (*i)->mid_ )
549 {
550 /* There is only a rear handle at this point */
551 if( (*i)->rearState_ == Concrete::PathPoint2D::COMPLETE )
552 {
553 continue;
554 }
555 if( ( (*i)->rearState_ & Concrete::PathPoint2D::UNFORCED_M ) != 0)
556 {
557 (*i)->rearModulus_ = (*i)->rearModulusPromise_->force( *prev, *i, true );
558 }
559 (*i)->rear_->x_ = (*i)->mid_->x_ + (*i)->rearModulus_ * cos( (*i)->rearAngle_ );
560 (*i)->rear_->y_ = (*i)->mid_->y_ + (*i)->rearModulus_ * sin( (*i)->rearAngle_ );
561 continue;
562 }
563 if( (*i)->rear_ == (*i)->mid_ )
564 {
565 /* There is only a front handle at this point */
566 if( (*i)->frontState_ == Concrete::PathPoint2D::COMPLETE )
567 {
568 continue;
569 }
570 if( ( (*i)->frontState_ & Concrete::PathPoint2D::UNFORCED_M ) != 0 )
571 {
572 (*i)->frontModulus_ = (*i)->frontModulusPromise_->force( *i, *next, false );
573 }
574 (*i)->front_->x_ = (*i)->mid_->x_ + (*i)->frontModulus_ * cos( (*i)->frontAngle_ );
575 (*i)->front_->y_ = (*i)->mid_->y_ + (*i)->frontModulus_ * sin( (*i)->frontAngle_ );
576 continue;
577 }
578
579 /* We reach here if there are two handles at the point */
580
581 if( (*i)->rearState_ != Concrete::PathPoint2D::COMPLETE )
582 {
583 if( ! ( (*i)->rearState_ & Concrete::PathPoint2D::FREE_MODULUS ) )
584 {
585 if( ( (*i)->rearState_ & Concrete::PathPoint2D::UNFORCED_M ) != 0 )
586 {
587 (*i)->rearModulus_ = (*i)->rearModulusPromise_->force( *prev, *i, true );
588 }
589 (*i)->rear_->x_ = (*i)->mid_->x_ + (*i)->rearModulus_ * cos( (*i)->rearAngle_ );
590 (*i)->rear_->y_ = (*i)->mid_->y_ + (*i)->rearModulus_ * sin( (*i)->rearAngle_ );
591 (*i)->rearState_ = Concrete::PathPoint2D::COMPLETE;
592 }
593 }
594
595 if( (*i)->frontState_ != Concrete::PathPoint2D::COMPLETE )
596 {
597 if( ! ( (*i)->frontState_ & Concrete::PathPoint2D::FREE_MODULUS ) )
598 {
599 if( ( (*i)->frontState_ & Concrete::PathPoint2D::UNFORCED_M ) != 0)
600 {
601 (*i)->frontModulus_ = (*i)->frontModulusPromise_->force( *i, *next, false );
602 }
603 (*i)->front_->x_ = (*i)->mid_->x_ + (*i)->frontModulus_ * cos( (*i)->frontAngle_ );
604 (*i)->front_->y_ = (*i)->mid_->y_ + (*i)->frontModulus_ * sin( (*i)->frontAngle_ );
605 (*i)->frontState_ = Concrete::PathPoint2D::COMPLETE;
606 }
607 }
608
609 if( (*i)->rearState_ == Concrete::PathPoint2D::COMPLETE &&
610 (*i)->frontState_ == Concrete::PathPoint2D::COMPLETE )
611 {
612 continue;
613 }
614
615 /* The only reason why a handle is not complete at this point is that it's modulus
616 * has not been determined.
617 */
618 if( (*i)->rearState_ == Concrete::PathPoint2D::COMPLETE )
619 {
620 /* The rear modulus is known, and may propagate to the other side. */
621 if( (*i)->frontState_ & Concrete::PathPoint2D::FREE_MODULUS )
622 {
623 (*i)->frontModulus_ = (*i)->rearModulus_;
624 (*i)->front_->x_ = (*i)->mid_->x_ + (*i)->frontModulus_ * cos( (*i)->frontAngle_ );
625 (*i)->front_->y_ = (*i)->mid_->y_ + (*i)->frontModulus_ * sin( (*i)->frontAngle_ );
626 }
627 continue;
628 }
629 if( (*i)->frontState_ == Concrete::PathPoint2D::COMPLETE )
630 {
631 /* Analogous to the above */
632 if( (*i)->rearState_ & Concrete::PathPoint2D::FREE_MODULUS )
633 {
634 (*i)->rearModulus_ = (*i)->frontModulus_;
635 (*i)->rear_->x_ = (*i)->mid_->x_ + (*i)->rearModulus_ * cos( (*i)->rearAngle_ );
636 (*i)->rear_->y_ = (*i)->mid_->y_ + (*i)->rearModulus_ * sin( (*i)->rearAngle_ );
637 }
638 continue;
639 }
640
641 /* We get here if both modulus are free.
642 * We first compute madulus for each individually, and then merge the two values somehow to make both equal in the end.
643 */
644
645 double rearModulus = (*i)->rearModulusPromise_->force( *prev, *i, true );
646 double frontModulus = (*i)->frontModulusPromise_->force( *i, *next, false );
647 double theModulus = min( rearModulus, frontModulus );
648 (*i)->rearModulus_ = theModulus;
649 (*i)->frontModulus_ = theModulus;
650 (*i)->front_->x_ = (*i)->mid_->x_ + (*i)->frontModulus_ * cos( (*i)->frontAngle_ );
651 (*i)->front_->y_ = (*i)->mid_->y_ + (*i)->frontModulus_ * sin( (*i)->frontAngle_ );
652 (*i)->rear_->x_ = (*i)->mid_->x_ + (*i)->rearModulus_ * cos( (*i)->rearAngle_ );
653 (*i)->rear_->y_ = (*i)->mid_->y_ + (*i)->rearModulus_ * sin( (*i)->rearAngle_ );
654
655 }
656
657 } // Closing scope of the_rend and the_rbegin
658
659
660 allComplete:
661
662 if( closed_ )
663 {
664 pth->close( );
665 }
666
667 elementaryPath_ = RefCountPtr< const Lang::ElementaryPath2D >( pth );
668
669 }
670
671
Graphics language