home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 11 / CDACTUAL11.iso / cdactual / demobin / share / os2 / IRIT50 / SCRIPTS / FREEFORM.IRT < prev    next >
Encoding:
Text File  |  1994-12-17  |  22.3 KB  |  793 lines
  1. #
  2. # Some routines to test surface/curve operators
  3. #
  4.  
  5. #
  6. # Set states.
  7. #
  8. iritstate("InterpProd", off);
  9.  
  10.  
  11. #
  12. # Set display to on to view some results, off to view nothing.
  13. #
  14. display = on;
  15.  
  16. #
  17. # Control the surface to polygons subdivison resolution, and isolines gen.
  18. #
  19. save_res = resolution;
  20.  
  21. if ( machine == msdos, resolution = 5, resolution = 20 );
  22.  
  23. s45 = sin( pi / 4 );
  24.  
  25. #  
  26. # Circular constructors
  27. #
  28.  
  29. circ = circle( vector( 0.25, 0.5, 0.5 ), 1.5 );
  30. circ = creparam( circ, 0.0, 1.0 );
  31. arc1 = arc( vector( 0.0, 0.0, 0.0 ),
  32.         vector( 0.5, 2.0, 0.0 ),
  33.         vector( 1.0, 0.0, 0.0 ) );
  34. arc2 = arc( vector( 0.0, 0.0, 0.0 ),
  35.         vector( 0.0, 2.0, 0.5 ),
  36.         vector( 0.0, 0.0, 1.0 ) );
  37.  
  38. iritState("DumpLevel", 9);
  39. pdomain( circ );
  40. iritState("DumpLevel", 1);
  41.  
  42. if ( display == on, interact( list( axes, circ, arc1, arc2 ) ) );
  43.  
  44. #
  45. # Piecewise linear approximation to a curve using ceval:
  46. #
  47. cb_all = nil();
  48. for ( t = 0.0, 0.05, 1.0,
  49.     cb = ceval( circ, t ):
  50.     snoc( cb, cb_all )
  51.     );
  52. cb_crv = creparam( cbspline( 2, cb_all, list( KV_OPEN ) ), 0.0, 2.0 );
  53. color( cb_crv, yellow );
  54. if ( display == on, interact( list( cb_crv, circ, axes ) ) );
  55. free( cb_crv ); free( cb_all ); free( cb );
  56.  
  57. #
  58. # Ruled surface constructor examples.
  59. #
  60. arc3 = arc( vector( 0.0,  0.0, 1.0 ),
  61.         vector( 0.5, -0.2, 1.0 ),
  62.         vector( 1.0,  0.0, 1.0 ) );
  63. ruled = ruledsrf( arc3,
  64.           ctlpt( E2, 0.0, 0.0 ) + ctlpt( E2, 1.0, 0.0 ) );
  65.  
  66. iritState("DumpLevel", 9);
  67. pdomain( ruled );
  68. iritState("DumpLevel", 1);
  69.  
  70. if ( display == on, interact( list( axes, ruled ) ) );
  71. free( ruled );
  72.  
  73. circ = circle( vector( 0.0, 0.0, 0.0 ), 0.25 );
  74. cyl = ruledsrf( circ, circ*trans( vector( 0.0, 0.0, 1.0 ) ) );
  75. if ( display == on, interact( list( axes, cyl ) ) );
  76. free( cyl );
  77.  
  78. skewcyl = ruledsrf( circ, circ*trans( vector( 0.2, 0.0, 1.0 ) ) );
  79. if ( display == on, interact( list( axes, skewcyl ) ) );
  80. free( skewcyl );
  81.  
  82. skew2cyl = ruledsrf( circ*rotx( 20 ),
  83.              circ*rotx( -20 )* trans( vector( 0.0, 0.0, 1.0 ) ) );
  84. if ( display == on, interact( list( axes, skew2cyl ) ) );
  85. free( skew2cyl );
  86.  
  87. free( arc1 ); free( arc2 ); free( arc3 ); free( circ );
  88.  
  89. #
  90. # Curve constructors.
  91. #
  92. crv1 = ctlpt( E3, 0.5, 0.0, 1.0 ) +
  93.        ctlpt( P3, 1.0, 0.5, 0.0, 1.2 ) +  # Note ctlpts can be different type.
  94.        ctlpt( E3, 1.0, 0.0, 1.2 );
  95. crv2 = crv1 +
  96.        arc( vector( 1.0,  0.0, 0.75 ),
  97.         vector( 0.75, 0.0, 0.7 ),
  98.         vector( 0.5,  0.0, 0.85 ) ) +
  99.        arc( vector( 0.5,  0.0, 0.75 ),
  100.         vector( 0.75, 0.0, 0.8 ),
  101.         vector( 1.0,  0.0, 0.65 ) );
  102. crv3 = crv2 +
  103.        crv2 * trans( vector( -0.5, 0.15, -0.5 ) ) +
  104.        crv2 * trans( vector( -1.0, 0.3,  -1.0 ) );
  105.  
  106. if ( display == on, interact( list( axes, crv3 ) ):
  107.             viewstate("FinrAprx"):
  108.             pause():
  109.             viewstate("CrsrAprx") );
  110.  
  111. free( crv1 ); free( crv2 ); free( crv3 );
  112.  
  113. cross = arc( vector( 0.2, 0.0, 0.0 ),
  114.          vector( 0.2, 0.2, 0.0 ),
  115.          vector( 0.0, 0.2, 0.0 ) ) +
  116.     arc( vector( 0.0, 0.4, 0.0 ),
  117.          vector( 0.1, 0.4, 0.0 ),
  118.          vector( 0.1, 0.5, 0.0 ) ) +
  119.     arc( vector( 0.8, 0.5, 0.0 ),
  120.          vector( 0.8, 0.3, 0.0 ),
  121.          vector( 1.0, 0.3, 0.0 ) ) +
  122.     arc( vector( 1.0, 0.1, 0.0 ),
  123.          vector( 0.9, 0.1, 0.0 ),
  124.          vector( 0.9, 0.0, 0.0 ) ) +
  125.     ctlpt( E2, 0.2, 0.0 );
  126. if ( display == on, interact( list( axes, cross ) ) );
  127.  
  128. #
  129. # Curves and surfaces convertions and compatibility.
  130. #
  131. crv1 = cbezier( list( ctlpt( E2, -1, 0 ),
  132.               ctlpt( E3,  0, 2, 0 ),
  133.               ctlpt( E2,  1, 0 ) ) );
  134. crv2 = cbspline( 4,
  135.          list( ctlpt( P3,  1.0,  0.0, 0.1,  1.0 ),
  136.                ctlpt( P3,  s45, -s45, 1.0,  s45 ),
  137.                ctlpt( P2,  1.0,  1.0, 0.1 ),
  138.                ctlpt( P3,  s45, -s45, 1.0, -s45 ),
  139.                ctlpt( P3,  1.0,  0.0, 0.1, -1.0 ) ),
  140.          list( KV_OPEN ) );
  141. color( crv1, yellow );
  142. color( crv2, yellow );
  143.  
  144. crv1bsp = bzr2bsp( crv1 );
  145. color( crv1bsp, green );
  146. crv2bzr = bsp2bzr( crv2 );
  147. color( crv2bzr, green );
  148. if ( display == on, interact( list( crv1bsp, crv1, crv2bzr, crv2 ) ) );
  149. free( crv1bsp );
  150. free( crv2bzr );
  151.  
  152. if ( display == on, interact( list( crv1, crv2 ) ) );
  153. ffcompat( crv1, crv2 );
  154. if ( display == on, interact( list( crv1, crv2 ) ) );
  155.  
  156. srf1 = sbezier( list( list( ctlpt( E2, 0.0, 0.0 ),
  157.                     ctlpt( E2, 0.0, 1.0 ),
  158.                     ctlpt( E3, 0.0, 2.0, 0.5 ) ),
  159.                   list( ctlpt( E2, 1.0, 0.0 ),
  160.                     ctlpt( E2, 1.0, 1.0 ),
  161.                     ctlpt( E3, 1.0, 2.0, -0.5 ) ) ) );
  162. srf2 = sbspline( 2, 4,
  163.          list( list( ctlpt( E3, 0.0, 0.0, 1.0 ),
  164.                      ctlpt( E2, 0.0, 1.0 ),
  165.                      ctlpt( E3, 0.0, 2.0, 1.0 ) ),
  166.                    list( ctlpt( E2, 1.0, 0.0 ),
  167.                      ctlpt( E3, 1.0, 1.0, 2.0 ),
  168.                      ctlpt( E2, 1.0, 2.0 ) ),
  169.                    list( ctlpt( E3, 2.0, 0.0, 2.0 ),
  170.                      ctlpt( E2, 2.0, 1.0 ),
  171.                      ctlpt( E3, 2.0, 2.0, 2.0 ) ),
  172.                    list( ctlpt( E2, 3.0, 0.0 ),
  173.                      ctlpt( E3, 3.0, 1.0, 2.0 ),
  174.                      ctlpt( E2, 3.0, 2.0 ) ),
  175.                    list( ctlpt( E3, 4.0, 0.0, 1.0 ),
  176.                      ctlpt( E2, 4.0, 1.0 ),
  177.                      ctlpt( E3, 4.0, 2.0, 1.0 ) ) ),
  178.          list( list( KV_OPEN ),
  179.                list( KV_OPEN ) ) );
  180. srf2 = sreparam( sreparam( srf2, row, 0.0, 1.0 ), col, 0.0, 1.0 );
  181.  
  182. color( srf1, yellow );
  183. color( srf2, yellow );
  184.  
  185. srf1bsp = bzr2bsp( srf1 );
  186. color( srf1bsp, green );
  187. srf2bzr = bsp2bzr( srf2 );
  188. color( srf2bzr, green );
  189. if ( display == on, interact( list( srf1bsp, srf1, srf2bzr, srf2 ) ) );
  190. free( srf1bsp );
  191. free( srf2bzr );
  192.  
  193. if ( display == on, interact( list( srf1, srf2 ) ) );
  194. ffcompat( srf1, srf2 );
  195. if ( display == on, interact( list( srf1, srf2 ) ) );
  196.  
  197. #
  198. # Create floating end condition examples (although barely used!).
  199. #
  200. viewstate( "DSrfMesh" );
  201. crv1f = cbspline( 4, 
  202.           list( ctlpt( E2, 0.0, 0.0 ),
  203.              ctlpt( E2, 1.0, 1.0 ),
  204.                 ctlpt( E2, 0.0, 2.0 ),
  205.                     ctlpt( E2, 1.0, 0.0 ) ),
  206.           list( KV_FLOAT ) );
  207. color( crv1f, yellow );
  208. if ( display == on, view( crv1f, on ):
  209.             viewstate("DSrfMesh"):
  210.             pause():
  211.             viewstate("DSrfMesh"):
  212.             pause() );
  213.  
  214. srf1f = sbspline( 2, 4,
  215.           list( list( ctlpt( E3, 0.0, 0.0, 1.0 ),
  216.                       ctlpt( E3, 0.0, 1.0, 0.0 ),
  217.                       ctlpt( E3, 0.0, 2.0, 1.0 ) ),
  218.                     list( ctlpt( E3, 1.0, 0.0, 0.0 ),
  219.                       ctlpt( E3, 1.0, 1.0, 2.0 ),
  220.                       ctlpt( E3, 1.0, 2.0, 0.0 ) ),
  221.                     list( ctlpt( E3, 2.0, 0.0, 2.0 ),
  222.                       ctlpt( E3, 2.0, 1.0, 0.0 ),
  223.                       ctlpt( E3, 2.0, 2.0, 2.0 ) ),
  224.                     list( ctlpt( E3, 3.0, 0.0, 0.0 ),
  225.                       ctlpt( E3, 3.0, 1.0, 2.0 ),
  226.                       ctlpt( E3, 3.0, 2.0, 0.0 ) ),
  227.                     list( ctlpt( E3, 4.0, 0.0, 1.0 ),
  228.                       ctlpt( E3, 4.0, 1.0, 0.0 ),
  229.                       ctlpt( E3, 4.0, 2.0, 1.0 ) ) ),
  230.           list( list( KV_FLOAT ),
  231.                 list( KV_FLOAT ) ) );
  232. color( srf1f, yellow );
  233. if ( display == on, view( srf1f, on ):
  234.             viewstate("DSrfMesh"):
  235.             pause():
  236.             viewstate("DSrfMesh"):
  237.             pause() );
  238.  
  239. free(crv1f);
  240. free(srf1f);
  241. viewstate( "DSrfMesh" );
  242.  
  243. #
  244. # Direct control points manipulation.
  245. #
  246. cb = cbezier( list( ctlpt( E3, -1, 0, 0 ),
  247.             ctlpt( E3,  0, 0, 0 ),
  248.             ctlpt( E3,  1, 0, 0 ) ) );
  249.  
  250. cb_all = list( axes );
  251. for ( z = -0.9, 0.3, 0.9,
  252.     cb1 = ceditpt( cb, ctlpt( E3, 0, 0, z ), 1 ):
  253.     color( cb1, green ):
  254.     snoc( cb1, cb_all )
  255.     );
  256. if ( display == on, interact( cb_all ) );
  257. free( cb_all ); free( cb ); free( cb1 );
  258.  
  259. sb = ruledSrf( cbezier( list( ctlpt( E3, -0.5, -0.5, 0.0 ),
  260.                   ctlpt( E3,  0.5, -0.5, 0.0 ) ) ),
  261.            cbezier( list( ctlpt( E3, -0.5,  0.5, 0.0 ),
  262.                   ctlpt( E3,  0.5,  0.5, 0.0 ) ) ) );
  263. sb = sraise( sraise( sb, row, 3 ),
  264.          col, 3 );
  265. sb = srefine( srefine( sb, row, false, list( 0.333, 0.667 ) ),
  266.           col, false, list( 0.333, 0.667 ) );
  267. sb_all = list( axes );
  268. for ( z = -0.9, 0.6, 0.9,
  269.     sb1 = seditpt( sb, ctlpt( E3, 0, 0, z ), 2, 2 ):
  270.     color( sb1, green ):
  271.     snoc( sb1, sb_all )
  272.     );
  273. if ( display == on, interact( sb_all ) );
  274. free( sb_all ); free( sb ); free( sb1 );
  275.  
  276. #
  277. # Curve order raise:
  278. #
  279. cb = cbezier( list( ctlpt( E2, -1, 0 ),
  280.             ctlpt( E2,  0, 2 ),
  281.             ctlpt( E2,  1, 0 ) ) );
  282.  
  283. cb_all = list( axes, cb );
  284. for ( o = 4, 1, 8,
  285.     cb1 = craise( cb, o ):
  286.     color( cb1, green ):
  287.     snoc( cb1, cb_all )
  288.     );
  289. if ( display == on, view( cb_all, on ):
  290.             viewstate("DSrfMesh"):
  291.             pause():
  292.             viewstate("DSrfMesh"):
  293.             pause() );
  294. free( cb_all ); free( cb ); free( cb1 );
  295.  
  296. #
  297. # Extrusion examples.
  298. #
  299. cbzr = cbezier( list( ctlpt( E2, 0.0, 0.0 ),
  300.               ctlpt( E2, 1.0, 0.0 ),
  301.               ctlpt( E2, 1.0, 1.0 ) ) );
  302. color( cbzr, white );
  303.  
  304. s = extrude( cbzr, vector( 0.0, 0.0, 1.0 ) );
  305.  
  306. if ( display == on, interact( list( axes, s, cbzr ) ) );
  307. free( cbzr ); free( s );
  308.  
  309. s = extrude( cross, vector( 0.0, 0.0, 1.0 ) );
  310. if ( display == on, interact( list( axes, s ) ) );
  311.  
  312. s = extrude( cross, vector( 0.1, 0.2, 1.0 ) );
  313. if ( display == on, interact( list( axes, s ) ) );
  314.  
  315. resolution = 10;
  316. ps = gpolygon( s, off );
  317. if ( display == on, interact( list( axes, ps ) ) );
  318. free( ps );
  319. free( s );
  320.  
  321. if ( machine == msdos, resolution = 5, resolution = 20 );
  322.  
  323. #
  324. # Srf of revolution examples
  325. #
  326.  
  327. cbzr = cbezier( list( ctlpt( E3, 0.0, 0.0, 0.0 ),
  328.               ctlpt( E3, 1.0, 0.0, 0.0 ),
  329.               ctlpt( E3, 1.0, 0.0, 1.0 ) ) );
  330. color( cbzr, white );
  331.  
  332. sb = surfrev( cbzr );
  333.  
  334. if ( display == on, interact( list( sb, cbzr ) ) );
  335.  
  336. halfcirc = cbspline( 3,
  337.              list( ctlpt( P3, 1.0,  0.0, 0.0,  1.0 ),
  338.                    ctlpt( P3, s45, -s45, 0.0,  s45 ),
  339.                    ctlpt( P3, 1.0, -1.0, 0.0,  0.0 ),
  340.                    ctlpt( P3, s45, -s45, 0.0, -s45 ),
  341.                ctlpt( P3, 1.0,  0.0, 0.0, -1.0 ) ),
  342.              list( 0, 0, 0, 1, 1, 2, 2, 2 ) );
  343. color( halfcirc, white );
  344.  
  345. sp = surfrev( halfcirc );
  346.  
  347. if ( display == on, interact( list( sp, halfcirc ) ) );
  348.  
  349. gcross = cbspline( 3,
  350.            list( ctlpt( E3, 0.3, 0.0, 0.0 ),
  351.                  ctlpt( E3, 0.3, 0.0, 0.05 ),
  352.                  ctlpt( E3, 0.1, 0.0, 0.05 ),
  353.                  ctlpt( E3, 0.1, 0.0, 0.4 ),
  354.                  ctlpt( E3, 0.5, 0.0, 0.4 ),
  355.                  ctlpt( E3, 0.6, 0.0, 0.8 ) ),
  356.            list( 0, 0, 0, 1, 2, 3, 4, 4, 4 ) );
  357. color( gcross, white );
  358. glass = surfrev( gcross );
  359. if ( display == on, interact( list( axes, glass, gcross ) ) );
  360.  
  361. #
  362. # Sweep examples.
  363. #
  364. ccross = cross * trans( vector( -0.5, -0.25, 0.0 ) )
  365.                * scale( vector( 0.2, 0.2, 0.2 ) );
  366.  
  367. sweep_axis = crefine( cbspline( 3,
  368.                     list( ctlpt( E3,  0.0,  1.0, 1.0 ),
  369.                       ctlpt( E3,  1.0,  1.0, 1.0 ),
  370.                       ctlpt( E3,  1.0, -1.0, 0.0 ),
  371.                       ctlpt( E3, -1.0, -1.0, 0.0 ),
  372.                       ctlpt( E3, -1.0,  1.0, 1.0 ),
  373.                       ctlpt( E3,  0.0,  1.0, 1.0 ) ),
  374.                     list( KV_OPEN ) ),
  375.               false,
  376.               list( 0.5, 1.5, 2.5, 3.5 ) );
  377.  
  378. arc1 = arc( vector( 1.0, 0.0, 0.0 ),
  379.         vector( 0.0, 0.0, 0.0 ),
  380.         vector( 0.0, 1.0, 0.0 ) );
  381. s = sweepsrf( ccross, arc1, off );
  382. if ( display == on, interact( list( axes, s ) ) );
  383.  
  384. arc1 = arc( vector( -1.0, 0.0, 0.0 ),
  385.         vector( 0.0, 0.0, 0.1 ),
  386.         vector( 1.0, 0.0, 0.0 ) );
  387. arc1 = crefine( arc1, false, list( 0.25, 0.5, 0.75 ) );
  388. scalecrv = cbezier( list( ctlpt( E2, 0.0, 0.1 ),
  389.                          ctlpt( E2, 1.0, 0.5 ),
  390.                          ctlpt( E2, 2.0, 0.1 ) ) );
  391. s = swpsclsrf( ccross * scale( vector( 6, 6, 6 ) ), arc1, scalecrv, off, 1 );
  392. if ( display == on, interact( list( axes, s ) ) );
  393.  
  394. circ = circle( vector( 0.0, 0.0, 0.0 ), 1.0 );
  395.  
  396. s = sweepsrf( circ * scale( vector( 0.25, 0.25, 1.0 ) ), circ, off );
  397. if ( display == on, interact( list( axes, s ) ) );
  398.  
  399. resolution = 10;
  400. ps = gpolygon( s, off );
  401. if ( display == on, interact( list( axes, ps ) ) );
  402. ps = gpolygon( s, on );
  403. if ( display == on, interact( list( axes, ps ) ) );
  404. free( ps );
  405.  
  406. if ( machine == msdos, resolution = 5, resolution = 20 );
  407.  
  408. s = swpsclsrf( circ, circ, scalecrv, off, 1 );
  409. if ( display == on, interact( list( axes, s ) ) );
  410.  
  411. s = swpsclsrf( ccross, sweep_axis, 1.0, off, 0 );
  412. if ( display == on, interact( list( axes, s ) ) );
  413.  
  414. s = swpsclsrf( ccross, sweep_axis, 1.0, vector( 0.0, 0.0, 1.0 ), 0 );
  415. if ( display == on, interact( list( axes, s ) ) );
  416.  
  417. s = swpsclsrf( ccross, circle( vector( 0.0, 0.0, 0.0 ), 1.0 ), 1.0,
  418.            circle( vector( 0.0, 0.0, 1.0 ), -1.0 ), 0 );
  419. if ( display == on, interact( list( axes, s ) ) );
  420.  
  421. free( ccross );
  422. free( circ );
  423. free( arc1 );
  424.  
  425. Cross = arc( vector( -0.11, -0.1,  0.0 ),
  426.              vector( -0.1,  -0.1,  0.0 ),
  427.              vector( -0.1,  -0.11, 0.0 ) ) +
  428.         arc( vector(  0.1,  -0.11, 0.0 ),
  429.              vector(  0.1,  -0.1,  0.0 ),
  430.              vector(  0.11, -0.1,  0.0 ) ) +
  431.         arc( vector(  0.11,  0.1,  0.0 ),
  432.              vector(  0.1,   0.1,  0.0 ),
  433.              vector(  0.1,   0.11, 0.0 ) ) +
  434.         arc( vector( -0.1,   0.11, 0.0 ),
  435.              vector( -0.1,   0.1,  0.0 ),
  436.              vector( -0.11,  0.1,  0.0 ) ) +
  437.         ctlpt( E2, -0.11, -0.1 );
  438. scaleCrv = cbspline( 3,
  439.                      list( ctlpt( E2, 0.05, 1.0 ),
  440.                            ctlpt( E2, 0.1,  0.0 ),
  441.                            ctlpt( E2, 0.2,  2.0 ),
  442.                            ctlpt( E2, 0.3,  0.0 ),
  443.                            ctlpt( E2, 0.4,  2.0 ),
  444.                            ctlpt( E2, 0.5,  0.0 ),
  445.                            ctlpt( E2, 0.6,  2.0 ),
  446.                            ctlpt( E2, 0.7,  0.0 ),
  447.                            ctlpt( E2, 0.8,  2.0 ),
  448.                            ctlpt( E2, 0.85, 1.0 ) ),
  449.                      list( KV_OPEN ) );
  450. Axis = circle( vector( 0, 0, 0 ), 1 );
  451. Frame = circle( vector( 0, 0, 0 ), 1 ) *
  452.         rotx( 90 ) * trans( vector( 1.5, 0.0, 0.0 ) );
  453.  
  454. s = swpsclsrf( Cross, Axis, scaleCrv, off, 0 );
  455. if ( display == on, interact( list( axes, s ) ) );
  456.  
  457. s = swpsclsrf( Cross, Axis, scaleCrv, off, 2 );
  458. if ( display == on, interact( list( axes, s ) ) );
  459.  
  460. s = swpsclsrf( Cross, Axis, 1.0, Frame, 0 );
  461. if ( display == on, interact( list( axes, s ) ) );
  462.  
  463. free( cross );
  464.  
  465. #
  466. # Periodic curves and surfaces.
  467. #
  468. cPer = cbspline( 4,
  469.          list( ctlpt( E2, -1, -1 ),
  470.                ctlpt( E2, -1,  1 ),
  471.                ctlpt( E2,  1,  1 ),
  472.                ctlpt( E2,  1, -1 ) ),
  473.          list( KV_PERIODIC ) );
  474. color( cPer, red );
  475. if ( display == on, view( cPer, on ) );
  476.  
  477. s = extrude( cPer, vector( 0.0, 0.0, 1.0 ) );
  478. if ( display == on, interact( list( axes, s, cper ) ) );
  479.  
  480. s = swpsclsrf( cPer, Axis, 0.1, off, 0 );
  481. if ( display == on, interact( list( axes, s, cper ) ) );
  482.  
  483. s = swpsclsrf( cPer * scale( vector( 0.2, 0.2, 0.2 ) ),
  484.            Axis, ScaleCrv, off, 2 );
  485. if ( display == on, interact( list( axes, s, cper ) ) );
  486.  
  487. free( cper );
  488. free( s );
  489.  
  490. #
  491. # Boolean sum examples.
  492. #
  493. cbzr1 = cbezier( list( ctlpt( E3, -0.2,  0.1,  0.5 ),
  494.                ctlpt( E3,  0.0,  0.5,  1.0 ),
  495.                ctlpt( E3,  0.1,  1.0, -0.2 ) ) );
  496. cbzr2 = cbezier( list( ctlpt( E3,  1.0,  0.0, -0.3 ),
  497.                ctlpt( E3,  0.8,  0.5, -1.0 ),
  498.                ctlpt( E3,  1.0,  1.0,  0.2 ) ) );
  499. cbzr3 = cbezier( list( ctlpt( E3, -0.2,  0.1,  0.5 ),
  500.                ctlpt( E3,  0.5,  0.0, -1.0 ),
  501.                ctlpt( E3,  1.0,  0.0, -0.3 ) ) );
  502. cbzr4 = cbezier( list( ctlpt( E3,  0.1,  1.0, -0.2 ),
  503.                ctlpt( E3,  0.5,  1.0,  1.0 ),
  504.                ctlpt( E3,  1.0,  1.0,  0.2 ) ) );
  505.  
  506. s = boolsum( cbzr1, cbzr2, cbzr3, cbzr4 );
  507. color(s, green);
  508. if ( display == on, interact( list( axes, s, cbzr1, cbzr2, cbzr3, cbzr4 ) ) );
  509.  
  510. cbzr1 = cbezier( list( ctlpt( E3, -0.1,  0.1,  0.2 ),
  511.                ctlpt( E3,  0.0,  0.5,  1.0 ),
  512.                ctlpt( E3,  0.1,  1.0,  0.2 ) ) );
  513. cbzr2 = cbezier( list( ctlpt( E3,  1.0,  0.2, -0.1 ),
  514.                ctlpt( E3,  1.0,  0.5, -1.0 ),
  515.                ctlpt( E3,  1.1,  1.1,  0.1 ) ) );
  516. cbzr3 = cbezier( list( ctlpt( E3, -0.1,  0.1,  0.2 ),
  517.                ctlpt( E3,  0.2,  0.1, -1.0 ),
  518.                ctlpt( E3,  0.4,  0.0,  2.0 ),
  519.                ctlpt( E3,  0.5, -0.1, -1.0 ),
  520.                ctlpt( E3,  1.0,  0.2, -0.1 ) ) );
  521. cbzr4 = cbezier( list( ctlpt( E3,  0.1,  1.0,  0.2 ),
  522.                ctlpt( E3,  0.5,  0.8,  1.0 ),
  523.                ctlpt( E3,  0.7,  0.9, -2.0 ),
  524.                ctlpt( E3,  0.8,  1.0,  1.0 ),
  525.                ctlpt( E3,  1.1,  1.1,  0.1 ) ) );
  526. s = boolsum( cbzr1, cbzr2, cbzr3, cbzr4 );
  527. color(s, green);
  528. if ( display == on, interact( list( axes, s, cbzr1, cbzr2, cbzr3, cbzr4 ) ) );
  529.  
  530. cbzr1 = cbezier( list( ctlpt( E3, 0.1, 0.1, 0.1 ),
  531.                ctlpt( E3, 0.0, 0.5, 1.0 ),
  532.                ctlpt( E3, 0.4, 1.0, 0.4 ) ) );
  533. cbzr2 = cbezier( list( ctlpt( E3, 1.0, 0.2, 0.2 ),
  534.                ctlpt( E3, 1.0, 0.5, -1.0 ),
  535.                ctlpt( E3, 1.0, 1.0, 0.3 ) ) );
  536. cbsp3 = cbspline( 4,
  537.           list( ctlpt( E3, 0.1,  0.1, 0.1 ),
  538.                 ctlpt( E3, 0.25, 0.0, -1.0 ),
  539.                 ctlpt( E3, 0.5,  0.0, 2.0 ),
  540.                 ctlpt( E3, 0.75, 0.0, -1.0 ),
  541.                 ctlpt( E3, 1.0,  0.2, 0.2 ) ),
  542.           list( KV_OPEN ) );
  543. cbsp4 = cbspline( 4,
  544.           list( ctlpt( E3, 0.4,  1.0, 0.4 ),
  545.                 ctlpt( E3, 0.25, 1.0, 1.0 ),
  546.                 ctlpt( E3, 0.5,  1.0, -2.0 ),
  547.                 ctlpt( E3, 0.75, 1.0, 1.0 ),
  548.                 ctlpt( E3, 1.0,  1.0, 0.3 ) ),
  549.           list( KV_OPEN ) );
  550.  
  551. s = boolsum( cbzr1, cbzr2, cbsp3, cbsp4 );
  552. color(s, green);
  553. if ( display == on, interact( list( axes, s, cbzr1, cbzr2, cbsp3, cbsp4 ) ) );
  554.  
  555. free( cbzr1 ); free( cbzr2 ); free( cbzr3 ); free( cbzr4 );
  556. free( cbsp3 ); free( cbsp4 );
  557.  
  558. #
  559. # Boolean one examples.
  560. #
  561. s = boolone( circle( vector( 0.0, 0.0, 0.0 ), 1.0 ) );
  562. color(s, green);
  563. if ( display == on, interact( list( axes, s ) ) );
  564.  
  565. c1 = ctlpt( E3, 0, 0, 0.5 ) +
  566.      ctlpt( E3, 1, 0, 0 ) +
  567.      ctlpt( E3, 1, 1, 0.5 ) +
  568.      ctlpt( E3, 0, 1, 0 ) +
  569.      ctlpt( E3, 0, 0, 0.5 );
  570. s = boolone( c1 );
  571. color(s, green);
  572. if ( display == on, interact( list( axes, s, c1 ) ) );
  573.  
  574. #
  575. # Surface from curves constructor.
  576. #
  577. c1 = cbspline( 3,
  578.            list( ctlpt( E3, 0.0, 0.0, 0.0 ),
  579.              ctlpt( E3, 1.0, 0.0, 0.0 ),
  580.              ctlpt( E3, 1.0, 1.0, 0.0 ) ),
  581.            list( KV_OPEN ) );
  582. c2 = cbspline( 3,
  583.            list( ctlpt( E3, 0.0, 0.0, 1.0 ),
  584.              ctlpt( E3, 1.0, 0.0, 1.0 ),
  585.              ctlpt( E3, 1.0, 2.0, 1.0 ) ),
  586.            list( KV_OPEN ) );
  587. c3 = cbspline( 3,
  588.            list( ctlpt( E3, 0.0, 0.0, 1.5 ),
  589.              ctlpt( E3, 2.0, 0.0, 1.5 ),
  590.              ctlpt( E3, 1.0, 0.5, 1.5 ),
  591.              ctlpt( E3, 1.0, 1.0, 1.5 ) ),
  592.            list( KV_OPEN ) );
  593. c4 = cbspline( 3,
  594.            list( ctlpt( E3, 0.0, 0.0, 2.5 ),
  595.              ctlpt( E3, 1.0, 0.0, 2.5 ),
  596.              ctlpt( E3, 1.0, 1.0, 2.5 ) ),
  597.            list( KV_OPEN ) );
  598.  
  599. s = sfromcrvs( list( c1, c2, c3, c4 ), 2 );
  600. color( s, green );
  601. if ( display == on, interact( list( s, c1, c2, c3, c4 ) ) );
  602. s = sfromcrvs( list( c1, c2, c3, c4 ), 4 );
  603. color( s, green );
  604. if ( display == on, interact( list( s, c1, c2, c3, c4 ) ) );
  605. free( c1 ); free( c2 ); free( c3 ); free( c4 );
  606.  
  607. #
  608. # Offset and adaptive, with global tolerance, aoffset.
  609. #
  610. cpawn = cbspline( 4,
  611.     list( ctlpt( E2, 0.95, 0.05 ),
  612.           ctlpt( E2, 0.95, 0.76 ),
  613.           ctlpt( E2, 0.30, 1.52 ),
  614.           ctlpt( E2, 0.30, 1.90 ),
  615.           ctlpt( E2, 0.50, 2.09 ),
  616.           ctlpt( E2, 0.72, 2.24 ),
  617.           ctlpt( E2, 0.72, 2.32 ),
  618.           ctlpt( E2, 0.38, 2.50 ),
  619.           ctlpt( E2, 0.42, 2.70 ),
  620.           ctlpt( E2, 0.57, 2.81 ),
  621.           ctlpt( E2, 0.57, 3.42 ),
  622.           ctlpt( E2, 0.19, 3.57 ),
  623.           ctlpt( E2, 0.00, 3.57 ) ),
  624.      list( KV_OPEN ) );
  625. c1 = offset(cpawn, 0.5, 0.05, off);
  626. color(c1, magenta);
  627. c2 = aoffset(cpawn, 0.5, 0.05, false, off);
  628. color(c2, green);
  629. c3 = aoffset(cpawn, 0.5, 0.05, true, off);
  630. color(c3, yellow);
  631. c4 = loffset(cpawn, 0.5, 100, 20, 4);
  632. color(c4, cyan);
  633. if ( display == on, interact( list( c1, c2, c3, c4, cpawn ) ) );
  634. free(c1);
  635. free(c2);
  636. free(c3);
  637. free(c4);
  638.  
  639. #
  640. # Zero set of curves and inflection points
  641. #
  642. cbsp = list( ctlpt( E2, 1.0, 1.0 ),
  643.          ctlpt( E2,-1.0, 1.0 ),
  644.          ctlpt( E2,-1.0,-1.0 ),
  645.          ctlpt( E2, 1.5, 1.0 ),
  646.          ctlpt( E2,-1.0,-1.4 ),
  647.          ctlpt( E2, 1.0, 0.1 ) );
  648. cb = cbspline( 4, cbsp, list( KV_OPEN ) );
  649.  
  650. xzeros = czeros( cb, 0.001, 1 );
  651. pt_xzeros = nil();
  652. pt = nil();
  653. for ( i = 1, 1, sizeof( xzeros ),
  654.     pt = ceval( cb, nth( xzeros, i ) ):
  655.     snoc( pt, pt_xzeros )
  656.     );
  657. if ( display == on, interact( list( axes, cb, pt_xzeros ) ) );
  658. free(xzeros);
  659. free(pt_xzeros);
  660.  
  661. yzeros = czeros( cb, 0.001, 2 );
  662. pt_yzeros = nil();
  663. pt = nil();
  664. for ( i = 1, 1, sizeof( yzeros ),
  665.     pt = ceval( cb, nth( yzeros, i ) ):
  666.     snoc( pt, pt_yzeros )
  667.     );
  668. if ( display == on, interact( list( axes, cb, pt_yzeros ) ) );
  669. free(yzeros);
  670. free(pt_yzeros);
  671.  
  672. xextremes = cextremes( cb, 0.001, 1 );
  673. pt_xextremes = nil();
  674. pt = nil();
  675. for ( i = 1, 1, sizeof( xextremes ),
  676.     pt = ceval( cb, nth( xextremes, i ) ):
  677.     snoc( pt, pt_xextremes )
  678.     );
  679. if ( display == on, interact( list( axes, cb, pt_xextremes ) ) );
  680. free(xextremes);
  681. free(pt_xextremes);
  682.  
  683. yextremes = cextremes( cb, 0.001, 2 );
  684. pt_yextremes = nil();
  685. pt = nil();
  686. for ( i = 1, 1, sizeof( yextremes ),
  687.     pt = ceval( cb, nth( yextremes, i ) ):
  688.     snoc( pt, pt_yextremes )
  689.     );
  690. if ( display == on, interact( list( axes, cb, pt_yextremes ) ) );
  691. free(yextremes);
  692. free(pt_yextremes);
  693.  
  694. inflect = cinflect( cb, 0.001 );
  695. pt_inflect = nil();
  696. pt = nil();
  697. for ( i = 1, 1, sizeof( inflect ),
  698.     pt = ceval( cb, nth( inflect, i ) ):
  699.     snoc( pt, pt_inflect )
  700.     );
  701. if ( display == on, interact( list( axes, cb, pt_inflect ) ) );
  702. free(inflect);
  703. free(pt_inflect);
  704.  
  705. #
  706. # Computation of extremum of curvature for curves
  707. #
  708. crv = cbezier( list( ctlpt( E3, -0.5,  0.5,  0.5 ),
  709.              ctlpt( E3, -0.5, -0.6,  0.5 ),
  710.              ctlpt( E3,  0.0,  1.0, -1.0 ),
  711.              ctlpt( E3,  0.5, -0.5,  0.5 ) ) );
  712.  
  713. crvtr = ccrvtr( crv, 0.001 );
  714. pt_crvtr = nil();
  715. pt = nil();
  716. for ( ( i = 1 ), 1, sizeof( crvtr ),
  717.     (
  718.       ( pt = ceval( crv, nth( crvtr, i ) ) ):
  719.       snoc( pt, pt_crvtr )
  720.     )
  721.     );
  722. if ( display == on, interact( list( crv, pt_crvtr ) ) );
  723.  
  724. crv = cbspline( 4,
  725.         list( ctlpt( E2, -1.0,  0.5 ),
  726.               ctlpt( E2,  0.0,  0.5 ),
  727.               ctlpt( E2,  0.0,  0.0 ),
  728.               ctlpt( E2, -1.0, -1.0 ),
  729.               ctlpt( E2,  1.0, -1.0 ),
  730.               ctlpt( E2,  1.0, -0.7 ),
  731.               ctlpt( E2,  0.0,  1.0 ),
  732.               ctlpt( E2,  1.0,  1.0 ) ),
  733.         list( KV_OPEN ) );
  734.  
  735. crvtr = ccrvtr( crv, 0.001 );
  736. pt_crvtr = nil();
  737. pt = nil();
  738. for ( ( i = 1 ), 1, sizeof( crvtr ),
  739.     (
  740.       ( pt = ceval( crv, nth( crvtr, i ) ) ):
  741.       snoc( pt, pt_crvtr )
  742.     )
  743.     );
  744. if ( display == on, interact( list( crv, pt_crvtr ) ) );
  745.  
  746. #
  747. # Computation of evolute curves
  748. #
  749. pl = nil();
  750. for ( x = 0, 1, 20,
  751.     snoc(point(cos(x * Pi / 10),
  752.            sin(x * Pi / 10),
  753.            0), pl)
  754.     );
  755.  
  756. #
  757. # Evolute of a very crude approximation of a circle
  758. #
  759. crv = cinterp( pl, 3, 4, PARAM_UNIFORM );
  760. cev = cevolute( crv );
  761. color( cev, red );
  762. color( crv, green );
  763. if ( display == on, interact( list( crv, cev ) ) );
  764.  
  765. #
  766. # Better approximation of a circle (evolute should degen. to a point if exact)
  767. #
  768. crv = cinterp( pl, 3, 8, PARAM_UNIFORM );
  769. cev = cevolute( crv );
  770. color( cev, red );
  771. color( crv, green );
  772. if ( display == on, interact( list( crv, cev ) ) );
  773.  
  774. #
  775. # And an evolute of a space curve.
  776. #
  777. crv = cbspline( 3,
  778.         list( ctlpt( E3, -1.0,  0.1,  0.2 ),
  779.               ctlpt( E3, -0.1,  1.0,  0.1 ),
  780.               ctlpt( E3,  0.1,  0.1,  1.0 ),
  781.               ctlpt( E3,  1.0,  0.1,  0.1 ),
  782.               ctlpt( E3,  0.1,  1.0,  0.2 ) ),
  783.         list( KV_OPEN ) );
  784. cev = cevolute( crv );
  785. color( cev, red );
  786. color( crv, green );
  787. if ( display == on, interact( list( crv, cev ) ) );
  788.  
  789. display = off;
  790.  
  791. resolution = save_res;
  792.  
  793.