irit.attrib( triang, "width", irit.GenStrObject("0.02" ))
irit.color( triang, irit.RED )
irit.SetViewMatrix( irit.scale( ( 0.2, 0.2, 0.2 ) ))
cube_prisa = irit.list( square,
square * irit.trans( ( 1, 0, 0 ) ),
square * irit.trans( ( 2, 0, 0 ) ),
square * irit.trans( ( (-1 ), 0, 0 ) ),
square * irit.trans( ( 0, 1, 0 ) ),
square * irit.trans( ( 0, (-1 ), 0 ) ) )
irit.interact( irit.list( irit.GetViewMatrix(), cube_prisa ) )
irit.save( "cubepris", cube_prisa )
irit.free( cube_prisa )
box_prisa = irit.list( rectan, square * irit.trans( ( 2, 0, 0 ) ), square * irit.trans( ( (-1 ), 0, 0 ) ), rectan * irit.trans( ( 0, 1, 0 ) ), rectan * irit.trans( ( 0, 2, 0 ) ), rectan * irit.trans( ( 0, (-1 ), 0 ) ) )
irit.interact( irit.list( irit.GetViewMatrix(), box_prisa ) )
irit.save( "box_pris", box_prisa )
irit.free( box_prisa )
piram_prisa = irit.list( square, triang * irit.trans( ( 1, 0, 0 ) ), triang * irit.rotz( 90 ) * irit.trans( ( 1, 1, 0 ) ), triang * irit.rotz( 180 ) * irit.trans( ( 0, 1, 0 ) ), triang * irit.rotz( 270 ) * irit.trans( ( 0, 0, 0 ) ) )
irit.interact( irit.list( irit.GetViewMatrix(), piram_prisa ) )
irit.save( "pirapris", piram_prisa )
irit.free( piram_prisa )
irit.SetViewMatrix( save_mat)
irit.free( square )
irit.free( triang )
irit.free( rectan )
#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)
crv2, irit.FetchRealObject(irit.crvptdst(crv2, (0, 0, 0), 0, 0.001)))
irit.interact(
irit.list(irit.GetAxes(), crv2, irit.coerce(pt_max, irit.VECTOR_TYPE)))
irit.save(
"crv4dist",
irit.list(irit.GetAxes(), crv2, irit.coerce(pt_max, irit.VECTOR_TYPE)))
crv3a = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0, 1 ), \
irit.ctlpt( irit.E2, 0.1, 1 ), \
irit.ctlpt( irit.E2, 0.1, 0.1 ), \
irit.ctlpt( irit.E2, 0.5, 0.1 ), \
irit.ctlpt( irit.E2, 0.5, (-0.1 ) ), \
irit.ctlpt( irit.E2, 0.1, (-0.1 ) ), \
irit.ctlpt( irit.E2, 0.1, (-1 ) ), \
irit.ctlpt( irit.E2, 0, (-1 ) ) ), irit.list( irit.KV_OPEN ) )
crv3b = crv3a * irit.rotz(180)
crv3 = (crv3a + crv3b) * irit.trans((0.1, 0.1, 0))
irit.color(crv3, irit.GREEN)
irit.attrib(crv3, "width", irit.GenRealObject(0.02))
pt_param = irit.crvptdst(crv3, (0, 0, 0), 0, (-0.001))
pt_extrem = irit.nil()
i = 1
while (i <= irit.SizeOf(pt_param)):
pt = irit.ceval(crv3, irit.FetchRealObject(irit.nth(pt_param, i)))
irit.snoc(irit.coerce(pt, irit.VECTOR_TYPE), pt_extrem)
i = i + 1
irit.interact(irit.list(irit.GetAxes(), crv3, pt_extrem))
irit.save("crv5dist", irit.list(irit.GetAxes(), crv3, pt_extrem))
pt_min = irit.ceval(
irit.Fetch3TupleObject(vec2), irit.Fetch3TupleObject(vec3))
rvec = vec2 ^ vec3
prism2 = prism1 * \
irit.rotvec( irit.Fetch3TupleObject(rvec), \
180 * math.acos( irit.FetchRealObject(irit.normalizeVec( vec2 ) * irit.normalizeVec( vec3 )) )/ math.pi ) * \
irit.trans( irit.Fetch3TupleObject(-vec2 ) ) * \
irit.rotvec( irit.Fetch3TupleObject(vec2), (-60 ) ) * \
irit.trans( irit.Fetch3TupleObject((-vec1 ) + irit.normalizeVec( vec1 + vec2 )*0.6 + irit.vector( 0, 0, 0.81 )) )
item1 = prism1 ^ prism2
irit.color(item1, irit.RED)
prism2a = prism2 * \
irit.rotz( an ) * \
irit.sy( (-1 ) ) * \
irit.tx( 1 ) * \
irit.trans( irit.Fetch3TupleObject(-vec3 ) )
item2 = prism1 ^ prism2a * irit.trans(irit.Fetch3TupleObject(vec3))
irit.color(item2, irit.MAGENTA)
prism2b = prism2 * irit.trans( irit.Fetch3TupleObject(vec1*2 - \
vec3*2 + \
vec2 ))
item3 = prism1 ^ \
prism2b * \
irit.rotz( 180 ) * \
irit.trans( irit.Fetch3TupleObject(vec3*2 + \
vec1 + \
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.color(derivevecs, irit.RED)
irit.interact(irit.list(c7, pll, derivevecs))
irit.save("interp12", irit.list(c7, pll, derivevecs))
irit.free(derivevecs)
irit.free(derivpt1)
irit.free(derivpt2)
irit.free(pt1)
irit.free(pt2)
irit.free(pll)
irit.free(c7)
# ############################################################################
irit.SetViewMatrix(
irit.rotz(50) * irit.rotx((-60)) * irit.scale((0.2, 0.2, 0.2)))
irit.viewobj(irit.GetViewMatrix())
pl = irit.nil()
pll = irit.nil()
x = (-5)
while (x <= 5):
pl = irit.nil()
y = (-5)
while (y <= 5):
irit.snoc(
irit.point(
x, y,
math.sin(x * math.pi / 2.0) * math.cos(y * 3.14159 / 2.0)), pl)
y = y + 1
irit.snoc(pl, pll)
prism2 = prism1 * \
irit.rotvec( irit.Fetch3TupleObject(rvec), \
180 * \
math.acos( irit.FetchRealObject(irit.normalizeVec( vec2 ) *
irit.normalizeVec( vec3 ) ) )/ \
math.pi ) * \
irit.trans( irit.Fetch3TupleObject(-vec2 ) ) * \
irit.rotvec( irit.Fetch3TupleObject(vec2), (-60 ) ) * \
irit.trans( irit.Fetch3TupleObject( (-vec1 ) + \
irit.normalizeVec( vec1 + vec2 )*0.6 + \
irit.vector( 0, 0, 0.81 ) ) )
item1 = prism1 ^ prism2
irit.color(item1, irit.RED)
prism2a = prism2 * \
irit.rotz( an ) * \
irit.sy( (-1 ) ) * \
irit.tx( 1 ) * \
irit.trans( irit.Fetch3TupleObject(-vec3 ) )
item2 = prism1 ^ prism2a * irit.trans(irit.Fetch3TupleObject(vec3))
irit.color(item2, irit.MAGENTA)
prism2b = prism2 * irit.trans(
irit.Fetch3TupleObject(vec1 * 2 - vec3 * 2 + 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)
#
# A chair base, to be used by most games below.
#
chairbasecrv = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0.6, 0, 0 ), \
irit.ctlpt( irit.E3, 0.3, 0, 0.05 ), \
irit.ctlpt( irit.E3, 0, 0, 0 ) ), irit.list( irit.KV_OPEN ) )
chairbasecross = ( irit.arc( ( 0.25, 0.05, 0 ), ( 0.25, 0, 0 ), ( 0.3, 0, 0 ) ) + \
irit.arc( ( 0.3, 0, 0 ), ( 0.25, 0, 0 ), ( 0.25, (-0.05 ), 0 ) ) + \
irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0.25, (-0.05 ), 0 ), \
irit.ctlpt( irit.E3, 0.22, (-0.05 ), 0 ), \
irit.ctlpt( irit.E3, 0, 0, 0 ), \
irit.ctlpt( irit.E3, (-0.22 ), (-0.05 ), 0 ), \
irit.ctlpt( irit.E3, (-0.25 ), (-0.05 ), 0 ) ), irit.list( irit.KV_OPEN ) ) + irit.arc( ( (-0.25 ), (-0.05 ), 0 ), ( (-0.25 ), 0, 0 ), ( (-0.3 ), 0, 0 ) ) + irit.arc( ( (-0.3 ), 0, 0 ), ( (-0.25 ), 0, 0 ), ( (-0.25 ), 0.05, 0 ) ) + \
irit.ctlpt( irit.E3, 0.25, 0.05, 0 ) )
chairbasemain = (-irit.sweepsrf( chairbasecross * irit.rotz( 90 ), chairbasecrv, irit.GenRealObject(0) ) )
chaircrv1 = irit.cmesh( chairbasemain, irit.ROW, 0 )
chaircrv1a = chaircrv1 * irit.trans( ( 0.06, 0, (-0.02 ) ) )
chaircrv1b = chaircrv1 * irit.scale( ( 0, 0.83, 0 ) ) * irit.trans( ( 0.66, 0, (-0.02 ) ) )
chairbasecover1 = (-irit.sfromcrvs( irit.list( chaircrv1, chaircrv1a, chaircrv1b ), 3, irit.KV_OPEN ) )
irit.free( chaircrv1 )
irit.free( chaircrv1a )
irit.free( chaircrv1b )
irit.free( chairbasecrv )
chaircrv2 = irit.cmesh( chairbasemain, irit.ROW, 2 )
chaircrv2a = chaircrv2 * irit.trans( ( (-0.06 ), 0, (-0.02 ) ) )
chaircrv2b = chaircrv2 * irit.scale( ( 0, 0.83, 0 ) ) * irit.trans( ( (-0.06 ), 0, (-0.02 ) ) )
chairbasecover2 = irit.sfromcrvs( irit.list( chaircrv2, chaircrv2a, chaircrv2b ), 3, irit.KV_OPEN )
irit.free( chaircrv2 )
#
# 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)
c = (a - b)
irit.free(a)
irit.free(b)
final = irit.convex(c)
irit.free(c)
#This is an IRIT script and as such requires both math and irit import: # import math import irit # a = irit.GetAxes() * irit.GetViewMatrix() ared = a irit.color(ared, irit.RED) irit.viewobj(ared) irit.free(ared) agreen = a * irit.rotz(15) irit.color(agreen, irit.GREEN) irit.viewobj(agreen) irit.free(agreen) ablue = a * irit.rotz(30) irit.color(ablue, irit.BLUE) irit.viewobj(ablue) irit.free(ablue) ayellow = a * irit.rotz(45) irit.color(ayellow, irit.YELLOW) irit.viewobj(ayellow) irit.free(ayellow) acyan = a * irit.rotz(60) irit.color(acyan, irit.CYAN) irit.viewobj(acyan)
(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)
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)
tan2 = irit.pcircle((0, 0, 3), 0)
blend = irit.hermite(crv1, (-crv2), tan1 * irit.sc(1), (-tan2) * irit.sc(1))
irit.color(blend, irit.RED)
irit.attrib(blend, "width", irit.GenRealObject(0.02))
all = irit.list(blend, tsrf1, (-srf2))
irit.interact(all)
irit.save("blend1", all)
view_mat2d = irit.scale((0.15, 0.15, 0.15)) * irit.trans((0, (-0.8), 0))
irit.interact(irit.list(view_mat2d, front_prisa, back_prisa))
# Animate:
b58_prisa2d = (irit.prisa(fuseback, samppercrv, 0.05, irit.COL,
(0, 0.1, 0), 0) * irit.trans((0, 4.4, 0)) +
irit.prisa(fusefront, samppercrv, 0.05, irit.COL,
(0, 0.1, 0), 0))
irit.color(b58_prisa2d, irit.RED)
b58_prisa3d = (irit.prisa(fusefront, samppercrv, (-0.05), irit.COL,
(0, 0, 0), 0) +
irit.prisa(fuseback, samppercrv, (-0.05), irit.COL,
(0, 0, 0), 0)) * irit.rotz(90) * irit.trans(
(0, 1, 3))
irit.color(b58_prisa3d, irit.MAGENTA)
irit.SetViewMatrix(
irit.rotx((-90)) * irit.roty(130) * irit.rotx((-35)) * irit.scale(
(0.18, 0.18, 0.18)) * irit.trans((0.9, (-0.9), 0)))
built_b58 = irit.nil()
iter_b58 = irit.nil()
morph_step = 0.02
b58_prisa2d_frame = srflistframecrvs(b58_prisa2d, 0.03)
irit.color(b58_prisa2d_frame, irit.RED)
b58_prisa3d_frame = srflistframecrvs(b58_prisa3d, 0.03)
irit.color(b58_prisa3d_frame, irit.GREEN)
irit.list(irit.vector((-10), (-10), 1.4), irit.vector(
(-10), 10, 1.4), irit.vector(10, 10, 1.4), irit.vector(
10, (-10), 1.4)), 0)) * irit.rotz2v(
irit.Fetch3TupleObject(irit.vector(1, 1, 0) * math.sqrt(3)))
irit.color(pl1, irit.GREEN)
irit.pause()
#
# Truncation along edges.
#
a = (-0.04)
while (a >= (-0.4)):
p = pl1 * irit.trans((a, a, a))
bt2 = b - p - p * irit.rotz(90) - p * irit.rotz(180) - p * irit.rotz(
270) - p * irit.rotx(90) - p * irit.rotx(90) * irit.rotz(
90) - p * irit.rotx(90) * irit.rotz(180) - p * irit.rotx(
90) * irit.rotz(270) - p * irit.rotx((-90)) - p * irit.rotx(
(-90)) * irit.rotz(90) - p * irit.rotx(
(-90)) * irit.rotz(180) - p * irit.rotx(
(-90)) * irit.rotz(270)
irit.color(bt2, irit.YELLOW)
irit.view(irit.list(bt2), irit.ON)
a = a + (-0.02)
irit.save("polytrnc", irit.list(bt1 * irit.tx((-2)), bt2 * irit.tx(2)))
# #############################################################################
irit.SetViewMatrix(save_mat)
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)
s1 = irit.sbezier( irit.list( irit.list( irit.ctlpt( irit.E3, 0.1, 0, 1.6 ), \
irit.ctlpt( irit.E3, 0.3, 1.1, 0.4 ), \
irit.ctlpt( irit.E3, 0, 2.2, 1.5 ) ), irit.list( \
irit.ctlpt( irit.E3, 1.1, 0.2, 3 ), \
irit.ctlpt( irit.E3, 1.3, 1, 1.4 ), \
irit.ctlpt( irit.E3, 1, 2.2, 2.7 ) ), irit.list( \
irit.ctlpt( irit.E3, 2.1, 0.1, 1.4 ), \
irit.ctlpt( irit.E3, 2.3, 1.3, 0.2 ), \
irit.ctlpt( irit.E3, 2, 2.2, 1.2 ) ) ) )
p = irit.seval(s1, 0.5, 0.5)
s2a = s1 * \
irit.trans( irit.Fetch3TupleObject(-irit.coerce( p, 4 ) ) ) * \
irit.scale( ( 1.2, 1.1, (-0.5 ) ) ) * \
irit.rotz( 15 ) * \
irit.trans( ( irit.FetchRealObject(irit.coord( p, 1 )),
irit.FetchRealObject(irit.coord( p, 2 )),
irit.FetchRealObject(irit.coord( p, 3 )) + 0.1 ) )
irit.color(s1, irit.RED)
irit.color(s2a, irit.GREEN)
i = testinter(s1, s2a)
all = irit.list(s1, s2a, i)
irit.interact(all)
irit.save("ssi10", all)
s2b = s1 * \
save_res = irit.GetResolution() irit.SetResolution(32) t1 = irit.cylin(((-1.1), 0, 0), (2.2, 0, 0), 0.2, 3) t2 = irit.cylin(((-0.8), 0, 0), (0.05, 0, 0), 0.3, 3) t3 = irit.cylin((0.8, 0, 0), ((-0.05), 0, 0), 0.3, 3) s1 = (t1 + t2 + t3) irit.free(t1) irit.free(t2) irit.free(t3) s1 = irit.convex(s1) irit.view(s1, irit.ON) s2 = s1 * irit.roty(90) s3 = s1 * irit.rotz(90) irit.view(irit.list(s2, s3), irit.OFF) s4 = (s1 + s2 + s3) irit.free(s1) irit.free(s2) irit.free(s3) irit.view(s4, irit.ON) irit.SetResolution(64) t4 = irit.sphere((0, 0, 0), 1) s5 = (t4 - s4) irit.free(s4) irit.free(t4)
save_res = irit.GetResolution()
# Number of samples per circle:
irit.SetResolution( 8)
# Note angle must be power of 2 as we multiply it by 2 each iteration, and
# angle_log should hold the base 2 log of the divider in angle: log2 16 = 4.
angle = 360/16.0
angle_log = 4
c = irit.cylin( ( 0.6, 0, (-0.1 ) ), ( 0, 0, 0.3 ), 0.1, 0 )
irit.view( irit.list( c, irit.GetAxes() ), irit.ON )
i = 1
while ( i <= angle_log ):
c = c ^ ( c * irit.rotz( angle ) )
angle = angle * 2
irit.view( irit.list( c, irit.GetAxes() ), irit.ON )
i = i + 1
#
# Now lets create the wheel, make a hole in it to make it looks more real,
# and subtract all the teeth from it:
#
irit.SetResolution( 32)
wheel = irit.cylin( ( 0, 0, 0 ), ( 0, 0, 0.08 ), 0.6, 3 )
irit.SetResolution( 16)
h1 = irit.cylin( ( 0, 0, (-0.1 ) ), ( 0, 0, 0.3 ), 0.1, 3 )
h2 = irit.box( ( (-0.2 ), (-0.05 ), (-0.1 ) ), 0.4, 0.1, 0.3 )
