def coercetobezsrf(mv, umin, umax, vmin, vmax): mvbzr = irit.coerce(mv, irit.BEZIER_TYPE) srfbzr = irit.coerce(irit.coerce(mvbzr, irit.SURFACE_TYPE), irit.E3) * irit.rotx((-90)) * irit.roty((-90)) srfbzr = irit.sregion( irit.sregion( srfbzr, irit.ROW, umin, umax ), irit.COL, vmin,\ vmax ) retval = srfbzr return retval
def plotfunc2d(minx, maxx, n): pl = plotfunc2d2poly(minx, maxx, n) irit.color(pl, irit.YELLOW) irit.attrib(pl, "width", irit.GenRealObject(0.05)) miny = 1e+006 maxy = -1e+006 i = 0 while (i <= 2): miny = miny + i i = i + 1 retval = pl i = 0 while (i <= irit.SizeOf(pl) - 1): v = irit.coord(pl, i) real_val = irit.FetchRealObject(irit.coord(v, 1)) if (real_val > maxy): maxy = irit.FetchRealObject(irit.coord(v, 1)) if (real_val < miny): miny = irit.FetchRealObject(irit.coord(v, 1)) i = i + 1 ax = (irit.poly( irit.list((irit.min(minx, 0), 0, 0), (irit.max(maxx, 0), 0, 0)), 1) + irit.poly( irit.list((0, irit.min(miny, 0), 0), (0, irit.max(maxy, 0), 0)), 1)) irit.color(ax, irit.RED) irit.attrib(ax, "width", irit.GenRealObject(0.02)) tr = irit.trans( ((-minx + maxx) / 2.0, (-miny + maxy) / 2.0, 0)) * irit.scale( (2.0 / (maxx - minx), 2.0 / (maxy - miny), 0)) sv = irit.GetViewMatrix() irit.SetViewMatrix(irit.rotx(0)) retval = irit.list(pl, ax) * tr irit.viewobj(irit.list(irit.GetViewMatrix(), retval)) irit.printf("xdomain = [%lf %lf], ydomain = [%lf %lf]\n", irit.list(minx, maxx, miny, maxy)) irit.SetViewMatrix(sv) return retval
(0, irit.max(maxy, 0), 0)), 1) + irit.poly( irit.list((0, 0, irit.min(minz, 0)), (0, 0, irit.max(maxz, 0))), 1)) irit.color(ax, irit.RED) irit.attrib(ax, "width", irit.GenRealObject(0.02)) retval = irit.list(pl, ax) irit.viewobj(retval) irit.printf( "xdomain = [%lf %lf], ydomain = [%lf %lf], zdomain = [%lf %lf]\n", irit.list(minx, maxx, miny, maxy, minz, maxz)) return retval echosrc = irit.iritstate("echosource", echosrc) irit.free(echosrc) irit.viewclear() fn = plotfunc2d((-1), 5, 50) irit.pause() irit.viewclear() irit.SetViewMatrix( irit.sz(5) * irit.rotz(35) * irit.rotx((-60)) * irit.sc(0.1)) irit.viewobj(irit.GetViewMatrix()) fn = plotfunc3d((-10), 10, (-10), 10, 50, 10) irit.pause() irit.SetViewMatrix(save_mat) irit.free(fn)
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(c, irit.RED) irit.adwidth(c, 3) irit.interact(irit.list(r1, r2, c)) zerosetsrf = 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, 1) zerosetsrfe3 = irit.coerce(zerosetsrf, irit.E3) * irit.rotx((-90)) * irit.roty( (-90)) * irit.sz(0.1) zeroset = irit.contour(zerosetsrfe3, irit.plane(0, 0, 1, 1e-005)) irit.color(zeroset, irit.RED) irit.adwidth(zeroset, 3) irit.interact(irit.list(irit.GetAxes(), zerosetsrfe3, zeroset)) # ############################################################################ # # Case 2 # 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 ) ), \
b5 = irit.box(((-0.2), 0.2, 0.2), (-0.8), 0.8, 0.8) b6 = irit.box(((-0.2), 0.2, (-0.2)), (-0.8), 0.8, (-0.8)) b7 = irit.box(((-0.2), (-0.2), 0.2), (-0.8), (-0.8), 0.8) b8 = irit.box(((-0.2), (-0.2), (-0.2)), (-0.8), (-0.8), (-0.8)) cubes = b1 ^ b2 ^ b3 ^ b4 ^ b5 ^ b6 ^ b7 ^ b8 irit.free(b1) irit.free(b2) irit.free(b3) irit.free(b4) irit.free(b5) irit.free(b6) irit.free(b7) irit.free(b8) rot_cubes = cubes * irit.rotx(30) * irit.rotz(25) intrcrv = irit.iritstate("intercrv", irit.GenIntObject(1)) crvs_cubes = (cubes + rot_cubes) irit.color(crvs_cubes, irit.GREEN) irit.interact(irit.list(crvs_cubes, cubes, rot_cubes)) irit.free(crvs_cubes) intrcrv = irit.iritstate("intercrv", intrcrv) irit.free(intrcrv) u_cubes = (cubes + rot_cubes) irit.interact(u_cubes) i_cubes = cubes * rot_cubes irit.interact(i_cubes)
a = a + 0.01 * speed a = 0.9 while (a <= 0): pt = (0.9 - a, a, 0) bisectsrf = irit.cbisector3d(irit.list(circ, pt), 0) display(circ, pt, bisectsrf) a = a + (-0.01) * speed # ############################################################################ # # A Helix # pt = (0.9, 0, 0) helix = circ * irit.rotx(0) i = 0 while (i <= irit.SizeOf(helix) - 1): pth = irit.coord(helix, i) helix = irit.ceditpt( helix, irit.ctlpt(irit.E3, i / 4, irit.FetchRealObject(irit.coord(pth, 2)), irit.FetchRealObject(irit.coord(pth, 3))), i) i = i + 1 a = 0 while (a <= 1): c1y = irit.cmorph(circ, helix, 0, a) bisectsrf = irit.cbisector3d(irit.list(c1y, pt), 0) display(c1y, pt, bisectsrf)
arc3 = irit.arc((0, 0, 1), (0.5, (-0.2), 1), (1, 0, 1)) ruled = irit.ruledsrf( arc3, irit.ctlpt( irit.E2, 0, 0 ) + \ irit.ctlpt( irit.E2, 1, 0 ) ) irit.free(arc3) printtest("ruled", irit.isgeom(ruled, irit.GEOM_RULED_SRF, 1e-010), 2) printtest("ruled", irit.isgeom(irit.sreverse(ruled), irit.GEOM_RULED_SRF, 1e-010), 1) circ = irit.circle((0, 0, 0), 0.25) ruled = irit.ruledsrf(circ, circ * irit.rx(10) * irit.sc(0.5) * irit.tz(1)) printtest("ruled", irit.isgeom(ruled, irit.GEOM_RULED_SRF, 1e-010), 2) printtest("ruled", irit.isgeom(irit.sreverse(ruled), irit.GEOM_RULED_SRF, 1e-010), 1) ruled = irit.ruledsrf(circ * irit.rotx(20), circ * irit.rotx((-20)) * irit.tz(1)) printtest("ruled", irit.isgeom(ruled, irit.GEOM_RULED_SRF, 1e-010), 2) printtest("ruled", irit.isgeom(ruled, irit.GEOM_EXTRUSION, 1e-010), 0) irit.free(circ) # # Extrusion examples. # printtest("extrusion", irit.isgeom(ruled, irit.GEOM_EXTRUSION, 1e-010), 0) crv = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, 0 ), \ irit.ctlpt( irit.E2, 1, 0 ), \ irit.ctlpt( irit.E2, 1, 1 ) ) ) extr = irit.extrude(crv, (0, 0, 1), 0)
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.roty( (-90 ) ) * \ irit.sz( 0.1 ) irit.color( bisectsrfe3, irit.GREEN ) irit.attrib( bisectsrfe3, "width", irit.GenRealObject(0.005 )) irit.SetResolution( 60) cntrs = irit.contour( bisectsrfe3, irit.plane( 0, 0, 1, 1e-008 ) ) irit.adwidth( cntrs, 2 ) irit.attrib( cntrs, "width", irit.GenRealObject(0.015 )) irit.interact( irit.list( bisectsrfe3, pl, cntrs, view_mat3d ) ) bisectcrvs = irit.cbisector2d( irit.list( c1, c2 ), 0, 1, 30, 1,\ 0 )
# 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 ) ) c = irit.nth( irit.gginter( c1, r1, c2, r2, 100, 0 ),\ 1 ) irit.interact( irit.list( s1, s2, c ) ) irit.save( "rngrng1", irit.list( zerosetsrf, s1, s2, c ) ) a = 0.9 while ( a >= 0.05 ):
def layouthandletrimmedsrfs(tsrfs, highlighttrim): retval = irit.nil() i = 1 while (i <= irit.SizeOf(tsrfs)): irit.snoc(layouthandleonetrimmed(irit.nth(tsrfs, i), highlighttrim), retval) i = i + 1 return retval # ############################################################################ # # Layout (prisa) of a sphere - several resolutions/directions. # view_mat3d = irit.rotx((-90)) * irit.roty(135) * irit.rotx((-30)) * irit.scale( (0.5, 0.5, 0.5)) view_mat2d = irit.scale((0.15, 0.15, 0.15)) * irit.trans((0, (-0.8), 0)) s45 = math.sin(math.pi / 4) halfcirc = irit.cbspline( 3, irit.list( irit.ctlpt( irit.P3, 1, 0, 0, 1 ), \ irit.ctlpt( irit.P3, s45, (-s45 ), 0, s45 ), \ irit.ctlpt( irit.P3, 1, (-1 ), 0, 0 ), \ irit.ctlpt( irit.P3, s45, (-s45 ), 0, (-s45 ) ), \ irit.ctlpt( irit.P3, 1, 0, 0, (-1 ) ) ), irit.list( 0, 0, 0, 1, 1, 2,\ 2, 2 ) ) sp = irit.surfrev(halfcirc) irit.color(sp, irit.YELLOW) irit.interact(irit.list(view_mat3d, sp))
irit.ctlpt( irit.E3, 2.5, 2.9, 0.7 ), \ irit.ctlpt( irit.E3, 2.3, 2.8, 1.7 ), \ irit.ctlpt( irit.E3, 2.1, 2.7, 2.7 ) ) ) ), irit.list( irit.list( irit.KV_OPEN ), irit.list( irit.KV_OPEN ), irit.list( irit.KV_OPEN ) ) ) irit.color(tv2, irit.YELLOW) tv2mesh = irit.ffmesh(tv2) irit.color(tv2mesh, irit.RED) irit.interact(irit.list(tv2, tv2mesh)) irit.save("trivar1", irit.list(tv1, tv2 * irit.tx(3), tv2mesh * irit.tx(3))) irit.free(tv2mesh) dlevel = irit.iritstate("dumplevel", dlevel) irit.free(dlevel) tv1t = tv1 * irit.rotx(50) * irit.trans((1.5, (-1.5), 2)) irit.color(tv1t, irit.RED) tv2t = tv2 * irit.sc(0.75) * irit.trans(((-1.5), 1.5, (-2))) irit.color(tv2t, irit.GREEN) irit.interact(irit.list(tv1, tv1t)) irit.interact(irit.list(tv2, tv2t)) irit.save( "trivar2a", irit.list( irit.list( tv1, tv1t ), \ irit.list( tv2, tv2t ) * irit.tx( 3 ), \ irit.list( irit.fforder( tv1 ), irit.ffctlpts( tv1 ), irit.ffmsize( tv1 ), \ irit.pdomain( tv1 ), irit.fforder( tv2 ), irit.ffmsize( tv2 ), \ irit.ffkntvec( tv2 ), irit.ffctlpts( tv2 ), irit.pdomain( tv2t ) ), \ irit.list( irit.tvolume( tv1, 1 ), irit.tvolume( tv1t, 1 ), \ irit.tvolume( tv2, 1 ), irit.tvolume( tv2t, 1 ) ) ) )
s2 = irit.sbspline( 3, 3, irit.list( irit.list( irit.ctlpt( irit.E3, 0.1, 0, 1 ), \ irit.ctlpt( irit.E3, 0.3, 0.7, 0.5 ), \ irit.ctlpt( irit.E3, 0.1, 1.2, 1 ), \ irit.ctlpt( irit.E3, 0, 2, 0.5 ) ), irit.list( \ irit.ctlpt( irit.E3, 1.1, 0, 0.5 ), \ irit.ctlpt( irit.E3, 1.3, 1, 0 ), \ irit.ctlpt( irit.E3, 1.1, 1.3, 0.5 ), \ irit.ctlpt( irit.E3, 1, 2, 0.5 ) ), irit.list( \ irit.ctlpt( irit.E3, 2.1, 0, 1.1 ), \ irit.ctlpt( irit.E3, 2.3, 0.5, 0.4 ), \ irit.ctlpt( irit.E3, 2, 1, 1.3 ), \ irit.ctlpt( irit.E3, 2, 2, 0.4 ) ), irit.list( \ irit.ctlpt( irit.E3, 3.1, 0, 1.9 ), \ irit.ctlpt( irit.E3, 3.3, 0.7, 1.4 ), \ irit.ctlpt( irit.E3, 3.1, 1.1, 1.5 ), \ irit.ctlpt( irit.E3, 3.1, 2, 1.9 ) ) ), irit.list( irit.list( irit.KV_OPEN ), irit.list( irit.KV_OPEN ) ) ) * irit.rotx( 90 ) * irit.trans( ( 1.5, 1.5, 0 ) ) irit.color(s1, irit.RED) irit.color(s2, irit.GREEN) i = testinter(s1, s2) all = irit.list(s1, s2, i) irit.interact(all) irit.save("ssi4", all) # # 5. Two biquadratic rational surface intersection - a cone and a sphere. # s1 = irit.conesrf(3, 0.7)
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # The most common example of wireframe ambiguity. See for example: # Geometric Modeling by Michael E. Mortenson, page 4... # save_res = irit.GetResolution() save_mat = irit.GetViewMatrix() irit.SetViewMatrix(irit.GetViewMatrix() * irit.scale( (0.6, 0.6, 0.6)) * irit.rotx(30) * irit.roty(20)) a = irit.box(((-0.5), (-0.5), (-0.55)), 1, 1, 1.1) irit.SetResolution(4) # To create 4 sided pyramids from cones... c1 = irit.cone((0, 0, (-0.6)), (0, 0, 0.6001), 0.6 * math.sqrt(2), 1) * irit.rotz(45) c2 = irit.cone((0, 0, 0.6), (0, 0, (-0.6)), 0.6 * math.sqrt(2), 1) * irit.rotz(45) a = (a - c1 - c2) irit.free(c1) irit.free(c2) irit.view(irit.list(irit.GetViewMatrix(), a), irit.ON) b = irit.box(((-0.3), (-0.3), (-1)), 0.6, 0.6, 2)
save_mat = irit.GetViewMatrix() irit.SetViewMatrix( irit.GetViewMatrix() * irit.scale( ( 0.5, 0.5, 0.5 ) )) save_res = irit.GetResolution() irit.SetResolution( 12) t1 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0.25, 0, 1 ), \ irit.ctlpt( irit.E3, 0.01, 0, 1 ), \ irit.ctlpt( irit.E3, 0.04, 0, 1.1 ), \ irit.ctlpt( irit.E3, 0.04, 0, 1.25 ), \ irit.ctlpt( irit.E3, 0.04, 0, 1.3 ), \ irit.ctlpt( irit.E3, 0.001, 0, 1.3 ) ), irit.list( 0, 0, 0, 1, 2, 3,\ 4, 4, 4 ) ) t1 = irit.surfrev( t1 ) t2 = t1 * irit.rotx( 180 ) t = irit.gpolygon( irit.list( t1, t2 ), 1 ) irit.free( t1 ) irit.free( t2 ) irit.interact( irit.list( irit.GetViewMatrix(), t ) ) irit.SetResolution( 20) t3 = irit.cylin( ( 0, 0, (-2 ) ), ( 0, 0, 4 ), 0.1, 3 ) irit.view( t3, irit.OFF ) s1 = t3 * t irit.free( t ) irit.free( t3 ) final = irit.convex( s1 )
irit.attrib( carouselbase, "reflect", irit.GenRealObject(0.9 )) carousel = irit.list( carouselbase, carouselrods * irit.trans( ( 0, 0, 0.3 ) ) ) irit.free( carouselbase ) irit.free( carouselrods ) # # A swing # swingsiderod = irit.sweepsrf( irit.circle( ( 0, 0, 0 ), 0.01 ), irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0.2, 0, (-0.05 ) ), \ irit.ctlpt( irit.E3, 0.1, 0, 0.95 ), \ irit.ctlpt( irit.E3, 0.05, 0, 1 ), \ irit.ctlpt( irit.E3, (-0.05 ), 0, 1 ), \ irit.ctlpt( irit.E3, (-0.1 ), 0, 0.95 ), \ irit.ctlpt( irit.E3, (-0.2 ), 0, (-0.05 ) ) ), irit.list( irit.KV_OPEN ) ), irit.GenRealObject(0 )) swingframe = irit.list( swingsiderod * irit.trans( ( 0, (-1 ), 0 ) ), swingsiderod * irit.trans( ( 0, 1, 0 ) ), irit.extrude( irit.circle( ( 0, 0, 0 ), 0.01 ), ( 0, 0, 2 ), 0 ) * irit.rotx( (-90 ) ) * irit.trans( ( 0, (-1 ), 1 ) ) ) irit.color( swingframe, irit.RED ) irit.attrib( swingframe, "reflect", irit.GenRealObject(0.5 )) irit.free( swingsiderod ) swingchairrods = irit.list( irit.extrude( irit.circle( ( 0, 0, 0 ), 0.02 ), ( 0, 0, 0.03 ), 0 ) * irit.rotx( (-90 ) ) * irit.trans( ( 0, (-0.015 ), 1 ) ), irit.extrude( irit.circle( ( 0, 0, 0.2 ), 0.01 ), ( 0, 0, 0.8 ), 0 ), (-irit.extrude( irit.circle( ( 0, 0, 0.2 ), 0.007 ), ( 0, 0, (-0.07 ) ), 0 ) ) * irit.roty( 90 ) * irit.trans( ( (-0.2 ), 0, 0.27 ) ) ) swingchair1rods = irit.list( swingchairrods * irit.trans( ( 0, (-0.07 ), 0 ) ), swingchairrods * irit.trans( ( 0, 0.07, 0 ) ) ) irit.color( swingchair1rods, irit.GREEN ) irit.attrib( swingchair1rods, "reflect", irit.GenRealObject(0.9 )) swingchair1 = irit.list( swingchair1rods, chair * irit.scale( ( 0.25, 0.28, 0.25 ) ) * irit.trans( ( (-0.07 ), 0, 0.05 ) ) ) irit.free( swingchair1rods ) swingchair2rods = irit.list( swingchairrods * irit.trans( ( 0, 0.53, 0 ) ), swingchairrods * irit.trans( ( 0, 0.67, 0 ) ) ) irit.color( swingchair2rods, irit.YELLOW ) irit.attrib( swingchair2rods, "reflect", irit.GenRealObject(0.9 )) swingchair2 = irit.list( swingchair2rods, chair * irit.scale( ( 0.25, 0.28, 0.25 ) ) * irit.trans( ( (-0.07 ), 0.6, 0.05 ) ) )
while (i <= n): pt2 = irit.coerce( irit.ceval(crv, irit.FetchRealObject(t1) + irit.FetchRealObject(dt) * i), irit.E3) retval = retval + distptpt(pt1, pt2) pt1 = pt2 i = i + 1 return retval # # Set a global variable in a function. # dumvar = irit.rotx(10) def modaxes(): dumvar = (1, 2, 3) retval = dumvar return retval irit.save( "functn3", irit.list( crvlength( irit.circle( ( 0, 0, 0 ), 1 ), 30 )/2, \ crvlength( irit.circle( ( 0, 0, 0 ), 1 ), 100 )/2, \ crvlength( irit.circle( ( 0, 0, 0 ), 1 ), 300 )/2, \ dumvar,\ modaxes(), \ dumvar ) )
c1 = ( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \ irit.ctlpt( irit.E3, 0, 0.01, 0 ), \ irit.ctlpt( irit.E3, 0.5, 0.02, 0 ), \ irit.ctlpt( irit.E3, 1, 0, 0 ) ), irit.list( irit.KV_OPEN ) ) + irit.cbspline( 3, irit.list( \ irit.ctlpt( irit.E3, 1, 0, 0 ), \ irit.ctlpt( irit.E3, 0.5, (-0.02 ), 0 ), \ irit.ctlpt( irit.E3, 0, (-0.01 ), 0 ), \ irit.ctlpt( irit.E3, 0, 0, 0 ) ), irit.list( irit.KV_OPEN ) ) ) tankwins = irit.ruledsrf( c1 * irit.sc( 0.01 ) * irit.trans( ( 0.99, 0, 0.56 ) ), c1 ) if ( do_texture == 1 ): irit.attrib( tankwins, "texture", texture ) irit.attrib( tankwins, "rgb", irit.GenStrObject(graycolor) ) irit.color( tankwins, irit.WHITE ) tankwing1 = tankwins * irit.rotx( 45 ) * irit.trans( ( 6.2, 0, (-0.5 ) ) ) tankwing2 = tankwins * irit.rotx( 135 ) * irit.trans( ( 6.2, 0, (-0.5 ) ) ) tankwing3 = tankwins * irit.rotx( 225 ) * irit.trans( ( 6.2, 0, (-0.5 ) ) ) tankwing4 = tankwins * irit.rotx( 315 ) * irit.trans( ( 6.2, 0, (-0.5 ) ) ) irit.free( tankwins ) tankholder = irit.ruledsrf( c1 * irit.scale( ( 4, 5.2, 1 ) ) * irit.trans( ( 2.7, 0, 0.1 ) ), c1 * irit.scale( ( 5.2, 5.2, 1 ) ) * irit.trans( ( 1.8, 0, (-0.5 ) ) ) ) irit.free( c1 ) if ( do_texture == 1 ): irit.attrib( tankholder, "texture", texture ) irit.attrib( tankholder, "rgb", irit.GenStrObject(graycolor) ) irit.color( tankholder, irit.WHITE ) tank = irit.list( tankbody, tankholder, tankwing1, tankwing2, tankwing3, tankwing4 ) irit.free( tankbody ) irit.free( tankholder )
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # A modern cup. # # Gershon Elber, November 1995 # save_mat = irit.GetViewMatrix() irit.SetViewMatrix( irit.rotx( (-90 ) ) * irit.tx( (-0.5 ) ) * irit.ty( (-1 ) ) * irit.sc( 0.8 )) irit.viewobj( irit.GetViewMatrix() ) ptlist = irit.nil( ) i = 0 while ( i <= 7 ): irit.snoc( irit.point( math.cos( i * 2 * math.pi/8 ), math.sin( i * 2 * 3.14159/8 ), 0 ), ptlist ) i = i + 1 c1 = irit.coerce( irit.cbspline( 3, ptlist, irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN ) * irit.rz( (-22.5 ) ) c2 = irit.coerce( irit.cbspline( 2, ptlist, irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN ) * irit.sc( 1.1 ) irit.free( ptlist ) minsize = 0.01 body = irit.sfromcrvs( irit.list( c2 * irit.sc( minsize ) * irit.tz( 0.05 ), c2 * irit.sc( 0.7 ) * irit.tz( 0.05 ), c2 * irit.sc( 0.8 ) * irit.tz( 0.05 ), c2 * irit.sc( 0.9 ), c2, c2 * irit.tz( 2 ), c2 * irit.tz( 2.2 ), c1 * irit.tz( 2.2 ), c1 * irit.tz( 2 ), c1 * irit.tz( 0.4 ), c1 * irit.sc( 0.5 ) * irit.tz( 0.2 ), c1 * irit.sc( minsize ) * irit.tz( 0.2 ) ), 3, irit.KV_OPEN ) irit.free( c1 ) irit.free( c2 )
# ############################################################################ 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) irit.interact(irit.list(srf1, srf1ms)) irit.free(srf1ms) srf1gs = irit.coerce(irit.sgauss(srf1, 0), irit.E3) * irit.rotx( (-90)) * irit.roty((-90)) * irit.sz(0.01) irit.color(srf1gs, irit.GREEN) irit.interact(irit.list(srf1, srf1gs)) irit.save("sgauss", irit.list(srf1, srf1gs)) irit.free(srf1gs) # ############################################################################ # Derive the coefficients of the three surface fundamental forms.
# save_res = irit.GetResolution() # ############################################################################ # StickStar # sqrt2 = math.sqrt(2) eps = 0.015 rad = 0.3 len = (rad + eps) * 2 itemaux1 = irit.box( ((-rad) / sqrt2, (-rad) / sqrt2, (-len)), rad * 2 / sqrt2, rad * 2 / sqrt2, len * 2) * irit.rz(45) itemaux2 = ( itemaux1 * irit.tx(rad) - itemaux1 * irit.rotx(90) * irit.tz(rad + eps) - itemaux1 * irit.rotx(90) * irit.tz((-rad) - eps)) * irit.tx(eps / 2) diag = (len + eps) diagpoly = irit.poly( irit.list((diag, diag, 0), ((-diag), diag, 0), ((-diag), 0, diag), (diag, 0, diag)), irit.FALSE) item1 = (itemaux2 - diagpoly - diagpoly * irit.sy((-1)) - diagpoly * irit.sz( (-1)) - diagpoly * irit.sz((-1)) * irit.sy((-1))) irit.color(item1, irit.RED) item2 = item1 * irit.sx((-1)) irit.color(item2, irit.MAGENTA) item3 = item1 * irit.rx(90) * irit.rz(90) irit.color(item3, irit.GREEN)
tr1 = virttree3(newpos, rotatevector2(dir, rfactor) * lfactor, size * wfactor, blevel, level - 1) tr2 = virttree3( newpos, rotatevector2(dir, rfactor * irit.random((-1), 1)) * lfactor, size * wfactor, blevel, level - 1) tr3 = virttree3(newpos, rotatevector2(dir, (-rfactor)) * lfactor, size * wfactor, blevel, level - 1) retval = retval + tr1 + tr2 + tr3 return retval irit.SetViewMatrix( irit.rotx((-90)) * irit.roty(135) * irit.rotx((-30)) * irit.scale( (0.2, 0.2, 0.2)) * irit.trans((0, (-0.5), 0))) tree1 = virttree2(irit.point(0, 0, 0), irit.vector(0, 0, 1), 0.3, 4, 7) irit.interact(irit.list(irit.GetViewMatrix(), tree1)) irit.free(tree1) tree2 = virttree3(irit.point(0, 0, 0), irit.vector(0, 0, 1), 0.5, 3, 5) irit.interact(tree2) irit.free(tree2) def forest3(n, m, blevel, level): retval = irit.nil() i = 0 while (i <= n):
# save_mat = irit.GetViewMatrix() # ############################################################################ # StickStar # sqrt2 = math.sqrt(2) eps = 0.015 rad = 0.3 len = (rad + eps) * 2 itemaux1 = irit.box( ((-rad) / sqrt2, (-rad) / sqrt2, (-len)), rad * 2 / sqrt2, rad * 2 / sqrt2, len * 2) * irit.rz(45) itemaux2 = ( itemaux1 * irit.tx(rad) - itemaux1 * irit.rotx(90) * irit.tz(rad + eps) - itemaux1 * irit.rotx(90) * irit.tz((-rad) - eps)) * irit.tx(eps / 2) diag = (len + eps) diagpoly = irit.poly( irit.list((diag, diag, 0), ((-diag), diag, 0), ((-diag), 0, diag), (diag, 0, diag)), irit.FALSE) item1 = (itemaux2 - diagpoly - diagpoly * irit.sy((-1)) - diagpoly * irit.sz( (-1)) - diagpoly * irit.sz((-1)) * irit.sy((-1))) item1 = irit.convex(item1) irit.color(item1, irit.RED) item2 = item1 * irit.sx((-1)) irit.color(item2, irit.MAGENTA) item3 = item1 * irit.rx(90) * irit.rz(90) irit.color(item3, irit.GREEN)
import irit # # # Simple molecule - 8 atoms connected as a cube. # t = irit.time( 1 ) save_res = irit.GetResolution() save_view = irit.GetViewMatrix() irit.SetViewMatrix( irit.GetViewMatrix() * \ irit.scale( ( 0.6, 0.6, 0.6 ) ) * \ irit.rotx( 20 ) * \ irit.roty( 45 ) * \ irit.trans( ( (-0.3 ), 0.2, 0 ) )) irit.SetResolution( 16) s1 = irit.sphere( ( 0, 0, 0 ), 0.2 ) s2 = irit.sphere( ( 1, 0, 0 ), 0.2 ) irit.SetResolution( 8) c1 = irit.cylin( ( 0, 0, 0 ), ( 1, 0, 0 ), 0.05, 3 ) irit.view( irit.list( irit.GetViewMatrix(), s1, s2, c1 ), irit.ON ) b1 = ( (s1 ^ s2) + c1 ) irit.free( s1 ) irit.free( s2 )
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 ) irit.interact( irit.list( irit.GetAxes(), cbzr, sbzr ) ) # # Rotate around the X Axes(): # a = 1 while ( a <= 36 ): cbzr = cbzr * rot10x irit.view( irit.list( cbzr, irit.GetAxes() ), irit.ON ) a = a + 1
irit.symbprod(ms1, ms1))) # # Examine MZERO # s1 = irit.bivariate2bezier("math.pow(x, 2) + math.pow(y, 2) - 1", 2, 2) s1 = irit.coerce( irit.sregion( irit.sregion( s1, irit.COL, (-3 ), 3 ), irit.ROW, (-3 ),\ 3 ), irit.MULTIVAR_TYPE ) s2 = irit.bivariate2bezier("math.pow((x + 1), 2) + math.pow(y, 2) - 1", 2, 2) s2 = irit.coerce( irit.sregion( irit.sregion( s2, irit.COL, (-3 ), 3 ), irit.ROW, (-3 ),\ 3 ), irit.MULTIVAR_TYPE ) sol = irit.mzero(irit.list(s1, s2), 0.01, 1e-006) irit.color(sol, irit.RED) m = irit.rotx((-90)) * irit.roty((-90)) * irit.sz(0.1) irit.interact( irit.list( irit.coerce(irit.coerce(s1, irit.SURFACE_TYPE), irit.E3) * m, irit.coerce(irit.coerce(s2, irit.SURFACE_TYPE), irit.E3) * m, irit.coerce(irit.coerce(s2, irit.SURFACE_TYPE), irit.E3) * m * irit.sz(0), sol)) sol = irit.mzero(irit.list(s1), 0.01, 1e-006) irit.color(sol, irit.RED) m = irit.rotx((-90)) * irit.roty((-90)) * irit.sz(0.1) irit.interact( irit.list( irit.coerce(irit.coerce(s1, irit.SURFACE_TYPE), irit.E3) * m, irit.coerce(irit.coerce(s2, irit.SURFACE_TYPE), irit.E3) * m * irit.sz(0), sol))
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # Some examples of 3d bisector computations between surfaces and points. # # Gershon Elber, February 1997. # save_res = irit.GetResolution() irit.SetResolution(60) save_mat = irit.GetViewMatrix() irit.SetViewMatrix(irit.rotz(35) * irit.rotx((-60)) * irit.sc(0.3)) irit.viewobj(irit.GetViewMatrix()) irit.viewstate("depthcue", 1) irit.viewstate("widthlines", 1) # ############################################################################ # # A bilinear surface: sphere--plane bisector # s1 = irit.ruledsrf( irit.ctlpt( irit.E3, (-1 ), (-1 ), 0 ) + \ irit.ctlpt( irit.E3, 1, (-1 ), 0 ), \ irit.ctlpt( irit.E3, (-1 ), 1, 0 ) + \ irit.ctlpt( irit.E3, 1, 1, 0 ) ) irit.color(s1, irit.RED) pt = irit.point(0, 0, 1)
irit.attrib(c3, "width", irit.GenRealObject(0.0001)) c12 = c1 * c2 c123 = c12 * c3 irit.attrib(c123, "width", irit.GenRealObject(0.005)) irit.color(c123, irit.RED) irit.adwidth(c123, 3) all = irit.list(c123, c1, c2, c3) irit.SetViewMatrix(irit.sc(1.1)) irit.viewobj(irit.GetViewMatrix()) tr = 0.4 proj1 = all * irit.trans(((-tr), tr, 0)) proj2 = all * irit.rotx(90) * irit.trans((tr, tr, 0)) proj3 = all * irit.roty(90) * irit.trans(((-tr), (-tr), 0)) proj4 = all * irit.roty(30) * irit.rotx(20) * irit.trans((tr, (-tr), 0)) allproj = irit.list(proj1, proj2, proj3, proj4) irit.save("cylin3a", allproj) irit.interact(allproj) c123a = c123 * irit.roty(30) * irit.rotx(20) * irit.scale((3, 3, 3)) irit.attrib(c123a, "width", irit.GenRealObject(0.015)) irit.save("cylin3b", c123a) irit.interact(c123a) c123b = c123 * irit.roty(60) * irit.rotx(65) * irit.scale((3, 3, 3))
v9 = (0, g, (-1)) pl1 = irit.poly(irit.list(v2, v3, v1), irit.FALSE) pl2 = irit.poly(irit.list(v1, v4, v2), irit.FALSE) pl3 = irit.poly(irit.list(v2, v6, v3), irit.FALSE) pl4 = irit.poly(irit.list(v3, v5, v1), irit.FALSE) pl5 = irit.poly(irit.list(v3, v9, v5), irit.FALSE) pl6 = irit.poly(irit.list(v3, v6, v9), irit.FALSE) pl7 = irit.poly(irit.list(v2, v7, v6), irit.FALSE) pl8 = irit.poly(irit.list(v2, v4, v7), irit.FALSE) pl9 = irit.poly(irit.list(v1, v8, v4), irit.FALSE) pl10 = irit.poly(irit.list(v1, v5, v8), irit.FALSE) icosa1 = irit.mergepoly( irit.list( pl1, pl2, pl3, pl4, pl5, pl6,\ pl7, pl8, pl9, pl10 ) ) icosa2 = icosa1 * irit.rotx(180) icosa = irit.mergepoly(irit.list(icosa1, icosa2)) # ############################################################################ tetraaux = tetra * irit.sc(0.15) irit.color(tetraaux, irit.WHITE) octaaux = octa * irit.sc(0.2) * irit.tx(1.175) irit.color(octaaux, irit.WHITE) dodecaaux = dodeca * irit.sc(0.1) * irit.ty(1.175) irit.color(dodecaaux, irit.WHITE) icosaaux = icosa * irit.sc(0.1) * irit.tx(1.175) * irit.ty(1.175) irit.color(icosaaux, irit.WHITE) plato = irit.list(tetraaux, octaaux, dodecaaux, icosaaux) irit.attrib(plato, "animation", irit.list(rot_x, rot_y, rot_z))
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # 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 ) ):
import math import irit # # # A test of intersection of two cubes. Assumes double precision floating point. # # Gershon Elber, April 94. # length = 1 angle = 10 b1 = irit.box( ( (-length )/2.0, (-length )/2.0, (-length )/2.0 ), length, length, length ) b2 = irit.box( ( 0, (-length )/2.0, (-length )/2.0 ), length, length, length ) * irit.rotx( angle ) irit.attrib( b1, "width", irit.GenRealObject(0.0001 )) irit.attrib( b2, "width", irit.GenRealObject(0.0001 )) b12a = b1 * b2 irit.attrib( b12a, "width", irit.GenRealObject(0.01) ) irit.interact( b12a ) angle = 1 b1 = irit.box( ( (-length )/2.0, (-length )/2.0, (-length )/2.0 ), length, length, length ) b2 = irit.box( ( 0, (-length )/2.0, (-length )/2.0 ), length, length, length ) * irit.rotx( angle ) irit.attrib( b1, "width", irit.GenRealObject(0.0001 )) irit.attrib( b2, "width", irit.GenRealObject(0.0001 )) b12b = b1 * b2 irit.attrib( b12b, "width", irit.GenRealObject(0.01 )) irit.interact( b12b )