def dominos(path, scl, piecetimestep): retval = irit.nil() animtime = 0 dominopiece = irit.box( (-0.01, -0.006, 0), 0.02, 0.006, 0.05) * irit.sc(scl) rot_x = irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, 80 ) ) ) crvdomain = irit.pdomain(path) t = irit.FetchRealObject(irit.nth(crvdomain, 1)) dpath = irit.cderive(path) while (t < irit.FetchRealObject(irit.nth(crvdomain, 2))): d = irit.Fetch3TupleObject( irit.coerce(irit.ceval(dpath, t), irit.POINT_TYPE)) dlen = math.sqrt(DotProd(d, d)) rot_x = irit.creparam(rot_x, animtime, animtime + piecetimestep) irit.attrib(dominopiece, "animation", irit.list(rot_x)) irit.setname(irit.getattr(dominopiece, "animation"), 0, "rot_x") dp = dominopiece * irit.rz( -math.atan2(d[0], d[1]) * 180 / math.pi) * irit.trans( irit.Fetch3TupleObject( irit.coerce(irit.ceval(path, t), irit.VECTOR_TYPE))) irit.snoc(dp, retval) t = t + 0.04 * scl / dlen animtime = animtime + piecetimestep * 0.6 return retval
def createcubicbezier(x1, y1, x2, y2, x3, y3): x1 = x1 / 1000.0 y1 = y1 / 1000.0 x2 = x2 / 1000.0 y2 = y2 / 1000.0 x3 = x3 / 1000.0 y3 = y3 / 1000.0 retval = irit.cbezier( irit.list( irit.ctlpt( irit.E2, x1, y1 ), \ irit.ctlpt( irit.E2, x1 + ( x2 - x1 ) * 2/3.0, y1 + ( y2 - y1 ) * 2/3.0 ), \ irit.ctlpt( irit.E2, x3 + ( x2 - x3 ) * 2/3.0, y3 + ( y2 - y3 ) * 2/3.0 ), \ irit.ctlpt( irit.E2, x3, y3 ) ) ) return retval
s45 = math.sin(math.pi / 4) helixaux = irit.cbspline( 3, irit.list( irit.ctlpt( irit.P3, 1, 1, 0, 0 ), \ irit.ctlpt( irit.P3, s45, s45, s45, 0.2 * s45 ), \ irit.ctlpt( irit.P3, 1, 0, 1, 0.4 ), \ irit.ctlpt( irit.P3, s45, (-s45 ), s45, 0.6 * s45 ), \ irit.ctlpt( irit.P3, 1, (-1 ), 0, 0.8 ), \ irit.ctlpt( irit.P3, s45, (-s45 ), (-s45 ), 1 * s45 ), \ irit.ctlpt( irit.P3, 1, 0, (-1 ), 1.2 ), \ irit.ctlpt( irit.P3, s45, s45, (-s45 ), 1.4 * s45 ), \ irit.ctlpt( irit.P3, 1, 1, 0, 1.6 ) ), irit.list( 0, 0, 0, 1, 1, 2,\ 2, 3, 3, 4, 4, 4 ) ) helixapx = (helixaux + helixaux * irit.trans( (0, 0, 1.6)) + helixaux * irit.trans((0, 0, 3.2))) scalecrv = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, 0.01 ), \ irit.ctlpt( irit.E2, 1, 1 ) ) ) srf4 = irit.swpsclsrf( irit.circle( ( 0, 0, 0 ), 0.8 ), helixapx, scalecrv, irit.GenRealObject(0), 0 ) * \ irit.scale( ( 0.2, 0.2, 0.2 ) ) * irit.trans( ( 0, 0, baselvl ) ) irit.free(helixaux) irit.free(helixapx) irit.free(scalecrv) irit.color(srf4, irit.MAGENTA) # # Must make them compatible before doing some morphing.
# # Examples of constructing uniform point distributions on freeforms. # # Gershon Elber, August 1996. # save_mat = irit.GetViewMatrix() irit.SetViewMatrix( irit.rotx( 0 )) irit.viewobj( irit.GetViewMatrix() ) # # Some examples for curves. # c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-1 ), 0 ), \ irit.ctlpt( irit.E2, (-1 ), 0.1 ), \ irit.ctlpt( irit.E2, (-0.9 ), (-0.1 ) ), \ irit.ctlpt( irit.E2, 0.9, 0 ) ) ) irit.color( c1, irit.MAGENTA ) pts = irit.ffptdist( c1, 0, 1000 ) e2pts = irit.nil( ) i = 1 while ( i <= irit.SizeOf( pts ) ): pt = irit.ceval( c1, irit.FetchRealObject(irit.coord( irit.nth( pts, i ), 0 ) )) irit.snoc( pt, e2pts ) i = i + 10 irit.interact( irit.list( e2pts, c1 ) ) irit.save( "ffptdst1", irit.list( e2pts, c1 ) ) pts = irit.ffptdist( c1, 1, 1000 )
res = "successful" else: res = "failed" all3 = irit.list(irit.nth(bb, 1), irit.nth(bb, 2), res) irit.printf("projection on srf2nrml bound from %8.5lf to %8.5lf (%s)\n", all3) irit.pause() retval = irit.list(all1, all2, all3) return retval # ############################################################################ crv1a = irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0.2 ), \ irit.ctlpt( irit.E2, 0.5, 4 ), \ irit.ctlpt( irit.E2, 1.3, 0.05 ) ) ) * irit.sy( 0.2 ) crv2a = irit.cbezier( irit.list( \ irit.ctlpt( irit.E1, (-0.2 ) ), \ irit.ctlpt( irit.E2, 0.25, 1.9 ), \ irit.ctlpt( irit.E2, 1.3, 0.05 ) ) ) * irit.ty( 0.3 ) * irit.sx( 1.5 ) crv1b = irit.cbezier( irit.list( \ irit.ctlpt( irit.E2, 0.2, (-0.5 ) ), \ irit.ctlpt( irit.E2, 0.5, 4 ), \ irit.ctlpt( irit.E2, 1.3, (-0.45 ) ) ) ) * irit.sy( 0.2 ) crv2b = irit.cbezier( irit.list( \ irit.ctlpt( irit.E2, (-0 ), (-0.5 ) ), \ irit.ctlpt( irit.E2, 0.25, 1.09 ), \ irit.ctlpt( irit.E2, 1.1, (-0.5 ) ) ) ) * irit.ty( 0.3 ) * irit.sx( 1.5 ) irit.save( "dist2ff1",
# # Set states. # save_mat = irit.GetViewMatrix() irit.SetViewMatrix(irit.GetViewMatrix() * irit.sc(0.35)) irit.viewobj(irit.GetViewMatrix()) # Faster product using Bezier decomposition. iprod = irit.iritstate("bspprodmethod", irit.GenIntObject(0)) # ############################################################################ # # A point and a line in the XY plane # c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-0.3 ), (-1 ) ), \ irit.ctlpt( irit.E2, (-0.3 ), 1 ) ) ) pt2 = irit.point(0.4, 0.2, 0) irit.color(c1, irit.RED) irit.adwidth(c1, 3) irit.color(pt2, irit.RED) irit.adwidth(pt2, 3) t = 0 while (t <= 1): bisectcrv = irit.calphasector(irit.list(c1, pt2), t) irit.color(bisectcrv, irit.GREEN) irit.view(irit.list(c1, pt2, bisectcrv), irit.ON) t = t + 0.03 irit.save( "asect2d1",
# A simple example of curve morphing. # # Gershon Elber, July 1994. # # # Sets the viewing direction on the display device. # save_mat = irit.GetViewMatrix() irit.SetViewMatrix( irit.rotx( 0 )) irit.viewobj( irit.GetViewMatrix() ) irit.SetViewMatrix( save_mat) # ############################################################################ crv1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0.3, 0 ), \ irit.ctlpt( irit.E2, 0, 0.5 ), \ irit.ctlpt( irit.E2, (-0.2 ), 0 ) ) ) crv1a = crv1 * irit.trans( ( (-0.4 ), 0, 0 ) ) crv1b = crv1a * irit.scale( ( (-1 ), 1, 1 ) ) irit.color( crv1a, irit.GREEN ) irit.color( crv1b, irit.GREEN ) irit.view( irit.list( crv1a, crv1b ), irit.ON ) i = 0 while ( i <= 300 ): c = irit.cmorph( crv1a, crv1b, 0, i/300.0 ) irit.color( c, irit.YELLOW ) irit.view( irit.list( crv1a, crv1b, c ), irit.ON ) i = i + 1 crvs = irit.cmorph( crv1a, crv1b, 2, 0.005 )
# Blend on a (polynomial approximation of a) sphere using BlSHermite # with scaling curves: # sclcrv = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E1, 0.01 ), \ irit.ctlpt( irit.E1, 0.4 ), \ irit.ctlpt( irit.E1, 0.01 ), \ irit.ctlpt( irit.E1, 0.4 ), \ irit.ctlpt( irit.E1, 0.01 ), \ irit.ctlpt( irit.E1, 0.4 ), \ irit.ctlpt( irit.E1, 0.01 ), \ irit.ctlpt( irit.E1, 0.4 ) ), irit.list( irit.KV_PERIODIC ) ) sclcrv = irit.coerce(sclcrv, irit.KV_OPEN) s1 = (-irit.blshermite( s, irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, 0.9 ), \ irit.ctlpt( irit.E2, 2, 0.9 ), \ irit.ctlpt( irit.E2, 4, 0.9 ) ) ), csec2, 1, irit.GenRealObject(0.2),\ sclcrv * irit.sc( 5 ) ) ) irit.color(s1, irit.RED) s2 = (-irit.blshermite( s, irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, 1.5 ), \ irit.ctlpt( irit.E2, 2, 1.5 ), \ irit.ctlpt( irit.E2, 4, 1.5 ) ) ), csec2, 0.7, sclcrv * irit.sc( 0.35 ) * irit.tx( 0.2 ), irit.GenRealObject(1.5) ) ) irit.color(s2, irit.GREEN) s3 = (-irit.blshermite( s, irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, 0.4 ), \ irit.ctlpt( irit.E2, 2, 0.4 ), \ irit.ctlpt( irit.E2, 4, 0.4 ) ) ), csec2, 0.5, sclcrv * irit.sc( 0.3 ) * irit.tx( 0.12 ), sclcrv * irit.sc( 3 ) ) ) irit.color(s3, irit.YELLOW) irit.free(sclcrv)
# # Set states. # save_mat = irit.GetViewMatrix() irit.SetViewMatrix(irit.sc(1)) irit.viewobj(irit.GetViewMatrix()) # Faster product using Bezier decomposition iprod = irit.iritstate("bspprodmethod", irit.GenRealObject(0)) # ############################################################################ # # Example 0 - Two simple open curves # c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-0.441758 ), (-0.503296 ) ), \ irit.ctlpt( irit.E2, 0.560439, (-0.516483 ) ) ) ) * irit.ty( 0.3 ) c2 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0.608924, (-0.358027 ) ), \ irit.ctlpt( irit.E2, 0.164947, (-0.371462 ) ), \ irit.ctlpt( irit.E2, 0.173393, 0.881714 ), \ irit.ctlpt( irit.E2, 0.107802, (-0.37589 ) ), \ irit.ctlpt( irit.E2, (-0.507619 ), (-0.363037 ) ) ) ) * irit.ty( 0.3 ) irit.view(irit.list(c1, c2), irit.ON) voronoi = irit.cvoronoicell(irit.list(c1, c2)) irit.color(voronoi, irit.GREEN) irit.attrib(voronoi, "width", irit.GenRealObject(0.005)) irit.interact(irit.list(c1, c2, voronoi))
z = 5 while (z <= 6.5): tmpbody = tmpbody ^ irit.box((7.9, 0.1, z), 1, 0.4, 0.05) z = z + 0.2 z = 1 while (z <= 6.5): tmpbody = tmpbody ^ irit.box((7.95, 4.3, z), 1, 0.6, 0.05) z = z + 0.3 base = base / tmpbody stopper = irit.box((6.85, 2.05, 7.37), 0.9, 0.9, 0.13) rot_y = irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, (-80 ) ) ) ) trns = irit.trans(((-7.75), 0, (-7.45))) irit.attrib(stopper, "animation", irit.list(trns, rot_y, trns ^ (-1))) irit.free(rot_y) irit.free(trns) # # Top round. # topround = irit.poly( lj8samplecurve( irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, (-0.7 ), 7.5 ), \ irit.ctlpt( irit.E3, 0, 2.5, 8 ), \ irit.ctlpt( irit.E3, 0, 5.7, 7.5 ) ) ), 10 ) + irit.list( ( 0, 5.7, 7.2 ), ( 0, 5.2, 7.2 ), irit.point( 0, 4.9, 6.8 ), irit.point( 0, 4.9, 6 ), irit.point( 0, 0.1, 6 ), irit.point( 0, 0.1, 6.3 ), irit.point( 0, (-0.2 ), 6.3 ), irit.point( 0, (-0.7 ), 7.1 ) ), 0 ) topround = irit.extrude(topround, (2, 0, 0), 3) * irit.tx(0.001) irit.SetResolution(4)
irit.ctlpt( irit.E3, 0.3, 1, 0 ), \ irit.ctlpt( irit.E3, 0, 2, 1 ) ), irit.list( \ irit.ctlpt( irit.E3, 1.1, 0, 0 ), \ irit.ctlpt( irit.E3, 1.3, 1.5, 2 ), \ irit.ctlpt( irit.E3, 1, 2.1, 0 ) ), irit.list( \ irit.ctlpt( irit.E3, 2.1, 0, 2 ), \ irit.ctlpt( irit.E3, 2.3, 1, 0 ), \ irit.ctlpt( irit.E3, 2, 2, 2 ) ), irit.list( \ irit.ctlpt( irit.E3, 3.1, 0, 0 ), \ irit.ctlpt( irit.E3, 3.3, 1.5, 2 ), \ irit.ctlpt( irit.E3, 3, 2.1, 0 ) ), irit.list( \ irit.ctlpt( irit.E3, 4.1, 0, 1 ), \ irit.ctlpt( irit.E3, 4.3, 1, 0 ), \ irit.ctlpt( irit.E3, 4, 2, 1 ) ) ) cb = irit.cbezier(cbzr) * irit.scale((0.7, 1.4, 1)) irit.color(cb, irit.RED) sb = irit.sbezier(sbzr) irit.color(sb, irit.RED) irit.save( "bezier1", irit.list(irit.fforder(cb), irit.ffmsize(cb), irit.ffctlpts(cb), irit.fforder(sb), irit.ffmsize(sb), irit.ffctlpts(sb))) if (display == 1): irit.interact(irit.list(irit.GetAxes(), cb, sb)) irit.viewstate("dsrfmesh", 1) irit.pause()
i = 1 while (i <= c): t = irit.coord(irit.coord(irit.nth(tmp, i), deg), 1) tmp2 = irit.nth(tmp3, i) * irit.sc(irit.FetchRealObject(t)) irit.snoc(irit.coerce(tmp2, irit.E1), net) i = i + 1 retval = irit.ffmerge(net, ptype) return retval # ######################################################################## # # Matching a curve along a shared boundary between two surfaces. # c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, 0 ), \ irit.ctlpt( irit.E2, 1, 1 ), \ irit.ctlpt( irit.E2, 2, 0 ), \ irit.ctlpt( irit.E2, 4, 1 ) ) ) irit.awidth(c1, 0.02) r1 = irit.coerce( irit.cpower( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, 0.25 ), \ irit.ctlpt( irit.E1, 0.75 ) ) ), irit.BEZIER_TYPE ) r2 = irit.coerce( irit.cpower( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, 1.5 ), \ irit.ctlpt( irit.E1, (-0.5 ) ) ) ), irit.BEZIER_TYPE ) c1a = irit.compose(c1, r1) c2a = irit.compose(c1, r2) s1 = irit.sfromcrvs( irit.list(c1a * irit.ty(1) * irit.tz(3),
baseunit1 = baseunit irit.color(baseunit1, irit.RED) baseunit2 = baseunit * irit.tx(1.175) irit.color(baseunit2, irit.GREEN) baseunit3 = baseunit * irit.rx(180) * irit.rz(90) irit.color(baseunit3, irit.CYAN) baseunit4 = baseunit3 * irit.ty(1.175) irit.color(baseunit4, irit.MAGENTA) irit.free(baseunit) rot_x = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, 360 ) ) ), 0, 1 ) rot_y = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, 720 ) ) ), 0, 1 ) rot_z = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, 360 ) ) ), 0, 1 ) mov_x = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, (-1.5 ) ) ) ), 3, 4 ) mov_z = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, 2 ) ) ), 1, 2 ) irit.attrib(baseunit1, "animation", irit.list(rot_x, rot_y, rot_z, mov_x, mov_z)) irit.free(mov_x) irit.free(mov_z) mov_x = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
pt = irit.point(0, 2, 0) irit.adwidth(pt, 3) irit.color(pt, irit.YELLOW) bisect = irit.sbisector(s, irit.Fetch3TupleObject(pt)) irit.color(bisect, irit.CYAN) irit.save("sbisect2", irit.list(s, pt, bisect)) irit.interact(irit.list(s, pt, bisect)) # ############################################################################ # # A quadratic surface # s2 = irit.sfromcrvs( irit.list( irit.cbezier( irit.list( irit.ctlpt( irit.E3, (-1 ), (-1 ), 0 ), \ irit.ctlpt( irit.E3, (-1 ), 0, 0.1 ), \ irit.ctlpt( irit.E3, (-1 ), 1, 0 ) ) ), irit.cbezier( irit.list( \ irit.ctlpt( irit.E3, 0, (-1 ), 0.1 ), \ irit.ctlpt( irit.E3, 0, 0, (-0.8 ) ), \ irit.ctlpt( irit.E3, 0, 1, 0.1 ) ) ), irit.cbezier( irit.list( \ irit.ctlpt( irit.E3, 1, (-1 ), 0 ), \ irit.ctlpt( irit.E3, 1, 0, 0.1 ), \ irit.ctlpt( irit.E3, 1, 1, 0 ) ) ) ), 3, irit.KV_OPEN ) irit.color(s2, irit.RED) pt = irit.point(0, 0, 1) irit.adwidth(pt, 3) irit.color(pt, irit.YELLOW) bisect = irit.sbisector(s2, irit.Fetch3TupleObject(pt)) irit.color(bisect, irit.CYAN)
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # This file existance is justified to demonstrate loops on free form trans.: # save_mat = irit.GetViewMatrix() irit.SetViewMatrix( irit.GetViewMatrix() * irit.scale( ( 0.7, 0.7, 0.7 ) ) ) cbzr = irit.cbezier( irit.list( irit.ctlpt( irit.P3, 1, 0, 0, 0 ), \ irit.ctlpt( irit.P3, 0.707, 0.707, 0, 0 ), \ irit.ctlpt( irit.P3, 1, 1, 1, 0 ) ) ) sbzr = irit.sbezier( irit.list( irit.list( irit.ctlpt( irit.E3, 0, 0, 0.5 ), \ irit.ctlpt( irit.E3, 0, 0.5, (-1 ) ), \ irit.ctlpt( irit.E3, 0, 1, 0.5 ) ), irit.list( \ irit.ctlpt( irit.E3, 0.5, 0, (-0.5 ) ), \ irit.ctlpt( irit.E3, 0.5, 0.5, 1 ), \ irit.ctlpt( irit.E3, 0.5, 1, (-0.5 ) ) ), irit.list( \ irit.ctlpt( irit.E3, 1, 0, 0.5 ), \ irit.ctlpt( irit.E3, 1, 0.5, (-1 ) ), \ irit.ctlpt( irit.E3, 1, 1, 0.5 ) ) ) ) rot10x = irit.rotx( 10 ) rot10y = irit.roty( 10 ) rot10z = irit.rotz( 10 )
vtail1 = irit.ruledsrf( c2, c1 ) vtail2 = irit.ruledsrf( c3, c2 ) if ( do_texture == 1 ): irit.attrib( vtail1, "texture", texture ) irit.attrib( vtail1, "rgb", irit.GenStrObject(redcolor) ) irit.color( vtail1, irit.RED ) if ( do_texture == 1 ): irit.attrib( vtail2, "texture", texture ) irit.attrib( vtail2, "rgb", irit.GenStrObject(redcolor) ) irit.color( vtail2, irit.RED ) irit.free( c1 ) irit.free( c2 ) irit.free( c3 ) vtailtop = irit.swpsclsrf( irit.circle( ( 0, 0, 0 ), 0.1 ), irit.cbezier( irit.list( irit.ctlpt( irit.E3, 10.732, 0, 2.048 ), \ irit.ctlpt( irit.E3, 10.972, 0, 2.048 ), \ irit.ctlpt( irit.E3, 11.212, 0, 2.048 ) ) ), irit.cbezier( irit.list( \ irit.ctlpt( irit.E2, 0, 0.01 ), \ irit.ctlpt( irit.E2, 0.5, 1 ), \ irit.ctlpt( irit.E2, 1, 0.01 ) ) ), irit.GenIntObject(0), 1 ) if ( do_texture == 1 ): irit.attrib( vtailtop, "texture", texture ) irit.attrib( vtailtop, "rgb", irit.GenStrObject(redcolor) ) irit.color( vtailtop, irit.RED ) vtailpara = irit.swpsclsrf( irit.circle( ( 0, 0, 0 ), 0.075 ), irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 9.15, 0, 0.6 ), \ irit.ctlpt( irit.E3, 9.5, 0, 0.6 ), \ irit.ctlpt( irit.E3, 9.9, 0, 0.6 ), \ irit.ctlpt( irit.E3, 10.7, 0, 0.6 ), \ irit.ctlpt( irit.E3, 10.8, 0, 0.6 ), \ irit.ctlpt( irit.E3, 10.85, 0, 0.6 ), \
aaa = int(irit.FetchRealObject(irit.nth(res, 1)) == val) print title + " test - " + str(aaa) # # Line # line = irit.circle((0.1, 0.7, 3), math.pi) printtest("line", irit.isgeom(line, irit.GEOM_LINEAR, 1e-010), 0) line = ( irit.ctlpt( irit.E3, (-2 ), 10, (-5 ) ) + \ irit.ctlpt( irit.E3, 1, (-2 ), 3 ) ) printtest("line", irit.isgeom(line, irit.GEOM_LINEAR, 1e-010), 1) line = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 1, (-2 ) ), \ irit.ctlpt( irit.E3, 1, 1, (-2 ) ), \ irit.ctlpt( irit.E3, 4, 1, (-2 ) ) ) ) printtest("line", irit.isgeom(line, irit.GEOM_LINEAR, 1e-010), 1) line = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 1, (-2 ) ), \ irit.ctlpt( irit.E3, 1, 2, (-2 ) ), \ irit.ctlpt( irit.E3, 4, 1, (-2 ) ) ) ) printtest("line", irit.isgeom(line, irit.GEOM_LINEAR, 1e-010), 0) # # Circle # printtest("circle", irit.isgeom(line, irit.GEOM_CIRCULAR, 0.001), 0) circ = irit.circle((0.1, 0.7, 3), math.pi) printtest("circle", irit.isgeom(circ, irit.GEOM_CIRCULAR, 1e-010), 1)
irit.color(iso, irit.RED) irit.adwidth(iso, 3) irit.color(pt, irit.CYAN) irit.adwidth(pt, 6) irit.color(bisrf, irit.MAGENTA) irit.view(irit.list(c1, c2, bisrf, iso, pt), irit.ON) # ############################################################################ # # Two linear curves # b = 0 while (b <= 1): c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, (-2.1 ), (-b ) ), \ irit.ctlpt( irit.E3, 0, (-2.1 ), b ) ) ) c2 = irit.cbezier( irit.list( \ irit.ctlpt( irit.E3, (-b ), 2.1, 0 ), \ irit.ctlpt( irit.E3, b, 2.1, 0 ) ) ) bisectsrf = irit.cbisector3d(irit.list(c1, c2), 1) display(c1, c2, bisectsrf) b = b + 0.01 * speed b = 2 while (b <= 0): c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, (-0.1 ) - b, (-1 ) ), \ irit.ctlpt( irit.E3, 0, (-0.1 ) - b, 1 ) ) ) c2 = irit.cbezier( irit.list( \ irit.ctlpt( irit.E3, (-1 ), 0.1 + b, 0 ), \ irit.ctlpt( irit.E3, 1, 0.1 + b, 0 ) ) ) bisectsrf = irit.cbisector3d(irit.list(c1, c2), 1)
irit.logfile(fname + "_" + "loffset") irit.logfile(1) i = 0 while (i <= steps): c = irit.offset(crv, dist, t, 1) c = irit.loffset(crv, dist, 300, irit.SizeOf(c), 4) computeerror(crv, irit.abs(dist), c) t = t * math.sqrt(0.1) i = i + 1 irit.logfile(0) # ############################################################################ bez = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-0.95 ), 0.7 ), \ irit.ctlpt( irit.E2, (-0.3 ), 0.5 ), \ irit.ctlpt( irit.E2, 0.3, (-2.5 ) ), \ irit.ctlpt( irit.E2, 0.9, (-0.2 ) ) ) ) bez_off = irit.loffset(bez, 0.5, 300, 64, 4) irit.attrib(bez_off, "width", irit.GenRealObject(0.02)) irit.save("bez_0.4_off", irit.list(bez, bez_off)) cmpoffalltols(bez, "bez_0.4", 0.4, 1, 6) cpawn = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E2, 0.95, 0.05 ), \ irit.ctlpt( irit.E2, 0.95, 0.76 ), \ irit.ctlpt( irit.E2, 0.3, 1.52 ), \ irit.ctlpt( irit.E2, 0.3, 1.9 ), \ irit.ctlpt( irit.E2, 0.5, 2.09 ), \ irit.ctlpt( irit.E2, 0.72, 2.24 ), \ irit.ctlpt( irit.E2, 0.72, 2.32 ), \ irit.ctlpt( irit.E2, 0.38, 2.5 ), \
i = 1 while (i <= n): pt = irit.coerce(irit.ceval(crv, t), irit.POINT_TYPE) nrml = irit.coerce(irit.cnormal(crv, t), irit.VECTOR_TYPE) irit.snoc( irit.coerce(pt - nrml * len, irit.E2) + irit.coerce(pt + nrml * len, irit.E2), retval) t = t + dt i = i + 1 return retval # ############################################################################ c1 = irit.cbezier( irit.list( irit.ctlpt( irit.P2, 1, 0, 0 ), \ irit.ctlpt( irit.P2, 1, 0, 1 ), \ irit.ctlpt( irit.P2, 1, 1, 1 ), \ irit.ctlpt( irit.P2, 1, 1, 0 ) ) ) irit.color(c1, irit.RED) c1tags = tagcurve(c1, 10, 0.02) irit.color(c1tags, irit.RED) c2 = irit.cbezier( irit.list( irit.ctlpt( irit.P2, 0.5, 0, 0 ), \ irit.ctlpt( irit.P2, 1, 0, 1 ), \ irit.ctlpt( irit.P2, 2, 2, 2 ), \ irit.ctlpt( irit.P2, 4, 4, 0 ) ) ) irit.color(c2, irit.GREEN) c2tags = tagcurve(c2, 10, 0.02) irit.color(c2tags, irit.GREEN) c3 = irit.cbezier( irit.list( irit.ctlpt( irit.P2, 0.25, 0, 0 ), \ irit.ctlpt( irit.P2, 1, 0, 1 ), \
irit.adwidth(c1, 3) irit.color(irit.point(pt[0], pt[1], pt[2]), irit.GREEN) irit.adwidth(irit.point(pt[0], pt[1], pt[2]), 3) irit.color(bisrf, irit.MAGENTA) irit.view(irit.list(c1, pt, bisrf), irit.ON) # ############################################################################ # # A line # b = 2 while (b <= 0): pt = (0, 0, 0) c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, (-0.2 ) - b, (-1 ) ), \ irit.ctlpt( irit.E3, 0, (-0.2 ) - b, 1 ) ) ) bisectsrf = irit.cbisector3d(irit.list(c1, pt), 0) display(c1, pt, bisectsrf) b = b + (-0.005) * speed b = 0 while (b <= 2): pt = (b, 0, 0) c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, (-0.2 ), (-1 ) ), \ irit.ctlpt( irit.E3, 0, (-0.2 ), 1 ) ) ) bisectsrf = irit.cbisector3d(irit.list(c1, pt), 0) display(c1, pt, bisectsrf) b = b + 0.0025 * speed b = 2 while (b <= 0):
save_res = irit.GetResolution() save_mat = irit.GetViewMatrix() irit.SetViewMatrix( irit.GetViewMatrix() * irit.sc( 0.3 )) irit.viewobj( irit.GetViewMatrix() ) irit.SetViewMatrix( save_mat) # ############################################################################ # # Cylinder-Cylinder intersection # s1 = irit.cylinsrf( 4, 1 ) * irit.tz( (-2 ) ) irit.color( s1, irit.RED ) c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0, (-1 ) ), \ irit.ctlpt( irit.E3, 0, 0, 1 ) ) ) r1 = irit.cbezier( irit.list( irit.ctlpt( irit.E1, 1 ) ) ) s2 = irit.cylinsrf( 4, 1 ) * irit.tz( (-2 ) ) * irit.rx( 90 ) * irit.tx( 0.5 ) irit.color( s2, irit.MAGENTA ) c2 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0.5, (-1 ), 0 ), \ irit.ctlpt( irit.E3, 0.5, 1, 0 ) ) ) r2 = irit.cbezier( irit.list( irit.ctlpt( irit.E1, 1 ) ) ) zerosetsrf = irit.coerce( irit.gginter( c1, r1, c2, r2, 10, 1 ),\ irit.E3 ) * irit.rotx( (-90 ) ) * irit.roty( (-90 ) ) irit.SetResolution( 100) zeroset = irit.contour( zerosetsrf, irit.plane( 0, 0, 1, 0 ) ) irit.color( zeroset, irit.GREEN ) irit.adwidth( zeroset, 3 ) irit.interact( irit.list( zerosetsrf * irit.sz( 0.1 ), zeroset, irit.GetAxes() ) * irit.sc( 3 ) )
# def printtest(title, res1, res2): irit.printf("%9s test - %d\n", irit.list(title, res1 == res2)) if (res1 != res2): irit.pause() # Faster product using Bezier decomposition. iprod = irit.iritstate("bspprodmethod", irit.GenRealObject(0)) echosrc = irit.iritstate("echosource", irit.GenRealObject(0)) dlevel = irit.iritstate("dumplevel", irit.GenRealObject(256 + 1)) c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, (-1 ), 0.5, 2 ), \ irit.ctlpt( irit.E3, 0, 0, 2 ), \ irit.ctlpt( irit.E3, 1, (-1 ), 2 ), \ irit.ctlpt( irit.E3, 1, 1, 2 ) ) ) irit.attrib(c1, "width", irit.GenRealObject(0.02)) irit.attrib(c1, "color", irit.GenRealObject(14)) c2 = irit.pcircle((1, 2, 3), 1.25) c2 = irit.creparam(c2, 0, 1) irit.attrib(c2, "width", irit.GenRealObject(0.02)) irit.attrib(c2, "color", irit.GenRealObject(15)) s1 = irit.sbezier( irit.list( irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \ irit.ctlpt( irit.E3, 0.25, 1, 0.5 ), \ irit.ctlpt( irit.E3, 0.5, 0.25, 1 ) ), irit.list( \ irit.ctlpt( irit.E3, 0.5, (-1 ), 0 ), \ irit.ctlpt( irit.E3, 0.75, 0.25, 0.5 ), \ irit.ctlpt( irit.E3, 1, (-0.5 ), 1 ) ), irit.list( \
scone2 = irit.ruledsrf(c1, c1 * irit.sc(0.1) * irit.tz(1)) * irit.scale((2, 1, 1)) irit.free(c1) irit.color(scone2, irit.YELLOW) scone2ev = irit.evolute(scone2) irit.color(scone2ev, irit.GREEN) irit.interact(irit.list(irit.GetAxes(), scone2, scone2ev)) irit.free(scone2) irit.free(scone2ev) # ############################################################################ # Gaussian curvature of a parametric surface. # ############################################################################ srf1 = irit.hermite( irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \ irit.ctlpt( irit.E3, 0.5, 0.2, 0 ), \ irit.ctlpt( irit.E3, 1, 0, 0 ) ) ), irit.cbezier( irit.list( \ irit.ctlpt( irit.E3, 0, 1, 0 ), \ irit.ctlpt( irit.E3, 0.5, 0.8, 0 ), \ irit.ctlpt( irit.E3, 1, 1, 0.5 ) ) ), irit.cbezier( irit.list( \ irit.ctlpt( irit.E3, 0, 2, 0 ), \ irit.ctlpt( irit.E3, 0, 2, 0 ), \ irit.ctlpt( irit.E3, 0, 2, 0 ) ) ), irit.cbezier( irit.list( \ irit.ctlpt( irit.E3, 0, 2, 0 ), \ irit.ctlpt( irit.E3, 0, 2, 0 ), \ irit.ctlpt( irit.E3, 0, 2, 0 ) ) ) ) irit.color(srf1, irit.YELLOW) srf1ms = irit.coerce(irit.smean(srf1, 0), irit.E3) * irit.rotx( (-90)) * irit.roty((-90)) * irit.sz(0.01) irit.color(srf1ms, irit.GREEN)
def cubeat(x, y, z): retval = irit.box((x - size / 2.0, y - size / 2.0, z - size / 2.0), size, size, size) irit.attrib( retval, "rgb", irit.GenStrObject( str(int(irit.random(64, 255))) + "," + str(int(irit.random(64, 255))) + "," + str(int(irit.random(64, 255))))) return retval stage1 = irit.list(cubeat(0, 0, 0), cubeat(0, (-size), 0), cubeat(0, (-2) * size, 0)) rot_x = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, 90 ) ) ), 0, 1 ) irit.attrib(stage1, "animation", irit.list(rot_x)) irit.free(rot_x) stage2 = irit.list(cubeat(0, 0, 0), cubeat(size, 0, 0), stage1 * irit.trans((2 * size, 0, 0))) rot_y = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, 90 ) ) ), 1, 2 ) irit.attrib(stage2, "animation", irit.list(rot_y)) irit.free(rot_y) irit.free(stage1) stage3 = irit.list(cubeat(0, 0, 0), cubeat(0, size, 0), stage2 * irit.trans((0, 2 * size, 0))) rot_z = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, (-90 ) ) ) ), 2, 3 )
# # Set states. # save_mat = irit.GetViewMatrix() irit.SetViewMatrix(irit.GetViewMatrix() * irit.sc(0.35)) irit.viewobj(irit.GetViewMatrix()) # Faster product using Bezier decomposition. iprod = irit.iritstate("bspprodmethod", irit.GenIntObject(0)) # ############################################################################ # # Two linear curves # c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0.1, (-1 ) ), \ irit.ctlpt( irit.E3, 0, 0.1, 1 ) ) ) c2 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, (-1 ), (-0.1 ), 0 ), \ irit.ctlpt( irit.E3, 1, (-0.1 ), 0 ) ) ) irit.color(c1, irit.RED) irit.adwidth(c1, 3) irit.color(c2, irit.RED) irit.adwidth(c2, 3) bisectsrf = irit.cbisector3d(irit.list(c1, c2), 1) irit.color(bisectsrf, irit.GREEN) irit.interact(irit.list(c1, c2, bisectsrf)) irit.save("bisectr1", irit.list(c1, c2, bisectsrf)) # ############################################################################
uv = irit.nth(uvs, i) irit.snoc( irit.seval(srf, irit.FetchRealObject(irit.coord(uv, 1)), irit.FetchRealObject(irit.coord(uv, 2))), retval) i = i + 1 irit.color(retval, clr) return retval # ############################################################################ # # Case 1 # c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, (-1 ), 0, (-1 ) ), \ irit.ctlpt( irit.E3, 0, 1, (-1 ) ), \ irit.ctlpt( irit.E3, 0.3, 0, (-1 ) ), \ irit.ctlpt( irit.E3, 1, 0, (-1 ) ) ) ) c2 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, (-1 ), 0, 1 ), \ irit.ctlpt( irit.E3, 0, 1, 1 ), \ irit.ctlpt( irit.E3, 0.3, 1, 1 ), \ irit.ctlpt( irit.E3, 1, 0, 1 ) ) ) r1 = irit.ruledsrf(c1, c2) r2 = r1 * irit.rx(90) c = irit.nth( irit.rrinter(irit.cmesh(r1, irit.ROW, 0), irit.cmesh(r1, irit.ROW, 1), irit.cmesh(r2, irit.ROW, 0), irit.cmesh(r2, irit.ROW, 1), 10, 0), 1)
irit.color( bisectlns, irit.MAGENTA ) if ( irit.FetchRealObject(irit.coord( interpt, 1 )) < 10 and \ irit.FetchRealObject(irit.coord( interpt, 1 )) > (-10 ) and \ irit.FetchRealObject(irit.coord( interpt, 2 )) < 10 and \ irit.FetchRealObject(irit.coord( interpt, 2 )) > (-10 ) ): irit.view( irit.list( crv1, crv2, data, pt1, pt2, interpt, \ bisectlns ), irit.ON ) i = i + 1 # ############################################################################ # # Two quadratic curves # c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-0.5 ), (-0.2 ) ), \ irit.ctlpt( irit.E2, 0, (-0.2 ) ), \ irit.ctlpt( irit.E2, 0.6, 0.6 ) ) ) c2 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0.3, (-0.7 ) ), \ irit.ctlpt( irit.E2, (-0.2 ), (-0.7 ) ), \ irit.ctlpt( irit.E2, 0.7, 0.6 ) ) ) irit.color( c1, irit.YELLOW ) irit.attrib( c1, "dwidth", irit.GenRealObject(2 )) irit.attrib( c1, "width", irit.GenRealObject(0.007 )) irit.color( c2, irit.YELLOW ) irit.attrib( c2, "dwidth", irit.GenRealObject(2 )) irit.attrib( c2, "width", irit.GenRealObject(0.007 )) bisectsrf = irit.cbisector2d( irit.list( c1, c2 ), 1, 1, 20, 1, 0 ) bisectsrfe3 = irit.coerce( bisectsrf, irit.E3 ) * \ irit.rotx( (-90 ) ) * \
irit.pause( ) # ############################################################################ # # Curves # # ############################################################################ view_mat1 = irit.sc( 0.5 ) irit.viewobj( view_mat1 ) # ############################################################################ c = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, (-1 ) ), \ irit.ctlpt( irit.E2, 0, 1 ) ) ) * irit.tx( 0.3 ) * irit.ty( 0.5 ) irit.adwidth( c, 3 ) k = irit.crvkernel( c, 15, 0, irit.GenIntObject(2), 2 ) irit.color( k, irit.YELLOW ) irit.interact( irit.list( c, k, irit.GetAxes() ) ) # ############################################################################ c = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-1 ), 1 ), \ irit.ctlpt( irit.E2, 0, (-1 ) ), \ irit.ctlpt( irit.E2, 1, 1 ) ) ) irit.adwidth( c, 3 ) irit.color( c, irit.RED ) ct = c * irit.tz( 1 )
vec2 )) item3 = prism1 ^ \ prism2b * \ irit.rotz( 180 ) * \ irit.trans( irit.Fetch3TupleObject(vec3*2 + \ vec1 + \ vec2 )) irit.color(item3, irit.GREEN) item4 = item1 * \ irit.rotx( 180 ) * \ irit.rotz( 180 - an ) * \ irit.trans( irit.Fetch3TupleObject(vec3*4 - vec1 - vec2) ) irit.color(item4, irit.YELLOW) mov_xyz = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \ irit.ctlpt( irit.E3, ( ca - 1 ) * 3, (-sa ) * 3, 1.4 * 3 ) ) ), 0, 0.25 ) irit.attrib(item4, "animation", mov_xyz) irit.free(mov_xyz) mov_xyz = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \ irit.ctlpt( irit.E3, ( ca - 1 ) * 2, (-sa ) * 2, 1.4 * 2 ) ) ), 0.25, 0.5 ) irit.attrib(item3, "animation", mov_xyz) irit.free(mov_xyz) mov_xyz = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \ irit.ctlpt( irit.E3, ( 1 - ca ) * 2, sa * 2, 1.4 * 2 ) ) ), 0.5, 0.75 ) irit.attrib(item2, "animation", mov_xyz) irit.free(mov_xyz) mov_z = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, 2 ) ) ), 0.75, 1 )