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 )
