?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update procedures
[shapes.git] / source / drawabletypes.cc
blob66a6571fb7c934400050accfee82594d10aaf6b8
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, 2009, 2010, 2014 Henrik Tidefelt
17 */
18
19 #include <cmath>
20
21 #include "shapestypes.h"
22 #include "shapesexceptions.h"
23 #include "astexpr.h"
24 #include "consts.h"
25 #include "angleselect.h"
26 #include "astvar.h"
27 #include "astclass.h"
28 #include "statetypes.h"
29 #include "lighttypes.h"
30 #include "shadingtypes.h"
31 #include "globals.h"
32 #include "trianglefunctions.h"
33 #include "pagecontentstates.h"
34 #include "continuations.h"
35 #include "warn.h"
36
37 #include <ctype.h>
38 #include <list>
39 #include <algorithm>
40
41 using namespace Shapes;
42
43
44 Lang::Drawable2D::Drawable2D( )
45 { }
46
47 Lang::Drawable2D::~Drawable2D( )
48 { }
49
50 RefCountPtr< const Lang::Transformed2D >
51 Lang::Drawable2D::typed_transformed( const Lang::Transform2D & tf, const RefCountPtr< const Lang::Drawable2D > & self ) const
52 {
53 return RefCountPtr< const Lang::Transformed2D >( new Lang::Transformed2D( self, tf ) );
54 }
55
56 RefCountPtr< const Lang::Geometric2D >
57 Lang::Drawable2D::transformed( const Lang::Transform2D & tf, const RefCountPtr< const Lang::Geometric2D > & self ) const
58 {
59 return typed_transformed( tf, self.down_cast< const Lang::Drawable2D >( ) );
60 }
61
62 RefCountPtr< const Lang::Geometric3D >
63 Lang::Drawable2D::to3D( const RefCountPtr< const Lang::Geometric2D > & self ) const
64 {
65 typedef const Lang::Drawable2D SelfType;
66 RefCountPtr< SelfType > typedSelf = self.down_cast< SelfType >( );
67 if( typedSelf == NullPtr< SelfType >( ) )
68 {
69 throw Exceptions::InternalError( "The self-value passed to Drawable2D::to3D was of bad type." );
70 }
71 return RefCountPtr< const Lang::Geometric3D >( new Lang::Drawable2Din3D( typedSelf ) );
72 }
73
74 void
75 Lang::Drawable2D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
76 {
77 // Not overloading this methods means that there are no tagged objects within this.
78 }
79
80 bool
81 Lang::Drawable2D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
82 {
83 // Not overloading this methods means that there are no tagged objects within this.
84 return false;
85 }
86
87 void
88 Lang::Drawable2D::gcMark( Kernel::GCMarkedSet & marked )
89 { }
90
91 RefCountPtr< const Lang::Class > Lang::Drawable2D::TypeID = NullPtr< const Lang::Class >( ); /* The value is set in main */
92 TYPEINFOIMPL( Drawable2D );
93 DISPATCHIMPL( Drawable2D );
94
95
96 Lang::Group2D::Group2D( )
97 { }
98
99 Lang::Group2D::~Group2D( )
100 { }
101
102 RefCountPtr< const Lang::Class > Lang::Group2D::TypeID( new Lang::SystemFinalClass( strrefdup( "Group2D" ) ) );
103 TYPEINFOIMPL( Group2D );
104
105
106 RefCountPtr< const Lang::Group2D >
107 Helpers::newGroup2D( const RefCountPtr< const Kernel::GraphicsState > & metaState, const RefCountPtr< const Lang::Drawable2D > & obj2, const RefCountPtr< const Lang::Drawable2D > & obj1 )
108 {
109 RefCountPtr< const Lang::Group2D > res = Lang::THE_NULL2D;
110 res = RefCountPtr< const Lang::GroupPair2D >( new Lang::GroupPair2D( obj1,
111 res,
112 metaState ) );
113 res = RefCountPtr< const Lang::GroupPair2D >( new Lang::GroupPair2D( obj2,
114 res,
115 metaState ) );
116 return res;
117 }
118
119 RefCountPtr< const Lang::Group2D >
120 Helpers::newGroup2D( const RefCountPtr< const Kernel::GraphicsState > & metaState, const RefCountPtr< const Lang::Drawable2D > & obj3, const RefCountPtr< const Lang::Drawable2D > & obj2, const RefCountPtr< const Lang::Drawable2D > & obj1 )
121 {
122 RefCountPtr< const Lang::Group2D > res = Lang::THE_NULL2D;
123 res = RefCountPtr< const Lang::GroupPair2D >( new Lang::GroupPair2D( obj1,
124 res,
125 metaState ) );
126 res = RefCountPtr< const Lang::GroupPair2D >( new Lang::GroupPair2D( obj2,
127 res,
128 metaState ) );
129 res = RefCountPtr< const Lang::GroupPair2D >( new Lang::GroupPair2D( obj3,
130 res,
131 metaState ) );
132 return res;
133 }
134
135
136 Lang::GroupPair2D::GroupPair2D( RefCountPtr< const Lang::Drawable2D > car, RefCountPtr< const Lang::Group2D > cdr, const RefCountPtr< const Kernel::GraphicsState > & metaState )
137 : metaState_( metaState ), car_( car ), cdr_( cdr )
138 { }
139
140 Lang::GroupPair2D::~GroupPair2D( )
141 { }
142
143 bool
144 Lang::GroupPair2D::isNull( ) const
145 {
146 return false;
147 }
148
149 void
150 Lang::GroupPair2D::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
151 {
152 cdr_->shipout( os, pdfState, tf );
153 if( pdfState->graphics_.synchBlend( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) ) )
154 {
155 os << std::endl ;
156 }
157 car_->shipout( os, pdfState, tf );
158 }
159
160 RefCountPtr< const Lang::ElementaryPath2D >
161 Lang::GroupPair2D::bbox( Lang::Drawable2D::BoxType boxType ) const
162 {
163 Concrete::Length xmin = Concrete::HUGE_LENGTH;
164 Concrete::Length ymin = Concrete::HUGE_LENGTH;
165 Concrete::Length xmax = -Concrete::HUGE_LENGTH;
166 Concrete::Length ymax = -Concrete::HUGE_LENGTH;
167
168 return bboxAdd( boxType, xmin, ymin, xmax, ymax );
169 }
170
171 RefCountPtr< const Lang::ElementaryPath2D >
172 Lang::GroupPair2D::bboxAdd( Lang::Drawable2D::BoxType boxType, Concrete::Length xmin, Concrete::Length ymin, Concrete::Length xmax, Concrete::Length ymax ) const
173 {
174 {
175 RefCountPtr< const Lang::ElementaryPath2D > carbbox = car_->bbox( boxType );
176 if( ! carbbox->empty( ) )
177 {
178 typedef typeof *carbbox PathType;
179 for( PathType::const_iterator i = carbbox->begin( ); i != carbbox->end( ); ++i )
180 {
181 Concrete::Length x = (*i)->mid_->x_;
182 xmin = std::min( xmin, x );
183 xmax = std::max( xmax, x );
184
185 Concrete::Length y = (*i)->mid_->y_;
186 ymin = std::min( ymin, y );
187 ymax = std::max( ymax, y );
188 }
189 }
190 }
191
192 return cdr_->bboxAdd( boxType, xmin, ymin, xmax, ymax );
193 }
194
195 void
196 Lang::GroupPair2D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
197 {
198 /* Note the order! Objects are added on the car side of a group being built, so the car side is the "latter".
199 */
200 cdr_->findTags( dst, dyn, key, tf );
201 car_->findTags( dst, dyn, key, tf );
202 }
203
204 bool
205 Lang::GroupPair2D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
206 {
207 return
208 cdr_->findOneTag( evalState, key, tf ) ||
209 car_->findOneTag( evalState, key, tf );
210 }
211
212 RefCountPtr< const Lang::Group2D >
213 Lang::GroupPair2D::removeShallow( Lang::Symbol::KeyType key ) const
214 {
215 {
216 typedef const Lang::Tagged2D TaggedType;
217 TaggedType * t = dynamic_cast< TaggedType * >( car_.getPtr( ) );
218 if( t != 0 && t->key( ) == key )
219 {
220 return cdr_->removeShallow( key );
221 }
222 }
223 return RefCountPtr< const Lang::Group2D >( new Lang::GroupPair2D( car_, cdr_->removeShallow( key ), metaState_ ) );
224 }
225
226 void
227 Lang::GroupPair2D::gcMark( Kernel::GCMarkedSet & marked )
228 {
229 const_cast< Lang::Drawable2D * >( car_.getPtr( ) )->gcMark( marked );
230 const_cast< Lang::Group2D * >( cdr_.getPtr( ) )->gcMark( marked );
231 }
232
233
234 Lang::GroupNull2D::GroupNull2D( )
235 { }
236
237 Lang::GroupNull2D::~GroupNull2D( )
238 { }
239
240 bool
241 Lang::GroupNull2D::isNull( ) const
242 {
243 return true;
244 }
245
246 RefCountPtr< const Lang::Group2D >
247 Lang::GroupNull2D::removeShallow( Lang::Symbol::KeyType key ) const
248 {
249 return Lang::THE_NULL2D;
250 }
251
252 void
253 Lang::GroupNull2D::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
254 { }
255
256 RefCountPtr< const Lang::ElementaryPath2D >
257 Lang::GroupNull2D::bbox( Lang::Drawable2D::BoxType boxType ) const
258 {
259 return Lang::THE_EMPTYPATH2D;
260 }
261
262 RefCountPtr< const Lang::ElementaryPath2D >
263 Lang::GroupNull2D::bboxAdd( Lang::Drawable2D::BoxType boxType, Concrete::Length xmin, Concrete::Length ymin, Concrete::Length xmax, Concrete::Length ymax ) const
264 {
265 Lang::ElementaryPath2D * res = new Lang::ElementaryPath2D;
266
267 res->push_back( new Concrete::PathPoint2D( xmin, ymin ) );
268 res->push_back( new Concrete::PathPoint2D( xmin, ymax ) );
269 res->push_back( new Concrete::PathPoint2D( xmax, ymax ) );
270 res->push_back( new Concrete::PathPoint2D( xmax, ymin ) );
271 res->close( );
272
273 return RefCountPtr< const Lang::ElementaryPath2D >( res );
274 }
275
276
277 Lang::XObject::XObject( const RefCountPtr< SimplePDF::PDF_Object > & resource, const RefCountPtr< const Lang::ElementaryPath2D > & boundingbox )
278 : metaState_( Kernel::THE_NO_STATE ), resource_( resource ), boundingbox_( boundingbox ), bleedbox_( boundingbox )
279 { }
280
281 Lang::XObject::XObject( const RefCountPtr< SimplePDF::PDF_Object > & resource, const RefCountPtr< const Lang::ElementaryPath2D > & boundingbox, const RefCountPtr< const Lang::ElementaryPath2D > & bleedbox, const RefCountPtr< const Kernel::GraphicsState > & metaState )
282 : metaState_( metaState ), resource_( resource ), boundingbox_( boundingbox ), bleedbox_( bleedbox )
283 { }
284
285 Lang::XObject::~XObject( )
286 { }
287
288 void
289 Lang::XObject::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
290 {
291 Kernel::Auto_qQ auto_qQ( & pdfState->graphics_, & pdfState->text_, os, false );
292 if( ! tf.isIdentity( ) )
293 {
294 auto_qQ.activate( );
295 tf.shipout( os );
296 os << " cm" << std::endl ;
297 }
298 if( metaState_ != Kernel::THE_NO_STATE )
299 {
300 pdfState->graphics_.synchForNonStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
301 }
302 os << pdfState->resources_->nameofXObject( resource_ ) << " Do" << std::endl ;
303 }
304
305 RefCountPtr< SimplePDF::PDF_Object >
306 Lang::XObject::getResource( ) const
307 {
308 return resource_;
309 }
310
311 RefCountPtr< const Lang::ElementaryPath2D >
312 Lang::XObject::bbox( Lang::Drawable2D::BoxType boxType ) const
313 {
314 switch( boxType )
315 {
316 case Lang::Drawable2D::BOUNDING:
317 return boundingbox_;
318 case Lang::Drawable2D::BLEED:
319 return bleedbox_;
320 }
321 throw Exceptions::InternalError( "Lang::XObject::bbox: boxType out of range." );
322 }
323
324 RefCountPtr< const Lang::XObject >
325 Lang::XObject::cloneWithState( const RefCountPtr< const Kernel::GraphicsState > & metaState, Concrete::Length bleedMargin ) const
326 {
327 Concrete::Coords2D llcorner( 0, 0 );
328 Concrete::Coords2D urcorner( 0, 0 );
329 boundingbox_->boundingRectangle( & llcorner, & urcorner );
330
331 Lang::ElementaryPath2D * bleedBox = new Lang::ElementaryPath2D;
332
333 bleedBox->push_back( new Concrete::PathPoint2D( llcorner.x_ - bleedMargin, llcorner.y_ - bleedMargin ) );
334 bleedBox->push_back( new Concrete::PathPoint2D( urcorner.x_ + bleedMargin, llcorner.y_ - bleedMargin ) );
335 bleedBox->push_back( new Concrete::PathPoint2D( urcorner.x_ + bleedMargin, urcorner.y_ + bleedMargin ) );
336 bleedBox->push_back( new Concrete::PathPoint2D( llcorner.x_ - bleedMargin, urcorner.y_ + bleedMargin ) );
337 bleedBox->close( );
338
339 return RefCountPtr< const Lang::XObject >( new Lang::XObject( resource_, boundingbox_, RefCountPtr< const Lang::ElementaryPath2D >( bleedBox ), metaState ) );
340 }
341
342 void
343 Lang::XObject::setDebugStr( const std::string & debugStr )
344 {
345 debugStr_ = debugStr;
346 }
347
348 const std::string &
349 Lang::XObject::getDebugStr( ) const
350 {
351 return debugStr_;
352 }
353
354 void
355 Lang::XObject::show( std::ostream & os ) const
356 {
357 os << "XObject (" << getDebugStr( ) << ")" ;
358 }
359
360 void
361 Lang::XObject::gcMark( Kernel::GCMarkedSet & marked )
362 {
363 // At the time of writing, there is nothing to propagate to.
364 }
365
366
367 Lang::TransparencyGroup::TransparencyGroup( const RefCountPtr< SimplePDF::PDF_Indirect_out > & indirection, RefCountPtr< const Lang::ElementaryPath2D > mybbox, const RefCountPtr< const Lang::ColorSpace > & colorSpace )
368 : Lang::XObject( indirection, mybbox ), colorSpace_( colorSpace ), indirection_( indirection )
369 { }
370
371 Lang::TransparencyGroup::~TransparencyGroup( )
372 { }
373
374 RefCountPtr< const Lang::ColorSpace >
375 Lang::TransparencyGroup::colorSpace( ) const
376 {
377 return colorSpace_;
378 }
379
380 RefCountPtr< SimplePDF::PDF_Indirect_out >
381 Lang::TransparencyGroup::getPDF_Object( ) const
382 {
383 return indirection_.unconst_cast< SimplePDF::PDF_Indirect_out >( );
384 }
385
386 RefCountPtr< const Lang::TransparencyGroup >
387 Helpers::newTransparencyGroup( const RefCountPtr< const Lang::Drawable2D > & content, bool isolated, bool knockout, const RefCountPtr< const Lang::ColorSpace > & blendSpace )
388 {
389 RefCountPtr< const Lang::ElementaryPath2D > theBBox = content->bbox( Lang::Drawable2D::BOUNDING );
390 Concrete::Coords2D llcorner( 0, 0 );
391 Concrete::Coords2D urcorner( 0, 0 );
392 if( ! theBBox->boundingRectangle( & llcorner, & urcorner ) )
393 {
394 throw Exceptions::InternalError( "newTransparencyGroup: The object has no bounding box!" );
395 }
396
397 using namespace Shapes;
398
399 RefCountPtr< SimplePDF::PDF_Stream_out > form;
400
401 (*form)[ "Subtype" ] = SimplePDF::newName( "Form" );
402 (*form)[ "FormType" ] = SimplePDF::newInt( 1 );
403 (*form)[ "BBox" ] = RefCountPtr< SimplePDF::PDF_Vector >( new SimplePDF::PDF_Vector( llcorner.x_.offtype< 1, 0 >( ), llcorner.y_.offtype< 1, 0 >( ),
404 urcorner.x_.offtype< 1, 0 >( ), urcorner.y_.offtype< 1, 0 >( ) ) );
405 RefCountPtr< SimplePDF::PDF_Resources > resources;
406 (*form)[ "Resources" ] = SimplePDF::indirect( resources, & Kernel::theIndirectObjectCount );
407
408 if( ! Kernel::allowTransparency )
409 {
410 /* OK, fine. */
411 }
412 else if( ! Kernel::the_PDF_version.greaterOrEqual( SimplePDF::PDF_Version::PDF_1_4 ) )
413 {
414 Kernel::the_PDF_version.message( SimplePDF::PDF_Version::PDF_1_4, "A transparency group was replaced by a plain XObject." );
415 }
416 else
417 {
418 RefCountPtr< SimplePDF::PDF_Dictionary > groupDic;
419 (*form)[ "Group" ] = groupDic;
420 (*groupDic)[ "S" ] = SimplePDF::newName( "Transparency" );
421 if( ! blendSpace->isInherent( ) )
422 {
423 (*groupDic)[ "CS" ] = blendSpace->name( );
424 }
425 if( isolated )
426 {
427 (*groupDic)[ "I" ] = SimplePDF::newBoolean( true );
428 }
429 if( knockout )
430 {
431 (*groupDic)[ "K" ] = SimplePDF::newBoolean( true );
432 }
433 }
434
435 /* There's a possibility of adding a transformation matrix entry in the dictionary here, but it is not used, not even
436 * for transformed drawables.
437 */
438 // (*markForm)[ "Matrix" ] = RefCountPtr<PDF_Object>( new PDF_Vector( 1, 0, 0, 1, -30, -30 ) );
439
440 Kernel::PageContentStates pdfState( resources );
441 content->shipout( form->data, & pdfState, Lang::Transform2D( 1, 0, 0, 1, Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH ) );
442
443 Lang::TransparencyGroup * res = new Lang::TransparencyGroup( SimplePDF::indirect( form, & Kernel::theIndirectObjectCount ),
444 content->bbox( Lang::Drawable2D::BOUNDING ),
445 blendSpace );
446 res->setDebugStr( "transparency group" );
447 return RefCountPtr< const Lang::TransparencyGroup >( res );
448 }
449
450 Lang::RasterImage *
451 Lang::RasterImage::newInstance( size_t size_x, size_t size_y, size_t size_depth, Concrete::Length pixelSize_x, Concrete::Length pixelSize_y, RefCountPtr< const Lang::ColorSpace > colorSpace )
452 {
453 RefCountPtr< SimplePDF::PDF_Stream_out > stream = RefCountPtr< SimplePDF::PDF_Stream_out >( new SimplePDF::PDF_Stream_out );
454 RefCountPtr< SimplePDF::PDF_Object > indirection = SimplePDF::indirect( stream, & Kernel::theIndirectObjectCount );
455
456 (*stream)[ "Subtype" ] = SimplePDF::newName( "Image" );
457 (*stream)[ "Width" ] = SimplePDF::newInt( size_x );
458 (*stream)[ "Height" ] = SimplePDF::newInt( size_y );
459 (*stream)[ "ColorSpace" ] = colorSpace->name( );
460 (*stream)[ "BitsPerComponent" ] = SimplePDF::newInt( size_depth );
461
462 return new RasterImage( indirection, size_x, size_y, size_depth, pixelSize_x, pixelSize_y, colorSpace, stream );
463 }
464
465 void
466 Lang::RasterImage::setSoftMask( const RefCountPtr< const Lang::RasterImage > & softMask )
467 {
468 /* The caller is responsible for also adding the soft mask under "SMask" in the stream dictionary! */
469 softMask_ = softMask;
470 }
471
472 Lang::RasterImage::RasterImage( const RefCountPtr< SimplePDF::PDF_Object > & resource, size_t size_x, size_t size_y, size_t size_depth, Concrete::Length pixelSize_x, Concrete::Length pixelSize_y, RefCountPtr< const Lang::ColorSpace > colorSpace, RefCountPtr< SimplePDF::PDF_Stream_out > & stream )
473 : Lang::XObject( resource, RefCountPtr< const Lang::ElementaryPath2D >( newBoundingBox( size_x, size_y, pixelSize_x, pixelSize_y ) ) ),
474 size_x_( size_x ), size_y_( size_y ), size_depth_( size_depth ), pixelSize_x_( pixelSize_x ), pixelSize_y_( pixelSize_y ), colorSpace_( colorSpace ),
475 softMask_( NullPtr< const Lang::RasterImage >( ) ),
476 stream_( stream )
477 { }
478
479 Lang::ElementaryPath2D *
480 Lang::RasterImage::newBoundingBox( size_t size_x, size_t size_y, Concrete::Length pixelSize_x, Concrete::Length pixelSize_y )
481 {
482 /* Note that this bounding box assumes that the image is scaled to resolution during shipout. */
483 Lang::ElementaryPath2D * res = new Lang::ElementaryPath2D;
484
485 res->push_back( new Concrete::PathPoint2D( Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH ) );
486 res->push_back( new Concrete::PathPoint2D( size_x * pixelSize_x, Concrete::ZERO_LENGTH ) );
487 res->push_back( new Concrete::PathPoint2D( size_x * pixelSize_x, size_y * pixelSize_y ) );
488 res->push_back( new Concrete::PathPoint2D( Concrete::ZERO_LENGTH, size_y * pixelSize_y ) );
489 res->close( );
490 return res;
491 }
492
493 Lang::RasterImage::~RasterImage( )
494 { }
495
496 RefCountPtr< const Lang::Class > Lang::RasterImage::TypeID( new Lang::SystemFinalClass( strrefdup( "RasterImage" ) ) );
497 TYPEINFOIMPL( RasterImage );
498
499 void
500 Lang::RasterImage::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
501 {
502 Lang::XObject::shipout( os, pdfState, Lang::Transform2D( tf, Transform2D( size_x_ * static_cast< double >( Concrete::Length::offtype( pixelSize_x_ ) ), 0, 0, size_y_ * static_cast< double >( Concrete::Length::offtype( pixelSize_y_ ) ),
503 Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH ) ) );
504 }
505
506 Kernel::VariableHandle
507 Lang::RasterImage::getField( const char * fieldID, const RefCountPtr< const Lang::Value > & selfRef ) const
508 {
509 if( strcmp( fieldID, "size_x" ) == 0 )
510 {
511 return Helpers::newValHandle( new Lang::Integer( size_x_ ) );
512 }
513 if( strcmp( fieldID, "size_y" ) == 0 )
514 {
515 return Helpers::newValHandle( new Lang::Integer( size_y_ ) );
516 }
517 if( strcmp( fieldID, "depth" ) == 0 )
518 {
519 return Helpers::newValHandle( new Lang::Integer( size_depth_ ) );
520 }
521 if( strcmp( fieldID, "space" ) == 0 )
522 {
523 return Kernel::VariableHandle( new Kernel::Variable( colorSpace_ ) );
524 }
525 throw Exceptions::NonExistentMember( getTypeName( ), fieldID );
526 }
527
528 void
529 Lang::RasterImage::gcMark( Kernel::GCMarkedSet & marked )
530 {
531 const_cast< Lang::ColorSpace * >( colorSpace_.getPtr( ) )->gcMark( marked );
532 if( softMask_ != NullPtr< const Lang::RasterImage >( ) )
533 {
534 const_cast< Lang::RasterImage * >( softMask_.getPtr( ) )->gcMark( marked );
535 }
536 Lang::XObject::gcMark( marked );
537 }
538
539
540
541 Lang::PaintedPath2D::PaintedPath2D( const RefCountPtr< const Kernel::GraphicsState > & metaState,
542 const char * paintCmd )
543 : metaState_( metaState ), paintCmd_( paintCmd )
544 { }
545
546 Lang::PaintedPath2D::PaintedPath2D( const RefCountPtr< const Kernel::GraphicsState > & metaState,
547 RefCountPtr< const Lang::ElementaryPath2D > path,
548 const char * paintCmd )
549 : metaState_( metaState ), paintCmd_( paintCmd )
550 {
551 addSubPath( path );
552 }
553
554 Lang::PaintedPath2D::PaintedPath2D( const RefCountPtr< const Kernel::GraphicsState > & metaState,
555 RefCountPtr< const Lang::MultiPath2D > paths,
556 const char * paintCmd )
557 : metaState_( metaState ), paintCmd_( paintCmd )
558 {
559 for( Lang::MultiPath2D::const_iterator i = paths->begin( ); i != paths->end( ); ++i )
560 {
561 {
562 typedef const Lang::ElementaryPath2D ArgType;
563 RefCountPtr< ArgType > subpath = (*i).down_cast< ArgType >( );
564 if( subpath != NullPtr< ArgType >( ) )
565 {
566 addSubPath( subpath );
567 continue;
568 }
569 }
570
571 {
572 typedef const Lang::CompositePath2D ArgType;
573 ArgType * subpath = dynamic_cast< ArgType * >( (*i).getPtr( ) );
574 if( subpath != 0 )
575 {
576 addSubPath( subpath->getElementaryPath( ) );
577 continue;
578 }
579 }
580 throw Exceptions::InternalError( "Painting 2D path: Encountered a subpath of unexpected type" );
581 }
582 }
583
584 Lang::PaintedPath2D::~PaintedPath2D( )
585 { }
586
587 RefCountPtr< const Lang::Class > Lang::PaintedPath2D::TypeID( new Lang::SystemFinalClass( strrefdup( "PaintedPath2D" ) ) );
588 TYPEINFOIMPL( PaintedPath2D );
589
590 void
591 Lang::PaintedPath2D::addSubPath( RefCountPtr< const Lang::ElementaryPath2D > subpath )
592 {
593 path_.push_back( subpath );
594 }
595
596 void
597 Lang::PaintedPath2D::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
598 {
599 /* Transforming the path by tf is not good enough, since that does not transform softmasks etc.
600 */
601
602 char pdfCmd[4];
603 strcpy( pdfCmd, paintCmd_ );
604
605 Kernel::Auto_qQ auto_qQ( & pdfState->graphics_, & pdfState->text_, os, false );
606 if( ! tf.isIdentity( ) )
607 {
608 auto_qQ.activate( );
609 tf.shipout( os );
610 os << " cm" << std::endl ;
611 }
612 if( strcmp( paintCmd_, "S" ) == 0 )
613 {
614 pdfState->graphics_.synchForStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
615 }
616 else if( strcmp( paintCmd_, "f" ) == 0 ||
617 strcmp( paintCmd_, "f*" ) == 0 )
618 {
619 pdfState->graphics_.synchForNonStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
620 }
621 else if( strcmp( paintCmd_, "B" ) == 0 ||
622 strcmp( paintCmd_, "B*" ) == 0 ||
623 strcmp( paintCmd_, "b" ) == 0 ||
624 strcmp( paintCmd_, "b*" ) == 0 )
625 {
626 pdfState->graphics_.synchForNonStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
627 pdfState->graphics_.synchForStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
628 }
629 else if( strcmp( paintCmd_, "E" ) == 0 ||
630 strcmp( paintCmd_, "E*" ) == 0 ||
631 strcmp( paintCmd_, "e" ) == 0 ||
632 strcmp( paintCmd_, "e*" ) == 0 )
633 {
634 pdfCmd[0] += 'B' - 'E';
635 // Note that this is my own interpretation; usually, the stroke is made with the stroking color,
636 // but I use this to make filled regions just a little bit bigger, and then it is the nonstroking
637 // color that shall be applied to the stroke as well.
638 pdfState->graphics_.synchForNonStroke( os, metaState_.getPtr( ), pdfState->resources_.getPtr( ) );
639 pdfState->graphics_.synchStrokingColorWithNonStrokingColor( os, pdfState->resources_.getPtr( ), Concrete::ZERO_LENGTH );
640 }
641 else
642 {
643 throw Exceptions::InternalError( "Unexpected paintCmd in PaintedPath2D::shipout" );
644 }
645
646 typedef typeof path_ ListType;
647 for( ListType::const_iterator i = path_.begin( ); i != path_.end( ); ++i )
648 {
649 (*i)->writePath( os );
650 }
651 os << " " << pdfCmd << std::endl ;
652 }
653
654 RefCountPtr< const Lang::ElementaryPath2D >
655 Lang::PaintedPath2D::bbox( Lang::Drawable2D::BoxType boxType ) const
656 {
657 if( path_.empty( ) )
658 {
659 return RefCountPtr< const Lang::ElementaryPath2D >( new Lang::ElementaryPath2D );
660 }
661
662 Concrete::Length xmin = Concrete::HUGE_LENGTH;
663 Concrete::Length xmax = -Concrete::HUGE_LENGTH;
664 Concrete::Length ymin = Concrete::HUGE_LENGTH;
665 Concrete::Length ymax = -Concrete::HUGE_LENGTH;
666
667 Concrete::Coords2D llcorner( 0, 0 ); /* Temporary variables to be used in the loop below. */
668 Concrete::Coords2D urcorner( 0, 0 );
669
670 typedef typeof path_ PathType;
671 for( PathType::const_iterator j = path_.begin( ); j != path_.end( ); ++j )
672 {
673 if( (*j)->boundingRectangle( & llcorner, & urcorner ) )
674 {
675 /* non-empty path */
676 xmin = std::min( xmin, llcorner.x_ );
677 xmax = std::max( xmax, urcorner.x_ );
678 ymin = std::min( ymin, llcorner.y_ );
679 ymax = std::max( ymax, urcorner.y_ );
680 }
681 }
682
683 Lang::ElementaryPath2D * res = new Lang::ElementaryPath2D;
684
685 if( xmin < Concrete::HUGE_LENGTH )
686 {
687 if( toupper( *paintCmd_ ) == 'S' ||
688 toupper( *paintCmd_ ) == 'B' )
689 {
690 xmin -= 0.5 * metaState_->width_;
691 ymin -= 0.5 * metaState_->width_;
692 xmax += 0.5 * metaState_->width_;
693 ymax += 0.5 * metaState_->width_;
694 }
695 res->push_back( new Concrete::PathPoint2D( xmin, ymin ) );
696 res->push_back( new Concrete::PathPoint2D( xmin, ymax ) );
697 res->push_back( new Concrete::PathPoint2D( xmax, ymax ) );
698 res->push_back( new Concrete::PathPoint2D( xmax, ymin ) );
699 res->close( );
700 }
701
702 return RefCountPtr< const Lang::ElementaryPath2D >( res );
703 }
704
705 void
706 Lang::PaintedPath2D::gcMark( Kernel::GCMarkedSet & marked )
707 { }
708
709
710 Lang::Transformed2D::Transformed2D( RefCountPtr< const Lang::Drawable2D > element, const Lang::Transform2D & mytf )
711 : mytf_( mytf ), element_( element )
712 { }
713
714 Lang::Transformed2D::~Transformed2D( )
715 { }
716
717 void
718 Lang::Transformed2D::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
719 {
720 element_->shipout( os, pdfState, Lang::Transform2D( tf, mytf_ ) );
721 }
722
723 RefCountPtr< const Lang::ElementaryPath2D >
724 Lang::Transformed2D::bbox( Lang::Drawable2D::BoxType boxType ) const
725 {
726 return element_->bbox( boxType )->elementaryTransformed( mytf_ );
727 }
728
729 void
730 Lang::Transformed2D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
731 {
732 element_->findTags( dst, dyn, key, Lang::Transform2D( tf, mytf_ ) );
733 }
734
735 bool
736 Lang::Transformed2D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
737 {
738 return
739 element_->findOneTag( evalState, key, Lang::Transform2D( tf, mytf_ ) );
740 }
741
742 void
743 Lang::Transformed2D::gcMark( Kernel::GCMarkedSet & marked )
744 {
745 const_cast< Lang::Drawable2D * >( element_.getPtr( ) )->gcMark( marked );
746 }
747
748
749 Lang::BBoxed2D::BBoxed2D( RefCountPtr< const Lang::Drawable2D > element, RefCountPtr< const Lang::ElementaryPath2D > mybbox, BoxType boxType )
750 : Lang::PaintedPolygon2D( Kernel::THE_NO_STATE, mybbox ), mybbox_( mybbox ), element_( element ), boxType_( boxType )
751 { }
752
753 Lang::BBoxed2D::~BBoxed2D( )
754 { }
755
756 void
757 Lang::BBoxed2D::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
758 {
759 /* At the moment, we don't clip according to the bbox, we only lie about our size.
760 */
761 element_->shipout( os, pdfState, tf );
762 }
763
764 RefCountPtr< const Lang::ElementaryPath2D >
765 Lang::BBoxed2D::bbox( Lang::Drawable2D::BoxType boxType ) const
766 {
767 if( boxType_ == BOTH
768 || ( boxType == Lang::Drawable2D::BOUNDING && boxType_ == BOUNDING )
769 || ( boxType == Lang::Drawable2D::BLEED && boxType_ == BLEED ) )
770 {
771 return mybbox_;
772 }
773 return element_->bbox( boxType );
774 }
775
776 void
777 Lang::BBoxed2D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
778 {
779 element_->findTags( dst, dyn, key, tf );
780 }
781
782 bool
783 Lang::BBoxed2D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
784 {
785 return
786 element_->findOneTag( evalState, key, tf );
787 }
788
789 void
790 Lang::BBoxed2D::gcMark( Kernel::GCMarkedSet & marked )
791 {
792 Lang::PaintedPolygon2D::gcMark( marked );
793 const_cast< Lang::Drawable2D * >( element_.getPtr( ) )->gcMark( marked );
794 }
795
796
797 Lang::Clipped2D::Clipped2D( const RefCountPtr< const Lang::Drawable2D > & element, const char * clipCommand )
798 : element_( element ), clipCommand_( clipCommand )
799 { }
800
801 Lang::Clipped2D::~Clipped2D( )
802 { }
803
804 void
805 Lang::Clipped2D::addSubPath( const RefCountPtr< const Lang::ElementaryPath2D > & subpath )
806 {
807 clipList_.push_back( subpath );
808 }
809
810 void
811 Lang::Clipped2D::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
812 {
813 Kernel::Auto_qQ auto_qQ( & pdfState->graphics_, & pdfState->text_, os );
814 if( ! tf.isIdentity( ) )
815 {
816 tf.shipout( os );
817 os << " cm" << std::endl ;
818 }
819 typedef typeof clipList_ ListType;
820 for( ListType::const_iterator i = clipList_.begin( ); i != clipList_.end( ); ++i )
821 {
822 (*i)->writePath( os );
823 }
824 os << " " << clipCommand_ << " n" << std::endl ;
825 element_->shipout( os, pdfState, THE_2D_IDENTITY );
826 }
827
828 RefCountPtr< const Lang::ElementaryPath2D >
829 Lang::Clipped2D::bbox( Lang::Drawable2D::BoxType boxType ) const
830 {
831 RefCountPtr< const Lang::ElementaryPath2D > elem_bbox = element_->bbox( boxType );
832
833 if( clipList_.empty( ) )
834 {
835 return RefCountPtr< const Lang::ElementaryPath2D >( new Lang::ElementaryPath2D );
836 }
837
838 Concrete::Coords2D llElemBbox( 0, 0 );
839 Concrete::Coords2D urElemBbox( 0, 0 );
840 elem_bbox->boundingRectangle( & llElemBbox, & urElemBbox );
841
842 Concrete::Length xmin = Concrete::HUGE_LENGTH;
843 Concrete::Length xmax = -Concrete::HUGE_LENGTH;
844 Concrete::Length ymin = Concrete::HUGE_LENGTH;
845 Concrete::Length ymax = -Concrete::HUGE_LENGTH;
846
847 Concrete::Coords2D llcorner( 0, 0 ); /* Temporary variables to be used in the loop below. */
848 Concrete::Coords2D urcorner( 0, 0 );
849
850 typedef typeof clipList_ PathType;
851 for( PathType::const_iterator j = clipList_.begin( ); j != clipList_.end( ); ++j )
852 {
853 if( (*j)->boundingRectangle( & llcorner, & urcorner ) )
854 {
855 /* non-empty path */
856 xmin = std::min( xmin, llcorner.x_ );
857 xmax = std::max( xmax, urcorner.x_ );
858 ymin = std::min( ymin, llcorner.y_ );
859 ymax = std::max( ymax, urcorner.y_ );
860 }
861 }
862
863 xmin = std::max( xmin, llElemBbox.x_ );
864 ymin = std::max( ymin, llElemBbox.y_ );
865 xmax = std::min( xmax, urElemBbox.x_ );
866 ymax = std::min( ymax, urElemBbox.y_ );
867
868 Lang::ElementaryPath2D * res = new Lang::ElementaryPath2D;
869
870 if( xmin < xmax && ymin < ymax )
871 {
872 res->push_back( new Concrete::PathPoint2D( xmin, ymin ) );
873 res->push_back( new Concrete::PathPoint2D( xmin, ymax ) );
874 res->push_back( new Concrete::PathPoint2D( xmax, ymax ) );
875 res->push_back( new Concrete::PathPoint2D( xmax, ymin ) );
876 res->close( );
877 }
878
879 return RefCountPtr< const Lang::ElementaryPath2D >( res );
880 }
881
882 void
883 Lang::Clipped2D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
884 {
885 element_->findTags( dst, dyn, key, tf );
886 }
887
888 bool
889 Lang::Clipped2D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
890 {
891 return
892 element_->findOneTag( evalState, key, tf );
893 }
894
895 void
896 Lang::Clipped2D::gcMark( Kernel::GCMarkedSet & marked )
897 {
898 const_cast< Lang::Drawable2D * >( element_.getPtr( ) )->gcMark( marked );
899 }
900
901 RefCountPtr< const Lang::Drawable2D >
902 Lang::Clipped2D::debugPolys( ) const
903 {
904 Kernel::GraphicsState * frameStatePtr = new Kernel::GraphicsState( true );
905 frameStatePtr->width_ = Concrete::Length( 0.2 );
906 RefCountPtr< const Kernel::GraphicsState > frameState( frameStatePtr );
907
908 Lang::PaintedPath2D * res = new Lang::PaintedPath2D( frameState, "S" );
909 typedef typeof clipList_ ListType;
910 for( ListType::const_iterator i = clipList_.begin( ); i != clipList_.end( ); ++i )
911 {
912 res->addSubPath( *i );
913 }
914
915 return RefCountPtr< const Lang::Drawable2D >( res );
916 }
917
918 bool
919 Lang::Clipped2D::isSingleConvexPoly( Concrete::Length tol ) const
920 {
921 if( clipList_.size( ) != 1 )
922 {
923 return false;
924 }
925 return clipList_.front( )->isConvexPoly( tol );
926 }
927
928 bool
929 Lang::Clipped2D::convexPolyContains( const Concrete::Coords2D & p, Concrete::Length tol ) const
930 {
931 return clipList_.front( )->convexPolyContains( p, tol );
932 }
933
934 Lang::SoftMasked2D::SoftMasked2D( const RefCountPtr< const Lang::Drawable2D > & element, const RefCountPtr< const Lang::SoftMask > & mask )
935 : element_( element ), mask_( mask )
936 { }
937
938 Lang::SoftMasked2D::~SoftMasked2D( )
939 { }
940
941 void
942 Lang::SoftMasked2D::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
943 {
944 const SimplePDF::PDF_Version::Version SOFTMASK_VERSION = SimplePDF::PDF_Version::PDF_1_4;
945 if( Kernel::the_PDF_version.greaterOrEqual( SOFTMASK_VERSION ) )
946 {
947 Kernel::Auto_qQ auto_qQ( & pdfState->graphics_, & pdfState->text_, os );
948 if( ! tf.isIdentity( ) )
949 {
950 tf.shipout( os );
951 os << " cm" << std::endl ;
952 }
953 os << pdfState->resources_->nameofGraphicsState( mask_->graphicsStateResource_ ) << " gs " << std::endl ;
954 element_->shipout( os, pdfState, THE_2D_IDENTITY );
955 }
956 else
957 {
958 Kernel::the_PDF_version.message( SOFTMASK_VERSION, "A soft mask was ignored." );
959 element_->shipout( os, pdfState, tf );
960 }
961 }
962
963 RefCountPtr< const Lang::ElementaryPath2D >
964 Lang::SoftMasked2D::bbox( Lang::Drawable2D::BoxType boxType ) const
965 {
966 return element_->bbox( boxType );
967 }
968
969 void
970 Lang::SoftMasked2D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
971 {
972 element_->findTags( dst, dyn, key, tf );
973 }
974
975 bool
976 Lang::SoftMasked2D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
977 {
978 return
979 element_->findOneTag( evalState, key, tf );
980 }
981
982 void
983 Lang::SoftMasked2D::gcMark( Kernel::GCMarkedSet & marked )
984 {
985 const_cast< Lang::Drawable2D * >( element_.getPtr( ) )->gcMark( marked );
986 const_cast< Lang::SoftMask * >( mask_.getPtr( ) )->gcMark( marked );
987 }
988
989
990 Lang::TextMasked2D::TextMasked2D( const RefCountPtr< const Lang::Drawable2D > & element, const RefCountPtr< const Lang::Text > & mask )
991 : element_( element ), mask_( mask )
992 { }
993
994 Lang::TextMasked2D::~TextMasked2D( )
995 { }
996
997 void
998 Lang::TextMasked2D::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
999 {
1000 mask_->shipout_clip( os, pdfState, tf, element_ );
1001 }
1002
1003 RefCountPtr< const Lang::ElementaryPath2D >
1004 Lang::TextMasked2D::bbox( Lang::Drawable2D::BoxType boxType ) const
1005 {
1006 return mask_->bbox( boxType );
1007 }
1008
1009 void
1010 Lang::TextMasked2D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
1011 {
1012 element_->findTags( dst, dyn, key, tf );
1013 }
1014
1015 bool
1016 Lang::TextMasked2D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform2D & tf ) const
1017 {
1018 return
1019 element_->findOneTag( evalState, key, tf );
1020 }
1021
1022 void
1023 Lang::TextMasked2D::gcMark( Kernel::GCMarkedSet & marked )
1024 {
1025 const_cast< Lang::Drawable2D * >( element_.getPtr( ) )->gcMark( marked );
1026 const_cast< Lang::Text * >( mask_.getPtr( ) )->gcMark( marked );
1027 }
1028
1029
1030 Lang::Drawable3D::Drawable3D( )
1031 { }
1032
1033 Lang::Drawable3D::~Drawable3D( )
1034 { }
1035
1036 RefCountPtr< const Lang::Transformed3D >
1037 Lang::Drawable3D::typed_transformed( const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
1038 {
1039 return RefCountPtr< const Lang::Transformed3D >( new Lang::Transformed3D( self, tf ) );
1040 }
1041
1042 RefCountPtr< const Lang::Geometric3D >
1043 Lang::Drawable3D::transformed( const Lang::Transform3D & tf, const RefCountPtr< const Lang::Geometric3D > & self ) const
1044 {
1045 return typed_transformed( tf, self.down_cast< const Lang::Drawable3D >( ) );
1046 }
1047
1048 RefCountPtr< const Lang::Geometric2D >
1049 Lang::Drawable3D::to2D( const Kernel::PassedDyn & dyn, const RefCountPtr< const Lang::Geometric3D > & self ) const
1050 {
1051 typedef const Lang::Drawable3D SelfType;
1052 RefCountPtr< SelfType > typedSelf = self.down_cast< SelfType >( );
1053 if( typedSelf == NullPtr< SelfType >( ) )
1054 {
1055 throw Exceptions::InternalError( "The self-value passed to Drawable3D::to2D was of bad type." );
1056 }
1057 return typed_to2D( dyn, Lang::THE_3D_IDENTITY, typedSelf );
1058 }
1059
1060 void
1061 Lang::Drawable3D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
1062 {
1063 // Not overloading this methods means that there are no tagged objects within this.
1064 }
1065
1066 bool
1067 Lang::Drawable3D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
1068 {
1069 // Not overloading this methods means that there are no tagged objects within this.
1070 return false;
1071 }
1072
1073 void
1074 Lang::Drawable3D::gcMark( Kernel::GCMarkedSet & marked )
1075 { }
1076
1077 RefCountPtr< const Lang::Class > Lang::Drawable3D::TypeID = NullPtr< const Lang::Class >( ); /* The value is set in main */
1078 TYPEINFOIMPL( Drawable3D );
1079 DISPATCHIMPL( Drawable3D );
1080
1081
1082 Lang::Group3D::Group3D( )
1083 { }
1084
1085 Lang::Group3D::~Group3D( )
1086 { }
1087
1088 RefCountPtr< const Lang::Drawable2D >
1089 Lang::Group3D::typed_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
1090 {
1091 return group_to2D( dyn, tf );
1092 }
1093
1094
1095 RefCountPtr< const Lang::Class > Lang::Group3D::TypeID( new Lang::SystemFinalClass( strrefdup( "Group3D" ) ) );
1096 TYPEINFOIMPL( Group3D );
1097
1098 RefCountPtr< const Lang::Group3D >
1099 Helpers::newGroup3D( const RefCountPtr< const Kernel::GraphicsState > & metaState, const RefCountPtr< const Lang::Drawable3D > & obj2, const RefCountPtr< const Lang::Drawable3D > & obj1 )
1100 {
1101 RefCountPtr< const Lang::Group3D > res = Lang::THE_NULL3D;
1102 res = RefCountPtr< const Lang::GroupPair3D >( new Lang::GroupPair3D( obj1,
1103 res,
1104 metaState ) );
1105 res = RefCountPtr< const Lang::GroupPair3D >( new Lang::GroupPair3D( obj2,
1106 res,
1107 metaState ) );
1108 return res;
1109 }
1110
1111 RefCountPtr< const Lang::Group3D >
1112 Helpers::newGroup3D( const RefCountPtr< const Kernel::GraphicsState > & metaState, const RefCountPtr< const Lang::Drawable3D > & obj3, const RefCountPtr< const Lang::Drawable3D > & obj2, const RefCountPtr< const Lang::Drawable3D > & obj1 )
1113 {
1114 RefCountPtr< const Lang::Group3D > res = Lang::THE_NULL3D;
1115 res = RefCountPtr< const Lang::GroupPair3D >( new Lang::GroupPair3D( obj1,
1116 res,
1117 metaState ) );
1118 res = RefCountPtr< const Lang::GroupPair3D >( new Lang::GroupPair3D( obj2,
1119 res,
1120 metaState ) );
1121 res = RefCountPtr< const Lang::GroupPair3D >( new Lang::GroupPair3D( obj3,
1122 res,
1123 metaState ) );
1124 return res;
1125 }
1126
1127
1128 Lang::GroupPair3D::GroupPair3D( const RefCountPtr< const Lang::Drawable3D > & car, const RefCountPtr< const Lang::Group3D > & cdr, const RefCountPtr< const Kernel::GraphicsState > & metaState )
1129 : metaState_( metaState ), car_( car ), cdr_( cdr )
1130 { }
1131
1132 Lang::GroupPair3D::~GroupPair3D( )
1133 { }
1134
1135 bool
1136 Lang::GroupPair3D::isNull( ) const
1137 {
1138 return false;
1139 }
1140
1141 RefCountPtr< const Lang::Group2D >
1142 Lang::GroupPair3D::group_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf ) const
1143 {
1144 return RefCountPtr< const Lang::Group2D >( new Lang::GroupPair2D( car_->typed_to2D( dyn, tf, car_ ),
1145 cdr_->group_to2D( dyn, tf ),
1146 metaState_ ) );
1147 }
1148
1149 void
1150 Lang::GroupPair3D::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
1151 {
1152 car_->polygonize( zBufPile, linePile, dyn, tf, car_ );
1153 cdr_->polygonize( zBufPile, linePile, dyn, tf, cdr_ );
1154 }
1155
1156 void
1157 Lang::GroupPair3D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
1158 {
1159 /* See note on order in GroupPair2D!
1160 */
1161 cdr_->findTags( dst, dyn, key, tf );
1162 car_->findTags( dst, dyn, key, tf );
1163 }
1164
1165 bool
1166 Lang::GroupPair3D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
1167 {
1168 return
1169 cdr_->findOneTag( evalState, key, tf ) ||
1170 car_->findOneTag( evalState, key, tf );
1171 }
1172
1173 RefCountPtr< const Lang::Group3D >
1174 Lang::GroupPair3D::removeShallow( Lang::Symbol::KeyType key ) const
1175 {
1176 {
1177 typedef const Lang::Tagged3D TaggedType;
1178 TaggedType * t = dynamic_cast< TaggedType * >( car_.getPtr( ) );
1179 if( t != 0 && t->key( ) == key )
1180 {
1181 return cdr_->removeShallow( key );
1182 }
1183 }
1184 return RefCountPtr< const Lang::Group3D >( new Lang::GroupPair3D( car_, cdr_->removeShallow( key ), metaState_ ) );
1185 }
1186
1187 void
1188 Lang::GroupPair3D::gcMark( Kernel::GCMarkedSet & marked )
1189 {
1190 const_cast< Lang::Drawable3D * >( car_.getPtr( ) )->gcMark( marked );
1191 const_cast< Lang::Group3D * >( cdr_.getPtr( ) )->gcMark( marked );
1192 }
1193
1194
1195 Lang::GroupNull3D::GroupNull3D( )
1196 { }
1197
1198 Lang::GroupNull3D::~GroupNull3D( )
1199 { }
1200
1201 bool
1202 Lang::GroupNull3D::isNull( ) const
1203 {
1204 return true;
1205 }
1206
1207 RefCountPtr< const Lang::Group3D >
1208 Lang::GroupNull3D::removeShallow( Lang::Symbol::KeyType key ) const
1209 {
1210 return Lang::THE_NULL3D;
1211 }
1212
1213 RefCountPtr< const Lang::Group2D >
1214 Lang::GroupNull3D::group_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf ) const
1215 {
1216 return Lang::THE_NULL2D;
1217 }
1218
1219 void
1220 Lang::GroupNull3D::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
1221 { }
1222
1223
1224 Lang::Drawable2Din3D::Drawable2Din3D( RefCountPtr< const Lang::Drawable2D > element )
1225 : element_( element )
1226 { }
1227
1228 Lang::Drawable2Din3D::~Drawable2Din3D( )
1229 { }
1230
1231 RefCountPtr< const Lang::Drawable2D >
1232 Lang::Drawable2Din3D::typed_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
1233 {
1234 Concrete::Length eyez = dyn->getEyeZ( );
1235 if( eyez < Concrete::HUGE_LENGTH )
1236 {
1237 std::ostringstream msg;
1238 msg << "An object of type " << element_->getTypeName( ) << " in 3D cannot go back to 2D viewed from a finite distance. Consider using facing rather than immerse." ;
1239 throw Exceptions::MiscellaneousRequirement( strrefdup( msg.str( ).c_str( ) ) );
1240 }
1241
1242 // The transform in 2D is obtained by setting z = 0 in the source 3D coordinates, and omitting the z-coordinate in the new coordinates
1243
1244 return RefCountPtr< const Lang::Drawable2D >( new Lang::Transformed2D( element_, Lang::Transform2D( tf.xx_, tf.yx_, tf.xy_, tf.yy_, tf.xt_, tf.yt_ ) ) );
1245 }
1246
1247 void
1248 Lang::Drawable2Din3D::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
1249 {
1250 throw Exceptions::NotImplemented( "Triangularization of immersed objects." );
1251 }
1252
1253 void
1254 Lang::Drawable2Din3D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
1255 {
1256 Concrete::Length eyez = dyn->getEyeZ( );
1257 if( eyez < Concrete::HUGE_LENGTH )
1258 {
1259 std::ostringstream msg;
1260 msg << "Tags in an immersed object are not accessible from a finite viewing distance. Consider using facing rather than immerse." ;
1261 throw Exceptions::MiscellaneousRequirement( strrefdup( msg.str( ).c_str( ) ) );
1262 }
1263
1264 // The transform in 2D is obtained by setting z = 0 in the source 3D coordinates, and omitting the z-coordinate in the new coordinates
1265
1266 element_->findTags( dst, dyn, key, Lang::Transform2D( tf.xx_, tf.yx_, tf.xy_, tf.yy_, tf.xt_, tf.yt_ ) );
1267 }
1268
1269 bool
1270 Lang::Drawable2Din3D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
1271 {
1272 Concrete::Length eyez = evalState->dyn_->getEyeZ( );
1273 if( eyez < Concrete::HUGE_LENGTH )
1274 {
1275 std::ostringstream msg;
1276 msg << "Tags in an immersed object are not accessible from a finite viewing distance. Consider using facing rather than immerse." ;
1277 throw Exceptions::MiscellaneousRequirement( strrefdup( msg.str( ).c_str( ) ) );
1278 }
1279
1280 // The transform in 2D is obtained by setting z = 0 in the source 3D coordinates, and omitting the z-coordinate in the new coordinates
1281
1282 return
1283 element_->findOneTag( evalState, key, Lang::Transform2D( tf.xx_, tf.yx_, tf.xy_, tf.yy_, tf.xt_, tf.yt_ ) );
1284 }
1285
1286 void
1287 Lang::Drawable2Din3D::gcMark( Kernel::GCMarkedSet & marked )
1288 {
1289 const_cast< Lang::Drawable2D * >( element_.getPtr( ) )->gcMark( marked );
1290 }
1291
1292
1293
1294 Lang::Facing2Din3D::Facing2Din3D( RefCountPtr< const Lang::Drawable2D > element, bool scale, bool distort )
1295 : element_( element ), scale_( scale ), distort_( distort )
1296 { }
1297
1298 Lang::Facing2Din3D::~Facing2Din3D( )
1299 { }
1300
1301 RefCountPtr< const Lang::Drawable2D >
1302 Lang::Facing2Din3D::typed_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
1303 {
1304 Concrete::Length eyez = dyn->getEyeZ( );
1305 double s = 1;
1306 if( scale_ && eyez < Concrete::HUGE_LENGTH )
1307 {
1308 s = eyez / ( eyez - tf.zt_ );
1309 }
1310
1311 Concrete::Length x;
1312 Concrete::Length y;
1313 if( eyez < Concrete::HUGE_LENGTH )
1314 {
1315 x = tf.xt_ * ( eyez / ( eyez - tf.zt_ ) );
1316 y = tf.yt_ * ( eyez / ( eyez - tf.zt_ ) );
1317 }
1318 else
1319 {
1320 x = tf.xt_;
1321 y = tf.yt_;
1322 }
1323
1324 if( distort_ )
1325 {
1326 return RefCountPtr< const Lang::Drawable2D >( new Lang::Transformed2D( element_, Lang::Transform2D( s * tf.xx_, s * tf.yx_, s * tf.xy_, s * tf.yy_, x, y ) ) );
1327 }
1328 else
1329 {
1330 return RefCountPtr< const Lang::Drawable2D >( new Lang::Transformed2D( element_, Lang::Transform2D( s, 0, 0, s, x, y ) ) );
1331 }
1332 }
1333
1334 void
1335 Lang::Facing2Din3D::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
1336 {
1337 throw Exceptions::MiscellaneousRequirement( "Facing objects cannot be polygonized." );
1338 }
1339
1340 void
1341 Lang::Facing2Din3D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
1342 {
1343 Concrete::Length eyez = dyn->getEyeZ( );
1344 double s = 1;
1345 if( scale_ && eyez < Concrete::HUGE_LENGTH )
1346 {
1347 s = eyez / ( eyez - tf.zt_ );
1348 }
1349
1350 Concrete::Length x;
1351 Concrete::Length y;
1352 if( eyez < Concrete::HUGE_LENGTH )
1353 {
1354 x = tf.xt_ * ( eyez / ( eyez - tf.zt_ ) );
1355 y = tf.yt_ * ( eyez / ( eyez - tf.zt_ ) );
1356 }
1357 else
1358 {
1359 x = tf.xt_;
1360 y = tf.yt_;
1361 }
1362
1363 if( distort_ )
1364 {
1365 element_->findTags( dst, dyn, key, Lang::Transform2D( s * tf.xx_, s * tf.yx_, s * tf.xy_, s * tf.yy_, x, y ) );
1366 }
1367 else
1368 {
1369 element_->findTags( dst, dyn, key, Lang::Transform2D( s, 0, 0, s, x, y ) );
1370 }
1371 }
1372
1373 bool
1374 Lang::Facing2Din3D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
1375 {
1376 Concrete::Length eyez = evalState->dyn_->getEyeZ( );
1377 double s = 1;
1378 if( scale_ && eyez < Concrete::HUGE_LENGTH )
1379 {
1380 s = eyez / ( eyez - tf.zt_ );
1381 }
1382
1383 Concrete::Length x;
1384 Concrete::Length y;
1385 if( eyez < Concrete::HUGE_LENGTH )
1386 {
1387 x = tf.xt_ * ( eyez / ( eyez - tf.zt_ ) );
1388 y = tf.yt_ * ( eyez / ( eyez - tf.zt_ ) );
1389 }
1390 else
1391 {
1392 x = tf.xt_;
1393 y = tf.yt_;
1394 }
1395
1396 if( distort_ )
1397 {
1398 return
1399 element_->findOneTag( evalState, key, Lang::Transform2D( s * tf.xx_, s * tf.yx_, s * tf.xy_, s * tf.yy_, x, y ) );
1400 }
1401 else
1402 {
1403 return
1404 element_->findOneTag( evalState, key, Lang::Transform2D( s, 0, 0, s, x, y ) );
1405 }
1406 }
1407
1408 void
1409 Lang::Facing2Din3D::gcMark( Kernel::GCMarkedSet & marked )
1410 {
1411 const_cast< Lang::Drawable2D * >( element_.getPtr( ) )->gcMark( marked );
1412 }
1413
1414
1415 Lang::FacingFunction3D::FacingFunction3D( Kernel::PassedDyn dyn, RefCountPtr< const Lang::Function > generator )
1416 : dyn_( dyn ), generator_( generator )
1417 { }
1418
1419 Lang::FacingFunction3D::~FacingFunction3D( )
1420 { }
1421
1422 RefCountPtr< const Lang::Drawable2D >
1423 Lang::FacingFunction3D::typed_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
1424 {
1425 /* Too bad we can't call the function CPP here...
1426 */
1427 Kernel::ValueRef valUntyped = NullPtr< const Lang::Value >( );
1428
1429 static Ast::SourceLocation loc( Ast::FileID::build_internal( "<Facing a function in 3D>" ) );
1430
1431 /* Note that the use of a StoreValueContinuation relies on valUntyped being alive at the time the continuation is invoked.
1432 */
1433 bool done = false;
1434 Kernel::EvalState evalState( 0,
1435 0,
1436 dyn_,
1437 Kernel::ContRef( new Kernel::StoreValueContinuation( & valUntyped,
1438 Kernel::ContRef( new Kernel::ExitContinuation( & done, loc ) ),
1439 loc ) ) );
1440
1441 generator_->call( & evalState, RefCountPtr< const Lang::Value >( new Lang::Transform3D( tf ) ), loc );
1442
1443 while( ! done )
1444 {
1445 evalState.expr_->eval( & evalState );
1446 }
1447
1448 return Helpers::down_cast< const Lang::Drawable2D >( valUntyped, loc );
1449 }
1450
1451 void
1452 Lang::FacingFunction3D::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
1453 {
1454 throw Exceptions::MiscellaneousRequirement( "Facing functions cannot be polygonized." );
1455 }
1456
1457 void
1458 Lang::FacingFunction3D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
1459 {
1460 /*
1461 * At the moment, we don't search facing functions for tags!
1462 */
1463 }
1464
1465 bool
1466 Lang::FacingFunction3D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
1467 {
1468 /*
1469 * At the moment, we don't search facing functions for tags!
1470 */
1471 return false;
1472 }
1473
1474 void
1475 Lang::FacingFunction3D::gcMark( Kernel::GCMarkedSet & marked )
1476 {
1477 const_cast< Lang::Function * >( generator_.getPtr( ) )->gcMark( marked );
1478 }
1479
1480
1481 Computation::PaintedPolygon3D::PaintedPolygon3D( bool singleSided, const Concrete::UnitFloatTriple & normal, Concrete::Length m, Concrete::Length tiebreaker )
1482 : singleSided_( singleSided ), normal_( normal ), m_( m ), tiebreaker_( tiebreaker )
1483 { }
1484
1485 Computation::PaintedPolygon3D::~PaintedPolygon3D( )
1486 { }
1487
1488 void
1489 Computation::PaintedPolygon3D::pushPoint( const Concrete::Coords3D & p )
1490 {
1491 Concrete::Length tmp = Concrete::inner( normal_, p ) - m_;
1492 if( tmp.abs( ) > Computation::theTrixelizeSplicingTol )
1493 {
1494 std::ostringstream msg;
1495 msg << "The 3D painted path was not flat enough (" << tmp.offtype< 1, 0 >( ) << " > splicingtol) to make a polygon." ;
1496 throw Exceptions::OutOfRange( strrefdup( msg ) );
1497 }
1498 points_.push_back( p );
1499 }
1500
1501 void
1502 Computation::PaintedPolygon3D::push_zBufTriangles( const Lang::Transform3D & tf, const Concrete::Length eyez, std::list< Computation::ZBufTriangle > * triangleQueue, bool respectSingleSided ) const
1503 {
1504 // This function shall not push tiny triangles!
1505
1506 // Note that the ZBufTriangles pushed are not completely transformed, since *this is the painter, and not transformed by tf.
1507 // The ugly solution to this is that tf must also be specified when painting the area.
1508
1509 if( points_.size( ) < 3 )
1510 {
1511 return;
1512 }
1513
1514 // At the moment, convexity is assumed!
1515
1516 typedef Computation::ZBufTriangle::ZMap ZMapType;
1517 if( tf.isIdentity( ) )
1518 {
1519 if( respectSingleSided && singleSided_ )
1520 {
1521 const Concrete::Coords3D & somePoint = points_.front( );
1522 if( normal_.z_ * eyez - Concrete::inner( normal_, somePoint ) <= 0 )
1523 {
1524 return;
1525 }
1526 }
1527
1528 RefCountPtr< const ZMapType > zMap( new ZMapType( normal_, m_, tiebreaker_, eyez ) );
1529 typedef typeof points_ ListType;
1530 ListType::const_iterator i = points_.begin( );
1531 Concrete::Coords2D p0 = i->make2DAutomatic( eyez );
1532 ++i;
1533 Concrete::Coords2D p1 = i->make2DAutomatic( eyez );
1534 ++i;
1535 for( ; i != points_.end( ); ++i )
1536 {
1537 Concrete::Coords2D p2 = i->make2DAutomatic( eyez );
1538 // This tolerance test assures that we don't produce tiny-tiny triangles. It is an inscribed circle test.
1539 if( Computation::triangleArea( p0, p1, p2 ) > Computation::theTrixelizeOverlapTol * Computation::triangleSemiPerimeter( p0, p1, p2 ) )
1540 {
1541 triangleQueue->push_back( Computation::ZBufTriangle( this,
1542 zMap,
1543 p0, p1, p2 ) );
1544 }
1545 p1 = p2;
1546 }
1547 }
1548 else
1549 {
1550 RefCountPtr< const ZMapType > zMap = RefCountPtr< const ZMapType >( NullPtr< const ZMapType >( ) );
1551 {
1552 Concrete::UnitFloatTriple Tnormal = tf.transformPlaneUnitNormal( normal_ );
1553 if( respectSingleSided && singleSided_ )
1554 {
1555 const Concrete::Coords3D & somePoint = points_.front( );
1556 if( Tnormal.z_ * eyez - Concrete::inner( Tnormal, somePoint.transformed( tf ) ) <= 0 )
1557 {
1558 return;
1559 }
1560 }
1561
1562 double ax = fabs( normal_.x_ );
1563 double ay = fabs( normal_.y_ );
1564 double az = fabs( normal_.z_ );
1565 Concrete::Coords3D x0( 0, 0, 0 );
1566 if( ax >= ay && ax >= az )
1567 {
1568 x0 = Concrete::Coords3D( m_ / normal_.x_, 0, 0 );
1569 }
1570 else if( ay >= az )
1571 {
1572 x0 = Concrete::Coords3D( 0, m_ / normal_.y_, 0 );
1573 }
1574 else
1575 {
1576 x0 = Concrete::Coords3D( 0, 0, m_ / normal_.z_ );
1577 }
1578 Concrete::Length Tm = Concrete::inner( Tnormal, x0.transformed( tf ) );
1579
1580 zMap = RefCountPtr< const ZMapType >( new ZMapType( Tnormal, Tm, tiebreaker_, eyez ) );
1581 }
1582
1583
1584 typedef typeof points_ ListType;
1585 ListType::const_iterator i = points_.begin( );
1586 Concrete::Coords2D p0 = i->transformed( tf ).make2DAutomatic( eyez );
1587 ++i;
1588 Concrete::Coords2D p1 = i->transformed( tf ).make2DAutomatic( eyez );
1589 ++i;
1590 for( ; i != points_.end( ); ++i )
1591 {
1592 Concrete::Coords2D p2 = i->transformed( tf ).make2DAutomatic( eyez );
1593 // This tolerance test assures that we don't produce tiny-tiny triangles. It is an inscribed circle test.
1594 if( Computation::triangleArea( p0, p1, p2 ) > Computation::theTrixelizeOverlapTol * Computation::triangleSemiPerimeter( p0, p1, p2 ) )
1595 {
1596 triangleQueue->push_back( Computation::ZBufTriangle( this,
1597 zMap,
1598 p0, p1, p2 ) );
1599 }
1600 p1 = p2;
1601 }
1602 }
1603 }
1604
1605 Concrete::Coords3D
1606 Computation::PaintedPolygon3D::computeMean( ) const
1607 {
1608 Concrete::Coords3D res( 0, 0, 0 );
1609 typedef typeof points_ ListType;
1610 for( ListType::const_iterator i = points_.begin( ); i != points_.end( ); ++i )
1611 {
1612 res = res + *i;
1613 }
1614 return ( 1. / points_.size( ) ) * res;
1615 }
1616
1617 const Computation::FacetLatticeVertex *
1618 Computation::FacetLatticeEdge::getOther( const FacetLatticeEdge * e ) const
1619 {
1620 if( p0_ == e->p0_ || p0_ == e->p1_ )
1621 {
1622 return p1_;
1623 }
1624 return p0_;
1625 }
1626
1627 bool
1628 Computation::FacetLatticeEdge::sharePoint( const FacetLatticeEdge * e ) const
1629 {
1630 return
1631 p0_ == e->p0_ ||
1632 p0_ == e->p1_ ||
1633 p1_ == e->p0_ ||
1634 p1_ == e->p1_;
1635 }
1636
1637
1638 void
1639 Computation::FacetLatticeEdge::split( const Concrete::Length eyez,
1640 PtrOwner_back_Access< std::list< const Computation::FacetLatticeEdge * > > * edgeMem,
1641 PtrOwner_back_Access< std::list< const Computation::FacetLatticeVertex * > > * vertexMem,
1642 const Computation::FacetLatticeEdge ** child1, const Computation::FacetLatticeEdge ** child2 ) const
1643 {
1644 if( child1_ != 0 )
1645 {
1646 *child1 = child1_;
1647 *child2 = child2_;
1648 return;
1649 }
1650
1651 if( eyez == Concrete::HUGE_LENGTH )
1652 {
1653 FacetLatticeVertex * pNew = new FacetLatticeVertex( 0.5 * ( p0_->p3D_ + p1_->p3D_ ), eyez, vertexMem->size( ) );
1654 vertexMem->push_back( pNew );
1655 child1_ = new Computation::FacetLatticeEdge( p0_, pNew );
1656 edgeMem->push_back( child1_ );
1657 child2_ = new Computation::FacetLatticeEdge( pNew, p1_ );
1658 edgeMem->push_back( child2_ );
1659 }
1660 else
1661 {
1662 // We compute the midpoint _in_view_, and then find where this is along the 3D line.
1663 Concrete::Coords2D mid2D = 0.5 * ( p0_->p2D_ + p1_->p2D_ );
1664
1665 // If we write the point we seek in 3D as
1666 // p0_ + lambda * ( p1_ - p0_ )
1667 // then <lambda> must solve the overdetermined system
1668 // a * lambda == -b
1669 // where
1670 const double ra = ( p1_->p3D_.z_ - p0_->p3D_.z_ ) / eyez;
1671 Concrete::Coords2D a( p1_->p3D_.x_ - p0_->p3D_.x_ + mid2D.x_ * ra,
1672 p1_->p3D_.y_ - p0_->p3D_.y_ + mid2D.y_ * ra );
1673 const double rb = static_cast< double >( p0_->p3D_.z_ / eyez ) - 1;
1674 Concrete::Coords2D b( p0_->p3D_.x_ + mid2D.x_ * rb,
1675 p0_->p3D_.y_ + mid2D.y_ * rb );
1676 const double lambda = - Concrete::innerScalar( a, b ) / Concrete::innerScalar( a, a );
1677
1678 FacetLatticeVertex * pNew = new FacetLatticeVertex( ( 1 - lambda ) * p0_->p3D_ + lambda * p1_->p3D_, eyez, vertexMem->size( ) );
1679 vertexMem->push_back( pNew );
1680 child1_ = new Computation::FacetLatticeEdge( p0_, pNew );
1681 edgeMem->push_back( child1_ );
1682 child2_ = new Computation::FacetLatticeEdge( pNew, p1_ );
1683 edgeMem->push_back( child2_ );
1684 }
1685
1686 *child1 = child1_;
1687 *child2 = child2_;
1688 }
1689
1690
1691 Computation::FacetLatticeVertex::FacetLatticeVertex( const Concrete::Coords3D & p3D, const Concrete::Length eyez, const size_t i )
1692 : p3D_( p3D ), p2D_( p3D.make2DAutomatic( eyez ) ), i_( i )
1693 { }
1694
1695 const Computation::FacetLatticeEdge *
1696 Computation::FacetLatticeTriangle::getOther( const Computation::FacetLatticeEdge *ea, const Computation::FacetLatticeEdge *eb ) const
1697 {
1698 if( ea == e0_ )
1699 {
1700 if( eb == e1_ )
1701 {
1702 return e2_;
1703 }
1704 return e1_;
1705 }
1706 else if( ea == e1_ )
1707 {
1708 if( eb == e0_ )
1709 {
1710 return e2_;
1711 }
1712 return e0_;
1713 }
1714 else if( ea == e2_ )
1715 {
1716 if( eb == e0_ )
1717 {
1718 return e1_;
1719 }
1720 return e0_;
1721 }
1722
1723 throw Exceptions::InternalError( "FacetTriangle::getOther called with alien edge." );
1724 }
1725
1726 bool
1727 Computation::FacetLatticeTriangle::fitsResolution( const Concrete::Length resolution, const Concrete::Length eyez,
1728 PtrOwner_back_Access< std::list< const Computation::FacetLatticeEdge * > > * edgeMem,
1729 PtrOwner_back_Access< std::list< const Computation::FacetLatticeVertex * > > * vertexMem,
1730 const Computation::FacetLatticeTriangle ** child1, const Computation::FacetLatticeTriangle ** child2 ) const
1731 {
1732 const Computation::FacetLatticeEdge * ec1;
1733 const Computation::FacetLatticeEdge * ec2;
1734
1735 Concrete::Length l0 = e0_->length2D( );
1736 Concrete::Length l1 = e1_->length2D( );
1737 Concrete::Length l2 = e2_->length2D( );
1738 Concrete::Length lMax = std::max( l0, std::max( l1, l2 ) );
1739
1740 if( lMax < resolution )
1741 {
1742 return true;
1743 }
1744
1745 const Computation::FacetLatticeEdge * ea = e0_;
1746 const Computation::FacetLatticeEdge * eb = e1_;
1747 const Computation::FacetLatticeEdge * ec = e2_;
1748 if( l1 == lMax )
1749 {
1750 ea = e1_;
1751 eb = e2_;
1752 ec = e0_;
1753 }
1754 else if( l2 == lMax )
1755 {
1756 ea = e2_;
1757 eb = e0_;
1758 ec = e1_;
1759 }
1760
1761
1762 ea->split( eyez, edgeMem, vertexMem, & ec1, & ec2 );
1763 Computation::FacetLatticeEdge * newEdge = new Computation::FacetLatticeEdge( ea->midpoint( ), eb->getOther( ea ) );
1764 edgeMem->push_back( newEdge );
1765 if( eb->sharePoint( ec2 ) )
1766 {
1767 *child1 = new Computation::FacetLatticeTriangle( ec2, eb, newEdge );
1768 *child2 = new Computation::FacetLatticeTriangle( newEdge, ec, ec1 );
1769 }
1770 else
1771 {
1772 *child1 = new Computation::FacetLatticeTriangle( ec1, eb, newEdge );
1773 *child2 = new Computation::FacetLatticeTriangle( newEdge, ec, ec2 );
1774 }
1775
1776 return false;
1777 }
1778
1779
1780 RefCountPtr< const Lang::Drawable2D >
1781 Computation::FacetLatticeTriangle::paint( const RefCountPtr< const Computation::FacetInterpolatorGray > & interpolator, const std::list< RefCountPtr< const Lang::LightSource > > & lights, const Concrete::Length eyez ) const
1782 {
1783 Kernel::GraphicsState * metaStatePtr = new Kernel::GraphicsState( true );
1784
1785 metaStatePtr->nonStrokingColor_ = interpolator->compute( Lang::THE_3D_IDENTITY, lights,
1786 Computation::triangleIncenter( v0_->p3D_, v1_->p3D_, v2_->p3D_ ),
1787 eyez );
1788
1789 RefCountPtr< const Kernel::GraphicsState > metaState( metaStatePtr );
1790
1791 RefCountPtr< Lang::ElementaryPath2D > path = RefCountPtr< Lang::ElementaryPath2D >( new Lang::ElementaryPath2D( ) );
1792 path->close( );
1793 // It's a pity we have to copy duplicate those points...
1794 path->push_back( new Concrete::PathPoint2D( new Concrete::Coords2D( v0_->p2D_ ) ) );
1795 path->push_back( new Concrete::PathPoint2D( new Concrete::Coords2D( v1_->p2D_ ) ) );
1796 path->push_back( new Concrete::PathPoint2D( new Concrete::Coords2D( v2_->p2D_ ) ) );
1797
1798 return RefCountPtr< const Lang::PaintedPolygon2D >( new Lang::PaintedPolygon2D( metaState, path ) );
1799 }
1800
1801 RefCountPtr< const Lang::Drawable2D >
1802 Computation::FacetLatticeTriangle::paint( const RefCountPtr< const Computation::FacetInterpolatorRGB > & interpolator, const std::list< RefCountPtr< const Lang::LightSource > > & lights, const Concrete::Length eyez ) const
1803 {
1804 Kernel::GraphicsState * metaStatePtr = new Kernel::GraphicsState( true );
1805
1806 metaStatePtr->nonStrokingColor_ = interpolator->compute( Lang::THE_3D_IDENTITY, lights,
1807 Computation::triangleIncenter( v0_->p3D_, v1_->p3D_, v2_->p3D_ ),
1808 eyez );
1809
1810 RefCountPtr< const Kernel::GraphicsState > metaState( metaStatePtr );
1811
1812 RefCountPtr< Lang::ElementaryPath2D > path = RefCountPtr< Lang::ElementaryPath2D >( new Lang::ElementaryPath2D( ) );
1813 path->close( );
1814 // It's a pity we have to copy duplicate those points...
1815 path->push_back( new Concrete::PathPoint2D( new Concrete::Coords2D( v0_->p2D_ ) ) );
1816 path->push_back( new Concrete::PathPoint2D( new Concrete::Coords2D( v1_->p2D_ ) ) );
1817 path->push_back( new Concrete::PathPoint2D( new Concrete::Coords2D( v2_->p2D_ ) ) );
1818
1819 return RefCountPtr< const Lang::PaintedPolygon2D >( new Lang::PaintedPolygon2D( metaState, path ) );
1820 }
1821
1822 void
1823 Computation::FacetLatticeTriangle::getVertexes( const Computation::FacetLatticeVertex ** va, const Computation::FacetLatticeVertex ** vb, const Computation::FacetLatticeVertex ** vc ) const
1824 {
1825 *va = v0_;
1826 *vb = v1_;
1827 *vc = v2_;
1828 }
1829
1830 // This function is very close to the PDF definition of a free-form triangle mesh.
1831 // If this triangle is an extension of va--vb--vc, then va, vb, vc are updated and the corresponding flag (se PDF spec) is returned.
1832 // If this is not an extension, the value 3 is returned (which is not a legal falg value), and va, vb, vc are left unchanged.
1833 unsigned char
1834 Computation::FacetLatticeTriangle::extendLattice( const Computation::FacetLatticeVertex ** va, const Computation::FacetLatticeVertex ** vb, const Computation::FacetLatticeVertex ** vc ) const
1835 {
1836 // vc must be part of this triangle if we are to extend va--vb--vc.
1837 if( v0_ == *vc || v1_ == *vc || v2_ == *vc )
1838 {
1839 // First, we try to extend vb--vc (corresponding to flag=1)
1840 if( v0_ == *vb || v1_ == *vb || v2_ == *vb )
1841 {
1842 // We now update va and vb so that they define the edge that is extended.
1843 *va = *vb;
1844 *vb = *vc;
1845
1846 // Now we need to find which of our corners that is the added one.
1847 if( v0_ != *va && v0_ != *vb )
1848 {
1849 *vc = v0_;
1850 }
1851 else if( v1_ != *va && v1_ != *vb )
1852 {
1853 *vc = v1_;
1854 }
1855 else
1856 {
1857 *vc = v2_;
1858 }
1859 return 1;
1860 }
1861
1862 // Then, we try to extend va--vc (corresponding to flag=2)
1863 if( v0_ == *va || v1_ == *va || v2_ == *va )
1864 {
1865 // We now update va and vb so that they define the edge that is extended.
1866 // *va = *va;
1867 *vb = *vc;
1868
1869 // Now we need to find which of our corners that is the added one.
1870 if( v0_ != *va && v0_ != *vb )
1871 {
1872 *vc = v0_;
1873 }
1874 else if( v1_ != *va && v1_ != *vb )
1875 {
1876 *vc = v1_;
1877 }
1878 else
1879 {
1880 *vc = v2_;
1881 }
1882 return 2;
1883 }
1884 }
1885
1886 return 3;
1887 }
1888
1889 void
1890 Computation::FacetLatticeTriangle::display2D( std::ostream & os ) const
1891 {
1892 Concrete::Length lMax = Concrete::ZERO_LENGTH;
1893 {
1894 Concrete::Length tmp = v0_->p2D_.distanceTo( v1_->p2D_ );
1895 if( tmp > lMax )
1896 {
1897 lMax = tmp;
1898 }
1899 }
1900 {
1901 Concrete::Length tmp = v1_->p2D_.distanceTo( v2_->p2D_ );
1902 if( tmp > lMax )
1903 {
1904 lMax = tmp;
1905 }
1906 }
1907 {
1908 Concrete::Length tmp = v2_->p2D_.distanceTo( v0_->p2D_ );
1909 if( tmp > lMax )
1910 {
1911 lMax = tmp;
1912 }
1913 }
1914
1915 os << "Triangle ( " << v0_->p2D_ << " -- " << v1_->p2D_ << " -- " << v2_->p2D_ << " ) "
1916 << " with 2D area " << Concrete::Area::offtype( Computation::triangleArea( v0_->p2D_, v1_->p2D_, v2_->p2D_ ) )
1917 << " and longest side " << Lang::Length( lMax ) ;
1918 }
1919
1920 void
1921 Computation::FacetLatticeTriangle::display3D( std::ostream & os ) const
1922 {
1923 os << "Triangle ( " << v0_->p3D_ << " -- " << v1_->p3D_ << " -- " << v2_->p3D_ << " )" ;
1924 }
1925
1926
1927 void
1928 Computation::PaintedPolygon3D::makeLattice( PtrOwner_back_Access< std::list< const Computation::FacetLatticeTriangle * > > * lattice,
1929 PtrOwner_back_Access< std::list< const Computation::FacetLatticeEdge * > > * edgeMem,
1930 PtrOwner_back_Access< std::list< const FacetLatticeVertex * > > * vertexMem,
1931 const Concrete::Length viewResolution,
1932 const Concrete::Length eyez, const Lang::Transform3D & tf ) const
1933 {
1934 if( points_.size( ) < 3 )
1935 {
1936 throw Exceptions::InternalError( "Less than three points in PaintedPolygon3D::makeLattice!" );
1937 }
1938
1939 std::list< const Computation::FacetLatticeTriangle * > jobQueue;
1940
1941 typedef typeof points_ ListType;
1942
1943 if( points_.size( ) == 3 )
1944 {
1945 ListType::const_iterator i = points_.begin( );
1946 Computation::FacetLatticeVertex * p0 = new Computation::FacetLatticeVertex( i->transformed( tf ), eyez, vertexMem->size( ) );
1947 vertexMem->push_back( p0 );
1948 ++i;
1949 Computation::FacetLatticeVertex * p1 = new Computation::FacetLatticeVertex( i->transformed( tf ), eyez, vertexMem->size( ) );
1950 vertexMem->push_back( p1 );
1951 ++i;
1952 Computation::FacetLatticeVertex * p2 = new Computation::FacetLatticeVertex( i->transformed( tf ), eyez, vertexMem->size( ) );
1953 vertexMem->push_back( p2 );
1954
1955 Computation::FacetLatticeEdge * e0 = new Computation::FacetLatticeEdge( p0, p1 );
1956 edgeMem->push_back( e0 );
1957 Computation::FacetLatticeEdge * e1 = new Computation::FacetLatticeEdge( p1, p2 );
1958 edgeMem->push_back( e1 );
1959 Computation::FacetLatticeEdge * e2 = new Computation::FacetLatticeEdge( p2, p0 );
1960 edgeMem->push_back( e2 );
1961
1962 jobQueue.push_back( new Computation::FacetLatticeTriangle( e0, e1, e2 ) );
1963 }
1964 else
1965 {
1966 ListType::const_iterator i = points_.begin( );
1967 Computation::FacetLatticeVertex * p0 = new Computation::FacetLatticeVertex( i->transformed( tf ), eyez, vertexMem->size( ) );
1968 vertexMem->push_back( p0 );
1969 ++i;
1970 Computation::FacetLatticeVertex * p1 = new Computation::FacetLatticeVertex( i->transformed( tf ), eyez, vertexMem->size( ) );
1971 vertexMem->push_back( p1 );
1972 ++i;
1973
1974 Computation::FacetLatticeEdge * e0 = new Computation::FacetLatticeEdge( p0, p1 );
1975 edgeMem->push_back( e0 );
1976
1977 for( ; i != points_.end( ); ++i )
1978 {
1979 Computation::FacetLatticeVertex * p2 = new Computation::FacetLatticeVertex( i->transformed( tf ), eyez, vertexMem->size( ) );
1980 vertexMem->push_back( p2 );
1981
1982 Computation::FacetLatticeEdge * e1 = new Computation::FacetLatticeEdge( p1, p2 );
1983 edgeMem->push_back( e1 );
1984
1985 Computation::FacetLatticeEdge * e2 = new Computation::FacetLatticeEdge( p2, p0 );
1986 edgeMem->push_back( e2 );
1987
1988 jobQueue.push_back( new Computation::FacetLatticeTriangle( e0, e1, e2 ) );
1989
1990 p1 = p2;
1991 e0 = e2;
1992 }
1993 }
1994
1995 while( ! jobQueue.empty( ) )
1996 {
1997 const Computation::FacetLatticeTriangle * currentTriangle = jobQueue.front( );
1998 jobQueue.pop_front( );
1999 const Computation::FacetLatticeTriangle * child1 = 0;
2000 const Computation::FacetLatticeTriangle * child2 = 0;
2001 if( currentTriangle->fitsResolution( viewResolution, eyez, edgeMem, vertexMem, & child1, & child2 ) )
2002 {
2003 lattice->push_back( currentTriangle );
2004 }
2005 else
2006 {
2007 jobQueue.push_back( child1 );
2008 jobQueue.push_back( child2 );
2009 delete currentTriangle;
2010 }
2011 }
2012 }
2013
2014 Computation::StrokedLine3D::StrokedLine3D( const Concrete::Coords3D & p0, const Concrete::Coords3D & p1, const RefCountPtr< const Kernel::GraphicsState > metaState )
2015 : p0_( p0 ), p1_( p1 ), metaState_( metaState )
2016 { }
2017
2018 Computation::StrokedLine3D::~StrokedLine3D( )
2019 { }
2020
2021 void
2022 Computation::StrokedLine3D::push_zBufLine( const Lang::Transform3D & tf, const Concrete::Length eyez, std::list< const Computation::ZBufLine * > * lineQueue ) const
2023 {
2024 typedef Computation::ZBufLine::ZMap ZMapType;
2025 typedef const Bezier::PolyCoeffs< Concrete::Coords2D > ViewType;
2026 RefCountPtr< ViewType > nullView = RefCountPtr< ViewType >( NullPtr< ViewType >( ) );
2027 if( tf.isIdentity( ) )
2028 {
2029 Concrete::Coords3D d = p1_ - p0_;
2030 RefCountPtr< const ZMapType > zMap( new ZMapType( p0_, d.directionNoFail( ), eyez ) );
2031 lineQueue->push_back( new Computation::ZBufLine( this, zMap, nullView, p0_.make2DAutomatic( eyez ), p1_.make2DAutomatic( eyez ) ) );
2032 }
2033 else
2034 {
2035 Concrete::Coords3D tfp0 = p0_.transformed( tf );
2036 Concrete::Coords3D tfp1 = p1_.transformed( tf );
2037 Concrete::Coords3D d = tfp1 - tfp0;
2038 RefCountPtr< const ZMapType > zMap( new ZMapType( tfp0, d.directionNoFail( ), eyez ) );
2039 lineQueue->push_back( new Computation::ZBufLine( this, zMap, nullView, tfp0.make2DAutomatic( eyez ), tfp1.make2DAutomatic( eyez ) ) );
2040 }
2041 }
2042
2043
2044 Computation::StrokedSplineSegment3D::StrokedSplineSegment3D( const Concrete::Coords3D & p0, const Concrete::Coords3D & p0front, const Concrete::Coords3D & p1rear, const Concrete::Coords3D & p1, const RefCountPtr< const Kernel::GraphicsState > metaState )
2045 : Computation::StrokedLine3D( p0, p1, metaState ),
2046 p0front_( p0front ),
2047 p1rear_( p1rear )
2048 { }
2049
2050 Computation::StrokedSplineSegment3D::~StrokedSplineSegment3D( )
2051 { }
2052
2053 void
2054 Computation::StrokedSplineSegment3D::push_zBufLine( const Lang::Transform3D & tf, const Concrete::Length eyez, std::list< const Computation::ZBufLine * > * lineQueue ) const
2055 {
2056 typedef Computation::ZBufLine::ZMap ZMapType;
2057 typedef const Bezier::PolyCoeffs< Concrete::Coords2D > ViewType;
2058 if( tf.isIdentity( ) )
2059 {
2060 Concrete::Coords3D d = p1_ - p0_;
2061 RefCountPtr< const ZMapType > zMap( new ZMapType( p0_, d.directionNoFail( ), eyez ) );
2062 RefCountPtr< ViewType > bezierView = RefCountPtr< ViewType >( new ViewType( Bezier::ControlPoints< Concrete::Coords2D >( p0_.make2DAutomatic( eyez ), p0front_.make2DAutomatic( eyez ), p1rear_.make2DAutomatic( eyez ), p1_.make2DAutomatic( eyez ) ) ) );
2063 lineQueue->push_back( new Computation::ZBufLine( this, zMap, bezierView, p0_.make2DAutomatic( eyez ), p1_.make2DAutomatic( eyez ) ) );
2064 }
2065 else
2066 {
2067 Concrete::Coords3D tfp0 = p0_.transformed( tf );
2068 Concrete::Coords3D tfp0front = p0front_.transformed( tf );
2069 Concrete::Coords3D tfp1rear = p1rear_.transformed( tf );
2070 Concrete::Coords3D tfp1 = p1_.transformed( tf );
2071 Concrete::Coords3D d = tfp1 - tfp0;
2072 RefCountPtr< const ZMapType > zMap( new ZMapType( tfp0, d.directionNoFail( ), eyez ) );
2073 RefCountPtr< ViewType > bezierView = RefCountPtr< ViewType >( new ViewType( Bezier::ControlPoints< Concrete::Coords2D >( tfp0.make2DAutomatic( eyez ), tfp0front.make2DAutomatic( eyez ), tfp1rear.make2DAutomatic( eyez ), tfp1.make2DAutomatic( eyez ) ) ) );
2074 lineQueue->push_back( new Computation::ZBufLine( this, zMap, bezierView, tfp0.make2DAutomatic( eyez ), tfp1.make2DAutomatic( eyez ) ) );
2075 }
2076 }
2077
2078
2079 Computation::FilledPolygon3D::FilledPolygon3D( const RefCountPtr< const Kernel::GraphicsState > & metaState,
2080 const Concrete::UnitFloatTriple & normal, Concrete::Length m,
2081 Concrete::Length tiebreaker )
2082 : Computation::PaintedPolygon3D( false, normal, m, tiebreaker ), metaState_( metaState ) // false means not single-sided.
2083 { }
2084
2085 Computation::FilledPolygon3D::~FilledPolygon3D( )
2086 { }
2087
2088 RefCountPtr< const Lang::PaintedPolygon2D >
2089 Computation::FilledPolygon3D::polygon_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const std::list< RefCountPtr< const Lang::LightSource > > & lights ) const
2090 {
2091 // A FilledPolygon3D is characterized by that it doesn't take notice about the lights or orientation.
2092
2093 Concrete::Length eyez = dyn->getEyeZ( );
2094
2095 RefCountPtr< Lang::ElementaryPath2D > path = RefCountPtr< Lang::ElementaryPath2D >( new Lang::ElementaryPath2D( ) );
2096 path->close( );
2097 if( tf.isIdentity( ) )
2098 {
2099 typedef typeof points_ ListType;
2100 for( ListType::const_iterator i = points_.begin( ); i != points_.end( ); ++i )
2101 {
2102 path->push_back( new Concrete::PathPoint2D( i->make2D( eyez ) ) );
2103 }
2104 }
2105 else
2106 {
2107 typedef typeof points_ ListType;
2108 for( ListType::const_iterator i = points_.begin( ); i != points_.end( ); ++i )
2109 {
2110 path->push_back( new Concrete::PathPoint2D( i->transformed( tf ).make2D( eyez ) ) );
2111 }
2112 }
2113
2114 return RefCountPtr< const Lang::PaintedPolygon2D >( new Lang::PaintedPolygon2D( metaState_, path ) );
2115 }
2116
2117 RefCountPtr< const Lang::Color >
2118 Computation::FilledPolygon3D::getColor( ) const
2119 {
2120 return metaState_->nonStrokingColor_;
2121 }
2122
2123 void
2124 Computation::FilledPolygon3D::gcMark( Kernel::GCMarkedSet & marked )
2125 {
2126 // const_cast< Kernel::GraphicsState * >( metaState_.getPtr( ) )->gcMark( marked );
2127 }
2128
2129 Computation::NullPolygon3D::NullPolygon3D( )
2130 : Computation::PaintedPolygon3D( true, Concrete::UnitFloatTriple( 1., 0., 0., 1. ), 0, Concrete::ZERO_LENGTH )
2131 { }
2132
2133 Computation::NullPolygon3D::~NullPolygon3D( )
2134 { }
2135
2136 RefCountPtr< const Lang::PaintedPolygon2D >
2137 Computation::NullPolygon3D::polygon_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const std::list< RefCountPtr< const Lang::LightSource > > & lights ) const
2138 {
2139 throw Exceptions::InternalError( "NullPolygon3D::polygon_to2D was invoked!" );
2140 // return Lang::THE_NULL_POLYGON2D;
2141 }
2142
2143 RefCountPtr< const Lang::Color >
2144 Computation::NullPolygon3D::getColor( ) const
2145 {
2146 return Lang::THE_BLACK;
2147 }
2148
2149 void
2150 Computation::NullPolygon3D::gcMark( Kernel::GCMarkedSet & marked )
2151 { }
2152
2153
2154 Lang::PaintedPolygon2D::PaintedPolygon2D( RefCountPtr< const Kernel::GraphicsState > metaState, RefCountPtr< const Lang::ElementaryPath2D > path )
2155 : Lang::PaintedPath2D( metaState, "E" ) // "E" for "extended fill"
2156 {
2157 if( ! path->isClosed( ) )
2158 {
2159 throw Exceptions::InternalError( "Attempt to create PaintedPolygon2D with non-closed path." );
2160 }
2161 addSubPath( path );
2162 }
2163
2164 Lang::PaintedPolygon2D::~PaintedPolygon2D( )
2165 { }
2166
2167 RefCountPtr< const Lang::Drawable2D >
2168 Lang::PaintedPolygon2D::clip( std::list< Computation::ZBufTriangle > * regions, const RefCountPtr< const Lang::PaintedPolygon2D > selfRef ) const
2169 {
2170 if( regions->empty( ) )
2171 {
2172 throw Exceptions::InternalError( "Empty list of regions in PaintedPolygon2D::clip. (This triangle should not have been generated at all!)" );
2173 }
2174 if( regions->size( ) == 1 )
2175 {
2176 const Computation::ZBufTriangle & theClip = regions->front( );
2177 const Lang::ElementaryPath2D & paintPath = * path_.front( );
2178 bool isInside = true;
2179 for( Lang::ElementaryPath2D::const_iterator i = paintPath.begin( ); i != paintPath.end( ); ++i )
2180 {
2181 if( ! theClip.contains( *((*i)->mid_), Computation::theTrixelizeOverlapTol ) )
2182 {
2183 isInside = false;
2184 break;
2185 }
2186 }
2187 if( isInside )
2188 {
2189 return selfRef;
2190 }
2191 }
2192
2193 // If we reach here, clipping shall be done
2194 Lang::Clipped2D * resPtr = new Lang::Clipped2D( selfRef, "W" );
2195 Lang::ZBuf::trianglesToPolys( regions, resPtr );
2196 RefCountPtr< const Lang::Clipped2D > res( resPtr );
2197
2198 if( selfRef->isContainedIn( resPtr ) )
2199 {
2200 return selfRef;
2201 }
2202
2203 const bool SHOW_POLYS = false;
2204 if( SHOW_POLYS )
2205 {
2206 return res->debugPolys( );
2207 }
2208
2209 return res;
2210 }
2211
2212
2213 bool
2214 Lang::PaintedPath2D::isContainedIn( const Lang::Clipped2D * clipping ) const
2215 {
2216 if( ! clipping->isSingleConvexPoly( Computation::theTrixelizeOverlapTol ) )
2217 {
2218 return false;
2219 }
2220
2221 typedef typeof path_ PathType;
2222 for( PathType::const_iterator subpath = path_.begin( ); subpath != path_.end( ); ++subpath )
2223 {
2224 typedef typeof **subpath SubpathType;
2225 for( SubpathType::const_iterator i = (*subpath)->begin( ); i != (*subpath)->end( ); ++i )
2226 {
2227 Concrete::PathPoint2D * pathPoint = *i;
2228 if( pathPoint->rear_ != pathPoint->mid_ ||
2229 pathPoint->front_ != pathPoint->mid_ )
2230 {
2231 return false;
2232 }
2233 if( ! clipping->convexPolyContains( *(pathPoint->mid_), Computation::theTrixelizeOverlapTol ) )
2234 {
2235 return false;
2236 }
2237 }
2238 }
2239
2240 return true;
2241 }
2242
2243
2244 Lang::PaintedPath3D::PaintedPath3D( RefCountPtr< const Kernel::GraphicsState > metaState,
2245 const char * paintCmd, Concrete::Length tiebreaker )
2246 : metaState_( metaState ), paintCmd_( paintCmd ), tiebreaker_( tiebreaker )
2247 { }
2248
2249 Lang::PaintedPath3D::PaintedPath3D( RefCountPtr< const Kernel::GraphicsState > metaState,
2250 RefCountPtr< const Lang::ElementaryPath3D > path,
2251 const char * paintCmd, Concrete::Length tiebreaker )
2252 : metaState_( metaState ), paintCmd_( paintCmd ), tiebreaker_( tiebreaker )
2253 {
2254 addSubPath( path );
2255 }
2256
2257 Lang::PaintedPath3D::PaintedPath3D( RefCountPtr< const Kernel::GraphicsState > metaState,
2258 RefCountPtr< const Lang::MultiPath3D > paths,
2259 const char * paintCmd, Concrete::Length tiebreaker )
2260 : metaState_( metaState ), paintCmd_( paintCmd ), tiebreaker_( tiebreaker )
2261 {
2262 for( Lang::MultiPath3D::const_iterator i = paths->begin( ); i != paths->end( ); ++i )
2263 {
2264 {
2265 typedef const Lang::ElementaryPath3D ArgType;
2266 RefCountPtr< ArgType > subpath = (*i).down_cast< ArgType >( );
2267 if( subpath != NullPtr< ArgType >( ) )
2268 {
2269 addSubPath( subpath );
2270 continue;
2271 }
2272 }
2273
2274 {
2275 typedef const Lang::CompositePath3D ArgType;
2276 ArgType * subpath = dynamic_cast< ArgType * >( (*i).getPtr( ) );
2277 if( subpath != 0 )
2278 {
2279 addSubPath( subpath->getElementaryPath( ) );
2280 continue;
2281 }
2282 }
2283 throw Exceptions::InternalError( "Painting 3D path: Encountered a subpath of unexpected type" );
2284 }
2285 }
2286
2287 Lang::PaintedPath3D::~PaintedPath3D( )
2288 { }
2289
2290 RefCountPtr< const Lang::Class > Lang::PaintedPath3D::TypeID( new Lang::SystemFinalClass( strrefdup( "PaintedPath3D" ) ) );
2291 TYPEINFOIMPL( PaintedPath3D );
2292
2293 void
2294 Lang::PaintedPath3D::addSubPath( RefCountPtr< const Lang::ElementaryPath3D > subpath )
2295 {
2296 path_.push_back( subpath );
2297 }
2298
2299 RefCountPtr< const Lang::Drawable2D >
2300 Lang::PaintedPath3D::typed_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
2301 {
2302 Concrete::Length eyez = dyn->getEyeZ( );
2303
2304 RefCountPtr< const Lang::Group2D > res( Lang::THE_NULL2D );
2305
2306 if( tf.isIdentity( ) )
2307 {
2308 if( ! metaState_->dash_->isSolid( ) && *paintCmd_ == 'S' )
2309 {
2310 for( std::list< RefCountPtr< const Lang::ElementaryPath3D > >::const_iterator i = path_.begin( ); i != path_.end( ); ++i )
2311 {
2312 (*i)->dashifyIn2D( & res, eyez, metaState_ );
2313 }
2314 }
2315 else
2316 {
2317 for( std::list< RefCountPtr< const Lang::ElementaryPath3D > >::const_iterator i = path_.begin( ); i != path_.end( ); ++i )
2318 {
2319 res = RefCountPtr< const Lang::Group2D >( new Lang::GroupPair2D( RefCountPtr< const Lang::Drawable2D >( new Lang::PaintedPath2D( metaState_, (*i)->make2D( eyez ), paintCmd_ ) ),
2320 res,
2321 metaState_ ) );
2322 }
2323 }
2324 }
2325 else
2326 {
2327 if( ! metaState_->dash_->isSolid( ) && *paintCmd_ == 'S' )
2328 {
2329 for( std::list< RefCountPtr< const Lang::ElementaryPath3D > >::const_iterator i = path_.begin( ); i != path_.end( ); ++i )
2330 {
2331 (*i)->elementaryTransformed( tf )->dashifyIn2D( & res, eyez, metaState_ );
2332 }
2333 }
2334 else
2335 {
2336 for( std::list< RefCountPtr< const Lang::ElementaryPath3D > >::const_iterator i = path_.begin( ); i != path_.end( ); ++i )
2337 {
2338 res = RefCountPtr< const Lang::Group2D >( new Lang::GroupPair2D( RefCountPtr< const Lang::Drawable2D >( new Lang::PaintedPath2D( metaState_,
2339 (*i)->elementaryTransformed( tf )->make2D( eyez ),
2340 paintCmd_ ) ),
2341 res,
2342 metaState_ ) );
2343 }
2344 }
2345 }
2346 return res;
2347 }
2348
2349 void
2350 Lang::PaintedPath3D::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
2351 {
2352 if( strcmp( paintCmd_, "S" ) == 0 )
2353 {
2354 typedef typeof path_ ListType;
2355 for( ListType::const_iterator subi = path_.begin( ); subi != path_.end( ); ++subi )
2356 {
2357 const RefCountPtr< const Lang::ElementaryPath3D > & theSub = *subi;
2358
2359 if( theSub->size( ) < 2 )
2360 {
2361 continue;
2362 }
2363
2364 typedef typeof *theSub SubListType;
2365 SubListType::const_iterator i = theSub->begin( );
2366 Concrete::Coords3D p0 = (*i)->mid_->transformed( tf );
2367 SubListType::const_iterator iLast = i;
2368 ++i;
2369 for( ; i != theSub->end( ); iLast = i, ++i )
2370 {
2371 Concrete::Coords3D p1 = (*i)->mid_->transformed( tf );
2372 if( (*iLast)->front_ != (*iLast)->mid_ || (*i)->rear_ != (*i)->mid_ )
2373 {
2374 linePile->push_back( RefCountPtr< Computation::StrokedSplineSegment3D >
2375 ( new Computation::StrokedSplineSegment3D( p0, (*iLast)->front_->transformed( tf ), (*i)->rear_->transformed( tf ), p1, metaState_ ) ) );
2376 }
2377 else
2378 {
2379 linePile->push_back( RefCountPtr< Computation::StrokedLine3D >
2380 ( new Computation::StrokedLine3D( p0, p1, metaState_ ) ) );
2381 }
2382 p0 = p1;
2383 }
2384 if( theSub->isClosed( ) )
2385 {
2386 i = theSub->begin( );
2387 Concrete::Coords3D p1 = (*i)->mid_->transformed( tf );
2388 if( (*iLast)->front_ != (*iLast)->mid_ || (*i)->rear_ != (*i)->mid_ )
2389 {
2390 linePile->push_back( RefCountPtr< Computation::StrokedSplineSegment3D >
2391 ( new Computation::StrokedSplineSegment3D( p0, (*iLast)->front_->transformed( tf ), (*i)->rear_->transformed( tf ), p1, metaState_ ) ) );
2392 }
2393 else
2394 {
2395 linePile->push_back( RefCountPtr< Computation::StrokedLine3D >
2396 ( new Computation::StrokedLine3D( p0, p1, metaState_ ) ) );
2397 }
2398 }
2399 }
2400
2401 return;
2402 }
2403
2404 if( ! ( strcmp( paintCmd_, "f" ) == 0 ||
2405 strcmp( paintCmd_, "B" ) == 0 ) )
2406 {
2407 throw Exceptions::MiscellaneousRequirement( "Only stroked and (non-*) filled polygons can be put i a z buffer." );
2408 }
2409
2410
2411 // When we get here we know that the paintCmd_ is "f" or "B", that is, a plain fill.
2412
2413 // if( path.size( ) > 1 )
2414 // {
2415 // WARN_OR_THROW( Exceptionssha::MiscellanueousRequirement( "The result from triangularizing a composite path may not be what is expected." ) );
2416 // }
2417
2418 typedef typeof path_ ListType;
2419 for( ListType::const_iterator subi = path_.begin( ); subi != path_.end( ); ++subi )
2420 {
2421 const RefCountPtr< const Lang::ElementaryPath3D > & theSub = *subi;
2422
2423 if( theSub->size( ) < 3 )
2424 {
2425 continue;
2426 }
2427 if( ! theSub->isClosed( ) )
2428 {
2429 throw "Not closed";
2430 }
2431
2432 typedef typeof *theSub SubListType;
2433
2434 RefCountPtr< Computation::FilledPolygon3D > newPoly = RefCountPtr< Computation::FilledPolygon3D >( NullPtr< Computation::FilledPolygon3D >( ) );
2435 {
2436 // First we must compute an equation for the polygon!
2437
2438 Concrete::Coords3D p0( 0, 0, 0 );
2439 Concrete::Coords3D p1( 0, 0, 0 );
2440 Concrete::Coords3D p2( 0, 0, 0 );
2441 theSub->getRepresentativePoints( tf, & p0, & p1, & p2 );
2442
2443 try
2444 {
2445 Concrete::UnitFloatTriple normal = Concrete::crossDirection( p2 - p0, p1 - p0 );
2446 Concrete::Length m = Concrete::inner( normal, p0 );
2447 newPoly = RefCountPtr< Computation::FilledPolygon3D >( new Computation::FilledPolygon3D( metaState_, normal, m, tiebreaker_ ) );
2448 }
2449 catch( const NonLocalExit::CrossDirectionOfParallel & ball )
2450 {
2451 // This means that the crossDirection called failed because the vectors were parallel.
2452 // A polygon of lower dimension is invisible, so we may just continue
2453 continue;
2454 }
2455 }
2456
2457 zBufPile->push_back( newPoly );
2458
2459 for( SubListType::const_iterator i = theSub->begin( ); i != theSub->end( ); ++i )
2460 {
2461 if( (*i)->front_ != (*i)->mid_ || (*i)->rear_ != (*i)->mid_ )
2462 {
2463 throw "Corner has handle";
2464 }
2465 newPoly->pushPoint( (*i)->mid_->transformed( tf ) );
2466 }
2467 }
2468 }
2469
2470 void
2471 Lang::PaintedPath3D::gcMark( Kernel::GCMarkedSet & marked )
2472 { }
2473
2474
2475 Lang::SingleSided3DGray::SingleSided3DGray( const RefCountPtr< const Lang::ElementaryPath3D > & points,
2476 const RefCountPtr< const Computation::FacetInterpolatorGray > & interpolator,
2477 bool singleSided,
2478 const Concrete::UnitFloatTriple & polygonUnitNormal,
2479 Concrete::Length m,
2480 Concrete::Length tiebreaker,
2481 Concrete::Length viewResolution,
2482 Computation::FacetShadeOrder shadeOrder )
2483 : points_( points ), interpolator_( interpolator ), singleSided_( singleSided ), polygonUnitNormal_( polygonUnitNormal ), m_( m ), tiebreaker_( tiebreaker ),
2484 viewResolution_( viewResolution ), shadeOrder_( shadeOrder )
2485 { }
2486
2487 Lang::SingleSided3DGray::~SingleSided3DGray( )
2488 { }
2489
2490 RefCountPtr< const Lang::Class > Lang::SingleSided3DGray::TypeID( new Lang::SystemFinalClass( strrefdup( "SingleSided3D(gray)" ) ) );
2491 TYPEINFOIMPL( SingleSided3DGray );
2492
2493 RefCountPtr< const Lang::Drawable2D >
2494 Lang::SingleSided3DGray::typed_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
2495 {
2496 throw Exceptions::NotImplemented( "SingleSided3DGray::typed_to2D; What light scene should be used?" );
2497 }
2498
2499 void
2500 Lang::SingleSided3DGray::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
2501 {
2502 Concrete::UnitFloatTriple Tnormal = tf.transformPlaneUnitNormal( polygonUnitNormal_ );
2503
2504 double ax = fabs( polygonUnitNormal_.x_ );
2505 double ay = fabs( polygonUnitNormal_.y_ );
2506 double az = fabs( polygonUnitNormal_.z_ );
2507 Concrete::Coords3D x0( 0, 0, 0 );
2508 if( ax >= ay && ax >= az )
2509 {
2510 x0 = Concrete::Coords3D( m_ / polygonUnitNormal_.x_, 0, 0 );
2511 }
2512 else if( ay >= az )
2513 {
2514 x0 = Concrete::Coords3D( 0, m_ / polygonUnitNormal_.y_, 0 );
2515 }
2516 else
2517 {
2518 x0 = Concrete::Coords3D( 0, 0, m_ / polygonUnitNormal_.z_ );
2519 }
2520 Concrete::Length Tm = Concrete::inner( Tnormal, x0.transformed( tf ) );
2521
2522 RefCountPtr< Computation::SingleSidedPolygon3DGray > res =
2523 RefCountPtr< Computation::SingleSidedPolygon3DGray >
2524 ( new Computation::SingleSidedPolygon3DGray( interpolator_->transformed( tf ),
2525 singleSided_,
2526 Tnormal,
2527 Tm,
2528 tiebreaker_,
2529 viewResolution_,
2530 shadeOrder_ ) );
2531 {
2532 typedef Lang::ElementaryPath3D ListType;
2533 for( ListType::const_iterator i = points_->begin( ); i != points_->end( ); ++i )
2534 {
2535 // The creator of *this is responsible for asserting that there are no handles at the pathpoints.
2536 res->pushPoint( (*i)->mid_->transformed( tf ) );
2537 }
2538 }
2539
2540 zBufPile->push_back( res );
2541 }
2542
2543 void
2544 Lang::SingleSided3DGray::gcMark( Kernel::GCMarkedSet & marked )
2545 {
2546 const_cast< Lang::ElementaryPath3D * >( points_.getPtr( ) )->gcMark( marked );
2547 const_cast< Computation::FacetInterpolatorGray * >( interpolator_.getPtr( ) )->gcMark( marked );
2548 }
2549
2550
2551 Lang::SingleSided3DRGB::SingleSided3DRGB( const RefCountPtr< const Lang::ElementaryPath3D > & points,
2552 const RefCountPtr< const Computation::FacetInterpolatorRGB > & interpolator,
2553 bool singleSided,
2554 const Concrete::UnitFloatTriple & polygonUnitNormal,
2555 Concrete::Length m,
2556 Concrete::Length tiebreaker,
2557 Concrete::Length viewResolution,
2558 Computation::FacetShadeOrder shadeOrder )
2559 : points_( points ), interpolator_( interpolator ), singleSided_( singleSided ), polygonUnitNormal_( polygonUnitNormal ), m_( m ), tiebreaker_( tiebreaker ),
2560 viewResolution_( viewResolution ), shadeOrder_( shadeOrder )
2561 { }
2562
2563 Lang::SingleSided3DRGB::~SingleSided3DRGB( )
2564 { }
2565
2566 RefCountPtr< const Lang::Class > Lang::SingleSided3DRGB::TypeID( new Lang::SystemFinalClass( strrefdup( "SingleSided3D(RGB)" ) ) );
2567 TYPEINFOIMPL( SingleSided3DRGB );
2568
2569 RefCountPtr< const Lang::Drawable2D >
2570 Lang::SingleSided3DRGB::typed_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
2571 {
2572 throw Exceptions::NotImplemented( "SingleSided3DRGB::typed_to2D; What light scene should be used?" );
2573 }
2574
2575 void
2576 Lang::SingleSided3DRGB::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
2577 {
2578 Concrete::UnitFloatTriple Tnormal = tf.transformPlaneUnitNormal( polygonUnitNormal_ );
2579
2580 double ax = fabs( polygonUnitNormal_.x_ );
2581 double ay = fabs( polygonUnitNormal_.y_ );
2582 double az = fabs( polygonUnitNormal_.z_ );
2583 Concrete::Coords3D x0( 0, 0, 0 );
2584 if( ax >= ay && ax >= az )
2585 {
2586 x0 = Concrete::Coords3D( m_ / polygonUnitNormal_.x_, 0, 0 );
2587 }
2588 else if( ay >= az )
2589 {
2590 x0 = Concrete::Coords3D( 0, m_ / polygonUnitNormal_.y_, 0 );
2591 }
2592 else
2593 {
2594 x0 = Concrete::Coords3D( 0, 0, m_ / polygonUnitNormal_.z_ );
2595 }
2596 Concrete::Length Tm = Concrete::inner( Tnormal, x0.transformed( tf ) );
2597
2598 RefCountPtr< Computation::SingleSidedPolygon3DRGB > res =
2599 RefCountPtr< Computation::SingleSidedPolygon3DRGB >
2600 ( new Computation::SingleSidedPolygon3DRGB( interpolator_->transformed( tf ),
2601 singleSided_,
2602 Tnormal,
2603 Tm,
2604 tiebreaker_,
2605 viewResolution_,
2606 shadeOrder_ ) );
2607 {
2608 typedef Lang::ElementaryPath3D ListType;
2609 for( ListType::const_iterator i = points_->begin( ); i != points_->end( ); ++i )
2610 {
2611 // The creator of *this is responsible for asserting that there are no handles at the pathpoints.
2612 res->pushPoint( (*i)->mid_->transformed( tf ) );
2613 }
2614 }
2615
2616 zBufPile->push_back( res );
2617 }
2618
2619 void
2620 Lang::SingleSided3DRGB::gcMark( Kernel::GCMarkedSet & marked )
2621 {
2622 const_cast< Lang::ElementaryPath3D * >( points_.getPtr( ) )->gcMark( marked );
2623 const_cast< Computation::FacetInterpolatorRGB * >( interpolator_.getPtr( ) )->gcMark( marked );
2624 }
2625
2626
2627
2628 Lang::ZBuf::ZBuf( const RefCountPtr< std::list< RefCountPtr< Computation::PaintedPolygon3D > > > & pile, const RefCountPtr< std::list< RefCountPtr< Computation::StrokedLine3D > > > & linePile, const RefCountPtr< std::list< RefCountPtr< const Lang::LightSource > > > & lightPile, const RefCountPtr< const Kernel::GraphicsState > & metaState )
2629 : metaState_( metaState ), pile_( pile ), linePile_( linePile ), lightPile_( lightPile )
2630 { }
2631
2632 Lang::ZBuf::~ZBuf( )
2633 { }
2634
2635 void
2636 Lang::ZBuf::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
2637 {
2638 {
2639 typedef typeof *pile_ ListType;
2640 for( ListType::const_iterator i = pile_->begin( ); i != pile_->end( ); ++i )
2641 {
2642 zBufPile->push_back( *i );
2643 }
2644 }
2645 {
2646 typedef typeof *linePile_ ListType;
2647 for( ListType::const_iterator i = linePile_->begin( ); i != linePile_->end( ); ++i )
2648 {
2649 linePile->push_back( *i );
2650 }
2651 }
2652 }
2653
2654 void
2655 Lang::ZBuf::gcMark( Kernel::GCMarkedSet & marked )
2656 {
2657 // At the time of writing, PaintedPolygon3D is not involved in gc.
2658 }
2659
2660
2661 Lang::ZSorter::ZSorter( const RefCountPtr< std::list< RefCountPtr< Computation::PaintedPolygon3D > > > & pile, const RefCountPtr< std::list< RefCountPtr< Computation::StrokedLine3D > > > & linePile, const RefCountPtr< std::list< RefCountPtr< const Lang::LightSource > > > & lightPile, const RefCountPtr< const Kernel::GraphicsState > & metaState )
2662 : metaState_( metaState ), pile_( pile ), linePile_( linePile ), lightPile_( lightPile )
2663 { }
2664
2665 Lang::ZSorter::~ZSorter( )
2666 { }
2667
2668 void
2669 Lang::ZSorter::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
2670 {
2671 {
2672 typedef typeof *pile_ ListType;
2673 for( ListType::const_iterator i = pile_->begin( ); i != pile_->end( ); ++i )
2674 {
2675 zBufPile->push_back( *i );
2676 }
2677 }
2678 {
2679 typedef typeof *linePile_ ListType;
2680 for( ListType::const_iterator i = linePile_->begin( ); i != linePile_->end( ); ++i )
2681 {
2682 linePile->push_back( *i );
2683 }
2684 }
2685 }
2686
2687 void
2688 Lang::ZSorter::gcMark( Kernel::GCMarkedSet & marked )
2689 {
2690 // At the time of writing, PaintedPolygon3D is not involved in gc.
2691 }
2692
2693
2694 Lang::Transformed3D::Transformed3D( RefCountPtr< const Lang::Drawable3D > element, const Lang::Transform3D & mytf )
2695 : mytf_( mytf ), element_( element )
2696 { }
2697
2698 Lang::Transformed3D::~Transformed3D( )
2699 { }
2700
2701 RefCountPtr< const Lang::Drawable2D >
2702 Lang::Transformed3D::typed_to2D( const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
2703 {
2704 return element_->typed_to2D( dyn, Lang::Transform3D( tf, mytf_ ), element_ );
2705 }
2706
2707 void
2708 Lang::Transformed3D::polygonize( std::list< RefCountPtr< Computation::PaintedPolygon3D > > * zBufPile, std::list< RefCountPtr< Computation::StrokedLine3D > > * linePile, const Kernel::PassedDyn & dyn, const Lang::Transform3D & tf, const RefCountPtr< const Lang::Drawable3D > & self ) const
2709 {
2710 element_->polygonize( zBufPile, linePile, dyn, Lang::Transform3D( tf, mytf_ ), element_ );
2711 }
2712
2713 void
2714 Lang::Transformed3D::findTags( std::vector< Kernel::ValueRef > * dst, const Kernel::PassedDyn & dyn, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
2715 {
2716 element_->findTags( dst, dyn, key, Lang::Transform3D( tf, mytf_ ) );
2717 }
2718
2719 bool
2720 Lang::Transformed3D::findOneTag( Kernel::EvalState * evalState, Lang::Symbol::KeyType key, const Lang::Transform3D & tf ) const
2721 {
2722 return
2723 element_->findOneTag( evalState, key, Lang::Transform3D( tf, mytf_ ) );
2724 }
2725
2726 void
2727 Lang::Transformed3D::gcMark( Kernel::GCMarkedSet & marked )
2728 {
2729 const_cast< Lang::Drawable3D * >( element_.getPtr( ) )->gcMark( marked );
2730 }
2731
2732 Lang::Text::Text( const RefCountPtr< const Kernel::TextState > & textState, const RefCountPtr< const std::list< RefCountPtr< const Lang::TextOperation > > > & elements, const RefCountPtr< const Lang::ElementaryPath2D > & mybbox )
2733 : textState_( textState ), elements_( elements ), mybbox_( mybbox )
2734 { }
2735
2736 Lang::Text::~Text( )
2737 { }
2738
2739 void
2740 Lang::Text::shipout( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf ) const
2741 {
2742 if( textState_->font_->outline( ) )
2743 {
2744 if( ( pdfState->text_.knockout_ & Kernel::TextState::KNOCKOUT_UNDEFINED_BIT ) != 0 &&
2745 ( pdfState->text_.knockout_ & Kernel::TextState::KNOCKOUT_FLAG_BIT ) == 0 )
2746 {
2747 Kernel::TextState newState;
2748 newState.knockout_ = 0; /* Clear the KNOCKOUT_FLAG_BIT. */
2749 Helpers::newTransparencyGroup( RefCountPtr< const Lang::Drawable2D >
2750 ( new Lang::Text( RefCountPtr< const Kernel::TextState >( new Kernel::TextState( newState, *textState_ ) ),
2751 elements_,
2752 mybbox_ ) ),
2753 false, /* The group shall be isolated. */
2754 false, /* Not knockout. */
2755 Lang::THE_INHERITED_COLOR_SPACE )->shipout( os, pdfState, tf );
2756 }
2757 else
2758 {
2759 Lang::Transform2D textMatrix( 0, 0, 0, 0, Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH );
2760 Lang::Transform2D lineMatrix( 0, 0, 0, 0, Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH );
2761 lineMatrix.replaceBy( Lang::THE_2D_IDENTITY );
2762 textMatrix.replaceBy( lineMatrix );
2763 typedef typeof *elements_ ListType;
2764 for( ListType::const_iterator i = elements_->begin( ); i != elements_->end( ); ++i )
2765 {
2766 (*i)->shipout_outlined( os, pdfState, tf, & textMatrix, & lineMatrix, 0 ); /* 0 means that this is a painting operation, not clipping. */
2767 }
2768 }
2769 }
2770 else
2771 {
2772 pdfState->resources_->requireProcedureSet( SimplePDF::PDF_Resources::PROC_SET_TEXT );
2773
2774 os << "BT" << std::endl ;
2775 if( ! tf.isIdentity( ) )
2776 {
2777 tf.shipout( os );
2778 os << " Tm" << std::endl ;
2779 }
2780
2781 pdfState->text_.synchKnockout( os, textState_.getPtr( ), pdfState->resources_.getPtr( ) );
2782
2783 typedef typeof *elements_ ListType;
2784 for( ListType::const_iterator i = elements_->begin( ); i != elements_->end( ); ++i )
2785 {
2786 (*i)->shipout( os, pdfState, tf );
2787 }
2788 os << "ET" << std::endl ;
2789 }
2790 }
2791
2792 void
2793 Lang::Text::shipout_clip( std::ostream & os, Kernel::PageContentStates * pdfState, const Lang::Transform2D & tf, const RefCountPtr< const Lang::Drawable2D > & content ) const
2794 {
2795 if( textState_->font_->outline( ) )
2796 {
2797 Lang::Transform2D textMatrix( 0, 0, 0, 0, Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH );
2798 Lang::Transform2D lineMatrix( 0, 0, 0, 0, Concrete::ZERO_LENGTH, Concrete::ZERO_LENGTH );
2799 textMatrix.replaceBy( Lang::THE_2D_IDENTITY );
2800 lineMatrix.replaceBy( Lang::THE_2D_IDENTITY );
2801 if( ( pdfState->text_.knockout_ & Kernel::TextState::KNOCKOUT_UNDEFINED_BIT ) != 0 &&
2802 ( pdfState->text_.knockout_ & Kernel::TextState::KNOCKOUT_FLAG_BIT ) == 0 )
2803 {
2804 /* If the text knockout mode is false (by default, it is true), we emulate the effect by creating a temporary
2805 * object with default knockout mode inside a transparency group with the correct knockout mode, and then
2806 * shipout that object instead.
2807 */
2808 Kernel::TextState newState;
2809 newState.knockout_ = 0; /* Clear the KNOCKOUT_FLAG_BIT. */
2810 Helpers::newTransparencyGroup( RefCountPtr< const Lang::Drawable2D >
2811 ( new Lang::TextMasked2D( content,
2812 RefCountPtr< const Lang::Text >
2813 ( new Lang::Text( RefCountPtr< const Kernel::TextState >( new Kernel::TextState( newState, *textState_ ) ),
2814 elements_,
2815 mybbox_ ) ) ) ),
2816 false, /* The group shall be isolated. */
2817 false, /* Not knockout. */
2818 Lang::THE_INHERITED_COLOR_SPACE )->shipout( os, pdfState, tf );
2819 }
2820 else
2821 {
2822 RefCountPtr< const Lang::ElementaryPath2D > theBBox = content->bbox( Lang::Drawable2D::BOUNDING )->elementaryTransformed( tf );
2823 Concrete::Coords2D llcorner( 0, 0 );
2824 Concrete::Coords2D urcorner( 0, 0 );
2825 if( ! theBBox->boundingRectangle( & llcorner, & urcorner ) )
2826 {
2827 throw Exceptions::InternalError( "Text mask: The content has no bounding box!" );
2828 }
2829
2830 RefCountPtr< SimplePDF::PDF_Stream_out > form;
2831 RefCountPtr< SimplePDF::PDF_Object > indirection = SimplePDF::indirect( form, & Kernel::theIndirectObjectCount );
2832
2833 RefCountPtr< SimplePDF::PDF_Resources > resources;
2834 (*form)[ "Resources" ] = SimplePDF::indirect( resources, & Kernel::theIndirectObjectCount );
2835
2836 (*form)[ "Subtype" ] = SimplePDF::newName( "Form" );
2837 (*form)[ "FormType" ] = SimplePDF::newInt( 1 );
2838 (*form)[ "BBox" ] = RefCountPtr< SimplePDF::PDF_Vector >( new SimplePDF::PDF_Vector( llcorner.x_.offtype< 1, 0 >( ), llcorner.y_.offtype< 1, 0 >( ),
2839 urcorner.x_.offtype< 1, 0 >( ), urcorner.y_.offtype< 1, 0 >( ) ) );
2840
2841 Kernel::PageContentStates contentState( resources );
2842 content->shipout( form->data, & contentState, tf );
2843
2844 const SimplePDF::PDF_Name & xoName = pdfState->resources_->nameofXObject( indirection );
2845 typedef typeof *elements_ ListType;
2846 for( ListType::const_iterator i = elements_->begin( ); i != elements_->end( ); ++i )
2847 {
2848 (*i)->shipout_outlined( os, pdfState, tf, & textMatrix, & lineMatrix, & xoName ); /* Passing xoName means "clip". */
2849 }
2850 }
2851 }
2852 else
2853 {
2854 Kernel::Auto_qQ auto_qQ( & pdfState->graphics_, & pdfState->text_, os );
2855 if( ! tf.isIdentity( ) )
2856 {
2857 tf.shipout( os );
2858 os << " cm" << std::endl ;
2859 }
2860
2861 pdfState->resources_->requireProcedureSet( SimplePDF::PDF_Resources::PROC_SET_TEXT );
2862
2863 os << "BT" << std::endl ;
2864
2865 pdfState->text_.synchKnockout( os, textState_.getPtr( ), pdfState->resources_.getPtr( ) );
2866
2867 typedef typeof *elements_ ListType;
2868 for( ListType::const_iterator i = elements_->begin( ); i != elements_->end( ); ++i )
2869 {
2870 (*i)->shipout( os, pdfState, THE_2D_IDENTITY, true ); /* true means "clip" */
2871 }
2872 os << "ET" << std::endl ;
2873
2874 content->shipout( os, pdfState, THE_2D_IDENTITY );
2875 }
2876 }
2877
2878 RefCountPtr< const Lang::ElementaryPath2D >
2879 Lang::Text::bbox( Lang::Drawable2D::BoxType boxType ) const
2880 {
2881 return mybbox_;
2882 }
2883
2884 void
2885 Lang::Text::gcMark( Kernel::GCMarkedSet & marked )
2886 {
2887 typedef typeof *elements_ ListType;
2888 for( ListType::const_iterator i = elements_->begin( ); i != elements_->end( ); ++i )
2889 {
2890 const_cast< Lang::TextOperation * >( i->getPtr( ) )->gcMark( marked );
2891 }
2892 }
2893
2894
2895
2896
2897 RefCountPtr< const Lang::TransparencyGroup >
2898 Helpers::newSolidTransparencyGroup( const RefCountPtr< const Lang::Drawable2D > & obj2, const RefCountPtr< const Lang::Drawable2D > & obj1 )
2899 {
2900 return Helpers::newTransparencyGroup( Helpers::newGroup2D( Kernel::THE_DEFAULT_STATE, obj2, obj1 ),
2901 true,
2902 true,
2903 Lang::THE_INHERITED_COLOR_SPACE );
2904 }
2905
2906 RefCountPtr< const Lang::TransparencyGroup >
2907 Helpers::newSolidTransparencyGroup( const RefCountPtr< const Lang::Drawable2D > & obj3, const RefCountPtr< const Lang::Drawable2D > & obj2, const RefCountPtr< const Lang::Drawable2D > & obj1 )
2908 {
2909 return Helpers::newTransparencyGroup( Helpers::newGroup2D( Kernel::THE_DEFAULT_STATE, obj3, obj2, obj1 ),
2910 true,
2911 true,
2912 Lang::THE_INHERITED_COLOR_SPACE );
2913 }
2914
2915
2916 bool
2917 Computation::operator < ( const Computation::UndirectedEdge & p1, const Computation::UndirectedEdge & p2 )
2918 {
2919 if( p1.low( ) < p2.low( ) )
2920 {
2921 return true;
2922 }
2923 if( p1.low( ) > p2.low( ) )
2924 {
2925 return false;
2926 }
2927 return p1.high( ) < p2.high( );
2928 }
Graphics language