def testrun( numcrvs, crvdeg, crvlen, crvsize, seed, subeps,\ numeps, opti ): ri = irit.iritstate("randominit", irit.GenIntObject(seed)) c = randomcrvs(numcrvs, crvdeg, crvlen, crvsize) irit.attrprop(c, "color", irit.GenIntObject(14)) irit.view(c, irit.ON) msc = irit.mscirc(c, irit.list(subeps, numeps)) irit.view(msc, irit.OFF) irit.pause() retval = irit.list(msc, c) return retval
def plgntoplln( pl ): retval = irit.nil( ) j = 0 while ( j <= irit.SizeOf( pl ) - 1 ): irit.snoc( irit.coord( pl, j ), retval ) j = j + 1 irit.snoc( irit.coord( pl, 0 ), retval ) retval = irit.poly( retval, irit.TRUE ) irit.attrib( retval, "dwidth", irit.GenIntObject(3 )) return retval
def cntrpolys( pls, zmin, dz, zmax ): retval = irit.nil( ) intrcrv = irit.iritstate( "intercrv", irit.GenIntObject(1 )) z = zmin while ( z <= zmax ): p = irit.circpoly( ( 0, 0, 1 ), ( 0, 0, z ), 6 ) irit.snoc( pls * p, retval ) z = z + dz intrcrv = irit.iritstate( "intercrv", intrcrv ) irit.color( retval, irit.YELLOW ) return retval
def mergeverticalbndrycrvs( crvs ): crvs = crvs * irit.tx( 0 ) retval = irit.nil( ) i = 1 while ( i <= irit.SizeOf( crvs ) ): c1 = irit.nth( crvs, i ) used = irit.getattr( c1, "used" ) if ( irit.ThisObject( used ) != irit.NUMERIC_TYPE ): j = i + 1 while ( j <= irit.SizeOf( crvs ) ): c2 = irit.nth( crvs, j ) used = irit.getattr( c2, "used" ) if ( irit.ThisObject( used ) != irit.NUMERIC_TYPE ): c1a = mergeverticaltwocrvs( c1, c2 ) if ( c1a != c1 ): irit.attrib( irit.nref( crvs, j ), "used", irit.GenIntObject(1 )) c1 = c1a j = j + 1 irit.snoc( c1 * irit.tx( 0 ), retval ) i = i + 1 return retval
def displayobjobjhdres( o1, o2, eps, onesided ): global glbltransx hdres = irit.hausdorff( o1, o2, eps, onesided ) dist = irit.nth( hdres, 1 ) param1 = irit.nth( hdres, 2 ) if ( onesided ): dtype = "one sided " else: dtype = "two sided " if ( irit.SizeOf( param1 ) == 0 ): pt1 = irit.coerce( o1, irit.E3 ) else: i = 1 while ( i <= irit.SizeOf( param1 ) ): t = irit.nth( param1, i ) irit.printf( "%shausdorff distance %f detected at t1 = %f\n", irit.list( dtype, dist, t ) ) i = i + 1 pt1 = irit.ceval( o1, irit.FetchRealObject(t) ) param2 = irit.nth( hdres, 3 ) if ( irit.SizeOf( param2 ) == 0 ): pt2 = irit.coerce( o2, irit.E3 ) else: i = 1 while ( i <= irit.SizeOf( param2 ) ): t = irit.FetchRealObject(irit.nth( param2, i )) irit.printf( "%shausdorff distance %f detected at t2 = %f\n", irit.list( dtype, dist, t ) ) i = i + 1 pt2 = irit.ceval( o2, t ) irit.color( pt1, irit.MAGENTA ) irit.color( o1, irit.MAGENTA ) irit.color( pt2, irit.YELLOW ) irit.color( o2, irit.YELLOW ) l = ( pt1 + pt2 ) if ( onesided == 0 ): irit.attrib( l, "dwidth", irit.GenIntObject(3 )) all = irit.list( o1, o2, pt1, pt2, l ) irit.snoc( all * irit.tx( glbltransx ), glblres ) glbltransx = ( glbltransx + 0.5 ) irit.interact( all )
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 ), \ irit.ctlpt( irit.E3, 10.9, 0, 0.6 ) ), irit.list( irit.KV_OPEN ) ), irit.cbspline( 3, irit.list( \ irit.ctlpt( irit.E2, 0, 0.01 ), \ irit.ctlpt( irit.E2, 0.01, 1 ), \ irit.ctlpt( irit.E2, 0.5, 1 ), \
# import math import irit # # # Some routines to test bezier curves/surfaces. # # # Set display to on to view some results, off to view nothing. # display = 1 save_res = irit.GetResolution() dlevel = irit.iritstate("dumplevel", irit.GenIntObject(255)) if (irit.GetMachine() == irit.MSDOS): irit.SetResolution(5) else: irit.SetResolution(10) s45 = math.sin(math.pi / 4) cbzr = irit.list( irit.ctlpt( irit.P2, 1, 1, 0 ), \ irit.ctlpt( irit.P2, s45, s45, s45 ), \ irit.ctlpt( irit.P2, 1, 0, 1 ) ) sbzr = irit.list( irit.list( irit.ctlpt( irit.E3, 0.1, 0, 1 ), \ 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 ), \
import irit # # # A small demo of the knot removal capabilities in IRIT # # Gershon Elber, July 1999 # pl1 = irit.nil() x = 0 while (x <= 200): irit.snoc(irit.point(x / 100.0 - 1, math.sin(x * math.pi / 100), 0), pl1) x = x + 1 c1 = irit.cinterp(pl1, 3, 50, irit.GenIntObject(irit.PARAM_UNIFORM), 0) c1r1 = irit.knotremove(c1, 0.001) irit.color(c1r1, irit.MAGENTA) irit.adwidth(c1r1, 3) irit.printf("size of c1 is %d and c1r1 is %d\n", irit.list(irit.SizeOf(c1), irit.SizeOf(c1r1))) irit.interact(irit.list(c1r1, c1)) c1r2 = irit.knotremove(c1, 0.01) irit.color(c1r2, irit.MAGENTA) irit.adwidth(c1r2, 3) irit.printf("size of c1 is %d and c1r2 is %d\n", irit.list(irit.SizeOf(c1), irit.SizeOf(c1r2))) irit.interact(irit.list(c1r2, c1))
irit.ctlpt( irit.E3, (-1.1 ), 0.2, 0 ), \ irit.ctlpt( irit.E3, (-1.1 ), 0.6, 0 ), \ irit.ctlpt( irit.E3, (-0.7 ), 1.1, 0 ), \ irit.ctlpt( irit.E3, (-0.5 ), 1.3, 0 ), \ irit.ctlpt( irit.E3, 0.5, 1.3, 0 ), \ irit.ctlpt( irit.E3, 0.7, 1.1, 0 ), \ irit.ctlpt( irit.E3, 1.1, 0.6, 0 ), \ irit.ctlpt( irit.E3, 1.1, 0.2, 0 ), \ irit.ctlpt( irit.E3, 1, 0, 0 ) ), irit.list( irit.KV_PERIODIC ) ) * irit.rz( (-90 ) ) * irit.sc( 0.3 ) direc = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, (-1.2 ), 0, 0 ), \ irit.ctlpt( irit.E3, 0, 0.24, 0 ), \ irit.ctlpt( irit.E3, 1.2, 0, 0 ) ), irit.list( irit.KV_OPEN ) ) irit.SetResolution(res) srf1 = irit.gpolygon((-irit.sweepsrf(irit.coerce(cross, irit.KV_OPEN), direc, irit.GenIntObject(0))), 1) irit.free(cross) irit.free(direc) irit.SetResolution(res * 5) cyl1 = irit.cylin((0, 0, (-1)), (0, 0, 2), 1.15, 3) srf2 = srf1 * cyl1 irit.free(cyl1) irit.SetResolution(res * 5) cyl2 = irit.cylin((0, 0.2, (-1)), (0, 0, 2), 0.6, 3) srf3 = srf1 * cyl2 * irit.sz(4) * irit.sx(0.9) * irit.ty((-0.15)) irit.free(srf1) irit.free(cyl2)
b1 = irit.box(((-3), (-2), (-1)), 6, 4, 2) b2 = irit.box(((-4), (-3), (-2)), 2, 2, 4) a1 = (b2 + b1) irit.interact(irit.list(irit.GetViewMatrix(), a1)) a2 = b2 * b1 irit.interact(a2) a3 = (b2 - b1) irit.interact(a3) a4 = (b1 - b2) irit.interact(a4) icrv = irit.iritstate("intercrv", irit.GenIntObject(1)) a5 = b2 * b1 irit.interact(irit.list(a5, b1, b2)) icrv = irit.iritstate("intercrv", icrv) irit.free(icrv) irit.save( "box-box", irit.list(a1, a2 * irit.tx(10), a3 * irit.tx(20), a4 * irit.tx(30), a5 * irit.tx(40))) irit.SetViewMatrix(save_mat) irit.free(a1) irit.free(a2) irit.free(a3)
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # Convex Hull and related computation for freeform curves. # # Gershon Elber, February 1996 # save_mat = irit.GetViewMatrix() irit.SetViewMatrix(irit.sc(0.5)) irit.viewobj(irit.GetViewMatrix()) ri = irit.iritstate("randominit", irit.GenIntObject(1964)) # Seed-initiate the randomizer, irit.free(ri) # ############################################################################ pts = irit.nil() len = 1 numpts = 5 i = 0 while (i <= numpts): r = irit.random(0, 2) pt = irit.ctlpt(irit.E2, len * r * math.cos(i * 2 * math.pi / numpts), len * r * math.sin(i * 2 * 3.14159 / numpts)) irit.snoc(pt, pts) i = i + 1
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # Hausdorff distances between freeforms # # Gershon Elber, October 2006. # # ############################################################################ ri = irit.iritstate( "randominit", irit.GenIntObject(1960 )) # Seed-initiate the randomizer, irit.free( ri ) glblres = irit.nil( ) glbltransx = -5 def displayobjobjhdres( o1, o2, eps, onesided ): global glbltransx hdres = irit.hausdorff( o1, o2, eps, onesided ) dist = irit.nth( hdres, 1 ) param1 = irit.nth( hdres, 2 ) if ( onesided ): dtype = "one sided " else: dtype = "two sided " if ( irit.SizeOf( param1 ) == 0 ):
import math import irit # # # This is the DtoP custom designed Gearbox 'EndPlate' # Designed by Andy Bray <*****@*****.**> 1992 # save_mat = irit.GetViewMatrix() irit.SetViewMatrix( irit.GetViewMatrix() * irit.scale( ( 0.13, 0.13, 0.13 ) )) save_res = irit.GetResolution() cplnr = irit.iritstate( "coplanar", irit.GenIntObject(1) ) # Try 'irit.iritstate("coplanar", false);' box1 = irit.box( ( 0, 0, 1 ), 7.8, 10.4, 1.6 ) # If the line below is uncommented, then the file fails at the first operation # most other resolutions work without problem. This could be because # coincidentally something approximates colinear when it is not, but in that # case a resultion of 50 or 20 might do it, and do not. # resolution = 10; hole1 = irit.cylin( ( 1, 1, 2.601 ), ( 0, 0, (-1.6015 ) ), 0.3, 3 ) solid1 = ( box1 - hole1 ) irit.free( hole1 ) irit.free( box1 ) irit.view( irit.list( irit.GetViewMatrix(), solid1 ), irit.ON ) # resolution = 20;
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # Some simple tests for blossom evaluations over Beziers and Bsplines. # # Gershon Elber, February 1999 # echosrc = irit.iritstate("echosource", irit.GenIntObject(0)) dumplvl = irit.iritstate("dumplevel", irit.GenIntObject(256 + 1)) oldeps = irit.iritstate("cmpobjeps", irit.GenRealObject(1e-010)) def printtest(title, ctlstring, reslist): irit.printf(ctlstring, irit.list(title) + reslist) # ############################################################################ c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 1.7, 0 ), \ irit.ctlpt( irit.E2, 0.7, 0.7 ), \ irit.ctlpt( irit.E2, 1.7, 0.3 ), \ irit.ctlpt( irit.E2, 1.5, 0.8 ), \ irit.ctlpt( irit.E2, 1.6, 1 ) ) ) printtest( "bezier test - ", "\n%40s %d %d %d %d %d, %d %d %d %d, %d %d %d\n",
irit.color(maxd, irit.GREEN) irit.adwidth(maxd, 3) mind = irit.crvdiamtr(c3, 0.01, (-1e-010), 0) mind = (irit.ceval(c3, irit.FetchRealObject(irit.coord(mind, 0))) + irit.ceval(c3, irit.FetchRealObject(irit.coord(mind, 1)))) irit.color(mind, irit.YELLOW) irit.adwidth(mind, 3) irit.interact(irit.list(c3, lns, maxd, mind, view_mat1)) k = irit.crvkernel(c3, 0, 0, irit.list(2, 2, 2), 0) irit.attrib(k, "rgb", irit.GenStrObject("1,1,1")) irit.interact(irit.list(c3, bg, k * irit.sz(0), view_mat1)) k = irit.crvkernel(c4, 0, 0, irit.GenIntObject(2), 0) irit.attrib(k, "rgb", irit.GenStrObject("1,1,1")) irit.interact(irit.list(c4, bg, k * irit.sz(0), view_mat1)) k1 = irit.crvkernel(c4, 5, 0, irit.GenIntObject(2), 0) irit.attrib(k1, "rgb", irit.GenStrObject("100,1,1")) k2 = irit.crvkernel(c4, (-5), 0, irit.GenIntObject(2), 0) irit.attrib(k2, "rgb", irit.GenStrObject("1,100,1")) irit.interact(irit.list(c4, bg, k1 * irit.sz(0), k2 * irit.sz(0), view_mat1)) irit.attrib(k, "rgb", irit.GenStrObject("0,255,255")) irit.interact(irit.list(c4, k * irit.sz((-3)), view_mat2)) s = irit.crvkernel(c4, 0, 0, irit.list(0.15, (-0.001)), 1) irit.attrib(s, "rgb", irit.GenStrObject("255,0,255")) irit.interact(irit.list(c4, k * irit.sz((-3)), s, view_mat2))
# Some examples of envelope offset # # Gershon Elber, August 1996 # save_mat = irit.GetViewMatrix() irit.SetViewMatrix( irit.rx( 180 )) irit.viewobj( irit.GetViewMatrix() ) c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-0.8 ), 0 ), \ irit.ctlpt( irit.E2, (-0.2 ), 1 ), \ irit.ctlpt( irit.E2, 0.2, 0 ), \ irit.ctlpt( irit.E2, 0.8, 0.6 ) ) ) irit.color( c1, irit.YELLOW ) irit.attrib( c1, "dwidth", irit.GenIntObject(4 )) s1 = irit.cenvoff( c1, 0.5, 0.01 ) irit.color( s1, irit.CYAN ) irit.interact( irit.list( c1, s1 ) ) irit.free( c1 ) irit.free( s1 ) c2 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 1, 0 ), \ irit.ctlpt( irit.E2, 1, 1 ), \ irit.ctlpt( irit.E2, 0.3, 1 ), \ irit.ctlpt( irit.E2, 0, (-0.5 ) ), \ irit.ctlpt( irit.E2, (-0.3 ), 1 ), \ irit.ctlpt( irit.E2, (-1 ), 1 ), \
irit.ctlpt( irit.E3, 3.1, 0, 0 ), \ irit.ctlpt( irit.E3, 3.3, 1, 0 ), \ irit.ctlpt( irit.E3, 3, 2, 0 ) ) ) ) tcrv1 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.5, 0.25 ), \ irit.ctlpt( irit.E2, 0.8, 0.25 ), \ irit.ctlpt( irit.E2, 0.8, 0.75 ), \ irit.ctlpt( irit.E2, 0.6, 0.75 ), \ irit.ctlpt( irit.E2, 0.6, 0.9 ), \ irit.ctlpt( irit.E2, 0.4, 0.9 ), \ irit.ctlpt( irit.E2, 0.4, 0.75 ), \ irit.ctlpt( irit.E2, 0.2, 0.75 ), \ irit.ctlpt( irit.E2, 0.2, 0.25 ), \ irit.ctlpt( irit.E2, 0.5, 0.25 ) ), irit.list( irit.KV_OPEN ) ) tsrf1 = irit.trimsrf(srf1, tcrv1, 0) irit.attrib(tsrf1, "resolution", irit.GenIntObject(2)) crv1 = irit.compose(srf1, tcrv1) irit.free(srf1) irit.free(tcrv1) irit.color(crv1, irit.GREEN) pc = irit.crefine(irit.pcircle(((-1.7), (-1), 1), 0.4), 0, irit.list(1, 2, 3)) srf2 = irit.ruledsrf( irit.ceditpt( irit.ceditpt( pc, irit.ctlpt( irit.E3, (-2.1 ), (-1 ), 1.2 ), 9 ), \ irit.ctlpt( irit.E3, (-1.3 ), (-1 ), 1.2 ), 3 ), pc * irit.tz( 1 ) ) * irit.rotz( (-90 ) ) * irit.trans( ( 2.7, (-0.7 ), 0 ) ) crv2 = irit.csurface(srf2, irit.ROW, 0) irit.color(crv2, irit.GREEN) irit.free(pc) tan1 = irit.symbdiff( crv1 * irit.scale((0.6, 0.4, 1)) * irit.trans((0.7, 0.6, 0)), crv1)
irit.color(s2, irit.GREEN) s3 = irit.blhermite(c1, c2, d1, d2, csec2, n) irit.color(s3, irit.YELLOW) irit.save("blending1", irit.list(s1, s2, s3)) irit.interact(irit.list(irit.GetAxes(), s1, s2, s3)) # # Blend on a (polynomial approximation of a) sphere: # s = (-irit.surfprev( irit.cregion(irit.pcircle((0, 0, 0), 1), 0, 2) * irit.rx(90))) irit.attrprop(s, "u_resolution", irit.GenIntObject(3)) irit.attrprop(s, "v_resolution", irit.GenIntObject(3)) ds = irit.sderive(s, irit.ROW) c1 = (-irit.csurface(s, irit.ROW, 0.8)) c2 = (-irit.csurface(s, irit.ROW, 1.2)) d1 = (-irit.csurface(ds, irit.ROW, 0.8)) d2 = (-irit.csurface(ds, irit.ROW, 1.2)) s1 = irit.hermite(c1, c2, d1, d2) irit.color(s1, irit.RED) n = irit.csurface(s, irit.ROW, 1) s2 = irit.blhermite(c1, c2, d1, d2, csec1, n)
# # Some examples of proper piecewise linear sampling in gpolyline. # save_res = irit.GetResolution() save_mat = irit.GetViewMatrix() irit.SetViewMatrix(irit.rotx(0)) irit.viewobj(irit.GetViewMatrix()) irit.SetViewMatrix(save_mat) irit.viewstate("dblbuffer", 1) irit.viewstate("depthcue", 1) dlevel = irit.iritstate("dumplevel", irit.GenIntObject(255)) # Faster product using Bezier decomposition. iprod = irit.iritstate("bspprodmethod", irit.GenIntObject(0)) # ############################################################################ pl2 = irit.nil() x = 0 while (x <= 5): irit.snoc( irit.point(math.cos(x * math.pi / 10), math.sin(x * 3.14159 / 10), 0), pl2) x = x + 1 crv1 = irit.cinterp(pl2, 4, 4, irit.GenRealObject(irit.PARAM_UNIFORM), 0)
import math import irit # # # Minimum Spanning Circle/Cone/Sphere and Convex Hull for polys. # # Gershon Elber, February 1996 # save_mat = irit.GetViewMatrix() irit.SetViewMatrix(irit.sc(0.5)) irit.viewobj(irit.GetViewMatrix()) irit.SetViewMatrix(save_mat) ri = irit.iritstate("randominit", irit.GenIntObject(1964)) # Seed-initiate the randomizer, irit.free(ri) def randompts(n): l = irit.nil() i = 1 while (i <= n): r = irit.random((-1), 1) t = irit.random(0, 2 * math.pi) irit.snoc(irit.vector(math.cos(t) * r, math.sin(t) * r, 0), l) i = i + 1 retval = irit.poly(l, irit.FALSE) irit.color(retval, irit.RED) irit.adwidth(retval, 5)
# # Some examples of 3d alpha-sector computations of 3-space freeform curves. # # Gershon Elber, October 1998. # # # 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):
y2 = y1 + (maxy - miny) * 0.8 / n if (x > x1 & x < x2 & y > y1 & y < y2): retval = i + 1 i = i + 1 return retval # # Ask all clients to send mouse/cursor events to the server. # irit.clntpickcrsr(irit.CLIENTS_ALL) # # Ask the server to keep mouse/cursor events to be read view ClntCrsr. # crsrkeep = irit.iritstate("cursorkeep", irit.GenIntObject(1)) # # Some examples of menus... Uses Button 1 (left button). # quit = 0 xyplane = irit.plane(0, 0, 1, 0) crv = irit.circle((0, 0, 0), 1) * irit.sx(0.5) * irit.rx(40) * irit.rz(44) irit.color(crv, irit.RED) srf = irit.swpcircsrf(irit.circle((0, 0, 0), 0.7), 0.2, 0) irit.color(srf, irit.GREEN) menu = menugengeometry( irit.list( "quit", "draw crv", "draw srf", "draw all", "ctl mesh" ), 0.7,\ 0.5, 0.5, 0.95, 0.95 ) irit.color(menu, irit.WHITE) irit.view(irit.list(menu, crv, srf), irit.ON) # Handle only button 1 down events:
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # Display the Gamma-Kernel surfaces. gershon Elber, September 2003. # ri = irit.iritstate( "randominit", irit.GenIntObject(1964 )) # Seed-initiate the randomizer, irit.free( ri ) def cntrpolys( pls, zmin, dz, zmax ): retval = irit.nil( ) intrcrv = irit.iritstate( "intercrv", irit.GenIntObject(1 )) z = zmin while ( z <= zmax ): p = irit.circpoly( ( 0, 0, 1 ), ( 0, 0, z ), 6 ) irit.snoc( pls * p, retval ) z = z + dz intrcrv = irit.iritstate( "intercrv", intrcrv ) irit.color( retval, irit.YELLOW ) return retval def setrandomcolor( obj ): irit.attrib( obj, "rgb", irit.GenStrObject(str(int( irit.random( 100, 255 ) )) + "," + str(int( irit.random( 100, 255 ) )) + "," + str(int( irit.random( 100, 255 ) ) ))) retval = obj return retval
import math import irit # # # Simple knots. # # Gershon Elber, 1997 # cross = irit.pcircle((0, 0, 0), 0.1) crv1 = irit.coerce( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, (-1 ), 0.9, 0 ), \ irit.ctlpt( irit.E3, 1, 0.9, 0 ), \ irit.ctlpt( irit.E3, 1, (-0.9 ), 0 ), \ irit.ctlpt( irit.E3, (-1 ), (-0.9 ), 0 ) ), irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN ) srf1 = irit.swpsclsrf(cross, crv1, irit.GenIntObject(1), irit.vector(0, 0, 1), 2) irit.attrib(srf1, "color", irit.GenIntObject(4)) crv2 = irit.coerce( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, (-1.3 ), 0, 0.75 ), \ irit.ctlpt( irit.E3, 1.3, 0, 0.75 ), \ irit.ctlpt( irit.E3, 1.3, 0, (-0.75 ) ), \ irit.ctlpt( irit.E3, (-1.3 ), 0, (-0.75 ) ) ), irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN ) srf2 = irit.swpsclsrf(cross, crv2, irit.GenIntObject(1), irit.vector(0, 1, 0), 2) irit.attrib(srf2, "color", irit.GenIntObject(2)) crv3 = irit.coerce( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0, 0.5, 1.1 ), \ irit.ctlpt( irit.E3, 0, 0.5, (-1.1 ) ), \ irit.ctlpt( irit.E3, 0, (-0.5 ), (-1.1 ) ), \ irit.ctlpt( irit.E3, 0, (-0.5 ), 1.1 ) ), irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN )
# save_mat = irit.GetViewMatrix() irit.SetViewMatrix( irit.roty( 180 )) irit.viewobj( irit.GetViewMatrix() ) irit.SetViewMatrix( save_mat) irit.viewstate( "polyaprx", 1 ) irit.viewstate( "widthlines", 1 ) # # Animation speed. The lower this number, the faster the animations will be, # skipping more frames. # speed = 0.25 echosrc = irit.iritstate( "echosource", irit.GenIntObject(0 )) # ########################################################################### locally = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.62705, (-0.418086 ) ), \ irit.ctlpt( irit.E2, 0.593439, (-0.416962 ) ), \ irit.ctlpt( irit.E2, 0.414706, (-0.366445 ) ), \ irit.ctlpt( irit.E2, 0.362948, (-0.332803 ) ), \ irit.ctlpt( irit.E2, 0.33727, (-0.293801 ) ), \ irit.ctlpt( irit.E2, 0.288731, (-0.146024 ) ), \ irit.ctlpt( irit.E2, 0.292251, (-0.0630604 ) ), \ irit.ctlpt( irit.E2, 0.326431, (-0.0942595 ) ), \ irit.ctlpt( irit.E2, 0.379121, (-0.513736 ) ), \ irit.ctlpt( irit.E2, 0.324176, (-0.348901 ) ), \ irit.ctlpt( irit.E2, 0.247253, (-0.337912 ) ), \ irit.ctlpt( irit.E2, 0.285714, (-0.32967 ) ), \ irit.ctlpt( irit.E2, 0.339394, (-0.378232 ) ), \
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # An example of the cosine shader - setting the cosine exponent for irender. # s = irit.spheresrf(0.2) * irit.rx(90) s1 = s * irit.trans(((-0.5), 0.3, 0)) irit.attrib(s1, "srf_cosine", irit.GenIntObject(1)) s2 = s * irit.trans((0, 0.3, 0)) irit.attrib(s2, "srf_cosine", irit.GenIntObject(4)) s3 = s * irit.trans((0.5, 0.3, 0)) irit.attrib(s3, "srf_cosine", irit.GenIntObject(16)) s4 = s * irit.trans((-0.5, -0.3, 0)) irit.attrib(s4, "srf_cosine", irit.GenIntObject(32)) s5 = s * irit.trans((0, (-0.3), 0)) irit.attrib(s5, "srf_cosine", irit.GenIntObject(128)) s6 = s * irit.trans((0.5, (-0.3), 0)) irit.attrib(s6, "srf_cosine", irit.GenIntObject(256)) allspheres = irit.list(s1, s2, s3, s4, s5, s6)