#
# Figures of IRIT documentation - generated using IRIT...
#

include("../../irit/iritinit"); # Just in case...
save_mat_docs = view_mat;
save_res = resolution;

iritstate("InterpProd", off);

#############################################################################
Arc1 = ARC( vector( 1.0, 0.0, 0.0 ),
            vector( 1.0, 1.0, 0.0 ),
            vector( 0.0, 1.0, 0.0 ) ) * scale( vector( 0.7, 0.7, 0.7 ) )
				      * trans( vector( -0.3, -0.5, 0.0 ) );
attrib( Arc1, "width", 0.02 );
view( Arc1, on );
save( "arc1cnst", Arc1 );

#############################################################################
Crv = cbspline( 3,
                list( ctlpt( E2, 0.7, 0.0 ),
                      ctlpt( E2, 0.7, 0.06 ),
                      ctlpt( E2, 0.1, 0.1 ),
                      ctlpt( E2, 0.1, 0.6 ),
                      ctlpt( E2, 0.6, 0.6 ),
                      ctlpt( E2, 0.8, 0.8 ),
                      ctlpt( E2, 0.8, 1.4 ),
                      ctlpt( E2, 0.6, 1.6 ) ),
                list( KV_OPEN ) );
attrib( Crv, "width", 0.01 );

OffCrv1 = AOFFSET( Crv, -0.4, 0.01, TRUE, FALSE );
OffCrv2 = AOFFSET( Crv, -0.4, 0.01, FALSE, FALSE );
attrib( OffCrv1, "width", 0.02 );
attrib( OffCrv2, "width", 0.02 );
All = list( list( Crv, OffCrv1 ) * trans( vector(  0.0,  1.0, 0.0 ) ),
	    list( Crv, OffCrv2 ) * trans( vector(  0.0, -1.0, 0.0 ) ) )
			  * rotz( 90 )
			  * scale( vector( 0.4, 0.4, 0.4 ) )
			  * trans( vector( 0.3, -0.3, 0.0 ) );
view( All, on );
save( "caoffset", All );

#############################################################################
Circ = circle( vector( 0.0, 0.0, 0.0 ), 1.0 )
				* scale( vector( 0.7, 0.7, 0.7 ) );
attrib( Circ, "width", 0.02 );
Srf = BOOLONE( Circ );
attrib( Srf, "width", 0.005 );
view( list( Srf, Circ ), on );
save( "boolone", list( Srf, Circ ) );

Cbzr1 = cbezier( list( ctlpt( E3, 0.1, 0.1, 0.1 ),
                       ctlpt( E3, 0.0, 0.5, 1.0 ),
                       ctlpt( E3, 0.4, 1.0, 0.4 ) ) );
Cbzr2 = cbezier( list( ctlpt( E3, 1.0, 0.2, 0.2 ),
                       ctlpt( E3, 1.0, 0.5, -1.0 ),
                       ctlpt( E3, 1.0, 1.0, 0.3 ) ) );
Cbsp3 = cbspline( 4,
                  list( ctlpt( E3, 0.1,  0.1, 0.1 ),
                        ctlpt( E3, 0.25, 0.0, -1.0 ),
                        ctlpt( E3, 0.5,  0.0, 2.0 ),
                        ctlpt( E3, 0.75, 0.0, -1.0 ),
                        ctlpt( E3, 1.0,  0.2, 0.2 ) ),
                  list( KV_OPEN ) );
Cbsp4 = cbspline( 4,
                  list( ctlpt( E3, 0.4,  1.0, 0.4 ),
                        ctlpt( E3, 0.25, 1.0, 1.0 ),
                        ctlpt( E3, 0.5,  1.0, -2.0 ),
                        ctlpt( E3, 0.75, 1.0, 1.0 ),
                        ctlpt( E3, 1.0,  1.0, 0.3 ) ),
                  list( KV_OPEN ) );
attrib( Cbzr1, "width", 0.02 );
attrib( Cbzr2, "width", 0.02 );
attrib( Cbsp3, "width", 0.02 );
attrib( Cbsp4, "width", 0.02 );

Srf = BOOLSUM( Cbzr1, Cbzr2, Cbsp3, Cbsp4 );
attrib( Srf, "width", 0.005 );

All = list( Srf, Cbzr1, Cbzr2, Cbsp3, Cbsp4 )
		* rotx( 160 ) * roty( 20 ) * trans( vector( -0.5, 0.3, 0.0 ) );
view( All, on );
save( "boolsum", All );

#############################################################################
B = BOX( vector( 0, 0, 0 ), 1, 1, 1);
attrib( B, "width", 0.02 );

All = B * rotx( 160 ) * roty( 20 ) * trans( vector( -0.3, 0.5, 0.0 ) );
view( All, on );
save( "prim_box", All );

#############################################################################
s45 = sin(pi / 4);
Arc90 = CBEZIER( list( ctlpt( P2, 1.0, 0.0, 1.0 ),
                       ctlpt( P2, s45, s45, s45 ),
                       ctlpt( P1, 1.0, 1.0 ) ) );
HalfCirc = CBSPLINE( 3,
                     list( ctlpt( P3,  1.0,  1.0,  0.0, 0.0 ),
			   ctlpt( P3,  s45,  s45,  s45, 0.0 ),
			   ctlpt( P3,  1.0,  0.0,  1.0, 0.0 ),
                           ctlpt( P3,  s45, -s45,  s45, 0.0 ),
                           ctlpt( P3,  1.0, -1.0,  0.0, 0.0 ) ),
                     list( 0, 0, 0, 1, 1, 2, 2, 2 ) );
attrib( Arc90, "width", 0.02 );
attrib( HalfCirc, "width", 0.02 );

All = list( Arc90 * trans( vector( -1.5, -1.0, 0.0 ) ),
	    HalfCirc * trans( vector( 0.6, -1.0, 0.0 ) ) )
	* scale( vector( 0.5, 0.5, 0.0 ) );
view( All, on );
save( "circular", All );

#############################################################################
c = CBSPLINE( 4,
              list( ctlpt( E2,  0.5,  0.5 ),
                    ctlpt( E2, -0.5,  0.5 ),
                    ctlpt( E2, -0.5, -0.5 ),
                    ctlpt( E2,  0.5, -0.5 ) ),
              list( KV_PERIODIC ) );
attrib( c, "width", 0.01 );
All = c * scale( vector( 0.7, 0.7, 0.7 ) );
view( All, on );
save( "cperiod", All );

#############################################################################

c1 = cbezier( list( ctlpt( E2, -0.5, -0.2 ),
		    ctlpt( E2,  0.0, -0.2 ),
		    ctlpt( E2,  0.6,  0.6 ) ) );
c2 = cbezier( list( ctlpt( E2,  0.3, -0.7 ),
		    ctlpt( E2, -0.2, -0.7 ),
		    ctlpt( E2,  0.7,  0.6 ) ) );
color( c1, yellow );
attrib( c1, "width", 0.007 );
color( c2, yellow );
attrib( c2, "width", 0.007 );

BisectCrvs = cbisector( list( c1, c2 ), 0, 12, true, false );
attrib( BisectCrvs, "width", 0.012 );
attrib( BisectCrvs, "gray", 0.5 );
color( BisectCrvs, green );

All = list( c1, c2, BisectCrvs ) * sc( 0.3 );
view( All, on );
save( "cbisectc", All );

c1 = creparam( pcircle( vector( 0.0, 0.0, 0.0 ), 1 ), 0, 1 );
c2 = cbezier( list( ctlpt( E3, -0.2, 0.0,  1.0 ),
		    ctlpt( E3,  0.2, 0.0, -1.0 ) ) );
color( c1, yellow );
attrib( c1, "width", 0.007 );
color( c2, yellow );
attrib( c2, "width", 0.007 );

BisectSrf = cbisector( list( c1, c2 ), -1, -1, true, false );
attrib( BisectSrf, "width", 0.012 );
attrib( BisectSrf, "gray", 0.5 );
color( BisectSrf, green );

All = list( c1, c2, BisectSrf ) * sc( 0.3 ) * rx( 60 ) * ry( 5 );
view( All, on );
save( "cbisects", All );

#############################################################################
crv1 = cbspline( 3,
                 list( ctlpt( E2, 0, 0 ),
                       ctlpt( E2, 0, 0.5 ),
                       ctlpt( E2, 0.5, 0.7 ),
                       ctlpt( E2, 1, 1 ) ),
                 list( KV_OPEN ) );
crv2 = cbspline( 3,
                 list( ctlpt( E2, 1, 0 ),
                       ctlpt( E2, 0.7, 0.25 ),
                       ctlpt( E2, 0.3, 0.5 ),
                       ctlpt( E2, 0, 1 ) ),
                 list( KV_OPEN ) );
attrib( crv1, "width", 0.01 );
attrib( crv2, "width", 0.01 );

inter_pts = CCINTER( crv1, crv2, 0.001, FALSE );

All = list( crv1, crv2, 
	    ceval( crv1, coord( nth( inter_pts, 1 ), 0 ) ) )
	* scale( vector( 0.7, 0.7, 0.7 ) ) 
	* trans( vector( -0.3, -0.5, 0.0 ) );
view( All, on );
save( "cci", All );

#############################################################################
crv = cbezier( list( ctlpt( E2, -1.0,  0.5 ),
                     ctlpt( E2, -0.5, -2.0 ),
                     ctlpt( E2,  0.0,  1.0 ),
                     ctlpt( E2,  1.0,  0.0 ) ) ) * rotz( 30 );
attrib( crv, "width", 0.01 );

crvtr = CCRVTR( crv, 0.001 );
pt_crvtr = nil();
pt = nil();
for ( i = 1, 1, sizeof( crvtr ),
    ( pt = ceval( crv, nth( crvtr, i ) ) ):
    snoc( pt, pt_crvtr )
);
All = list( crv, pt_crvtr ) * scale( vector( 0.5, 0.5, 0.5 ) );
view( All, on );
save( "ccrvtr", All );

#############################################################################
Circ = circle( vector( 0.0, 0.0, 0.0 ), 1.0 );
attrib( Circ, "width", 0.01 );
Hodograph = CDERIVE( Circ );
attrib( Hodograph, "width", 0.02 );

All = list( Circ, Hodograph ) * scale( vector( 0.3, 0.3, 0.3 ) );
view( All, on );
save( "cderive", All );

#############################################################################
Crv = cbspline( 4,
		list( ctlpt( E2, -0.9,  0.0 ),
                      ctlpt( E2, -0.5, -1.1 ),
                      ctlpt( E2,  0.0,  0.8 ),
                      ctlpt( E2,  0.5, -1.1 ),
                      ctlpt( E2,  0.9,  0.0 ) ),
		list( KV_OPEN ) );
attrib( Crv, "width", 0.01 );
CrvLst = CDIVIDE( Crv, 1.3 );
Crv1 = nth( CrvLst, 1 ) * trans( vector(-0.03, 0.5, 0.0 ) );
Crv2 = nth( CrvLst, 2 ) * trans( vector( 0.03, 0.5, 0.0 ) );
attrib( Crv1, "width", 0.02 );
attrib( Crv2, "width", 0.02 );

All = list( Crv, Crv1, Crv2 );

view( All, on );
save( "cdivide", All );

#############################################################################

c1 = cbezier( list( ctlpt( E2, -0.8, 0.0 ),
		    ctlpt( E2, -0.2, 1.0 ),
		    ctlpt( E2,  0.2, 0.0 ),
		    ctlpt( E2,  0.8, 0.6 ) ) );
color( c1, yellow );
attrib( c1, "width", 0.02 );

s1 = cenvoff( c1, 0.5, 0.01 );
color( s1, cyan );
attrib( s1, "width", 0.007 );

All = list( c1, s1 ) * sc( 0.5 ) * rx( -70 ) * ry( 5 ) * ty( -0.5 );

view( All, on );
save( "cenvoff", All );

#############################################################################
Crv = cbspline( 3,
                list( ctlpt( E3, -1.0,  0.1,  0.2 ),
                      ctlpt( E3, -0.1,  1.0,  0.1 ),
                      ctlpt( E3,  0.1,  0.1,  1.0 ),
                      ctlpt( E3,  1.0,  0.1,  0.1 ),
                      ctlpt( E3,  0.1,  1.0,  0.2 ) ),
                list( KV_OPEN ) );
attrib( Crv, "width", 0.01 );
Cev = EVOLUTE( crv );
attrib( Cev, "width", 0.02 );

All = list( crv, cev ) * rotx( -20 )
		       * roty( 0 )
		       * scale( vector( 0.3, 0.3, 0.3 ) );
view( All, on );
save( "cevolute", All );

#############################################################################
Crv = cbspline( 3,
                list( ctlpt( E3, -0.3,  0.5,  0.0 ),
                      ctlpt( E3, -0.0,  1.0,  0.0 ),
                      ctlpt( E3, -1.0,  0.1,  0.0 ),
                      ctlpt( E3,  1.0,  0.1,  0.0 ),
                      ctlpt( E3,  0.1,  1.0,  0.0 ) ),
                list( KV_OPEN ) );
attrib( Crv, "width", 0.01 );
extremes = cextremes( crv, 0.0001, 1 );
pt_extremes = nil();
pt = nil();
for ( i = 1, 1, sizeof( extremes ),
    ( pt = ceval( crv, nth( extremes, i ) ) ):
    snoc( pt, pt_extremes )
);

All = list( Crv, pt_extremes ) * scale( vector( 0.6, 0.6, 0.6 ) );
view( All, on );
save( "cextreme", All );

#############################################################################
Crv = cbspline( 4,
                list( ctlpt( E3, -1.0,  0.1,  0.0 ),
                      ctlpt( E3, -0.5,  1.0,  0.0 ),
                      ctlpt( E3,  0.7, -1.0,  0.0 ),
                      ctlpt( E3,  1.0,  1.0,  0.0 ),
                      ctlpt( E3,  1.0,  0.0,  0.0 ) ),
                list( KV_OPEN ) );
attrib( Crv, "width", 0.01 );

inflect = CINFLECT( crv, 0.001 );
pt_inflect = nil();
pt = nil();
for ( i = 1, 1, sizeof( inflect ),
       pt = ceval( crv, nth( inflect, i ) ):
       snoc( pt, pt_inflect )
    );

All = list( Crv, pt_inflect ) * scale( vector( 0.6, 0.6, 0.6 ) );
view( All, on );
save( "cinflect", All );

#############################################################################
pl = nil();
for ( x = 0, 1, 100,
      snoc(point(cos(x / 5), sin(x / 5), x / 50 - 1), pl)
    );
c = CINTERP( pl, 3, 21, PARAM_UNIFORM, false );
attrib( c, "width", 0.01 );

All = list( c, pl, axes * trans( vector( -2, 0, -2 ) ) )
	* roty( 45 ) * rotx( 30 )
        * scale( vector( 0.3, 0.3, 0.3 ) )
	* trans( vector( 0.3, -0.3, 0.0 ) );
view( All, on );
save( "cinterp", All );

#############################################################################
Pts1 = nil();
Pts2 = nil();
for ( i = 0, 1, 7,
    R = 0.2 + fmod( i, 2 ) / 2:
    Pt = ctlpt( E2, R * cos( i * 2 * pi / 8 ), R * sin( i * 2 * pi / 8 ) ):
    snoc( Pt, Pts1 ):
    snoc( coerce( Pt, point_type ),  Pts2 ) );
PCrv = cbspline( 4, Pts1, list( KV_PERIODIC ) );
attrib( PCrv, "width", 0.007 );
Crv = coerce( PCrv, KV_OPEN );

CtlPoly = cbspline( 2, Pts1, list( KV_PERIODIC ) );
attrib( CtlPoly, "width", 0.001 );

CHCrv = CNVXHULL( Crv, 14 );
attrib( CHCrv, "width", 0.015 );
attrib( CHCrv, "gray", 0.5 );

CHPts = CNVXHULL( poly( Pts2, 0 ), 0 );
attrib( CHPts, "width", 0.015 );
attrib( CHPts, "gray", 0.5 );

All = list( list( CHPts, Pts2 ) * tx( -0.8 ),
	    list( CHCrv, Pts1, PCrv, CtlPoly ) * tx( 0.8 ) );
view( All, on );
save( "cnvxhull", All );

#############################################################################
Pts = nil();
for ( i = 0, 1, 8,
    R = ( -0.2 + fmod( i, 2 ) ) * (1 + i / 20):
    Pt = ctlpt( E2, R * cos( i * 2 * pi / 8 ), R * sin( i * 2 * pi / 8 ) ):
    snoc( Pt, Pts ) );
Crv = cbspline( 4, Pts, list( KV_OPEN ) );
attrib( Crv, "width", 0.01 );
attrib( Crv, "gray", 0.5 );

Tans = nil();
Pt = point( 2, 0, 0 );
CrvPtTns = CrvPtTan( Crv, Pt, 0.01 );
for ( i = 1, 1, sizeof( CrvPtTns ),
	snoc( ceval( Crv, nth( CrvPtTns, i ) ) + coerce( Pt, e3 ), Tans )
    );
attrib( Tans, "width", 0.003 );

All = list( Crv, Tans, Pt );

view( All, on );
save( "crvpttan", All );

#############################################################################
Pts = nil();
for ( i = 0, 1, 8,
    R = ( -0.2 + fmod( i, 2 ) ) * (1 + i / 20):
    Pt = ctlpt( E2, R * cos( i * 2 * pi / 8 ), R * sin( i * 2 * pi / 8 ) ):
    snoc( Pt, Pts ) );
Crv = cbspline( 4, Pts, list( KV_OPEN ) );
attrib( Crv, "width", 0.01 );
attrib( Crv, "gray", 0.5 );

Tans = nil();
Crv2Tns = Crv2Tans( Crv, 14 );
for ( i = 1, 1, sizeof( Crv2Tns ),
	pt = nth( Crv2Tns, i ):
	snoc( ceval( Crv, coord( pt, 0 ) ) +
              ceval( Crv, coord( pt, 1 ) ), Tans )
    );
attrib( Tans, "width", 0.003 );

All = list( Crv, Tans );
view( All, on );
save( "crv2tans", All );

#############################################################################
srf = sbezier( list( list( ctlpt( E3, 0.0, 0.0, 0.0 ),
                           ctlpt( E3, 0.0, 0.5, 1.0 ),
                           ctlpt( E3, 0.0, 1.0, 0.0 ) ),
                     list( ctlpt( E3, 0.5, 0.0, 1.0 ),
                           ctlpt( E3, 0.5, 0.5, 0.0 ),
                           ctlpt( E3, 0.5, 1.0, 1.0 ) ),
                     list( ctlpt( E3, 1.0, 0.0, 1.0 ),
                           ctlpt( E3, 1.0, 0.5, 0.0 ),
                           ctlpt( E3, 1.0, 1.0, 1.0 ) ) ) );
attrib( srf, "width", 0.007 );
crv = coerce( circle( vector( 0.0, 0.0, 1.0 ), 0.4 ) *
			      trans( vector( 0.5, 0.5, 0.0 ) ),
	      p2 );
attrib( crv, "width", 0.02 );
comp_crv = COMPOSE( srf, crv );
attrib( comp_crv, "width", 0.02 );

All = list( Srf, comp_crv, crv )
	* rotx( -50 ) * roty( -40 ) * rotz( -30 )
        * scale( vector( 0.7, 0.7, 0.7 ) )
	* trans( vector( -0.6, -0.3, 0.0 ) );
view( All, on );
save( "compose", All );

#############################################################################
Cone1 = CONE( vector( 0, 0, 0 ), vector( 1, 1, 1 ), 1 );
Cone2 = CON2( vector( 0, 0, -1 ), vector( 0, 0, 4 ), 2, 1 )
	* scale( vector( 0.5, 0.5, 0.5 ) ) * rotx( -60 ) * roty( 5 );
attrib( Cone1, "width", 0.02 );
attrib( Cone2, "width", 0.02 );

All = list( Cone1 * trans( vector( -1.9, -0.4, 0.0 ) ),
	    Cone2 * trans( vector(  0.6, -0.5, 0.0 ) ) )
	* scale( vector( 0.3, 0.3, 0.3 ) );
view( All, on );
save( "cones", All );

#############################################################################
crv1 = cbezier( list( ctlpt( E2,  0.3,  0.0 ),
                      ctlpt( E2,  0.0,  0.5 ),
                      ctlpt( E2, -0.2,  0.0 ) ) );
crv1a = crv1 * trans( vector( -0.4, 0.0, 0.0 ) );
crv1b = crv1a * scale( vector( -1.0, 1.0, 1.0 ) );
crvs = list( crv1a, crv1b );
attrib( crvs, "width", 0.02 );
color( crvs, red );

cm1 = nil();
for ( i = 1, 1, 5,
    snoc( cmorph( crv1a, crv1b, 0, i / 6.0 ), cm1 )
);
attrib( cm1, "width", 0.01 );
color( cm1, yellow );
All1 = list( crvs, cm1 );

cm2aux = cmorph( crv1a, crv1b, 2, 0.01 ); # 121 curves
cm2 = list( nth( cm2aux,  12 ),
	    nth( cm2aux,  30 ),
	    nth( cm2aux,  49 ),
	    nth( cm2aux,  70 ),
	    nth( cm2aux,   85 ) );
attrib( cm2, "width", 0.01 );
All2 = list( crvs, cm2 );

All = list( All1 * sc( 0.7 ) * tx( - 0.5 ), All2 * sc( 0.7 ) * tx( 0.5 ) );
view( All, on );
save( "cmorph", All );

#############################################################################

Wolf = cbspline( 3,
	list( ctlpt( E3, 0.0137625, 0.633593, 0 ),
	      ctlpt( E3, 0.0340417, 0.666021, 0 ),
	      ctlpt( E3, 0.021901, 0.536923, 0 ),
	      ctlpt( E3, 0.0758621, 0.649562, 0 ),
	      ctlpt( E3, 0.0675947, 0.537695, 0 ),
	      ctlpt( E3, 0.068195, 0.502156, 0 ),
	      ctlpt( E3, 0.240198, 0.240978, 0 ),
	      ctlpt( E3, 0.262479, 0.124548, 0 ),
	      ctlpt( E3, 0.294399, 0.0387525, 0 ),
	      ctlpt( E3, 0.286561, -0.0985001, 0 ),
	      ctlpt( E3, 0.273302, -0.21553, 0 ),
	      ctlpt( E3, 0.213835, -0.302869, 0 ),
	      ctlpt( E3, 0.27536, -0.33738, 0 ),
	      ctlpt( E3, 0.377073, -0.345819, 0 ),
	      ctlpt( E3, 0.513382, -0.29781, 0 ),
	      ctlpt( E3, 0.53954, -0.343074, 0 ),
	      ctlpt( E3, 0.45443, -0.415611, 0 ),
	      ctlpt( E3, 0.35306, -0.427481, 0 ),
	      ctlpt( E3, 0.246184, -0.414051, 0 ),
	      ctlpt( E3, 0.184745, -0.384617, 0 ),
	      ctlpt( E3, 0.129583, -0.426177, 0 ),
	      ctlpt( E3, 0.125707, -0.497342, 0 ),
	      ctlpt( E3, 0.157541, -0.578061, 0 ),
	      ctlpt( E3, 0.060991, -0.574613, 0 ),
	      ctlpt( E3, 0.0493789, -0.488474, 0 ),
	      ctlpt( E3, 0.0375953, -0.392181, 0 ),
	      ctlpt( E3, 0.0660852, -0.274894, 0 ),
	      ctlpt( E3, 0.0588641, -0.148053, 0 ),
	      ctlpt( E3, 0.0664454, 0.0044308, 0 ),
	      ctlpt( E3, 0.00414836, 0.0846349, 0 ),
	      ctlpt( E3, -0.0813043, 0.0324062, 0 ),
	      ctlpt( E3, -0.162881, 0.0513423, 0 ),
	      ctlpt( E3, -0.164081, 0.122421, 0 ),
	      ctlpt( E3, -0.0979935, 0.118459, 0 ),
	      ctlpt( E3, -0.0272575, 0.139968, 0 ),
	      ctlpt( E3, 0.00725293, 0.201493, 0 ),
	      ctlpt( E3, -0.0296588, 0.282126, 0 ),
	      ctlpt( E3, -0.0307737, 0.348128, 0 ),
	      ctlpt( E3, -0.0220775, 0.43461, 0 ),
	      ctlpt( E3, -0.0824878, 0.403118, 0 ),
	      ctlpt( E3, -0.184029, 0.401403, 0 ),
	      ctlpt( E3, -0.219569, 0.400803, 0 ),
	      ctlpt( E3, -0.25528, 0.410357, 0 ),
	      ctlpt( E3, -0.2354, 0.436085, 0 ),
	      ctlpt( E3, -0.118971, 0.458366, 0 ),
	      ctlpt( E3, -0.246326, 0.481607, 0 ),
	      ctlpt( E3, -0.267063, 0.50665, 0 ),
	      ctlpt( E3, -0.171199, 0.543819, 0 ),
	      ctlpt( E3, -0.1206, 0.55483, 0 ),
	      ctlpt( E3, -0.0193159, 0.571777, 0 ),
	      ctlpt( E3, 0.0109983, 0.629168, 0 ),
	      ctlpt( E3, 0.0137625, 0.633593, 0 ) ),
	 list( KV_OPEN ) );
Turtle = cbspline( 3,
	list( ctlpt( E3, 0.701296, 0.109924, 0 ),
	      ctlpt( E3, 0.739662, 0.0742423, 0 ),
	      ctlpt( E3, 0.67555, 0.0451864, 0 ),
	      ctlpt( E3, 0.622799, 0.0253083, 0 ),
	      ctlpt( E3, 0.528549, -0.0031255, 0 ),
	      ctlpt( E3, 0.553875, -0.0996828, 0 ),
	      ctlpt( E3, 0.578967, -0.170447, 0 ),
	      ctlpt( E3, 0.475377, -0.184302, 0 ),
	      ctlpt( E3, 0.481183, -0.129174, 0 ),
	      ctlpt( E3, 0.446478, -0.038468, 0 ),
	      ctlpt( E3, 0.321198, -0.0910543, 0 ),
	      ctlpt( E3, 0.16753, -0.1139, 0 ),
	      ctlpt( E3, -0.0164529, -0.111404, 0 ),
	      ctlpt( E3, -0.143121, -0.0942071, 0 ),
	      ctlpt( E3, -0.171761, -0.165513, 0 ),
	      ctlpt( E3, -0.148612, -0.219148, 0 ),
	      ctlpt( E3, -0.276828, -0.213848, 0 ),
	      ctlpt( E3, -0.233285, -0.139603, 0 ),
	      ctlpt( E3, -0.224534, -0.0789489, 0 ),
	      ctlpt( E3, -0.277875, -0.0235942, 0 ),
	      ctlpt( E3, -0.337456, -0.0147889, 0 ),
	      ctlpt( E3, -0.379716, -0.00833056, 0 ),
	      ctlpt( E3, -0.440339, -0.0108002, 0 ),
	      ctlpt( E3, -0.511554, -0.0144118, 0 ),
	      ctlpt( E3, -0.570627, -0.00900783, 0 ),
	      ctlpt( E3, -0.642095, -0.00765952, 0 ),
	      ctlpt( E3, -0.614006, 0.0181918, 0 ),
	      ctlpt( E3, -0.660299, 0.020044, 0 ),
	      ctlpt( E3, -0.686693, 0.044913, 0 ),
	      ctlpt( E3, -0.65532, 0.0874954, 0 ),
	      ctlpt( E3, -0.614725, 0.109882, 0 ),
	      ctlpt( E3, -0.606253, 0.112428, 0 ),
	      ctlpt( E3, -0.55563, 0.109351, 0 ),
	      ctlpt( E3, -0.515803, 0.0693713, 0 ),
	      ctlpt( E3, -0.401591, 0.0625973, 0 ),
	      ctlpt( E3, -0.29319, 0.172388, 0 ),
	      ctlpt( E3, -0.0928708, 0.271787, 0 ),
	      ctlpt( E3, 0.144772, 0.29244, 0 ),
	      ctlpt( E3, 0.369477, 0.252865, 0 ),
	      ctlpt( E3, 0.494291, 0.14237, 0 ),
	      ctlpt( E3, 0.570056, 0.0688663, 0 ),
	      ctlpt( E3, 0.625387, 0.0802739, 0 ),
	      ctlpt( E3, 0.701296, 0.109924, 0 ) ),
	 list( KV_OPEN ) );
color( Wolf, red );
attrib( Wolf, "width", 0.015 );

color( Turtle, green );
attrib( Turtle, "width", 0.015 );

Turtle2 = ffmatch( Wolf, Turtle, 20, 100, 2, false, 2 );
ffcompat( Wolf, Turtle2 );
mm = nil();
for ( i = 0, 1, 5,
    snoc( cmorph( Wolf, Turtle2, 0, i / 5 ), mm )
);

All1 = list( nth( mm, 1 ) * tx( 0.7 ),
	     nth( mm, 2 ) * tx( 1.5 ),
	     nth( mm, 3 ) * tx( 2.4 ),
	     nth( mm, 4 ) * tx( 3.4 ),
	     nth( mm, 5 ) * tx( 4.6 ) );
attrib( All1, "width", 0.007 );

All = list( Wolf, All1, Turtle * tx( 6.1 ) )
		* sc( 0.25 ) * tx( -0.8 ) * ty( -0.4 );
view( All, on );
save( "cmorph2", All );


#############################################################################
Animal = cbspline( 3,
	list( ctlpt( E2, -0.595962, 0.0864362 ),
	      ctlpt( E2, -0.568514, 0.0200271 ),
	      ctlpt( E2, -0.441777, -0.0737656 ),
	      ctlpt( E2, -0.270007, -0.0568941 ),
	      ctlpt( E2, -0.121934, 0.000755916 ),
	      ctlpt( E2, 0.036764, 0.0478527 ),
	      ctlpt( E2, 0.204987, 0.0464348 ),
	      ctlpt( E2, 0.377392, 0.0333501 ),
	      ctlpt( E2, 0.531846, 0.0866489 ),
	      ctlpt( E2, 0.616283, 0.241468 ),
	      ctlpt( E2, 0.699134, 0.377015 ),
	      ctlpt( E2, 0.778686, 0.517436 ),
	      ctlpt( E2, 0.963123, 0.536075 ),
	      ctlpt( E2, 0.990621, 0.357959 ),
	      ctlpt( E2, 0.789682, 0.404197 ),
	      ctlpt( E2, 0.769339, 0.200839 ),
	      ctlpt( E2, 0.656245, 0.0942741 ),
	      ctlpt( E2, 0.574709, -0.0322164 ),
	      ctlpt( E2, 0.539827, -0.195691 ),
	      ctlpt( E2, 0.532404, -0.372588 ),
	      ctlpt( E2, 0.542739, -0.516865 ),
	      ctlpt( E2, 0.471853, -0.736121 ),
	      ctlpt( E2, 0.421893, -0.580767 ),
	      ctlpt( E2, 0.429569, -0.426424 ),
	      ctlpt( E2, 0.449716, -0.197989 ),
	      ctlpt( E2, 0.350794, -0.222485 ),
	      ctlpt( E2, 0.337066, -0.430322 ),
	      ctlpt( E2, 0.356357, -0.604534 ),
	      ctlpt( E2, 0.295381, -0.71917 ),
	      ctlpt( E2, 0.276532, -0.47444 ),
	      ctlpt( E2, 0.293408, -0.323639 ),
	      ctlpt( E2, 0.267722, -0.163262 ),
	      ctlpt( E2, 0.0607484, -0.181326 ),
	      ctlpt( E2, -0.0694025, -0.236196 ),
	      ctlpt( E2, -0.065581, -0.433478 ),
	      ctlpt( E2, -0.057199, -0.596829 ),
	      ctlpt( E2, -0.16308, -0.743576 ),
	      ctlpt( E2, -0.176097, -0.510317 ),
	      ctlpt( E2, -0.140701, -0.387083 ),
	      ctlpt( E2, -0.117562, -0.164098 ),
	      ctlpt( E2, -0.220942, -0.335686 ),
	      ctlpt( E2, -0.203195, -0.495159 ),
	      ctlpt( E2, -0.240217, -0.682391 ),
	      ctlpt( E2, -0.271166, -0.466215 ),
	      ctlpt( E2, -0.218763, -0.324742 ),
	      ctlpt( E2, -0.212225, -0.137441 ),
	      ctlpt( E2, -0.40272, -0.162737 ),
	      ctlpt( E2, -0.534712, -0.0879198 ),
	      ctlpt( E2, -0.608031, 0.0537921 ),
	      ctlpt( E2, -0.598074, 0.134321 ) ),
	 list( KV_PERIODIC ) );
MRCrv = CMULTIRES( Animal, false );

sum = nth( MRCrv, 1 );
MRCrvs = list( sum * tx( 3.0 ) );
for ( ( i = 2 ), 1, sizeof( MRCrv ),
    sum = symbsum( sum, nth( MRCrv, i ) ):
    snoc( sum * tx( ( 3 - i ) * 1.5 ), MRCrvs )
);

All = MRCrvs * sc ( 0.25 );
attrib( All, "width", 0.01 );
view( All, on );
save( "cmultres", All );

#############################################################################
Crv = cbezier( list( ctlpt( E2, -0.7,  0.3 ),
                     ctlpt( E2,  0.0,  1.0 ),
                     ctlpt( E2,  0.7,  0.0 ) ) );
Crv2 = CRAISE( Crv, 5 );
attrib( Crv, "width", 0.01 );
attrib( Crv2, "width", 0.02 );

All = list( Crv, Crv2 );
view( All, on );
save( "craise", All );

#############################################################################
Crv = cbezier( list( ctlpt( E2, -0.7,  0.3 ),
                     ctlpt( E2,  0.0,  1.0 ),
                     ctlpt( E2,  0.7,  0.0 ) ) );
Crv2 = CREFINE( Crv, FALSE, list( 0.25, 0.5, 0.75 ) );
attrib( Crv, "width", 0.01 );
attrib( Crv2, "width", 0.02 );

All = list( Crv, Crv2 );
view( All, on );
save( "crefine", All );

#############################################################################
Crv = cbezier( list( ctlpt( E2, -0.7,  0.3 ),
                     ctlpt( E2,  0.0,  1.0 ),
                     ctlpt( E2,  0.7,  0.0 ) ) );
SubCrv = CREGION( Crv, 0.3, 0.6 );
attrib( Crv, "width", 0.01 );
attrib( SubCrv, "width", 0.02 );

All = list( Crv, SubCrv * trans( vector( 0.0, 0.02, 0.0 ) ) );
view( All, on );
save( "cregion", All );

#############################################################################
Crv = cbspline( 3,
		list( ctlpt( E2,  0.5, -1.0 ),
		      ctlpt( E2, -1.5, -0.5 ),
		      ctlpt( E2,  1.5,  0.0 ),
		      ctlpt( E2, -0.5,  1.0 ) ),
		list( KV_OPEN ) );
attrib( Crv, "width", 0.02 );

Pnt = point( 0, 0, 0 );
Param1 = CRVPTDST( Crv, Pnt, FALSE, -0.0001 ); 
Pt1lst = nil();
for ( i = 1, 1, sizeof( Param1 ),
	pt = coerce( ceval( crv, nth( Param1, i ) ), vector_type ):
	snoc( pt, Pt1lst )
    );
All1 = list( Crv, Pnt, Pt1lst ) * scale( vector( 0.3, 0.3, 0.3 ) );
view( All1, on );

line_pt = point( -1, 1.2, 0 );
line_vec = vector( 1, -1, 0 );
line_pt2 = line_pt + ( line_vec * 2 );
Line = poly( list( line_pt, line_pt2 ), true );
attrib( line, "width", 0.01 );
Param2 = CRVLNDST( Crv, line_pt, line_vec, FALSE, -0.001 );
Pt2lst = nil();
for ( i = 1, 1, sizeof( Param2 ),
	pt = ceval( crv, nth( Param2, i ) ):
	snoc( pt, Pt2lst )
    );
All2 = list( Crv, Line, Pt2lst ) * scale( vector( 0.3, 0.3, 0.3 ) );
view( All2, on );

save( "crvptdst", All1 );
save( "crvlndst", All2 );

#############################################################################
c1 = cbspline( 3,
	       list( ctlpt( E3, 0.0, 0.0, 0.0 ),
		     ctlpt( E3, 1.0, 0.0, 0.0 ),
		     ctlpt( E3, 1.0, 1.0, 0.0 ) ),
	       list( KV_OPEN ) );
c2 = cbspline( 3,
	       list( ctlpt( E3, 0.0, 0.0, 1.0 ),
		     ctlpt( E3, 1.0, 0.0, 1.0 ),
		     ctlpt( E3, 1.0, 2.0, 1.0 ) ),
	       list( KV_OPEN ) );
c3 = cbspline( 3,
	       list( ctlpt( E3, 0.0, 0.0, 1.5 ),
		     ctlpt( E3, 2.0, 0.0, 1.5 ),
		     ctlpt( E3, 1.0, 0.5, 1.5 ),
		     ctlpt( E3, 1.0, 1.0, 1.5 ) ),
	       list( KV_OPEN ) );
c4 = cbspline( 3,
	       list( ctlpt( E3, 0.0, 0.0, 2.5 ),
		     ctlpt( E3, 1.0, 0.0, 2.5 ),
		     ctlpt( E3, 1.0, 1.0, 2.5 ) ),
	       list( KV_OPEN ) );
s = sfromcrvs( list( c1, c2, c3, c4 ), 3 );
attrib( s, "width", 0.005 );

Crv = CSURFACE( s, COL, 0.45 );
attrib( Crv, "width", 0.02 );

All = list( s, Crv ) * roty( 50 ) * rotx( 33 )
	* scale( vector( 0.3, 0.3, 0.3 ) )
	* trans( vector( -0.4, -0.3, 0.0 ) );
view( All, on );
save( "csurface", All );

#############################################################################
spts = list( list( ctlpt( E3, 0.1, 0.0, 1.0 ),
                   ctlpt( E3, 0.3, 1.0, 0.0 ),
                   ctlpt( E3, 0.0, 2.0, 1.0 ) ),
             list( ctlpt( E3, 1.1, 0.0, 0.0 ),
                   ctlpt( E3, 1.3, 1.5, 2.0 ),
                   ctlpt( E3, 1.0, 2.1, 0.0 ) ),
             list( ctlpt( E3, 2.1, 0.0, 2.0 ),
                   ctlpt( E3, 2.3, 1.0, 0.0 ),
                   ctlpt( E3, 2.0, 2.0, 2.0 ) ),
             list( ctlpt( E3, 3.1, 0.0, 0.0 ),
                   ctlpt( E3, 3.3, 1.5, 2.0 ),
                   ctlpt( E3, 3.0, 2.1, 0.0 ) ),
             list( ctlpt( E3, 4.1, 0.0, 1.0 ),
                   ctlpt( E3, 4.3, 1.0, 0.0 ),
                   ctlpt( E3, 4.0, 2.0, 1.0 ) ) );
sb2 = sbspline( 3, 3, spts, list( list( KV_OPEN ), list( KV_OPEN ) ) );

tcrv1 = cbspline( 2,
                  list( ctlpt( E2, 0.3, 0.3 ),
                        ctlpt( E2, 0.7, 0.3 ),
                        ctlpt( E2, 0.7, 0.7 ),
                        ctlpt( E2, 0.3, 0.7 ),
                        ctlpt( E2, 0.3, 0.3 ) ),
                  list( KV_OPEN ) );
tcrv2 = circle( vector( 0.5, 0.5, 0.0 ), 0.25 );
tcrv3 = cbspline( 3,
                  list( ctlpt( E2, 0.3, 0.3 ),
                        ctlpt( E2, 0.7, 0.3 ),
                        ctlpt( E2, 0.7, 0.7 ),
                        ctlpt( E2, 0.3, 0.7 ) ),
                  list( KV_PERIODIC ) );

crvs = list( tcrv1, tcrv2 * ty( 1 ), tcrv3 * ty( 2 ) );
tsrf = trimsrf( sb2, crvs, false );

CrvParam = CTRIMSRF( tsrf, true );
CrvEuclid = CTRIMSRF( tsrf, false );
attrib( CrvParam, "width", 0.02 );
attrib( CrvEuclid, "width", 0.02 );

Tr = rotz( 70 ) * rotx( 30 ) * sc( 0.25 );

All = list( tsrf * Tr * trans( vector( -0.5, -0.5, 0.0 ) ),
	    CrvEuclid * Tr * trans( vector( 0.15, -0.5, 0.0 ) ),
	    Crvparam * sc( 0.3 ) * trans( vector( 0.55, -0.5, 0.0 ) ) );
view( All, on );
save( "ctrimsrf", All );

#############################################################################
Cylinder1 = CYLIN( vector( 0, 0, 0 ), vector( 1, 0, 0 ), 10 );
attrib( Cylinder1, "width", 0.02 );

All = list( Cylinder1 * scale( vector( 0.05, 0.05, 0.05 ) ),
	    axes * scale( vector( 0.25, 0.25, 0.25 ) ) )
	* rotx( 16 ) * roty( 15 ) * rotz( 90 )
	* trans( vector( -0.0, -0.4, 0.0 ) );
view( All, on );
save( "cylinder", All );

#############################################################################
Crv = cbspline( 3,
		list( ctlpt( E2,  0.5, -1.0 ),
		      ctlpt( E2, -1.5, -0.5 ),
		      ctlpt( E2,  1.5,  0.0 ),
		      ctlpt( E2, -0.5,  1.0 ) ),
		list( KV_OPEN ) );
attrib( Crv, "width", 0.015 );

xzeros = CZEROS( Crv, 0.0001, 1 );
pt_xzeros = nil();
pt = nil();
for ( i = 1, 1, sizeof( xzeros ),
       pt = ceval( Crv, nth( xzeros, i ) ):
       snoc( pt, pt_xzeros )
    );

xyaxis = list( ctlpt( E2, -1, 0 ) + ctlpt( E2, 1, 0 ),
	       ctlpt( E2, 0, -1 ) + ctlpt( E2, 0, 1 ) );

All = list( Crv, xyaxis, pt_xzeros ) * scale( vector( 0.5, 0.5, 0.5 ) );

view( All, on );
save( "czeros", All );

#############################################################################
Cross = cbspline( 3,
                  list( ctlpt( E2, -0.018, 0.001 ),
                        ctlpt( E2,  0.018, 0.001 ),
                        ctlpt( E2,  0.019, 0.002 ),
                        ctlpt( E2,  0.018, 0.004 ),
                        ctlpt( E2, -0.018, 0.004 ),
                        ctlpt( E2, -0.019, 0.001 ) ),
                  list( KV_OPEN ) );
Cross = Cross + -Cross * scale( vector( 1, -1, 1 ) );
Cross = Cross * scale( vector( 1.6, 1.6, 1.6 ) );
attrib( Cross, "width", 0.015 );

Napkin = EXTRUDE( Cross, vector( 0.02, 0.03, 0.2 ) );
attrib( Napkin, "width", 0.003 );

All = list( Cross, Napkin ) * scale( vector( 10, 10, 10 ) );
view( All, on );
save( "extrude", All );

#############################################################################

c1 = cbezier( list( ctlpt( E2, -1.0,  0.0 ),
		    ctlpt( E2, -1.0,  0.1 ),
		    ctlpt( E2, -0.9, -0.1 ),
		    ctlpt( E2,  0.9,  0.0 ) ) );
color( c1, magenta );
attrib( c1, "width", 0.005 );

pts = ffptdist( c1, false, 300 );
e2pts = nil();
for ( i = 1, 10, sizeof( pts ),
	pt = ceval( c1, coord( nth( pts, i ), 0 ) ):
	snoc( pt, e2pts )
    );
All = list( e2pts, c1 ) * sc( 0.7 ) * ty( -0.5 );
view( All, on );
save( "ffptdst1", All );

pts = ffptdist( c1, true, 300 );
e2pts = nil();
for ( i = 1, 10, sizeof( pts ),
	pt = ceval( c1, coord( nth( pts, i ), 0 ) ):
	snoc( pt, e2pts )
    );
All = list( e2pts, c1 ) * sc( 0.7 ) * ty( -0.5 );
view( All, 1 );
save( "ffptdst2", All );

#############################################################################
GB = GBOX(vector(0.0, -0.35, 0.63), vector(0.5, 0.0, 0.5),
                                    vector(-0.5, 0.0, 0.5),
                                    vector(0.0, 0.7, 0.0));
attrib( GB, "width", 0.02 );

All = list( GB * scale( vector( 0.5, 0.5, 0.5 ) ),
	    axes * scale( vector( 0.25, 0.25, 0.25 ) ) )
	* rotx( -90 ) * roty( 40 ) * rotx( -30 )
	* trans( vector( -0.0, -0.4, 0.0 ) );
view( All, on );
save( "gbox", All );

#############################################################################
Vrtx1 = vector( -3, -2, -1 );
Vrtx2 = vector( 3, -2, -1 );
Vrtx3 = vector( 3, 2, -1 );
Vrtx4 = vector( -3, 2, -1 );
Poly1 = poly( list( Vrtx1, Vrtx2, Vrtx3, Vrtx4 ), false ); 

Vrtx1 = vector( -3, 2, 1 );
Vrtx2 = vector( 3, 2, 1 );
Vrtx3 = vector( 3, -2, 1 );
Vrtx4 = vector( -3, -2, 1 );
Poly2 = poly( list( Vrtx1, Vrtx2, Vrtx3, Vrtx4 ), false );

Vrtx1 = vector( -3, -2, 1 );
Vrtx2 = vector( 3, -2, 1 );
Vrtx3 = vector( 3, -2, -1 );
Vrtx4 = vector( -3, -2, -1 );
Poly3 = poly( list( Vrtx1, Vrtx2, Vrtx3, Vrtx4 ), false );

PolyObj = MERGEPOLY( list( Poly1, Poly2, Poly3 ) );
attrib( PolyObj, "width", 0.01 );

All = PolyObj * scale( vector( 0.15, 0.15, 0.15 ) )
	      * rotx( -90 ) * roty( 40 ) * rotx( -30 );
view( All, on );
save( "mergpoly", All );

#############################################################################
Crv = cbspline( 3,
                list( ctlpt( E2, 0.7, 0.0 ),
                      ctlpt( E2, 0.7, 0.06 ),
                      ctlpt( E2, 0.1, 0.1 ),
                      ctlpt( E2, 0.1, 0.6 ),
                      ctlpt( E2, 0.6, 0.6 ),
                      ctlpt( E2, 0.8, 0.8 ),
                      ctlpt( E2, 0.8, 1.4 ),
                      ctlpt( E2, 0.6, 1.6 ) ),
                list( KV_OPEN ) );
attrib( Crv, "width", 0.01 );

OffCrv = OFFSET( Crv, -0.4, 1.0, FALSE );
attrib( OffCrv, "width", 0.02 );
All = list( Crv, OffCrv ) * rotz( 90 )
			  * scale( vector( 0.7, 0.7, 0.7 ) )
			  * trans( vector( 0.4, -0.4, 0.0 ) );
view( All, on );
save( "coffset", All );

############################################################################
pt = point( 0.0, -0.65, 0 );
crv = cbezier( list( ctlpt( E2, -0.8, -0.6 ),
		     ctlpt( E2, -0.3, -0.5 ),
		     ctlpt( E2,  0.0,  0.6 ),
		     ctlpt( E2,  0.8, -0.6 ) ) );
Orth = orthotomc( crv, pt, 2 );
attrib( Orth, "gray", 0.5 );

All = list( Orth, crv, pt ) * sc( 0.5 );
attrib( All, "width", 0.015 );

view( All, on );
save( "orthotmc", All );

free( Orth );
free( crv );
free( pt );

############################################################################
gcross = cbspline( 3,
                   list( ctlpt( E3, 0.3, 0.0, 0.0 ),
                         ctlpt( E3, 0.1, 0.0, 0.1 ),
                         ctlpt( E3, 0.1, 0.0, 0.4 ),
                         ctlpt( E3, 0.5, 0.0, 0.5 ),
                         ctlpt( E3, 0.6, 0.0, 0.8 ) ),
                   list( KV_OPEN ) );
resolution = 30;
glass = surfprev( gcross );

pglass = gpolygon( glass, false );
color( pglass, red );

dglass = PDECIMATE( pglass, 0.005, 3, 1, 0 );
color( dglass, green );

Tran = rx( -70 ) * ry( 5 );

All = list( pglass * Tran * sc( 0.7 ) * tx( -0.4 ) * ty( -0.55 ),
	    dglass * Tran * sc( 0.7 ) * tx( 0.5 ) * ty( -0.55 ) );
attrib( All, "width", 0.01 );

view( All, on );
save( "pdecimat", All );

resolution = save_res;

#############################################################################
V1  = vector( 0.0, 0.0, 0.0 );
V2  = vector( 0.3, 0.0, 0.0 );
V3  = vector( 0.3, 0.0, 0.1 );
V4  = vector( 0.2, 0.0, 0.1 );
V5  = vector( 0.2, 0.0, 0.5 );
V6  = vector( 0.3, 0.0, 0.5 );
V7  = vector( 0.3, 0.0, 0.6 );
V8  = vector( 0.0, 0.0, 0.6 );
V9  = vector( 0.0, 0.0, 0.5 );
V10 = vector( 0.1, 0.0, 0.5 );
V11 = vector( 0.1, 0.0, 0.1 );
V12 = vector( 0.0, 0.0, 0.1 );
I = POLY( list( V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12 ),
          FALSE ) * rotx( 90 );
attrib( I, "width", 0.01 );

All = I * scale( vector( 0.85, 0.85, 0.85 ) );

view( All, on );
save( "poly", All );

#############################################################################

cross = cbspline( 3,
                  list( ctlpt( E3, 0.7, 0.0, 0. ),
                        ctlpt( E3, 0.7, 0.0, 0.06 ),
                        ctlpt( E3, 0.1, 0.0, 0.1 ),
                        ctlpt( E3, 0.1, 0.0, 0.6 ),
                        ctlpt( E3, 0.6, 0.0, 0.6 ),
                        ctlpt( E3, 0.8, 0.0, 0.8 ),
                        ctlpt( E3, 0.8, 0.0, 1.4 ),
                        ctlpt( E3, 0.6, 0.0, 1.6 ) ),
                  list( KV_OPEN ) );
wglass = surfrev( cross );
attrib( wglass, "width", 0.02 );
wgl_ruled = PRISA( wglass, 6, -0.1, COL, vector( 0, 0.25, 0.0 ) );
attrib( wgl_ruled, "width", 0.01 );
wgl_prisa = PRISA( wglass, 30, 0.1, COL, vector( 0, 0.25, 0.0 ) );
attrib( wgl_prisa, "width", 0.001 );

All = list( wglass * scale( vector( 0.5, 0.5, 0.5 ) )
		   * rotx( -90 ) * roty( 40 ) * rotx( 20 )
		   * trans( vector( -0.7, -0.3, 0.0 ) ),
	    wgl_ruled * scale( vector( 0.5, 0.5, 0.5 ) )
		      * rotx( -90 ) * roty( 40 ) * rotx( 20 )
		      * trans( vector( 0.13, -0.3, 0.0 ) ),
	    wgl_prisa * scale( vector( 0.1, 0.1, 0.1 ) ) 
		      * trans( vector( 0.8, -0.4, 0.0 ) ) );

view( All, on );
save( "prisa", All );

#############################################################################

gcross = cbspline( 3,
		   list( ctlpt( E3, 0.3, 0.0, 0.0 ),
		         ctlpt( E3, 0.3, 0.0, 0.05 ),
		         ctlpt( E3, 0.1, 0.0, 0.05 ),
		         ctlpt( E3, 0.1, 0.0, 0.4 ),
		         ctlpt( E3, 0.5, 0.0, 0.4 ),
		         ctlpt( E3, 0.6, 0.0, 0.8 ) ),
		   list( 0, 0, 0, 1, 2, 3, 4, 4, 4 ) );
glass = surfprev( gcross );
color( glass, red );
attrib( glass, "width", 0.005 );

nglass = snrmlsrf( glass ) * vector( 1, 1, 1 );

resolution = 12;
sils = contour( nglass, plane( 1, 0, 0, 0 ), glass );

color( sils, cyan );
attrib( sils, "width", 0.02 );

All = list( list( glass, sils )	* save_mat_docs
		* sc( 0.7 ) * trans( vector( -0.5, -0.7, 0.0 ) ) ,
	    list( glass, sils )	* rx( 30 ) * ry( -80 ) * rz( -120 )
		* sc( 0.8 ) * trans( vector(  0.5, -0.75, 0.0 ) ) );
view( All, on );
save( "silhouet", All );

resolution = save_res;

#############################################################################
c1 = cbspline( 3,
             list( ctlpt(E3, 1.7, 0.0 , 0  ),
                   ctlpt(E3, 0.7, 0.7 , 0  ),
                   ctlpt(E3, 1.7, 0.3 , 0  ),
                   ctlpt(E3, 1.5, 0.8 , 0  ),
                   ctlpt(E3, 1.6, 1.0 , 0  ) ),
        list (KV_OPEN ));
attrib( c1, "width", 0.015 );

c2 = cbspline( 3,
             list( ctlpt(E3, 0.7, 0.0 , 0  ),
                   ctlpt(E3,-0.7, 0.2 , 0  ),
                   ctlpt(E3, 0.7, 0.5 , 0  ),
                   ctlpt(E3,-0.7, 0.7 , 0  ),
                   ctlpt(E3, 0.7, 1.0 , 0  ) ) ,
        list (KV_OPEN ));
attrib( c2, "width", 0.015 );

srf1 = ruledsrf( c1, c2 );
All1 = list( c1, c2, srf1 );

c2a = ffmatch( c1, c2, 50, 100, 2, false, 1 );
srf2 = ruledsrf( c1, c2a );
All2 = list( c1, c2, srf2 );

All = list( All1 * tx( -1.6 ),
	    All2 * tx( 0.3 ) ) * sc( 0.5 ) * ty( -0.4 );
view( All, on );
save( "ruledsrf", All );

#############################################################################
BzrSrf = SBEZIER( list ( list( ctlpt( E3, 0.0, 0.0, 1.0 ),
                               ctlpt( E3, 0.0, 1.0, 0.0 ),
                               ctlpt( E3, 0.0, 2.0, 1.0 ) ),
                         list( ctlpt( E3, 1.0, 0.0, 0.0 ),
                               ctlpt( E3, 1.0, 1.0, 2.0 ),
                               ctlpt( E3, 1.0, 2.0, 0.0 ) ),
                         list( ctlpt( E3, 2.0, 0.0, 2.0 ),
                               ctlpt( E3, 2.0, 1.0, 0.0 ),
                               ctlpt( E3, 2.0, 2.0, 2.0 ) ),
                         list( ctlpt( E3, 3.0, 0.0, 0.0 ),
                               ctlpt( E3, 3.0, 1.0, 2.0 ),
                               ctlpt( E3, 3.0, 2.0, 0.0 ) ),
                         list( ctlpt( E3, 4.0, 0.0, 1.0 ),
                               ctlpt( E3, 4.0, 1.0, 0.0 ),
                               ctlpt( E3, 4.0, 2.0, 1.0 ) ) ) );

Mesh = list ( list( ctlpt( E3, 0.0, 0.0, 1.0 ),
                    ctlpt( E3, 0.0, 1.0, 0.0 ),
                    ctlpt( E3, 0.0, 2.0, 1.0 ) ),
              list( ctlpt( E3, 1.0, 0.0, 0.0 ),
                    ctlpt( E3, 1.0, 1.0, 2.0 ),
                    ctlpt( E3, 1.0, 2.0, 0.0 ) ),
              list( ctlpt( E3, 2.0, 0.0, 2.0 ),
                    ctlpt( E3, 2.0, 1.0, 0.0 ),
                    ctlpt( E3, 2.0, 2.0, 2.0 ) ),
              list( ctlpt( E3, 3.0, 0.0, 0.0 ),
                    ctlpt( E3, 3.0, 1.0, 2.0 ),
                    ctlpt( E3, 3.0, 2.0, 0.0 ) ),
              list( ctlpt( E3, 4.0, 0.0, 1.0 ),
                    ctlpt( E3, 4.0, 1.0, 0.0 ),
                    ctlpt( E3, 4.0, 2.0, 1.0 ) ) );
BspSrf = SBSPLINE( 3, 3, Mesh, list( list( KV_OPEN ),
                                     list( 3, 3, 3, 4, 5, 6, 6, 6 ) ) );

All = list( BzrSrf * scale( vector( 0.2, 0.2, 0.2 ) )
		   * rotx( -90 ) * roty( 40 ) * rotx( -30 )
		   * trans( vector( -0.5, -0.35, 0.0 ) ),
	    BspSrf * scale( vector( 0.2, 0.2, 0.2 ) )
		   * rotx( -90 ) * roty( 40 ) * rotx( -30 )
		   * trans( vector( 0.4, -0.35, 0.0 ) ) );
attrib( All, "width", 0.01 );

view( All, on );
save( "surface", All );

#############################################################################
s = ruledSrf( ctlpt( E3, -1.0, -1.0, 0.0 ) + ctlpt( E3,  1.0, -1.0, 0.0 ),
	      ctlpt( E3, -1.0,  1.0, 0.0 ) + ctlpt( E3,  1.0,  1.0, 0.0 ) );
    
pt = point( 0.0, 0.0, 1.0 );
    
bisect = sbisector( s, pt );

All = list( s, pt, bisect );
attrib( All, "width", 0.01 );

view( All, on );
save( "sbisect", All );

free( pt );
free( s );
free( bisect );

#############################################################################
cross = cbspline( 3,
                  list( ctlpt( E2,  0.0,  0.0 ),
                        ctlpt( E2,  0.8,  0.0 ),
                        ctlpt( E2,  0.8,  0.2 ),
                        ctlpt( E2,  0.07, 1.4 ),
                        ctlpt( E2, -0.07, 1.4 ),
                        ctlpt( E2, -0.8,  0.2 ),
                        ctlpt( E2, -0.8,  0.0 ),
                        ctlpt( E2,  0.0,  0.0 ) ),
                  list( KV_OPEN ) );
s = sFromCrvs( list( cross,
                     cross * trans( vector( 0.5, 0, 1 ) ),
                     cross * trans( vector( 0, 0, 2 ) ) ), 3 );
attrib( s, "width", 0.01 );

UCrvtrZXY = scrvtr( s, E3, row );
VCrvtrZXY = scrvtr( s, E3, col );
UCrvtrXYZ = UCrvtrZXY * rotx( -90 ) * roty( -90 ) * scale( vector( 1, 1, 10 ) );
VCrvtrXYZ = VCrvtrZXY * rotx( -90 ) * roty( -90 ) * scale( vector( 1, 1, 0.001 ) );
 
CrvtrZXY = scrvtr( s, E3, off );
CrvtrXYZ = CrvtrZXY * rotx( -90 ) * roty( -90 ) * scale( vector( 1, 1, 0.001 ) );

All = list( s * scale( vector( 0.2, 0.2, 0.2 ) )
	      * rotx( -90 ) * roty( 40 ) * rotx( -30 )
	      * trans( vector( -0.7, -0.45, 0.0 ) ),
	    UCrvtrXYZ
	      * scale( vector( 0.1, 0.1, 0.1 ) )
	      * rotx( -90 ) * roty( 40 ) * rotx( -30 )
	      * trans( vector( -0.45, -0.35, 0.0 ) ),
	    VCrvtrXYZ
	      * scale( vector( 0.1, 0.1, 0.1 ) )
	      * rotx( -90 ) * roty( 40 ) * rotx( -30 )
	      * trans( vector( 0.05, -0.35, 0.0 ) ),
	    CrvtrXYZ
	      * scale( vector( 0.1, 0.1, 0.1 ) )
	      * rotx( -90 ) * roty( 40 ) * rotx( -30 )
	      * trans( vector( 0.53, -0.35, 0.0 ) ) );

view( All, on );
save( "scrvtr", All );

#############################################################################
BzrSrf = SBEZIER( list ( list( ctlpt( E3, 0.0, 0.0, 1.0 ),
                               ctlpt( E3, 0.0, 1.0, 0.0 ),
                               ctlpt( E3, 0.0, 2.0, 1.0 ) ),
                         list( ctlpt( E3, 1.0, 0.0, 0.0 ),
                               ctlpt( E3, 1.0, 1.0, 2.0 ),
                               ctlpt( E3, 1.0, 2.0, 0.0 ) ),
                         list( ctlpt( E3, 3.0, 0.0, 0.0 ),
                               ctlpt( E3, 3.0, 1.0, 2.0 ),
                               ctlpt( E3, 3.0, 2.0, 0.0 ) ),
                         list( ctlpt( E3, 4.0, 0.0, 1.0 ),
                               ctlpt( E3, 4.0, 1.0, 0.0 ),
                               ctlpt( E3, 4.0, 2.0, 1.0 ) ) ) );
SrfLst = SDIVIDE( BzrSrf, ROW, 0.5 );
Srf1 = nth( SrfLst, 1 );
Srf2 = nth( SrfLst, 2 );

All = list( BzrSrf * scale( vector( 0.3, 0.3, 0.3 ) )
	           * trans( vector( 0.0, -0.35, 0.0 ) ),
	    Srf1 * scale( vector( 0.3, 0.3, 0.3 ) )
	         * trans( vector( -0.1, -0.35, 0.6 ) ),
	    Srf2 * scale( vector( 0.3, 0.3, 0.3 ) )
	         * trans( vector( 0.1, -0.35, 0.6 ) ) )
	         * rotx( -90 ) * roty( 10 ) * rotx( -30 )
		 * trans( vector( -0.5, -0.5, 0.0 ) );
attrib( All, "width", 0.01 );

view( All, on );
save( "sdivide", All );

############################################################################
gcross = cbspline( 3,
                   list( ctlpt( E3, 0.3, 0.0, 0.0 ),
                         ctlpt( E3, 0.1, 0.0, 0.1 ),
                         ctlpt( E3, 0.1, 0.0, 0.4 ),
                         ctlpt( E3, 0.5, 0.0, 0.5 ),
                         ctlpt( E3, 0.6, 0.0, 0.8 ) ),
                   list( KV_OPEN ) );
glass = surfprev( gcross );
color( glass, red );
attrib( glass, "transp", 0.5 );
save( "glass", glass );
    
gfocal = SFOCAL(glass, col);

Tran = rx( -70 ) * ry( 5 );
All = list( glass * Tran * sc( 0.75 ) * tx( -0.4 ) * ty( -0.55 ),
	    gfocal * Tran * sc( 0.5 ) * tx( 0.5 ) * ty( -0.4 ) );
attrib( All, "width", 0.01 );

view(All, on );
save( "sfocal", All );

############################################################################
Crv1 = cbspline( 3,
                 list( ctlpt( E3, 0.0, 0.0, 0.0 ),
                       ctlpt( E3, 1.0, 0.0, 0.0 ),
                       ctlpt( E3, 1.0, 1.0, 0.0 ) ),
                 list( KV_OPEN ) );
Crv2 = Crv1 * trans( vector( 0.0, 0.0, 1.0 ) );
Crv3 = Crv2 * trans( vector( 0.0, 1.0, 0.0 ) );
attrib( Crv1, "width", 0.02 );
attrib( Crv2, "width", 0.02 );
attrib( Crv3, "width", 0.02 );
Srf = SFROMCRVS( list( Crv1, Crv2, Crv3 ), 3 );
attrib( Srf, "width", 0.005 );

All = list( Crv1, Crv2, Crv3, Srf )
	* scale( vector( 0.6, 0.6, 0.6 ) )
	* rotx( -90 ) * roty( 40 ) * rotx( -30 )
	* trans( vector( -0.2, -0.5, 0.0 ) );
view( All, on );
save( "sfromcrvs", All );

#############################################################################
pl = nil();
pll = nil();
for ( x = -5, 1, 5,
      pl = nil():
      for ( y = -5, 1, 5,
            snoc( point( x, y, sin( x * Pi / 2 ) * cos( y * Pi / 2 ) ),
                  pl )
      ):
      snoc( pl, pll ) );
s1 = sinterp( pll, 3, 3, 8, 8, PARAM_UNIFORM );
s2 = sinterp( pll, 3, 3, 11, 11, PARAM_UNIFORM );

All = list( list( s1, pll )
		* scale( vector( 0.07, 0.07, 0.07 ) )
		* rotx( -90 ) * roty( 40 ) * rotx( -30 )
		* trans( vector( -0.5, -0.5, 0.0 ) ),
	    list( s2, pll )
		* scale( vector( 0.07, 0.07, 0.07 ) )
		* rotx( -90 ) * roty( 40 ) * rotx( -30 )
		* trans( vector( 0.5, -0.5, 0.0 ) ) );
view( All, on );
save( "sinterp", All );

#############################################################################

srf1 = hermite( cbezier( list( ctlpt( E3, 0.0, 0.0, 0.0 ),
			       ctlpt( E3, 0.5, 0.2, 0.0 ),
			       ctlpt( E3, 1.0, 0.0, 0.0 ) ) ),
		cbezier( list( ctlpt( E3, 0.0, 1.0, 0.0 ),
			       ctlpt( E3, 0.5, 0.8, 0.0 ),
			       ctlpt( E3, 1.0, 1.0, 0.5 ) ) ),
		cbezier( list( ctlpt( E3, 0.0, 2.0, 0.0 ),
			       ctlpt( E3, 0.0, 2.0, 0.0 ),
			       ctlpt( E3, 0.0, 2.0, 0.0 ) ) ),
		cbezier( list( ctlpt( E3, 0.0, 2.0, 0.0 ),
			       ctlpt( E3, 0.0, 2.0, 0.0 ),
			       ctlpt( E3, 0.0, 2.0, 0.0 ) ) ) );
color( srf1, yellow );

srf1MS = coerce( smeansqr( srf1 ), e3 )
	* rotx( -90 ) * roty( -90 ) * sz( 0.01 );

All = list( srf1 * rz( 150 ) * rx( 50 ) * tx( -0.1 ) * ty( -0.6 ),
	    srf1MS * rz( 150 ) * rx( 50 ) * tx( 1.4 ) * ty( -0.6 ) );
attrib( All, "width", 0.01 );
view( All, on );
save( "smeansqr", All );

srf1GS = coerce( sgauss( srf1 ), e3 ) * rotx( -90 ) * roty( -90 ) * sz( 0.01 );

All = list( srf1 * rz( 150 ) * rx( 50 ) * tx( -0.1 ) * ty( -0.6 ),
	    srf1GS * rz( 150 ) * rx( 50 ) * tx( 1.4 ) * ty( -0.6 ) );
attrib( All, "width", 0.01 );
view( All, on );
save( "sgauss", All );

#############################################################################

bcross = cbspline( 3,
		   list( ctlpt( E3,  0.0,  0.0, -0.71 ),
		         ctlpt( E3,  0.2,  0.0, -0.72 ),
		         ctlpt( E3,  0.25, 0.0, -0.7 ),
		         ctlpt( E3,  0.25, 0.0, -0.1 ),
		         ctlpt( E3,  0.2,  0.0, -0.05 ),
		         ctlpt( E3,  0.15, 0.0,  0.0 ),
		         ctlpt( E3,  0.1,  0.0,  0.6 ),
			 ctlpt( E3,  0.11, 0.0,  0.61 ),
			 ctlpt( E3,  0.12, 0.0,  0.61 ),
			 ctlpt( E3,  0.12, 0.0,  0.65 ),
			 ctlpt( E3,  0.09, 0.0,  0.65 ),
			 ctlpt( E3,  0.07, 0.0,  0.64 ),
			 ctlpt( E3,  0.10, 0.0, -0.05 ),
			 ctlpt( E3,  0.21, 0.0, -0.1 ),
			 ctlpt( E3,  0.21, 0.0, -0.64 ),
			 ctlpt( E3,  0.18, 0.0, -0.67),
			 ctlpt( E3,  0.0,  0.0, -0.66 ) ),
		   list( KV_OPEN ) );
Srf2 = surfrev( bcross );

gcross = cbspline( 3,
		   list( ctlpt( E3, 0.001, 0.0, 0.02 ),
		  	 ctlpt( E3, 0.2,   0.0, 0.02 ),
			 ctlpt( E3, 0.22,  0.0, 0. ),
			 ctlpt( E3, 0.22,  0.0, 0.03 ),
			 ctlpt( E3, 0.03,  0.0, 0.03 ),
			 ctlpt( E3, 0.03,  0.0, 0.07 ),
			 ctlpt( E3, 0.04,  0.0, 0.3 ),
			 ctlpt( E3, 0.3,   0.0, 0.3 ),
			 ctlpt( E3, 0.4,   0.0, 0.4 ),
			 ctlpt( E3, 0.3,   0.0, 0.7 ),
			 ctlpt( E3, 0.28,  0.0, 0.7 ),
			 ctlpt( E3, 0.37,  0.0, 0.42 ),
			 ctlpt( E3, 0.31,  0.0, 0.32 ),
			 ctlpt( E3, 0.001, 0.0, 0.32 ) ),
		list( KV_OPEN ) );
Srf3 = surfrev( gcross * trans( vector( 0.0, 0.0, -0.45 ) ) *
			 scale( vector( 1.6, 1.6, 1.6 ) ) );

ffcompat( Srf2, Srf3 );

Msrf1 = SMORPH( Srf2, Srf3, 0.0 );
attrib( Msrf1, "width", 0.01 );
Msrf2 = SMORPH( Srf2, Srf3, 0.2 );
attrib( Msrf2, "width", 0.003 );
Msrf3 = SMORPH( Srf2, Srf3, 0.4 );
attrib( Msrf3, "width", 0.003 );
Msrf4 = SMORPH( Srf2, Srf3, 0.6 );
attrib( Msrf4, "width", 0.003 );
Msrf5 = SMORPH( Srf2, Srf3, 0.8 );
attrib( Msrf5, "width", 0.003 );
Msrf6 = SMORPH( Srf2, Srf3, 1.0 );
attrib( Msrf6, "width", 0.01 );

All = list( Msrf1 * scale( vector( 0.25, 0.25, 0.25 ) )
		  * rotx( -90 ) * roty( 40 ) * rotx( -30 )
		  * trans( vector( -0.8, -0.5, 0.0 ) ),
	    Msrf2 * scale( vector( 0.25, 0.25, 0.25 ) )
		  * rotx( -90 ) * roty( 40 ) * rotx( -30 )
		  * trans( vector( -0.5, -0.5, 0.0 ) ),
	    Msrf3 * scale( vector( 0.25, 0.25, 0.25 ) )
		  * rotx( -90 ) * roty( 40 ) * rotx( -30 )
		  * trans( vector( -0.2, -0.5, 0.0 ) ),
	    Msrf4 * scale( vector( 0.25, 0.25, 0.25 ) )
		  * rotx( -90 ) * roty( 40 ) * rotx( -30 )
		  * trans( vector(  0.1, -0.5, 0.0 ) ),
	    Msrf5 * scale( vector( 0.25, 0.25, 0.25 ) )
		  * rotx( -90 ) * roty( 40 ) * rotx( -30 )
		  * trans( vector(  0.4, -0.5, 0.0 ) ),
	    Msrf6 * scale( vector( 0.25, 0.25, 0.25 ) )
		  * rotx( -90 ) * roty( 40 ) * rotx( -30 )
		  * trans( vector(  0.7, -0.5, 0.0 ) ) );

view( All, on );
save( "smorph", All );

#############################################################################

s45 = sin( 45 * pi / 180 );
halfcirc = cbspline( 3,
		     list( ctlpt( P3, 1.0,  0.0, 0.0,  1.0 ),
		           ctlpt( P3, s45, -s45, 0.0,  s45 ),
		           ctlpt( P3, 1.0, -1.0, 0.0,  0.0 ),
		           ctlpt( P3, s45, -s45, 0.0, -s45 ),
			   ctlpt( P3, 1.0,  0.0, 0.0, -1.0 ) ),
		     list( 0, 0, 0, 1, 1, 2, 2, 2 ) );
Srf = surfrev( halfcirc );

NrmlSrf = SNRMLSRF( Srf ) * sc( 0.6 );

All = list( Srf * trans( vector( -1.0, 2.0, 0.0 ) ),
	    NrmlSrf * trans( vector( 1.4, 0.0, 0.0 ) ) )
	* rotx( -90 ) * roty( 40 ) * rotx( 30 )
  	* scale( vector( 0.25, 0.25, 0.25 ) );
attrib( All, "width", 0.01 );

view( All, on );
save( "snrmlsrf", All );

#############################################################################

Srf = ruledSrf( cbezier( list( ctlpt( E3, -0.5, -0.5, 0.5 ),
			       ctlpt( E3,  0.0,  0.5, 0.0 ),
                               ctlpt( E3,  0.5, -0.5, 0.0 ) ) ),
                cbezier( list( ctlpt( E3, -0.5,  0.5, 0.0 ),
			       ctlpt( E3,  0.0,  0.0, 0.0 ),
                               ctlpt( E3,  0.5,  0.5, 0.5 ) ) ) );
SubSrf = SREGION( Srf, ROW, 0.3, 0.6 );

All = list( Srf, SubSrf * trans( vector( 0.0, 0.0, 0.2 ) ) )
	* rotx( -90 ) * roty( 20 ) * rotx( -10 )
	* trans( vector( 0.0, -0.5, 0.0 ) );
attrib( All, "width", 0.01 );

view( All, on );
save( "sregion", All );

#############################################################################
TV1 = tbezier( list( list( list( ctlpt( E3, 0.1, 0.0, 0.8 ),
                                 ctlpt( E3, 0.2, 0.1, 2.4 ) ),
                           list( ctlpt( E3, 0.3, 2.2, 0.2 ),
                                 ctlpt( E3, 0.4, 2.3, 2.0 ) ) ),
                     list( list( ctlpt( E3, 2.4, 0.8, 0.1 ),
                                 ctlpt( E3, 2.2, 0.7, 2.3 ) ),
                           list( ctlpt( E3, 2.3, 2.6, 0.5 ),
                                 ctlpt( E3, 2.1, 2.5, 2.7) ) ) ) );
Srf = STRIVAR( TV1, col, 0.4 ); 
attrib( Srf, "width", 0.015 );
color( Srf, red );

Tr = rotz( 70 ) * rotx( 30 ) * roty( 20 ) * sc( 0.2 );

All = list( TV1 * Tr * trans( vector( -0.6, -0.4, 0.0 ) ),
	    list( Srf, TV1 ) * Tr * trans( vector( 0.0, -0.4, 0.0 ) ),
	    Srf * Tr * trans( vector( 0.6, -0.4, 0.0 ) ) );

view( All, on );
save( "strivar", All );

#############################################################################
VTailAntn = SURFREV( ctlpt( E3, 0.001, 0.0, 1.0 ) +
                     ctlpt( E3, 0.01,  0.0, 1.0 ) +
                     ctlpt( E3, 0.01,  0.0, 0.8 ) +
                     ctlpt( E3, 0.03,  0.0, 0.7 ) +
                     ctlpt( E3, 0.03,  0.0, 0.3 ) +
                     ctlpt( E3, 0.001, 0.0, 0.0 ) );

All = VTailAntn
  	* scale( vector( 2, 2, 2 ) )
	* roty( 45 ) * rotx( -30 )
	* trans( vector( -0.7, -0.7, 0.0 ) );
attrib( All, "width", 0.01 );

view( All, on );
save( "surfrev", All );

#############################################################################
c1 = cbezier( list( ctlpt( E3, 1.0, 0.0,  0.5 ),
                    ctlpt( E3, 1.1, 0.0,  0.0 ),
                    ctlpt( E3, 1.0, 0.0, -0.5 ) ) );
Simp = sregion( surfPRev( c1 ), col, 0.0, 1.0 ) * rz( 45 ) * rx( 90 );
Decomp = SVISIBLE( Simp, 20, 30 * pi / 180 );

v = l = i = j = 1;
SimDecomp = nil();
Mod = 5;
for ( i = 1, 1, sizeof( Decomp ),
    o = nth( Decomp, i ):
    awidth( o, 0.015 ):
    adwidth( o, 3 ):
    color( o, i ):
    v = getattr( o, "ViewDir" ):
    l = ( ctlpt( E3, 0, 0, 0 ) + coerce( v, e3 ) ) * sc( 1.5 ):
    j = floor( ( i - 1 ) / Mod ):
    snoc( list( o, Simp, l, axes )
                * view_mat * tx( ( i - 1 - j * Mod ) * 2 - 4 )
                           * ty( -j * 2 ),
          SimDecomp ) );

SimDecomp = SimDecomp * sc( 0.2 );

view( SimDecomp, on );
save( "svisible", SimDecomp );

free( c1 );
free( Simp );
free( Decomp );
free( SimDecomp );
free( Mod );
free( o );
free( i );
free( j );
free( l );
free( v );

#############################################################################
Cross = arc( vector( 0.2, 0.0, 0.0 ),
             vector( 0.2, 0.2, 0.0 ),
             vector( 0.0, 0.2, 0.0 ) ) +
        arc( vector( 0.0, 0.4, 0.0 ),
             vector( 0.1, 0.4, 0.0 ),
             vector( 0.1, 0.5, 0.0 ) ) +
        arc( vector( 0.8, 0.5, 0.0 ),
             vector( 0.8, 0.3, 0.0 ),
             vector( 1.0, 0.3, 0.0 ) ) +
        arc( vector( 1.0, 0.1, 0.0 ),
             vector( 0.9, 0.1, 0.0 ),
             vector( 0.9, 0.0, 0.0 ) ) +
        ctlpt( E2, 0.2, 0.0 );
Axis = arc( vector( -1.0, 0.0, 0.0 ),
            vector(  0.0, 0.0, 0.1 ),
            vector(  1.0, 0.0, 0.0 ) );
Axis = crefine( Axis, FALSE, list( 0.25, 0.5, 0.75 ) );
Srf1 = SWEEPSRF( Cross, Axis, OFF );
Srf2 = SWEEPSRF( Cross, Axis, vector( 0.0, 1.0, 1.0 ) );
Srf3 = SWEEPSRF( Cross, Axis,
                 cbezier( list( ctlpt( E3,  1.0, 0.0, 0.0 ),
                                ctlpt( E3,  0.0, 1.0, 0.0 ),
                                ctlpt( E3, -1.0, 0.0, 0.0 ) ) ) );

All = list( Srf1 * rotx( -90 ) * roty( 20 ) * rotx( -10 )
		 * trans( vector(-4.0, -0.5, 0.0 ) ),
	    Srf2 * rotx( -90 ) * roty( 20 ) * rotx( -10 )
		 * trans( vector( 0.5, -0.5, 0.0 ) ),
	    Srf3 * rotx( -90 ) * roty( 20 ) * rotx( -10 )
		 * trans( vector( 4.0, -0.5, 0.0 ) ) )
	* scale( vector( 0.15, 0.15, 0.15 ) );
attrib( All, "width", 0.01 );
   
view( All, on );
save( "sweepsrf", All );

#############################################################################
Cross = arc( vector( -0.11, -0.01, 0.0 ),
             vector( -0.1,  -0.1,  0.0 ),
             vector( -0.1,  -0.11, 0.0 ) ) +
        arc( vector(  0.1,  -0.11, 0.0 ),
             vector(  0.1,  -0.1,  0.0 ),
             vector(  0.11, -0.1,  0.0 ) ) +
        arc( vector(  0.11,  0.1,  0.0 ),
             vector(  0.1,   0.1,  0.0 ),
             vector(  0.1,   0.11, 0.0 ) ) +
        arc( vector( -0.1,   0.11, 0.0 ),
             vector( -0.1,   0.1,  0.0 ),
             vector( -0.11,  0.1,  0.0 ) ) +
        ctlpt( E2, -0.11, -0.1 );
scaleCrv = cbspline( 3,
                     list( ctlpt( E2, 0.05, 1.0 ),
                           ctlpt( E2, 0.1,  0.0 ),
                           ctlpt( E2, 0.2,  2.0 ),
                           ctlpt( E2, 0.3,  0.0 ),
                           ctlpt( E2, 0.4,  2.0 ),
                           ctlpt( E2, 0.5,  0.0 ),
                           ctlpt( E2, 0.6,  2.0 ),
                           ctlpt( E2, 0.7,  0.0 ),
                           ctlpt( E2, 0.8,  2.0 ),
                           ctlpt( E2, 0.85, 1.0 ) ),
                     list( KV_OPEN ) );
Axis = circle( vector( 0, 0, 0 ), 1 );
Frame = circle( vector( 0, 0, 0 ), 1 )
        * rotx( 90 ) * trans( vector( 1.5, 0.0, 0.0 ) );

Srf1 = SWPSCLSRF( Cross, Axis, scaleCrv, off, 0 );
Srf2 = SWPSCLSRF( Cross, Axis, scaleCrv, off, 2 );
Srf3 = SWPSCLSRF( Cross, Axis, 1.0, Frame, 0 );

All = list( Srf1 * rotx( -90 ) * roty( 20 ) * rotx( -30 )
		 * trans( vector(-2.6, -1.7, 0.0 ) ),
	    Srf2 * rotx( -90 ) * roty( 20 ) * rotx( 30 )
		 * trans( vector( 0.0, -1.7, 0.0 ) ),
	    Srf3 * rotx( -90 ) * roty( 20 ) * rotx( 30 )
		 * trans( vector( 2.6, -1.7, 0.0 ) ) )
	* scale( vector( 0.25, 0.25, 0.25 ) );
attrib( All, "width", 0.003 );
   
view( All, on );
save( "swpsclsrf", All );

#############################################################################
TV1 = TBEZIER( list( list( list( ctlpt( E3, 0.1, 0.1, 0.0 ),
                                ctlpt( E3, 0.2, 0.5, 1.1 ),
                                ctlpt( E3, 0.3, 0.1, 2.2 ) ),
                          list( ctlpt( E3, 0.4, 1.3, 0.5 ),
                                ctlpt( E3, 0.5, 1.7, 1.7 ),
                                ctlpt( E3, 0.6, 1.3, 2.9 ) ),
                          list( ctlpt( E3, 0.7, 2.4, 0.5 ),
                                ctlpt( E3, 0.8, 2.6, 1.4 ),
                                ctlpt( E3, 0.9, 2.8, 2.3 ) ) ),
                    list( list( ctlpt( E3, 1.1, 0.1, 0.5 ),
                                ctlpt( E3, 1.3, 0.2, 1.7 ),
                                ctlpt( E3, 1.5, 0.3, 2.9 ) ),
                          list( ctlpt( E3, 1.7, 1.2, 0.0 ),
                                ctlpt( E3, 1.9, 1.4, 1.2 ),
                                ctlpt( E3, 1.2, 1.6, 2.4 ) ),
                          list( ctlpt( E3, 1.4, 2.3, 0.9 ),
                                ctlpt( E3, 1.6, 2.5, 1.7 ),
                                ctlpt( E3, 1.8, 2.7, 2.5 ) ) ) ) );

TV2 = TBSPLINE( 2, 2, 2,
               list( list( list( ctlpt( E3, 0.1, 0.1, 0.0 ),
                                 ctlpt( E3, 0.2, 0.5, 1.1 ),
                                 ctlpt( E3, 0.3, 0.1, 2.2 ) ),
                           list( ctlpt( E3, 0.4, 1.3, 0.5 ),
                                 ctlpt( E3, 0.5, 1.7, 1.7 ),
                                 ctlpt( E3, 0.6, 1.3, 2.9 ) ),
                           list( ctlpt( E3, 0.7, 2.4, 0.5 ),
                                 ctlpt( E3, 0.8, 2.6, 1.4 ),
                                 ctlpt( E3, 0.9, 2.8, 2.3 ) ) ),
                     list( list( ctlpt( E3, 1.1, 0.1, 0.5 ),
                                 ctlpt( E3, 1.3, 0.2, 1.7 ),
                                 ctlpt( E3, 1.5, 0.3, 2.9 ) ),
                           list( ctlpt( E3, 1.7, 1.2, 0.0 ),
                                 ctlpt( E3, 1.9, 1.4, 1.2 ),
                                 ctlpt( E3, 1.2, 1.6, 2.4 ) ),
                           list( ctlpt( E3, 1.4, 2.3, 0.9 ),
                                 ctlpt( E3, 1.6, 2.5, 1.7 ),
                                 ctlpt( E3, 1.8, 2.7, 2.5 ) ) ) ),
               list( list( KV_OPEN ),
                     list( KV_OPEN ),
                     list( KV_OPEN ) ) );
attrib( TV1, "width", 0.012 );
attrib( TV2, "width", 0.012 );

Tr = rotx( 30 ) * roty( 30 ) * sc( 0.3 );

All = list( TV1 * Tr * trans( vector( -0.9, -0.5, 0.0 ) ),
	    TV2 * Tr * trans( vector(  0.0, -0.5, 0.0 ) ) );
view( All, on );
save( "tbezier", All );

#############################################################################
TV2 = tbspline( 3, 3, 2,
                list( list( list( ctlpt( E3, 0.1, 0.1, 0.0 ),
                                  ctlpt( E3, 0.2, 0.5, 1.1 ),
                                  ctlpt( E3, 0.3, 0.1, 2.2 ) ),
                            list( ctlpt( E3, 0.4, 1.3, 0.5 ),
                                  ctlpt( E3, 0.5, 1.7, 1.7 ),
                                  ctlpt( E3, 0.6, 1.3, 2.9 ) ),
                            list( ctlpt( E3, 0.7, 2.4, 0.5 ),
                                  ctlpt( E3, 0.8, 2.6, 1.4 ),
                                  ctlpt( E3, 0.9, 2.8, 2.3 ) ) ),
                      list( list( ctlpt( E3, 1.1, 0.1, 0.5 ),
                                  ctlpt( E3, 1.3, 0.2, 1.7 ),
                                  ctlpt( E3, 1.5, 0.3, 2.9 ) ),
                            list( ctlpt( E3, 1.7, 1.2, 0.0 ),
                                  ctlpt( E3, 1.9, 1.4, 1.2 ),
                                  ctlpt( E3, 1.2, 1.6, 2.4 ) ),
                            list( ctlpt( E3, 1.4, 2.3, 0.9 ),
                                  ctlpt( E3, 1.6, 2.5, 1.7 ),
                                  ctlpt( E3, 1.8, 2.7, 2.5 ) ) ),
                      list( list( ctlpt( E3, 2.8, 0.1, 0.4 ),
                                  ctlpt( E3, 2.6, 0.7, 1.3 ),
                                  ctlpt( E3, 2.4, 0.2, 2.2 ) ),
                            list( ctlpt( E3, 2.2, 1.1, 0.4 ),
                                  ctlpt( E3, 2.9, 1.2, 1.5 ),
                                  ctlpt( E3, 2.7, 1.3, 2.6 ) ),
                            list( ctlpt( E3, 2.5, 2.9, 0.7 ),
                                  ctlpt( E3, 2.3, 2.8, 1.7 ),
                                  ctlpt( E3, 2.1, 2.7, 2.7 ) ) ) ),
                list( list( KV_OPEN ),
                      list( KV_OPEN ),
                      list( KV_OPEN ) ) );
color( TV2, green );
attrib( TV2, "width", 0.012 );

TvDiv = TDIVIDE( Tv2, depth, 0.8 );
Tv2a = nth( TvDiv, 1 ) * tx( -2.6 );
Tv2b = nth( TvDiv, 2 ) * tx( 2.8 );
color( Tv2a, yellow );
color( Tv2b, yellow );
attrib( Tv2a, "width", 0.012 );
attrib( Tv2b, "width", 0.012 );

All = list( TV2, Tv2a, Tv2b ) *
      rotx( 35 ) * roty( 20 ) * sc( 0.2 ) * trans( vector( -0.4, -0.5, 0.0 ) );
view( All, on );
save( "tdivide", All );

#############################################################################
s1 = sbezier( list( list( ctlpt( E3, -0.5, -0.5, 0 ),
			  ctlpt( E3, -0.5,  0.5, 0 ) ),
		    list( ctlpt( E3,  0.5, -0.5, 0 ),
			  ctlpt( E3,  0.5,  0.5, 0 ) ) ) ) * sc( 0.3 );
Srfs = list( s1 * sc( 2.0 ),
	     s1 * sx( 1.4 ) * ry( 45 ) * tz( 1.0 ),
	     s1 * ry( 90 ) * trans( vector( 1.0, 0.0, 1.1 ) ),
	     s1 * sx( 1.4 ) * ry( 135 ) * trans( vector( 2.0, 0.0, 1.0 ) ),
	     s1 * sc( 2.0 ) * ry( 180 ) * trans( vector( 2.0, 0.0, 0.0 ) ) );
color( Srfs, red );
attrib( Srfs, "width", 0.015 );

ts = tfromsrfs( Srfs, 3 );
attrib( ts, "width", 0.005 );
color( ts, green );

All = list( Srfs, ts ) * sc( 0.5 ) *tx( -0.5 ) * rx( -60 ) * ry( 20 );
view( All, on );
save( "tfromsrf", All );

#############################################################################
Tv1 = tbezier( list( list( list( ctlpt( E3, 0.1, 0.0, 0.8 ),
                                 ctlpt( E3, 0.2, 0.1, 2.4 ) ),
                           list( ctlpt( E3, 0.3, 2.2, 0.2 ),
                                 ctlpt( E3, 0.4, 2.3, 2.0 ) ) ),
                     list( list( ctlpt( E3, 2.4, 0.8, 0.1 ),
                                 ctlpt( E3, 2.2, 0.7, 2.3 ) ),
                           list( ctlpt( E3, 2.3, 2.6, 0.5 ),
                                 ctlpt( E3, 2.1, 2.5, 2.7) ) ) ) );
color( Tv1, green );
attrib( Tv1, "width", 0.001 );

Tv1r1 = TREGION( Tv1, row, 0.1, 0.2 );
Tv1r2 = TREGION( Tv1, row, 0.4, 0.6 );
Tv1r3 = TREGION( Tv1, row, 0.99, 1.0 );
color( Tv1r1, red );
attrib( Tv1r1, "width", 0.012 );
color( Tv1r2, red );
attrib( Tv1r2, "width", 0.012 );
color( Tv1r3, red );
attrib( Tv1r3, "width", 0.012 );

Tvs1 = list( Tv1, Tv1r1, Tv1r2, Tv1r3 );
Tvs2 = list( Tv1r1, Tv1r2, Tv1r3 );

Tr = rotx( 30 ) * roty( 30 ) * sc( 0.3 );

All = list( Tvs1 * Tr * trans( vector( -1.1, -0.5, 0.0 ) ),
            Tvs2 * Tr * trans( vector( -0.1, -0.5, 0.0 ) ) );

view( All, on );
save( "tregion", All );

#############################################################################
spts = list( list( ctlpt( E3, 0.1, 0.0, 1.0 ),
                   ctlpt( E3, 0.3, 1.0, 0.0 ),
                   ctlpt( E3, 0.0, 2.0, 1.0 ) ),
             list( ctlpt( E3, 1.1, 0.0, 0.0 ),
                   ctlpt( E3, 1.3, 1.5, 2.0 ),
                   ctlpt( E3, 1.0, 2.1, 0.0 ) ),
             list( ctlpt( E3, 2.1, 0.0, 2.0 ),
                   ctlpt( E3, 2.3, 1.0, 0.0 ),
                   ctlpt( E3, 2.0, 2.0, 2.0 ) ),
             list( ctlpt( E3, 3.1, 0.0, 0.0 ),
                   ctlpt( E3, 3.3, 1.5, 2.0 ),
                   ctlpt( E3, 3.0, 2.1, 0.0 ) ),
             list( ctlpt( E3, 4.1, 0.0, 1.0 ),
                   ctlpt( E3, 4.3, 1.0, 0.0 ),
                   ctlpt( E3, 4.0, 2.0, 1.0 ) ) );
sb = sbspline( 3, 3, spts, list( list( KV_OPEN ), list( KV_OPEN ) ) );
color( sb, red );
attrib( sb, "width", 0.001 );

TCrv1 = cbspline( 2,
                  list( ctlpt( E2, 0.3, 0.3 ),
                        ctlpt( E2, 0.7, 0.3 ),
                        ctlpt( E2, 0.7, 0.7 ),
                        ctlpt( E2, 0.3, 0.7 ),
                        ctlpt( E2, 0.3, 0.3 ) ),
                  list( KV_OPEN ) );
TCrv2 = circle( vector( 0.5, 0.5, 0.0 ), 0.25 );
TCrv3 = cbspline( 3,
                  list( ctlpt( E2, 0.3, 0.3 ),
                        ctlpt( E2, 0.7, 0.3 ),
                        ctlpt( E2, 0.7, 0.7 ),
                        ctlpt( E2, 0.3, 0.7 ) ),
                  list( KV_PERIODIC ) );

TSrf1 = TRIMSRF( sb, TCrv1, false );
TSrf2 = TRIMSRF( sb, TCrv1, true );
TSrf3 = TRIMSRF( sb, list( TCrv1, TcRv2 * ty( 1 ), TCrv3 * ty( 2 ) ),
                  false );
color( TSrf1, green );
attrib( TSrf1, "width", 0.012 );
color( TSrf2, green );
attrib( TSrf2, "width", 0.012 );
color( TSrf3, green );
attrib( TSrf3, "width", 0.012 );

Tr = rotz( 90 ) * rotx( 30 ) * roty( 30 ) * sc( 0.25 );

All = list( list( sb, TSrf1 ) * Tr * trans( vector( -0.6, -0.6, 0.0 ) ),
	    list( sb, TSrf2 ) * Tr * trans( vector(  0.0, -0.6, 0.0 ) ),
	    list( sb, TSrf3 ) * Tr * trans( vector(  0.6, -0.6, 0.0 ) ) );

view( All, on );
save( "trimsrf", All );


#############################################################################

b = tsbezier( 3,
	      list( ctlpt( E3, 0.0,  0.0,  0.4 ),
                    ctlpt( E3, 0.3,  0.0,  0.3 ),
                    ctlpt( E3, 0.7,  0.0,  0.8 ),

                    ctlpt( E3, 0.2,  0.4,  1.0 ),
                    ctlpt( E3, 0.4,  0.5,  1.0 ),

                    ctlpt( E3, 0.5,  1.0,  0.7 ) ) )
	* rx( 70 ) * tx( -0.2 );
color( b, green );
attrib( b, "width", 0.02 );
view( b, on );
save( "tsbezier", b );

#############################################################################
resolution = 16;

T = TORUS( vector( 0.0, 0.0, 0.0), vector( 0.0, 0.0, 1.0), 0.5, 0.2 );
attrib( T, "width", 0.012 );

All = list( T * scale( vector( 0.75, 0.75, 0.75 ) ),
	    axes * scale( vector( 0.25, 0.25, 0.25 ) ) )
	* rotx( -90 ) * roty( 40 ) * rotx( -30 )
	* trans( vector( -0.0, -0.4, 0.0 ) );
view( All, on );
save( "torus", All );

resolution = save_res;

#############################################################################

resolution = 20;
B = box(vector(-1, -1, -0.25), 2, 1.2, 0.5);
C = con2(vector(0, 0, -1.5), vector(0, 0, 3), 0.7, 0.3);

D = convex(B - C);
E = convex(C - B);
F = convex(B + C);
G = convex(B * C);
attrib( D, "width", 0.015 );
attrib( E, "width", 0.015 );
attrib( F, "width", 0.015 );
attrib( G, "width", 0.015 );

tr = rotx( -90 ) * roty( 40 ) * rotx( -30 );

All = list( D * tr * trans( vector(  0.6,  0.5, 0.0 ) ),
	    E * tr * trans( vector(  3.0,  0.0, 0.0 ) ),
	    F * tr * trans( vector( -2.0,  0.0, 0.0 ) ),
	    G * tr * trans( vector(  0.7, -1.0, 0.0 ) ) )
	* scale( vector( 0.25, 0.25, 0.25 ) )
	* trans( vector( -0.1, -0.3, 0.0 ) );
view( All, on );
view_mat = rotx( 0 );
save( "booleans", list( view_mat, All ) );

#############################################################################
#
# CGS examples
#

b1 = box(vector(-0.6, -0.3, 0.0), 1.2, 0.6, 0.6);
c1 = cylin(vector(0.0, -0.25, 0.59), vector(0.0, 0.5, 0.0), 0.55);
s1 = convex(b1 + c1);

b2 = box(vector(-0.4, -0.4, -0.1), 0.8, 0.8, 0.35);
s2 = convex(s1 - b2);

c2 = cylin(vector(0.0, -0.4, 0.595), vector(0.0, 0.8, 0.0), 0.3);
s3 = convex(s2 - c2);

trans_mat = rotz( 40 ) * rotx( -70 ) * scale( vector( 0.3, 0.3, 0.3 ) );
Obj = list( b1 * trans_mat * trans( vector( -0.7, -0.9, 0.0 ) ),
	    c1 * trans_mat * trans( vector( -0.1, -0.9, 0.0 ) ),
	    s1 * trans_mat * trans( vector( -0.4, -0.3, 0.0 ) ),
	    b2 * trans_mat * trans( vector(  0.2, -0.3, 0.0 ) ),
	    s2 * trans_mat * trans( vector( -0.1,  0.3, 0.0 ) ),
	    c2 * trans_mat * trans( vector(  0.5,  0.3, 0.0 ) ),
	    s3 * trans_mat * trans( vector(  0.2,  0.9, 0.0 ) ) );
attrib( Obj, "width", 0.01 );

edge2d = function( x1, y1, x2, y2 ):
    return = ctlpt( E2, x1, y1 ) + ctlpt( E2, x2, y2 );

Lines = list( edge2d( -0.6, -0.65, -0.5, -0.4 ),
	      edge2d( -0.2, -0.55, -0.3, -0.35 ),
	      edge2d( -0.3, 0.05, -0.25, 0.2 ),
	      edge2d(  0.1, -0.16, -0.05, 0.25 ),
	      edge2d(  0.0, 0.65, 0.1, 0.8 ),
	      edge2d(  0.4, 0.6, 0.3, 0.85 ) );
attrib( Lines, "width", 0.01 );

All = list( Lines, Obj ) * scale( vector( 0.7, 0.7, 0.7 ) );
view_mat = rotx( 0 );

view( All, on );
save( "csg", All );

#############################################################################
#
# Trivariate - COVERISO and MRCHCUBE
#

ThreeCyls = tbspline( 4, 4, 4,
	list( list( list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 1 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ) ),
	      list( list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 1 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ) ),
	      list( list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 1 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 1 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 1 ),
	                  ctlpt( E1, 1 ),
	                  ctlpt( E1, 1 ),
	                  ctlpt( E1, 1 ),
	                  ctlpt( E1, 1 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 1 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 1 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ) ),
	      list( list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 1 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ) ),
	      list( list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 1 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ),
	            list( ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ),
	                  ctlpt( E1, 0 ) ) ) ),
	list( list( 0, 0, 0, 0, 2, 4, 4, 4, 4 ),
	      list( 0, 0, 0, 0, 2, 4, 4, 4, 4 ),
	      list( 0, 0, 0, 0, 2, 4, 4, 4, 4 ) ) );
attrib( ThreeCyls, "color", red );

RefList = list( 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8,
	        2.2, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8 );

ThreeCyls = trefine( trefine( trefine( ThreeCyls, row, false, RefList ),
			      col, false, RefList ),
		     depth, false, RefList );
free( RefList );

IsoVal = 0.12;

Srf1 = mrchcube( list( ThreeCyls, 1, TRUE ), point( 1, 1, 1 ), 1, IsoVal )
		  * sc( 0.04 ) * tx( -0.4 ) * ty( -0.5 ) * rx( 40 ) * ry( 30 );
color( Srf1, red );
view( Srf1, 1 );
save( "mrchcube", Srf1 );

Cover1 = CoverIso( ThreeCyls, 500, 1, vector( 3, 10, 1.0 ), 0.2, IsoVal )
		  * sc( 0.04 ) * tx( -0.4 ) * ty( -0.5 ) * rx( 40 ) * ry( 30 );
color( Cover1, yellow );
view( Cover1, 1 );
save( "coveriso", Cover1 );

#############################################################################
#
# Three cubes in robust Booleans
#

length = 1;

angle = 10;
b1 = box( vector( -length / 2, -length / 2, -length / 2 ),
          length, length, length );
b2 = box( vector( 0, -length / 2, -length / 2 ),
          length, length, length ) * rotx( angle );
attrib( b1, "width", 0.0001 );
attrib( b2, "width", 0.0001 );
b12a = b1 * b2;
attrib( b12a, "width", 0.01 );
color( b12a, green );
All = list( b1, b2, b12a ) * rx( 60 ) * ry( 30 ) * sc( 0.7 ) * rz( 90 );
view( All, 1 );
save( "cubes1", All );

angle = 1;
b1 = box( vector( -length / 2, -length / 2, -length / 2 ),
          length, length, length );
b2 = box( vector( 0, -length / 2, -length / 2 ),
          length, length, length ) * rotx( angle );
attrib( b1, "width", 0.0001 );
attrib( b2, "width", 0.0001 );
b12b = b1 * b2;
attrib( b12b, "width", 0.01 );
color( b12b, green );
All = list( b1, b2, b12b ) * rx( 60 ) * ry( 30 ) * sc( 0.7 ) * rz( 90 );
view( All, 1 );
save( "cubes2", All );

angle = 0.1;
b1 = box( vector( -length / 2, -length / 2, -length / 2 ),
          length, length, length );
b2 = box( vector( 0, -length / 2, -length / 2 ),
          length, length, length ) * rotx( angle );
attrib( b1, "width", 0.0001 );
attrib( b2, "width", 0.0001 );
b12c = b1 * b2;
attrib( b12c, "width", 0.01 );
color( b12c, green );
All = list( b1, b2, b12c ) * rx( 60 ) * ry( 30 ) * sc( 0.7 ) * rz( 90 );
view( All, 1 );
save( "cubes3", All );

#############################################################################
#
# We are going to use these models for figures...
#
# We redefine pause so we will not puase...
#
view_mat = rotx( 0 );
save("view0mat", list( view_mat ) );

pause = procedure():
    printf("Press return to continue:", nil());

include("../../scripts/solid1.irt");
include("../../scripts/solid2h.irt");
include("../../scripts/molecule.irt");
include("../../scripts/platonic.irt");

#############################################################################
#
# Point coverate for solid1
#
Solid1 = load("solid1");
Pts = CoverPt( Solid1, 1000 );
All = list( Solid1, Pts );

view( All, 1 );
save( "coverpt", All );

free( Solid1 );
free( Pts );

#############################################################################


view_mat = save_mat_docs * roty( 5 ) * rotx( 10 )
	   * scale( vector( 0.35, 0.35, 0.35 ) );
save("view1mat", list( view_mat ) );

view_mat = save_mat_docs * roty( 5 ) * rotx( 10 )
	   * scale( vector( 0.8, 0.8, 0.8 ) );
save("view2mat", list( view_mat ) );

pause = procedure():t:
    printf("Press return to continue:", nil()):
    t = getline(string_type);

#############################################################################

exit();
