def plotfunc3d2poly(minx, maxx, miny, maxy, n, m):
first = 1
x = minx
while (x <= maxx):
lst = irit.nil()
y = miny
while (y <= maxy):
irit.snoc(irit.vector(x, y, plotfn3d(x, y)), lst)
y = y + (maxy - miny) / float(n - 1)
if (first == 1):
retval = irit.poly(lst, irit.TRUE)
first = 0
else:
retval = retval + irit.poly(lst, irit.TRUE)
x = x + (maxx - minx) / float(m - 1)
y = miny
while (y <= maxy):
lst = irit.nil()
x = minx
while (x <= maxx):
irit.snoc(irit.vector(x, y, plotfn3d(x, y)), lst)
x = x + (maxx - minx) / float(n - 1)
retval = retval + irit.poly(lst, irit.TRUE)
y = y + (maxy - miny) / float(m - 1)
return retval
def plotfunc2d2poly(min, max, n):
lst = irit.nil()
t = min
while (t <= max):
irit.snoc(irit.vector(t, plotfn2d(t), 0), lst)
t = t + (max - min) / float(n - 1)
retval = irit.poly(lst, irit.TRUE)
return retval
def forest3(n, m, blevel, level):
retval = irit.nil()
i = 0
while (i <= n):
j = 0
while (j <= m):
irit.snoc( virttree3( irit.point( i * 5, j * 5, 0 ), irit.vector( 0, 0, 1 ), 0.3, blevel, level ),\
retval )
j = j + 1
i = i + 1
return retval
def randomvecs(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, 2, math.sin(t) * r), l)
i = i + 1
retval = l
irit.color(retval, irit.RED)
irit.adwidth(retval, 3)
return retval
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)
return retval
def uvpos2ln(srf, lnpt, lndir, mindist):
uvpt = irit.srflndst(srf, irit.Fetch3TupleObject(lnpt), lndir, mindist,
0.001, 1e-010)
e3pt = irit.seval(srf, irit.FetchRealObject(irit.coord(uvpt, 0)),
irit.FetchRealObject(irit.coord(uvpt, 1)))
e3nrml = irit.snormal(srf, irit.FetchRealObject(irit.coord(uvpt, 0)),
irit.FetchRealObject(irit.coord(uvpt, 1)))
edge = irit.coerce( irit.ptptln( irit.Fetch3TupleObject(irit.coerce( e3pt, irit.POINT_TYPE )),
irit.Fetch3TupleObject(lnpt),
lndir ),
irit.E3 ) + \
e3pt
nedge = (e3pt +
irit.coerce(irit.coerce(e3pt, irit.POINT_TYPE) - e3nrml, irit.E3))
irit.color(e3pt, irit.MAGENTA)
irit.adwidth(e3pt, 3)
irit.color(edge, irit.CYAN)
irit.color(nedge, irit.GREEN)
line = irit.coerce( lnpt + irit.vector(lndir[0], lndir[1], lndir[2]) * irit.sc( 2 ), irit.E3 ) + \
irit.coerce( lnpt - irit.vector(lndir[0], lndir[1], lndir[2]) * irit.sc( 2 ), irit.E3 )
irit.color(line, irit.YELLOW)
retval = irit.list(line, e3pt, edge, nedge)
return retval
def genanimationorthomatchprmpts(ppl):
prm1 = ( irit.ctlpt( irit.E2, 0, 0 ) + \
irit.ctlpt( irit.E2, 0, 1 ) )
irit.color(prm1, irit.YELLOW)
prm2 = ( \
irit.ctlpt( irit.E2, 0, 0 ) + \
irit.ctlpt( irit.E2, 1, 0 ) )
irit.color(prm2, irit.CYAN)
pos1 = irit.nil()
pos2 = irit.nil()
pos12 = irit.nil()
i = 0
while (i <= irit.SizeOf(ppl) - 1):
pl = irit.coord(ppl, i)
j = 0
while (j <= irit.SizeOf(pl) - 1):
pt = irit.coord(pl, j)
t1 = irit.coord(pt, 0)
t2 = irit.coord(pt, 1)
if (t1 > t2):
irit.snoc(irit.vector(irit.FetchRealObject(t1), 0, 0), pos1)
irit.snoc(irit.vector(0, irit.FetchRealObject(t2), 0), pos2)
irit.snoc(pt, pos12)
j = j + 1
if (t1 > t2):
irit.snoc(irit.vector(10000, 0, 0), pos1)
irit.snoc(irit.vector(10000, 0, 0), pos2)
i = i + 1
pt = irit.point(0, 0, 0)
irit.color(pt, irit.RED)
irit.adwidth(pt, 3)
irit.attrib(pt, "animation", makerottransanimobj(irit.nil(), pos12))
irit.attrib(prm1, "animation", makerottransanimobj(irit.nil(), pos1))
irit.attrib(prm2, "animation", makerottransanimobj(irit.nil(), pos2))
retval = irit.list(pt, prm1, prm2)
return retval
def genanimationorthomatchcrvpts(ppl, crv, scl):
pt1 = irit.point(0, 0, 0)
pt2 = irit.point(0, 0, 0)
vec1 = ( irit.ctlpt( irit.E2, 0, 0 ) + \
irit.ctlpt( irit.E2, 0, scl ) )
irit.color(vec1, irit.YELLOW)
vec2 = ( \
irit.ctlpt( irit.E2, 0, 0 ) + \
irit.ctlpt( irit.E2, 0, scl ) )
irit.color(vec2, irit.CYAN)
pos1 = irit.nil()
pos2 = irit.nil()
rot1 = irit.nil()
rot2 = irit.nil()
i = 0
while (i <= irit.SizeOf(ppl) - 1):
pl = irit.coord(ppl, i)
j = 0
while (j <= irit.SizeOf(pl) - 1):
pt = irit.coord(pl, j)
t1 = irit.coord(pt, 0)
t2 = irit.coord(pt, 1)
if (t1 > t2):
irit.snoc(
irit.coerce(irit.ceval(crv, irit.FetchRealObject(t1)),
irit.POINT_TYPE), pos1)
irit.snoc(
irit.coerce(irit.ceval(crv, irit.FetchRealObject(t2)),
irit.POINT_TYPE), pos2)
n1 = irit.cnormal(crv, irit.FetchRealObject(t1))
n2 = irit.cnormal(crv, irit.FetchRealObject(t2))
irit.snoc(
irit.vector(
math.atan2(irit.FetchRealObject(irit.coord(n1, 0)),
irit.FetchRealObject(irit.coord(n1, 1))) *
180 / math.pi, 0, 0), rot1)
irit.snoc(
irit.vector(
math.atan2(irit.FetchRealObject(irit.coord(n2, 0)),
irit.FetchRealObject(irit.coord(n2, 1))) *
180 / math.pi, 0, 0), rot2)
j = j + 1
if (t1 > t2):
irit.snoc(irit.vector(10000, 0, 0), pos1)
irit.snoc(irit.vector(10000, 0, 0), pos2)
irit.snoc(irit.vector(0, 0, 0), rot1)
irit.snoc(irit.vector(0, 0, 0), rot2)
i = i + 1
irit.attrib(pt1, "animation", makerottransanimobj(irit.nil(), pos1))
irit.attrib(pt2, "animation", makerottransanimobj(irit.nil(), pos2))
irit.attrib(vec1, "animation", makerottransanimobj(rot1, pos1))
irit.attrib(vec2, "animation", makerottransanimobj(rot2, pos2))
retval = irit.list(pt1, pt2, vec1, vec2)
return retval
def extractcrvregion( crv, t1, t2, idx ):
if ( irit.FetchRealObject(t1) < 0 ):
retval = irit.cregion( crv, irit.FetchRealObject(t1) + 1, 1 ) + irit.cregion( crv, 0, irit.FetchRealObject(t2) )
else:
retval = irit.cregion( crv, irit.FetchRealObject(t1), irit.FetchRealObject(t2) )
retval = irit.creparam( retval, 0, 1 )
tn = irit.vector( 1, 0, 0 ) * irit.rz( irit.FetchRealObject( idx ) )
retval = irit.list( retval * irit.trans( irit.Fetch3TupleObject( tn * irit.sc( 0.15 ) ) ),
irit.arrow3d( irit.coerce( irit.ceval( retval, 0.5 ), 3 ),
tn, 0.35, 0.01, 0.1, 0.02 ) )
irit.attrib( retval, "width", irit.GenRealObject( irit.random( 0.007, 0.01 ) ) )
irit.attrib( retval, "gray", irit.GenRealObject( irit.random( 0.2, 0.8 ) ) )
irit.attrib( retval, "rgb", irit.GenStrObject( str(int(irit.random( 100, 255 ) ) ) +
"," +
str(int(irit.random( 100, 255 ) ) ) +
"," +
str(int(irit.random( 100, 255 ) ) ) ) )
return retval
def evalsrfrayinter(raypt, raydir, srf):
raygeom = irit.list(
irit.coerce(irit.point(raypt[0], raypt[1], raypt[2]), irit.E3) +
irit.coerce(
irit.point(raypt[0], raypt[1], raypt[2]) +
irit.vector(raydir[0], raydir[1], raydir[2]), irit.E3),
irit.point(raypt[0], raypt[1], raypt[2]))
irit.color(raygeom, irit.MAGENTA)
interpts = irit.srayclip(raypt, raydir, srf)
numinters = irit.FetchRealObject(irit.nth(interpts, 1))
intere3 = irit.nil()
i = 1
while (i <= numinters):
irit.snoc(irit.nth(interpts, i * 2 + 1), intere3)
i = i + 1
irit.color(intere3, irit.YELLOW)
retval = irit.list(raygeom, intere3)
return retval
def cnormalplnr( crv, t ):
v = irit.ctangent( crv, irit.FetchRealObject(t), 1 )
retval = irit.vector( irit.FetchRealObject(irit.coord( v, 1 )),
irit.FetchRealObject(-irit.coord( v, 0 )),
0 )
return retval
def makenormal(v):
retval = (irit.coord(v, 0) + irit.GenStrObject(",") + irit.coord(v, 1) +
irit.GenStrObject(",") + irit.coord(v, 2))
return retval
def makergb(v):
retval = ((irit.coord(v, 0) + 1) * 127 + irit.GenStrObject(",") +
(irit.coord(v, 1) + 1) * 127 + irit.GenStrObject(",") +
(irit.coord(v, 2) + 1) * 127)
return retval
v1 = irit.vector((-1), (-1), (-1))
v2 = irit.vector((-1), (-1), 1)
v3 = irit.vector((-1), 1, (-1))
v4 = irit.vector((-1), 1, 1)
v5 = irit.vector(1, (-1), (-1))
v6 = irit.vector(1, (-1), 1)
v7 = irit.vector(1, 1, (-1))
v8 = irit.vector(1, 1, 1)
f1 = irit.poly(irit.list(v1, v2, v4, v3), irit.FALSE)
f2 = irit.poly(irit.list(v5, v6, v8, v7), irit.FALSE)
f3 = irit.poly(irit.list(v1, v2, v6, v5), irit.FALSE)
f4 = irit.poly(irit.list(v2, v4, v8, v6), irit.FALSE)
f5 = irit.poly(irit.list(v4, v3, v7, v8), irit.FALSE)
f6 = irit.poly(irit.list(v3, v1, v5, v7), irit.FALSE)
a = irit.pattrib(f6, 0, "authored by", irit.GenStrObject("irit"))
z = (y + y)
retval = (x + y + z)
return retval
#
# Call a function within a function.
#
def somemath(x, y):
retval = (irit.sqr(x) * factor(y) + irit.sqr(y) * factor(x))
return retval
irit.save( "functn2", irit.list( irit.GenRealObject(apply( 5, "*", 6 )), \
apply( irit.vector( 1, 2, 3 ), "+", irit.vector( 1, 1, 1 ) ), \
lcl( 3 ), \
lcl( 5 ), \
somemath( 2, 2 ), \
somemath( 4, 3 ) ) )
#
# Computes an approximation to the arclength of a curve, by approximating it
# as a piecewise linear curve with n segments.
#
def distptpt(pt1, pt2):
retval = math.sqrt( irit.sqr( irit.FetchRealObject(irit.coord( pt1, 1 )) - \
irit.FetchRealObject(irit.coord( pt2, 1 )) ) + \
irit.sqr( irit.FetchRealObject(irit.coord( pt1, 2 )) - irit.FetchRealObject(irit.coord( pt2, 2 ) )) + \
irit.sqr( irit.FetchRealObject(irit.coord( pt1, 3 )) - irit.FetchRealObject(irit.coord( pt2, 3 )) ) )
#
sandboxboundary = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0.5, 0, 0.03 ), \
irit.ctlpt( irit.E3, 0.5, 0.7, 0.03 ), \
irit.ctlpt( irit.E3, (-0.5 ), 0.7, 0.03 ), \
irit.ctlpt( irit.E3, (-1.5 ), 0.7, 0.03 ), \
irit.ctlpt( irit.E3, (-1.9 ), 0, 0.03 ), \
irit.ctlpt( irit.E3, (-1.5 ), (-0.9 ), 0.03 ), \
irit.ctlpt( irit.E3, (-1 ), (-0.7 ), 0.03 ), \
irit.ctlpt( irit.E3, (-0.5 ), (-0.4 ), 0.03 ), \
irit.ctlpt( irit.E3, 0.5, (-0.6 ), 0.03 ), \
irit.ctlpt( irit.E3, 0.5, 0, 0.03 ) ), irit.list( irit.KV_OPEN ) )
sandboxwall = irit.sweepsrf( ( irit.ctlpt( irit.E3, (-0.03 ), 0, (-0.05 ) ) + \
irit.ctlpt( irit.E3, (-0.03 ), 0, 0.05 ) + \
irit.ctlpt( irit.E3, 0.1, 0, 0.05 ) + \
irit.ctlpt( irit.E3, 0.1, 0, (-0.05 ) ) + \
irit.ctlpt( irit.E3, (-0.03 ), 0, (-0.05 ) ) ) * irit.rotx( 90 ), sandboxboundary, irit.vector( 0, 0, 1 ) )
irit.color( sandboxwall, irit.RED )
irit.attrib( sandboxwall, "rgb", irit.GenStrObject("244,50,50" ))
irit.attrib( sandboxwall, "reflect", irit.GenRealObject(0.1 ))
irit.attrib( sandboxwall, "resolution", irit.GenRealObject(4 ))
sandboxsand = irit.ruledsrf( irit.cregion( sandboxboundary, 0, 0.4375 ), (-irit.cregion( sandboxboundary, 0.4375, 1 ) ) )
irit.color( sandboxsand, irit.WHITE )
irit.attrib( sandboxsand, "rgb", irit.GenStrObject("255,255,150" ))
sandbox = irit.list( sandboxsand, sandboxwall )
irit.free( sandboxsand )
irit.free( sandboxwall )
irit.free( sandboxboundary )
#
pln, irit.cnvrtpolytocrv(irit.pts2plln(spts, 0.1), 2, irit.KV_PERIODIC), 0)
all = irit.list(psphere, trimpln)
irit.save("saccess1t", all)
irit.interact(all)
# ############################################################################
#
# Sphere surface - sphere check surface example.
#
possrf = psphere * irit.sc(2)
pts = irit.saccess(possrf, irit.GenRealObject(0), psphere,
irit.vector(1, 0, 0), 0.1, 1e-005)
spts = irit.nil()
sptserr = irit.nil()
i = 1
while (i <= irit.SizeOf(pts)):
pt = irit.nth(pts, i)
err = irit.FetchRealObject(irit.getattr(pt, "rngerror"))
if (err > 1e-005):
irit.snoc(
irit.seval(possrf, irit.FetchRealObject(irit.coord(pt, 1)),
irit.FetchRealObject(irit.coord(pt, 2))), sptserr)
else:
irit.snoc(
irit.seval(possrf, irit.FetchRealObject(irit.coord(pt, 1)),
irit.FetchRealObject(irit.coord(pt, 2))), spts)
def perpvector(v):
v1 = irit.vector(irit.FetchRealObject(irit.coord(v, 1)),
irit.FetchRealObject(irit.coord(v, 2)),
irit.FetchRealObject(irit.coord(v, 0)))
retval = irit.normalizeVec(v1 ^ v)
return retval
irit.adwidth(chc2, 2)
irit.interact(irit.list(c2, chc2))
irit.save(
"ffcnvhl1",
irit.list(irit.list(c0, chc0),
irit.list(c1, chc1) * irit.tx(3),
irit.list(c2, chc2) * irit.tx(6)))
# Discrete case works on loops as well:
l = irit.nil()
numpts = 30
i = 0
while (i <= numpts):
irit.snoc(irit.vector(irit.random((-1), 1), irit.random((-1), 1), 0), l)
i = i + 1
p = irit.poly(l, irit.FALSE)
irit.color(p, irit.RED)
irit.adwidth(p, 5)
ch = irit.cnvxhull(p, 0)
irit.color(ch, irit.GREEN)
irit.adwidth(ch, 2)
irit.interact(irit.list(ch, p))
irit.save("ffcnvhl2", irit.list(p, ch))
#
# Tangents to curve through a point.
#
reflectlns = irit.nil()
x = (-1.6)
while (x <= 1.6):
irit.snoc( irit.ctlpt( irit.E3, x, 2, (-10 ) ) + \
irit.ctlpt( irit.E3, x, 2, 10 ), reflectlns )
x = x + 0.8
irit.color(reflectlns, irit.CYAN)
irit.adwidth(reflectlns, 2)
irit.SetResolution(30)
# highlight lines - view is zero vector.
hl = irit.rflctln(
s, (0, 0, 0),
irit.list(
irit.vector(0, 0, 1),
irit.list(irit.point((-1.6), 2, 0), irit.point((-0.8), 2, 0),
irit.point(0, 2, 0), irit.point(0.8, 2, 0),
irit.point(1.6, 2, 0))), 1)
irit.color(hl, irit.GREEN)
irit.adwidth(hl, 3)
all = irit.list(irit.GetAxes() * irit.sc(1.1), reflectlns, hl, s)
irit.interact(all)
irit.SetResolution(30)
rf = irit.rflctln(
s, (0, 1, 0),
irit.list(
irit.vector(0, 0, 1),
irit.list(irit.point((-1.6), 2, 0), irit.point((-0.8), 2, 0),
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):
j = 0
while (j <= m):
irit.snoc( virttree3( irit.point( i * 5, j * 5, 0 ), irit.vector( 0, 0, 1 ), 0.3, blevel, level ),\
# Seed-initiate the randomizer,
irit.free(ri)
save_res = irit.GetResolution()
ed1 = irit.edge2d(0, 0, 1, 1)
ed2 = irit.edge2d((-1), (-1), (-1), 2)
ed3 = irit.edge3d(0, 0, 0, 1, 1, 1)
ed4 = irit.edge3d((-1), 0, 1, 1, 2, (-1))
irit.interact(irit.list(irit.GetAxes(), ed1, ed2, ed3, ed4))
# printf( "%d) v3 = %19.16vf :: ", list( i, v3- v3*m ) ):
i = 0
while (i <= 9):
v1 = irit.vector(irit.random((-1), 1), irit.random((-1), 1),
irit.random((-1), 1))
v1 = irit.normalizeVec(v1)
v2 = irit.vector(irit.random((-1), 1), irit.random((-1), 1),
irit.random((-1), 1))
v2 = irit.normalizeVec(v2)
v3 = v1 ^ v2
v3 = irit.normalizeVec(v3)
m = irit.rotv2v(irit.Fetch3TupleObject(v1), irit.Fetch3TupleObject(v2))
#irit.printf( "%d) v1 = %7.4vf v2 = %7.4vf :: ", irit.list( i, v1, v2 ) )
print str(i) + \
") v1 = " + \
str(irit.Fetch3TupleObject(v1)) + \
") v2 = " + \
str(irit.Fetch3TupleObject(v2))
if (v1 * m != v2 or v2 * (m ^ (-1)) != v1 or v3 != v3 * m):
irit.free(itemaux1)
irit.free(itemaux2)
irit.free(diagpoly)
allitems = irit.list(item1, item2, item3, item4, item5, item6)
irit.interact(allitems)
irit.save("stckstrr", allitems)
# ############################################################################
# Coupled prisms
#
eps = 0.025
an = 71
ca = math.cos(an * math.pi / 180)
sa = math.sin(an * math.pi / 180)
vec1 = irit.vector(1, 0, 0)
vec2 = irit.vector((-ca), sa, 0)
vec3 = irit.coerce(
irit.normalizeVec(irit.normalizeVec(vec1 + vec2) + irit.vector(0, 0, 1.4))
* 0.5, irit.VECTOR_TYPE)
prism1 = irit.gbox((0, 0, 0), irit.Fetch3TupleObject(vec1),
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 ) ) * \
while (i <= irit.SizeOf(tsrfs2aux)):
irit.snoc(irit.nth(tsrfs2aux, i) * irit.tz(2 + (i - 2) / 5.0), tsrfs2)
i = i + 1
irit.free(tsrfs2aux)
irit.interact(tsrfs2)
irit.save("trimsrf4", irit.list(tsrfs1, tsrfs2))
irit.free(tsrfs1)
irit.free(tsrfs2)
#
# Operators on trimmed surfaces
#
s1 = subdivtodepth(tsrf1a, 4, irit.vector(0, 0.02, 0), irit.vector(0.02, 0, 0))
irit.interact(s1)
s2 = subdivtodepth(tsrf1a, 8, irit.vector(0, 0.01, 0), irit.vector(0.01, 0, 0))
irit.interact(s2)
irit.save("trimsrf5", irit.list(s1, s2))
s1 = subdivtodepth(tsrf3a, 4, irit.vector(0, 0.04, 0), irit.vector(0.02, 0, 0))
irit.interact(s1)
s2 = subdivtodepth(tsrf3a, 8, irit.vector(0, 0.01, 0),
irit.vector(0.005, 0, 0))
irit.interact(s2)
irit.save("trimsrf6", irit.list(s1, s2))
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.GetViewMatrix() * irit.sc(0.3) * irit.rx(5) * irit.ry(
(-5)))
# ############################################################################
b = irit.box(((-1), (-1), (-1)), 2, 2, 2)
irit.color(b, irit.YELLOW)
irit.view(irit.list(b, irit.GetViewMatrix()), irit.ON)
irit.pause()
#
# Truncation along vertices.
#
pl1 = (-irit.poly(
irit.list(irit.vector((-10), (-10), 1.8), irit.vector(
(-10), 10, 1.8), irit.vector(10, 10, 1.8), irit.vector(
10, (-10), 1.8)), 0)) * irit.rotz2v(
irit.Fetch3TupleObject(irit.vector(1, 1, 1) * math.sqrt(3)))
irit.color(pl1, irit.GREEN)
a = (-0.04)
while (a >= (-0.5)):
p = pl1 * irit.trans((a, a, a))
bt1 = b - p - p * irit.roty(90) - p * irit.roty(180) - p * irit.roty(
270) - p * irit.rotx(90) - p * irit.rotx(90) * irit.roty(
90) - p * irit.rotx(90) * irit.roty(180) - p * irit.rotx(
90) * irit.roty(270)
irit.color(bt1, irit.YELLOW)
irit.view(irit.list(bt1), irit.ON)
a = a + (-0.02)
#
save_res = irit.GetResolution()
import teapot2
spout2 = teapot2.spout2
irit.SetResolution(10)
spout2 = irit.gpolygon(spout2, 1)
irit.color(spout2, irit.RED)
#
# Extract silhouettes.
#
pl1 = irit.ppropftch(spout2, 1,
irit.list(irit.normalizeVec(irit.vector(1, 1, 1)), 90))
pl2 = irit.ppropftch(spout2, 1,
irit.list(irit.normalizeVec(irit.vector(1, (-1), 1)), 90))
pl3 = irit.ppropftch(spout2, 1,
irit.list(irit.normalizeVec(irit.vector(1, 0, 1)), 90))
irit.color(pl1, irit.WHITE)
irit.color(pl2, irit.CYAN)
irit.color(pl3, irit.GREEN)
irit.adwidth(pl1, 3)
irit.adwidth(pl2, 3)
irit.adwidth(pl3, 3)
view_mat2 = irit.GetViewMatrix() * irit.sc(0.5) * irit.ty(0.5)
all = irit.list(spout2, pl1, pl2, pl3)
irit.save("poly1prp", all)
irit.interact(irit.list(view_mat2, irit.GetAxes(), all))
irit.ctlpt( irit.E2, 0.231, (-0.173 ) ), \
irit.ctlpt( irit.E2, 0.675, 0.057 ) ), irit.list( irit.KV_PERIODIC ) )
irit.color( c6, irit.GREEN )
crvs = irit.list( c1, c2, c3, c4, c5, c6 )
# ############################################################################
res = irit.nil( )
i = 1
while ( i <= irit.SizeOf( crvs ) ):
c = irit.nth( crvs, i )
a = 0
while ( a <= 360 ):
dir = irit.vector( math.cos( a * math.pi/180 ),
math.sin( a * math.pi/180 ),
0 )
vc = irit.cvisible( c, irit.Fetch3TupleObject(dir), 1e-005 )
irit.adwidth( vc, 3 )
irit.color( vc, irit.YELLOW )
if ( a == 80 or a == 160 or a == 240 or a == 20 ):
irit.snoc( irit.list( irit.coerce( dir, irit.E2 ) +
irit.ctlpt( irit.E2, 0, 0 ),
vc, c ) *
irit.ty( i * 1.6 ) *
irit.tx( ( a - 200 )/40.0 ), res )
irit.view( irit.list( dir, vc, c ), irit.ON )
a = a + 20
i = i + 1
res = res * irit.sc( 0.2 ) * \
irit.free(mov_z)
all = irit.list(item1, item2, item3, item4, item5, item6)
irit.interact(all)
irit.save("puz2anm2", all)
# ############################################################################
#
# Prism's puzzle.
#
eps = 0.025
an = 71
ca = math.cos(an * math.pi / 180)
sa = math.sin(an * math.pi / 180)
vec1 = irit.vector(1, 0, 0)
vec2 = irit.vector((-ca), sa, 0)
vec3 = irit.coerce(
irit.normalizeVec(irit.normalizeVec(vec1 + vec2) + irit.vector(0, 0, 1.4))
* 0.5, irit.VECTOR_TYPE)
prism1 = irit.gbox((0, 0, 0), irit.Fetch3TupleObject(vec1),
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 )) )
crv3, irit.FetchRealObject(irit.crvptdst(crv3, (0, 0, 0), 1, 0.001)))
irit.interact(
irit.list(irit.GetAxes(), crv3, irit.coerce(pt_min, irit.VECTOR_TYPE)))
pt_max = irit.ceval(
crv3, irit.FetchRealObject(irit.crvptdst(crv3, (0, 0, 0), 0, 0.001)))
irit.interact(
irit.list(irit.GetAxes(), crv3, irit.coerce(pt_max, irit.VECTOR_TYPE)))
irit.save(
"crv6dist",
irit.list(irit.GetAxes(), crv3, irit.coerce(pt_max, irit.VECTOR_TYPE)))
#
# Curve line distance.
#
line_pt = irit.point((-1), 1.2, 0)
line_vec = irit.vector(1, (-1), 0)
line_pt2 = line_pt + line_vec * 2
line = irit.poly(irit.list(line_pt, line_pt2), irit.TRUE)
crv1 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 1.5, (-0.5 ) ), \
irit.ctlpt( irit.E2, 0.5, (-1 ) ), \
irit.ctlpt( irit.E2, (-1.5 ), (-0.5 ) ), \
irit.ctlpt( irit.E2, 2.5, 0 ), \
irit.ctlpt( irit.E2, (-1.5 ), 0.5 ) ), irit.list( irit.KV_OPEN ) )
irit.color(crv1, irit.GREEN)
irit.attrib(crv1, "width", irit.GenRealObject(0.02))
pt_param = irit.crvlndst( crv1, \
irit.Fetch3TupleObject(line_pt), \
irit.Fetch3TupleObject(line_vec), \
0, \
(-0.001 ) )
def snaket( t ):
p = irit.point( 0, 0, 0 )
ct = irit.cbspline( 3, irit.list( p * \
ctx( 0 + t, 1.5 ) * \
irit.ty( 0.22 ),
p * \
ctx( 0 + t, 1.5 ) * \
irit.ty( 0.22 ),
p * \
ctx( 0.3 + t, 1.5 ) * \
irit.ty( 0.17 ) * \
irit.tz( 0.3 ),
p * \
ctx( 2 + t, 1.5 ) * \
irit.ty( (-0.06 ) ) * \
irit.tz( 2 ),
p * \
ctx( 4 + t, 1.5 ) * \
irit.ty( (-0.06 ) ) * \
irit.tz( 4 ),
p * \
ctx( 6 + t, 1.5 ) * \
irit.ty( (-0.06 ) ) * \
irit.tz( 6 ),
p * \
ctx( 8 + t, 2.5 ) * \
irit.ty( (-0.065 ) ) * \
irit.tz( 8 ),
p * \
ctx( 10 + t, 2.5 ) * \
irit.ty( (-0.07 ) ) * \
irit.tz( 10 ),
p * \
ctx( 12 + t, 2.5 ) * \
irit.ty( (-0.075 ) ) * \
irit.tz( 12 ),
p * \
ctx( 14 + t, 1.5 ) * \
irit.ty( (-0.08 ) ) * \
irit.tz( 14 ),
p * \
ctx( 16 + t, 1.5 ) * \
irit.ty( (-0.09 ) ) * \
irit.tz( 16 ),
p * \
ctx( 18 + t, 1.5 ) *
irit.ty( (-0.1 ) ) *
irit.tz( 18 ),
p * \
irit.ty( (-0.1 ) ) * \
irit.tz( 20 ),
p * \
irit.ty( (-0.1 ) ) * \
irit.tz( 21 ) ),
irit.list( irit.KV_OPEN ) )
c = irit.circle( ( 0, 0, 0 ), 0.36 ) * irit.rz( (-90 ) )
scalecrv = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0, 0.001 ), \
irit.ctlpt( irit.E2, 0.1, 0.1 ), \
irit.ctlpt( irit.E2, 0.2, 0.4 ), \
irit.ctlpt( irit.E2, 0.3, 0.7 ), \
irit.ctlpt( irit.E2, 0.4, 0.8 ), \
irit.ctlpt( irit.E2, 0.5, 0.9 ), \
irit.ctlpt( irit.E2, 0.6, 0.95 ), \
irit.ctlpt( irit.E2, 0.7, 1 ), \
irit.ctlpt( irit.E2, 0.8, 1 ) ), irit.list( irit.KV_OPEN ) )
s1 = irit.swpsclsrf( c, ct, scalecrv, irit.vector( 0, 1, 0 ), 1 )
irit.attrib( s1, "ptexture", irit.GenStrObject("snake2.gif,1,30" ))
s2 = irit.sfromcrvs( irit.list( c * \
irit.ty( (-0.1 ) ) * \
irit.tz( 21 ),
c * \
irit.ty( (-0.1 ) ) * \
irit.tz( 22 ),
c * \
irit.ty( (-0.14 ) ) * \
irit.sx( 2.2 ) * \
irit.sy( 1.2 ) * \
irit.tz( 23 ),
c * \
irit.ty( (-0.14 ) ) * \
irit.sx( 2.2 ) * \
irit.sy( 1.2 ) * \
irit.tz( 24 ),
c * \
irit.sy( 0.9 ) * \
irit.ty( (-0.1 ) ) * \
irit.sx( 1.2 ) * \
irit.tz( 25 ),
c * \
irit.ty( (-0.1 ) ) * \
irit.sc( 0.001 ) * \
irit.tz( 25 ) ),
3,
irit.KV_OPEN )
irit.attrib( s2, "ptexture", irit.GenStrObject("snake2.gif,1,5" ))
eyes = irit.list( irit.sphere( ( 0.42, (-0.35 ), 24.5 ), 0.1 ), irit.sphere( ( (-0.42 ), (-0.35 ), 24.5 ), 0.1 ) )
irit.color( eyes, irit.BLACK )
retval = irit.list( s1, s2, eyes ) * irit.rx( (-90 ) ) * irit.tz( 0.261 )
return retval
irit.box( ( (-1 ), 189, 25 ), 80, 2, 20 ),\
irit.box( ( 79, (-1 ), 25 ), 2, 190, 20 ),\
irit.box( ( (-1 ), 90, 25 ), 80, 2, 20 ) )
irit.attrib(skel, "rgb", irit.GenStrObject("255,255,100"))
irit.viewobj(skel)
cover = irit.box((0, 0, 45), 80, 190, 1)
irit.attrib(cover, "rgb", irit.GenStrObject("244,164,96"))
backcross = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0, 0, 75 ), \
irit.ctlpt( irit.E3, 15, 0, 75 ), \
irit.ctlpt( irit.E3, 30, 0, 95 ), \
irit.ctlpt( irit.E3, 50, 0, 95 ), \
irit.ctlpt( irit.E3, 65, 0, 75 ), \
irit.ctlpt( irit.E3, 80, 0, 75 ) ), irit.list( irit.KV_OPEN ) )
backcrosspts = irit.list(irit.vector(80, 0, 75), irit.vector(80, 0, 45),
irit.vector(0, 0, 45))
heartcross = ( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0, 0, (-10 ) ), \
irit.ctlpt( irit.E3, 3, 0, 0 ), \
irit.ctlpt( irit.E3, 12, 0, 5 ), \
irit.ctlpt( irit.E3, 12, 0, 15 ), \
irit.ctlpt( irit.E3, 3, 0, 15 ), \
irit.ctlpt( irit.E3, 0, 0, 10 ) ), irit.list( irit.KV_OPEN ) ) + irit.cbspline( 3, irit.list( \
irit.ctlpt( irit.E3, 0, 0, 10 ), \
irit.ctlpt( irit.E3, (-2 ), 0, 15 ), \
irit.ctlpt( irit.E3, (-13 ), 0, 15 ), \
irit.ctlpt( irit.E3, (-13 ), 0, 5 ), \
irit.ctlpt( irit.E3, (-5 ), 0, 0 ), \
irit.ctlpt( irit.E3, 0, 0, (-10 ) ) ), irit.list( irit.KV_OPEN ) ) ) * irit.sc( 0.5 ) * irit.trans( ( 40, 1, 65 ) )
c0 = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E2, (-0.324 ), (-0.29 ) ), \
irit.ctlpt( irit.E2, 0.882, (-0.07 ) ), \
irit.ctlpt( irit.E2, (-0.803 ), 0.414 ), \
irit.ctlpt( irit.E2, 0.347, 0.347 ), \
irit.ctlpt( irit.E2, 0.431, 0.899 ), \
irit.ctlpt( irit.E2, 0.082, 0.978 ), \
irit.ctlpt( irit.E2, (-0.335 ), 1 ), \
irit.ctlpt( irit.E2, (-0.403 ), 0.132 ), \
irit.ctlpt( irit.E2, (-0.521 ), (-0.984 ) ) ), irit.list( irit.KV_OPEN ) )
c0 = irit.creparam(irit.carclen(c0, 0.0001, 3), 0, 1)
ptlist = irit.nil()
i = 0
while (i <= 600):
irit.snoc( irit.coerce( irit.coerce( irit.ceval( c0, irit.random( 0, 1 ) ), irit.POINT_TYPE ) + \
irit.vector( irit.random( (-0.02 ), 0.02 ), irit.random( (-0.02 ), 0.02 ), 0 ), irit.POINT_TYPE ), ptlist )
i = i + 1
irit.color(ptlist, irit.RED)
irit.view(ptlist, irit.ON)
c1 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, (-0.324 ), (-0.29 ) ), \
irit.ctlpt( irit.E2, 0.1, 0.414 ), \
irit.ctlpt( irit.E2, 0.431, 0.899 ), \
irit.ctlpt( irit.E2, 0.082, 0.978 ), \
irit.ctlpt( irit.E2, (-0.403 ), 0.132 ), \
irit.ctlpt( irit.E2, (-0.521 ), (-0.984 ) ) ), irit.list( irit.KV_OPEN ) )
irit.color(c1, irit.CYAN)
irit.interact(irit.list(ptlist, c1))
c1 = irit.cbsp_fit(ptlist, c1, 2, irit.list(5, 0, 0, 0.001))
