def rook(s, clr):
rookbase = (-irit.surfprev( ( irit.ctlpt( irit.E2, 0.001, 0.55 ) + \
irit.ctlpt( irit.E2, 0.11, 0.55 ) + \
irit.ctlpt( irit.E2, 0.11, 0.63 ) + \
irit.ctlpt( irit.E2, 0.13, 0.63 ) + irit.cbspline( 3, irit.list( \
irit.ctlpt( irit.E2, 0.13, 0.53 ), \
irit.ctlpt( irit.E2, 0.05, 0.51 ), \
irit.ctlpt( irit.E2, 0.07, 0.29 ), \
irit.ctlpt( irit.E2, 0.18, 0.12 ), \
irit.ctlpt( irit.E2, 0.18, 0 ) ), irit.list( irit.KV_OPEN ) ) ) * irit.rx( 90 ) ) )
axs = irit.crefine( irit.creparam( irit.pcircle( ( 0, 0, 0 ), 1 ), 0, 1 ),\
0, irit.list( 0.05, 0.1, 0.15, 0.2, 0.3, 0.35,\
0.4, 0.45, 0.55, 0.6, 0.65, 0.7,\
0.8, 0.85, 0.9, 0.95 ) )
scl = irit.cbspline( 2, irit.list( \
irit.ctlpt( irit.E2, 0, 0.01 ), \
irit.ctlpt( irit.E2, 0.5, 0.01 ), \
irit.ctlpt( irit.E2, 0.5, 1 ), \
irit.ctlpt( irit.E2, 1, 1 ), \
irit.ctlpt( irit.E2, 0, 0.01 ) ), irit.list( 0, 0, 0.7, 0.701, 1.999, 2,\
3 ) )
scl = irit.creparam( scl + scl * irit.tx( 1 ) + scl * irit.tx( 2 ) + scl * irit.tx( 3 ) + scl * irit.tx( 4 ) + scl * irit.tx( 5 ) + \
irit.ctlpt( irit.E2, 6, 0.01 ), 0, 1 )
rookwall = irit.swpsclsrf( \
irit.ctlpt( irit.E2, (-0.08 ), 0 ) + \
irit.ctlpt( irit.E2, 0.08, 0 ) + \
irit.ctlpt( irit.E2, 0.08, 0.6 ) + \
irit.ctlpt( irit.E2, (-0.08 ), 0.6 ) + \
irit.ctlpt( irit.E2, (-0.08 ), 0 ), axs, scl, irit.point( 0, 0, 1 ), 2 ) * irit.sc( 0.12 ) * irit.tz( 0.63 )
irit.attrib(rookwall, "rgb", irit.GenStrObject("255,255,100"))
irit.attrib(rookbase, "rgb", irit.GenStrObject(clr))
retval = irit.list(rookbase, rookwall) * irit.sc(s)
return retval
def computeerror(fname, crv, dist, ocrv):
crv = irit.creparam(crv, 0, 1)
ocrv = irit.creparam(ocrv, 0, 1)
dst = irit.symbdiff(crv, ocrv)
dstsqr = irit.symbdprod(dst, dst)
ffmin = irit.max(
irit.FetchRealObject(irit.coord(irit.ffextreme(dstsqr, 1), 1)), 0)
ffmax = irit.max(
irit.FetchRealObject(irit.coord(irit.ffextreme(dstsqr, 0), 1)), 0)
irit.printf(
"\n\t%s: min %lf, max %lf, max error %lf (ctlpts = %1.0lf)",
irit.list(
fname, math.sqrt(ffmin), math.sqrt(ffmax),
irit.max(abs(math.sqrt(ffmin) - dist),
abs(math.sqrt(ffmax) - dist)), irit.SizeOf(ocrv)))
def antanim(scl):
save_res = irit.GetResolution()
bodyall = antbody()
body = irit.nth(bodyall, 1)
eyes = irit.nth(bodyall, 2)
llegs = irit.list(
antlleganim(1) * irit.sc(1.1) * irit.sx(1.3) * irit.ry(
(-45)) * irit.trans((0.1, 0, 1.02)),
antlleganim((-1)) * irit.sc(1.3) * irit.ry(10) * irit.trans(
(0.1, 0.05, 1)),
antlleganim(1) * irit.sc(1.2) * irit.sx(1.4) * irit.ry(40) *
irit.trans((0.1, 0.02, 0.95)))
rlegs = irit.list(
antrleganim(
(-1)) * irit.sc(1.1) * irit.sx(1.3) * irit.ry(45) * irit.trans(
((-0.1), 0, 1.02)),
antrleganim(1) * irit.sc(1.3) * irit.ry((-10)) * irit.trans(
((-0.1), 0.05, 1)),
antrleganim((-1)) * irit.sc(1.2) * irit.sx(1.4) * irit.ry(
(-40)) * irit.trans(((-0.1), 0.02, 0.95)))
irit.SetResolution(20)
antennas = irit.list(
antantenna() * irit.ry((-110)) * irit.trans(((-0.02), 0.2, 1.6)),
antantenna() * irit.ry((-70)) * irit.trans((0.02, 0.2, 1.6)))
irit.attrprop(antennas, "u_resolution", irit.GenRealObject(0.2))
body = (body + irit.gpolygon(antennas, 1))
irit.attrib(body, "rgb", irit.GenStrObject("255,50,50"))
irit.SetResolution(save_res)
retval = irit.list(
body, llegs, rlegs,
eyes) * irit.sz(1.3) * irit.sc(1) * irit.ty(0.28785) * irit.rx(90)
mov_y = irit.creparam( irit.ctlpt( irit.E1, 0 ) + \
irit.ctlpt( irit.E1, (-1 ) ), 0, 1.2 )
irit.attrib(retval, "animation", mov_y)
return retval
def dominos(path, scl, piecetimestep):
retval = irit.nil()
animtime = 0
dominopiece = irit.box(
(-0.01, -0.006, 0), 0.02, 0.006, 0.05) * irit.sc(scl)
rot_x = irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 80 ) ) )
crvdomain = irit.pdomain(path)
t = irit.FetchRealObject(irit.nth(crvdomain, 1))
dpath = irit.cderive(path)
while (t < irit.FetchRealObject(irit.nth(crvdomain, 2))):
d = irit.Fetch3TupleObject(
irit.coerce(irit.ceval(dpath, t), irit.POINT_TYPE))
dlen = math.sqrt(DotProd(d, d))
rot_x = irit.creparam(rot_x, animtime, animtime + piecetimestep)
irit.attrib(dominopiece, "animation", irit.list(rot_x))
irit.setname(irit.getattr(dominopiece, "animation"), 0, "rot_x")
dp = dominopiece * irit.rz(
-math.atan2(d[0], d[1]) * 180 / math.pi) * irit.trans(
irit.Fetch3TupleObject(
irit.coerce(irit.ceval(path, t), irit.VECTOR_TYPE)))
irit.snoc(dp, retval)
t = t + 0.04 * scl / dlen
animtime = animtime + piecetimestep * 0.6
return retval
def antrleganim(s):
retval = antleg() * irit.ry(180)
t = 0.2 * (s + 1) / 2
rot_y = irit.creparam( irit.cbspline( 2, irit.list( irit.ctlpt( irit.E1, 13 * s ), \
irit.ctlpt( irit.E1, (-13 ) * s ), \
irit.ctlpt( irit.E1, (-13 ) * s ), \
irit.ctlpt( irit.E1, 13 * s ) ), irit.list( 0, 0, 1.3, 1.7, 3, 3 ) ),\
0 + t, 1 + t )
rot_z = irit.creparam( irit.cbspline( 2, irit.list( \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 7 + 7 * s ), \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 7 - 7 * s ), \
irit.ctlpt( irit.E1, 0 ) ), irit.list( irit.KV_OPEN ) ), 0 + t, 1 + t )
irit.attrib(retval, "animation", irit.list(rot_z, rot_y))
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
piece4 = piece1 * irit.rz( 270 ) irit.color( piece4, irit.YELLOW ) # All = list( Piece1, Piece2, Piece3, Piece4 ) * tz( -0.25 ); # view( All, 1 ); # save( "puz4pcs", All ); pt1 = irit.ctlpt( irit.E1, 0 ) pt2 = irit.ctlpt( irit.E1, 0.16 ) list1 = irit.list( pt1, pt2 ) irit.setname( list1, 0, "pt1" ) irit.setname( list1, 1, "pt2" ) mov_z1 = irit.creparam( irit.cbezier( list1 ), 0, 1 ) pt3 = irit.ctlpt( irit.E1, 0 ) pt4 = irit.ctlpt( irit.E1, -0.16 ) list2 = irit.list( pt3, pt4 ) irit.setname( list2, 0, "pt3" ) irit.setname( list2, 1, "pt4" ) mov_z2 = irit.creparam( irit.cbezier( list2 ), 0, 1 ) pt5 = irit.ctlpt( irit.E1, 0 ) pt6 = irit.ctlpt( irit.E1, 12 ) list3 = irit.list( pt5, pt6 ) irit.setname( list3, 0, "pt5" ) irit.setname( list3, 1, "pt6" )
i = 0
while ( i <= irit.SizeOf( cntrs ) - 1 ):
animbisectcrv2( c1, c2, bisectcrvs, irit.coord( cntrs, i ) )
i = i + 1
irit.save( "cbisect1", irit.list( c1, c2, bisectcrvs ) )
# ############################################################################
#
# Self bisectors of a cubic Bspline curves
#
c1 = irit.creparam( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, (-0.5 ), 0.5 ), \
irit.ctlpt( irit.E2, 0, (-0.1 ) ), \
irit.ctlpt( irit.E2, (-0.9 ), (-1.9 ) ), \
irit.ctlpt( irit.E2, 0.9, (-0.4 ) ), \
irit.ctlpt( irit.E2, 0.9, 0.5 ) ), irit.list( irit.KV_OPEN ) ), 0, 1 )
irit.color( c1, irit.YELLOW )
irit.attrib( c1, "dwidth", irit.GenRealObject(4 ))
# BisectSrf = cbisector( c1, 0, -1, true, false );
bisectsrf = irit.cbisector2d( c1, 1, 1, 20, 1, 0 )
bisectsrfe3 = irit.coerce( bisectsrf, irit.E3 ) * irit.rotx( (-90 ) ) * irit.roty( (-90 ) ) * irit.sz( 0.0002 )
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 ))
kn = irit.ceval(crvtrcrv, t)
k1 = math.sqrt(
irit.FetchRealObject(
irit.coerce(kn, irit.VECTOR_TYPE) *
irit.coerce(kn, irit.VECTOR_TYPE)))
k2 = irit.FetchRealObject(irit.ccrvtreval(c, t))
if (abs(k1 - k2) > 1e-05):
irit.printf(
"mismatch in curve curvature evaluation (%.13f vs. %.13f)\n",
irit.list(k1, k2))
t = t + dt
c = irit.circle((0, 0, 0), 2)
comparecurvaturecrvevals(c)
comparecurvaturecrvevals(irit.creparam(c, 0, 1000))
comparecurvaturecrvevals(irit.creparam(c, 0, 0.001))
c = irit.pcircle((0, 0, 0), 0.5)
comparecurvaturecrvevals(c)
comparecurvaturecrvevals(irit.creparam(c, 0, 1000))
comparecurvaturecrvevals(irit.creparam(c, 0, 0.001))
c = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E3, (-0.168 ), 0.794, 0 ), \
irit.ctlpt( irit.E2, (-0.118 ), 0.637 ), \
irit.ctlpt( irit.E2, 0.071, 0.771 ), \
irit.ctlpt( irit.E2, 0.237, 0.691 ), \
irit.ctlpt( irit.E2, (-0.091 ), 0.452 ), \
irit.ctlpt( irit.E2, 0.134, 0.039 ), \
irit.ctlpt( irit.E2, 0.489, 0.223 ), \
irit.ctlpt( irit.E2, 0.39, 0.439 ), \
irit.ctlpt( irit.E3, 0, (-0.1 ) - a, 0 ), \
irit.ctlpt( irit.E3, 0, (-0.1 ), 1 ) ) )
c2 = irit.cbezier( irit.list( \
irit.ctlpt( irit.E3, (-1 ), 0.1, 0 ), \
irit.ctlpt( irit.E3, 0, 2.1, 0 ), \
irit.ctlpt( irit.E3, 1, 0.1, 0 ) ) )
bisectsrf = irit.cbisector3d(irit.list(c1, c2), 1)
display(c1, c2, bisectsrf)
a = a + 0.02 * speed
# ############################################################################
#
# A line and a circle
#
circ = irit.creparam(irit.pcircle((0, 0, 0), 1), 0, 1) * irit.rz(
(-90)) * irit.ry(180)
irit.ffcompat(c2, circ)
a = 0
while (a <= 1):
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0, (-1 ) ), \
irit.ctlpt( irit.E3, 0, 0, 1 ) ) )
c2x = irit.cmorph(c2, circ, 0, a)
bisectsrf = irit.cbisector3d(irit.list(c1, c2x), 1)
display(c1, c2x, bisectsrf)
a = a + 0.01 * speed
# ############################################################################
#
# A line and a circle (again)
baseunit1 = baseunit
irit.color(baseunit1, irit.RED)
baseunit2 = baseunit * irit.tx(1.175)
irit.color(baseunit2, irit.GREEN)
baseunit3 = baseunit * irit.rx(180) * irit.rz(90)
irit.color(baseunit3, irit.CYAN)
baseunit4 = baseunit3 * irit.ty(1.175)
irit.color(baseunit4, irit.MAGENTA)
irit.free(baseunit)
rot_x = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 360 ) ) ), 0, 1 )
rot_y = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 720 ) ) ), 0, 1 )
rot_z = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 360 ) ) ), 0, 1 )
mov_x = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, (-1.5 ) ) ) ), 3, 4 )
mov_z = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 2 ) ) ), 1, 2 )
irit.attrib(baseunit1, "animation", irit.list(rot_x, rot_y, rot_z, mov_x,
mov_z))
irit.free(mov_x)
irit.free(mov_z)
mov_x = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
#
# Curve-curve and curve-surface composition.
#
dlevel = irit.iritstate("dumplevel", irit.GenRealObject(255))
irit.viewstate("dsrfmesh", 1)
crv1 = irit.circle((0, 0, 0), 0.8)
crv2 = irit.cbspline( 5, irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 1 ), \
irit.ctlpt( irit.E1, 2 ), \
irit.ctlpt( irit.E1, 3 ), \
irit.ctlpt( irit.E1, 4 ) ), irit.list( irit.KV_OPEN ) )
crv1c = irit.compose(crv1, crv2)
crv1m = irit.creparam(irit.cmoebius(crv1, 1), 0, 1)
all = irit.list(crveqlparamsegmarkers(crv1c),
crveqlparamsegmarkers(crv1m) * irit.tz(0.1))
if (display == 1):
irit.interact(all)
irit.save("cc1comps", all)
crv2 = irit.cbspline( 5, irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 4 ) ), irit.list( irit.KV_OPEN ) )
crv1c = irit.compose(crv1, crv2)
crv1m = irit.creparam(irit.cmoebius(crv1, 0.2), 0, 1)
irit.view(irit.list(c1, c2, bisectsrf), irit.ON)
t = t + 0.2
irit.save(
"asect3d4",
irit.list(c1, c2, irit.calphasector(irit.list(c2, c1), 0.1),
irit.calphasector(irit.list(c2, c1), 0.7),
irit.calphasector(irit.list(c2, c1), 1)))
irit.pause()
# ############################################################################
#
# A line and a (approximation of a) circle.
#
c1 = irit.creparam(irit.pcircle((0, 0, 0), 1), 0, 1)
c2 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, (-2 ), 0, 1 ), \
irit.ctlpt( irit.E3, (-2 ), 0, (-1 ) ) ) )
c1 = irit.coerce(c1, irit.E3)
irit.color(c1, irit.RED)
irit.adwidth(c1, 3)
irit.color(c2, irit.RED)
irit.adwidth(c2, 3)
t = 0
while (t <= 1.05):
bisectsrf = irit.calphasector(irit.list(c1, c2), t)
bisectsrf1 = irit.sregion(bisectsrf, irit.COL, 0, 0.3)
bisectsrf2 = irit.sregion(bisectsrf, irit.COL, 0.7, 1)
bisectsrf3 = irit.sregion(bisectsrf, irit.COL, 0.36, 0.64)
# Faster product using Bezier decomposition.
iprod = irit.iritstate("bspprodmethod", irit.GenRealObject(0))
echosrc = irit.iritstate("echosource", irit.GenRealObject(0))
dlevel = irit.iritstate("dumplevel", irit.GenRealObject(256 + 1))
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, (-1 ), 0.5, 2 ), \
irit.ctlpt( irit.E3, 0, 0, 2 ), \
irit.ctlpt( irit.E3, 1, (-1 ), 2 ), \
irit.ctlpt( irit.E3, 1, 1, 2 ) ) )
irit.attrib(c1, "width", irit.GenRealObject(0.02))
irit.attrib(c1, "color", irit.GenRealObject(14))
c2 = irit.pcircle((1, 2, 3), 1.25)
c2 = irit.creparam(c2, 0, 1)
irit.attrib(c2, "width", irit.GenRealObject(0.02))
irit.attrib(c2, "color", irit.GenRealObject(15))
s1 = irit.sbezier( irit.list( irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \
irit.ctlpt( irit.E3, 0.25, 1, 0.5 ), \
irit.ctlpt( irit.E3, 0.5, 0.25, 1 ) ), irit.list( \
irit.ctlpt( irit.E3, 0.5, (-1 ), 0 ), \
irit.ctlpt( irit.E3, 0.75, 0.25, 0.5 ), \
irit.ctlpt( irit.E3, 1, (-0.5 ), 1 ) ), irit.list( \
irit.ctlpt( irit.E3, 1, 0, 0 ), \
irit.ctlpt( irit.E3, 1.25, 1, 0.5 ), \
irit.ctlpt( irit.E3, 1.3, 0.25, 1 ) ) ) )
irit.attrib(s1, "color", irit.GenRealObject(7))
irit.attrib(s1, "rgb", irit.GenStrObject("244,164,96"))
block1 = (irit.box(((-3), (-3), (-3)), 2.5, 6, 6) - irit.box(
((-1), (-4), (-0.5)), 1, 8, 1) + irit.box(
((-5), (-0.5), (-4)), 6, 1, 8) + irit.box(((-1.001), (-1), (-0.5)),
(-0.5), 2, 1))
irit.attrib(block1, "rgb", irit.GenStrObject("50, 100, 255"))
block2 = block1 * irit.rz(180)
irit.attrib(block2, "rgb", irit.GenStrObject("100, 50, 255"))
#
# Add the animation curves:
#
mov_xyz = irit.creparam( irit.cbspline( 2, irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \
irit.ctlpt( irit.E3, 0, 0, 16 ), \
irit.ctlpt( irit.E3, 0, 4, 16 ) ), irit.list( irit.KV_OPEN ) ), 0, 2 )
irit.attrib(stick1, "animation", mov_xyz)
irit.free(mov_xyz)
mov_xyz = irit.creparam( irit.cbspline( 2, irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \
irit.ctlpt( irit.E3, 0, 0, 16 ), \
irit.ctlpt( irit.E3, 0, (-2 ), 16 ) ), irit.list( irit.KV_OPEN ) ), 0, 2 )
irit.attrib(bar1, "animation", mov_xyz)
irit.free(mov_xyz)
mov_xyz = irit.creparam( irit.cbspline( 2, irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \
irit.ctlpt( irit.E3, 0, (-1 ), 0 ), \
irit.ctlpt( irit.E3, 0, (-1 ), 12 ) ), irit.list( irit.KV_OPEN ) ), 2, 3 )
irit.attrib(bar2, "animation", mov_xyz)
irit.free(mov_xyz)
irit.free(view_mat3d)
irit.free(front_prisa)
irit.free(back_prisa)
# ############################################################################
#
# Layout (prisa) of a trimmed wine glass.
#
view_mat3d = irit.rotx((-90)) * irit.roty(130) * irit.rotx((-35)) * irit.scale(
(0.5, 0.5, 0.5)) * irit.trans((0, (-0.5), 0))
view_mat2d = irit.scale((0.1, 0.1, 0.1)) * irit.trans((0, (-0.8), 0))
cross = irit.creparam( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0.7, 0, 0 ), \
irit.ctlpt( irit.E3, 0.7, 0, 0.06 ), \
irit.ctlpt( irit.E3, 0.1, 0, 0.1 ), \
irit.ctlpt( irit.E3, 0.1, 0, 0.6 ), \
irit.ctlpt( irit.E3, 0.6, 0, 0.6 ), \
irit.ctlpt( irit.E3, 0.8, 0, 0.8 ), \
irit.ctlpt( irit.E3, 0.8, 0, 1.4 ), \
irit.ctlpt( irit.E3, 0.6, 0, 1.6 ) ), irit.list( irit.KV_OPEN ) ), 0, 6 )
wglasssrf = irit.surfprev(cross * irit.scale((1.6, 1.6, 1.6)))
circ1 = irit.pcircle((0, 0, 0), 0.4)
circ2 = irit.pcircle((0, 0, 0), 0.2)
wglass = irit.trimsrf(
wglasssrf,
irit.list(circ1 * irit.trans((0.5, 5, 0)), circ1 * irit.trans((1.5, 5, 0)),
circ1 * irit.trans((2.5, 5, 0)), circ1 * irit.trans((3.5, 5, 0)),
circ2 * irit.trans((0.5, 1, 0)), circ2 * irit.trans((1.5, 1, 0)),
circ2 * irit.trans((2.5, 1, 0)), circ2 * irit.trans(
(3.5, 1, 0))), 0)
def queen(s, clr):
queenbase = (-irit.surfprev( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.001, 1.01 ), \
irit.ctlpt( irit.E2, 0.02, 1.01 ), \
irit.ctlpt( irit.E2, 0.02, 0.972 ), \
irit.ctlpt( irit.E2, 0.01, 0.972 ), \
irit.ctlpt( irit.E2, 0.01, 0.97 ), \
irit.ctlpt( irit.E2, 0.09, 0.96 ), \
irit.ctlpt( irit.E2, 0.1, 0.912 ), \
irit.ctlpt( irit.E2, 0.1, 0.911 ), \
irit.ctlpt( irit.E2, 0.12, 0.911 ), \
irit.ctlpt( irit.E2, 0.12, 0.91 ), \
irit.ctlpt( irit.E2, 0.09, 0.84 ), \
irit.ctlpt( irit.E2, 0.07, 0.76 ), \
irit.ctlpt( irit.E2, 0.07, 0.74 ), \
irit.ctlpt( irit.E2, 0.085, 0.74 ), \
irit.ctlpt( irit.E2, 0.085, 0.72 ), \
irit.ctlpt( irit.E2, 0.07, 0.72 ), \
irit.ctlpt( irit.E2, 0.07, 0.7 ), \
irit.ctlpt( irit.E2, 0.1, 0.68 ), \
irit.ctlpt( irit.E2, 0.1, 0.66 ), \
irit.ctlpt( irit.E2, 0.14, 0.64 ), \
irit.ctlpt( irit.E2, 0.14, 0.62 ), \
irit.ctlpt( irit.E2, 0.06, 0.57 ), \
irit.ctlpt( irit.E2, 0.09, 0.33 ), \
irit.ctlpt( irit.E2, 0.21, 0.14 ), \
irit.ctlpt( irit.E2, 0.21, 0 ) ), irit.list( irit.KV_OPEN ) ) * irit.rx( 90 ) ) )
queencrwn = (-irit.swpsclsrf( \
irit.ctlpt( irit.E2, (-0.1 ), 0 ) + \
irit.ctlpt( irit.E2, 0.1, 0 ) + \
irit.ctlpt( irit.E2, (-0.42 ), (-0.7 ) ) + \
irit.ctlpt( irit.E2, (-0.44 ), (-0.7 ) ) + \
irit.ctlpt( irit.E2, (-0.1 ), 0 ), irit.pcircle( ( 0, 0, 0 ), 1 ), irit.creparam( irit.coerce( irit.cbspline( 3, irit.list( \
irit.ctlpt( irit.E2, 0, (-0.3 ) ), \
irit.ctlpt( irit.E2, 1, 1.5 ), \
irit.ctlpt( irit.E2, 2, (-0.3 ) ), \
irit.ctlpt( irit.E2, 3, 1.5 ), \
irit.ctlpt( irit.E2, 4, (-0.3 ) ), \
irit.ctlpt( irit.E2, 5, 1.5 ), \
irit.ctlpt( irit.E2, 6, (-0.3 ) ), \
irit.ctlpt( irit.E2, 7, 1.5 ), \
irit.ctlpt( irit.E2, 8, (-0.3 ) ), \
irit.ctlpt( irit.E2, 9, 1.5 ), \
irit.ctlpt( irit.E2, 10, (-0.3 ) ), \
irit.ctlpt( irit.E2, 11, 1.5 ) ), irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN ), 0, 1 ), irit.point( 0, 0, (-1 ) ), 2 ) ) * irit.sc( 0.11 ) * irit.tz( 0.911 )
irit.attrib(queencrwn, "rgb", irit.GenStrObject("255,255,100"))
irit.attrib(queenbase, "rgb", irit.GenStrObject(clr))
retval = irit.list(queenbase, queencrwn) * irit.sc(s)
return retval
def checktangenteval(c):
dc = irit.cderive(c)
retval = (irit.ctangent(c, 0, 0) == irit.coerce(irit.ceval(
dc, 0), irit.VECTOR_TYPE)) & (irit.ctangent(c, 0.1, 0) == irit.coerce(
irit.ceval(dc, 0.1),
irit.VECTOR_TYPE)) & (irit.ctangent(c, 0.3, 0) == irit.coerce(
irit.ceval(dc, 0.3), irit.VECTOR_TYPE)) & (irit.ctangent(
c, 0.5, 0) == irit.coerce(irit.ceval(
dc, 0.5), irit.VECTOR_TYPE)) & (irit.ctangent(
c, 0.9, 0) == irit.coerce(irit.ceval(
dc, 0.9), irit.VECTOR_TYPE)) & (irit.ctangent(
c, 1, 0) == irit.coerce(
irit.ceval(dc, 1), irit.VECTOR_TYPE))
return retval
irit.printf( "tangent evaluations for\n\trational - %d\n\tpolynomial - %d\n", irit.list( checktangenteval( irit.creparam( irit.circle( ( 0, 0, 0 ), 1 ), 0, 1 ) ),\
checktangenteval( irit.creparam( irit.pcircle( ( 0, 0, 0 ), 1 ), 0, 1 ) ) ) )
z = irit.iritstate("cmpobjeps", z)
irit.free(z)
#
#
# Surface and Curve normals.
#
irit.save(
"bspline4",
irit.list(irit.cnormal(cb, 0), irit.cnormal(cb, 0.1),
irit.cnormal(cb, 0.3), irit.cnormal(cb, 0.5),
irit.cnormal(cb, 0.9), irit.cnormal(cb,
irit.interact(irit.list(ptlist, c1a))
irit.save("cbsp5fit", irit.list(ptlist, c1, c1a))
# ############################################################################
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 ), \
#
# Find all bitangents between two planar curves.
#
c1 = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E3, 0, 1, 0 ), \
irit.ctlpt( irit.E2, 0.55228, 1 ), \
irit.ctlpt( irit.E2, 1, 0.55228 ), \
irit.ctlpt( irit.E2, 1, (-0.55228 ) ), \
irit.ctlpt( irit.E2, 0.55228, (-1 ) ), \
irit.ctlpt( irit.E2, (-0.35 ), (-1 ) ), \
irit.ctlpt( irit.E2, (-0.36 ), (-0.55228 ) ), \
irit.ctlpt( irit.E2, (-0.36 ), 0.55228 ), \
irit.ctlpt( irit.E2, (-0.35 ), 1 ), \
irit.ctlpt( irit.E2, 0, 1 ) ), irit.list( irit.KV_OPEN ) ) * irit.sc( 0.7 )
c2 = irit.creparam(c1 * irit.rz(5) * irit.tx(0.65) * irit.ty(0.1), 0, 1)
c1 = irit.creparam(c1 * irit.tx((-0.5)), 0, 1)
irit.color(c1, irit.RED)
irit.color(c2, irit.RED)
mc1 = irit.mpromote(irit.coerce(c1, irit.MULTIVAR_TYPE), irit.list(1))
mc2 = irit.mpromote(irit.coerce(c2, irit.MULTIVAR_TYPE), irit.list(2, 1))
mn1 = irit.mpromote(irit.coerce(irit.cnrmlcrv(c1), irit.MULTIVAR_TYPE),
irit.list(1))
mn2 = irit.mpromote(irit.coerce(irit.cnrmlcrv(c2), irit.MULTIVAR_TYPE),
irit.list(2, 1))
constraints = irit.list(irit.symbdprod(irit.symbdiff(mc1, mc2), mn1),
irit.symbdprod(irit.symbdiff(mc1, mc2), mn2))
irit.free(mc1)
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# A trimmed surface in the shape of a mask.
#
# Gershon Elber, March 1999
#
crv = irit.creparam( irit.cbspline( 4, irit.list( irit.ctlpt( irit.E2, (-0.5 ), 0 ), \
irit.ctlpt( irit.E2, (-0.4 ), 0.4 ), \
irit.ctlpt( irit.E2, 0, 0.5 ), \
irit.ctlpt( irit.E2, 0.4, 0.4 ), \
irit.ctlpt( irit.E2, 0.5, 0 ) ), irit.list( irit.KV_OPEN ) ), 0, 2 )
crv2 = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E3, (-0.5 ), 0, 0 ), \
irit.ctlpt( irit.E3, (-0.4 ), 0.3, 0 ), \
irit.ctlpt( irit.E3, (-0.3 ), 0.4, 0 ), \
irit.ctlpt( irit.E3, (-0.07 ), 0.46, 0 ), \
irit.ctlpt( irit.E3, 0, 0.75, 0 ), \
irit.ctlpt( irit.E3, 0.07, 0.46, 0 ), \
irit.ctlpt( irit.E3, 0.3, 0.4, 0 ), \
irit.ctlpt( irit.E3, 0.4, 0.3, 0 ), \
irit.ctlpt( irit.E3, 0.5, 0, 0 ) ), irit.list( 0, 0, 0, 0, 0.8, 0.85,\
1, 1.15, 1.2, 2, 2, 2,\
2 ) )
srf = irit.sfromcrvs(
irit.list(crv2, crv2 * irit.tz(0.02),
pt4 = irit.ctlpt( irit.E3, 4, 4, 0 ) pt5 = irit.ctlpt( irit.E3, (-1 ), (-1 ), 0 ) pt6 = irit.ctlpt( irit.E3, (-2 ), (-2 ), 0 ) pt7 = irit.ctlpt( irit.E3, (-4 ), (-4 ), 0 ) pt8 = irit.ctlpt( irit.E3, 0.4, 0.4, 0 ) pt9 = irit.ctlpt( irit.E3, 2, 2, 0 ) pt11 = irit.ctlpt( irit.E2, 3, 3 ) pt12 = irit.ctlpt( irit.E2, (-3 ), (-3 ) ) pt13 = irit.ctlpt( irit.E2, 1.5, 1.5 ) pt14 = irit.ctlpt( irit.E2, (-1.5 ), (-1.5 ) ) pt15 = irit.ctlpt( irit.E2, 3.6, 3.6 ) pt16 = irit.ctlpt( irit.E2, (-0.9 ), (-0.9 ) ) pt17 = irit.ctlpt( irit.E2, (-3.6 ), (-3.6 ) ) pt18 = irit.ctlpt( irit.E2, 0.9, 0.9 ) mov_x = irit.creparam( irit.cbezier( irit.list( pt0, pt1, pt2, pt4, pt2, pt1,\ pt0 ) ), 0, 2 ) scl_x = irit.creparam( irit.cbezier( irit.list( pt1, pt8, pt1 ) ), 2, 3 ) scl_y = irit.creparam( irit.cbezier( irit.list( pt1, pt9, pt1 ) ), 2, 3 ) visible = irit.creparam( irit.cbezier( irit.list( pt11, pt14 ) ), 0, 4.5 ) anim1 = irit.list( visible, mov_x, scl_x, scl_y ); irit.setname( anim1, 0, "visible" ); irit.setname( anim1, 1, "mov_x" ); irit.setname( anim1, 2, "scl_x" ); irit.setname( anim1, 3, "scl_y" ); irit.attrib( a, "animation", anim1) irit.color( a, irit.MAGENTA ) irit.free( mov_x ) irit.free( scl_x )
irit.SetResolution(50)
bisectcrv = irit.contour(bisectsrf, irit.plane(0, 0, 1, epsilon))
irit.color(bisectcrv, irit.GREEN)
irit.adwidth(bisectcrv, 3)
irit.interact(irit.list(irit.GetAxes(), c1, c2, bisectcrv, bisectsrf))
irit.save("cbisect2a", irit.list(c1, c2, bisectcrv, bisectsrf))
# ############################################################################
#
# A line and a (approximation of a) circle.
#
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, (-1 ) ), \
irit.ctlpt( irit.E2, 0, 1 ) ) )
c2 = irit.coerce( irit.creparam( irit.pcircle( ( 0, 0, 0 ), 1 ), 0, 1 ),\
irit.E2 )
irit.color(c1, irit.YELLOW)
irit.color(c2, irit.YELLOW)
irit.adwidth(c1, 3)
irit.adwidth(c2, 3)
bisectsrf = irit.cbisector3d(irit.list(c1, c2), 4) * irit.sz(0.1)
irit.color(bisectsrf, irit.RED)
irit.SetResolution(150)
bisectcrv = irit.contour(bisectsrf, irit.plane(0, 0, 1, epsilon))
irit.color(bisectcrv, irit.GREEN)
irit.adwidth(bisectcrv, 3)
irit.interact(irit.list(c1, c2, bisectcrv, bisectsrf))
#
# Animation one - all in parallel.
#
i1xt = i1x * irit.trans(((-0.5), 0.5, (-0.3)))
r2xt = r2x * irit.trans(((-0.5), 0.5, (-0.3)))
i3xt = i3x * irit.trans(((-0.5), 0.5, (-0.3)))
t4xt = t4x * irit.trans(((-0.5), 0.5, (-0.3)))
irit.SetViewMatrix(save_mat * irit.scale(((-0.9), 0.9, 0.9)) * irit.trans(
(0, 0, 0)))
irit.viewobj(irit.GetViewMatrix())
scl = irit.creparam( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E1, 0.05 ), \
irit.ctlpt( irit.E1, 0.1 ), \
irit.ctlpt( irit.E1, 1 ) ), irit.list( irit.KV_OPEN ) ), 0, 2 )
mov_x = irit.creparam( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E1, 3 ), \
irit.ctlpt( irit.E1, (-8 ) ), \
irit.ctlpt( irit.E1, 3 ), \
irit.ctlpt( irit.E1, 0 ) ), irit.list( irit.KV_OPEN ) ), 0, 2 )
list1 = irit.list(mov_x, scl)
irit.setname(list1, 0, "mov_x")
irit.setname(list1, 1, "scl")
irit.attrib(i1xt, "animation", list1)
irit.free(mov_x)
mov_y = irit.creparam( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E1, (-3 ) ), \
irit.ctlpt( irit.E1, 8 ), \
irit.save( "warp2trv", all )
# ############################################################################
#
# Let the Genie come out of the teapot...
#
teapot = teapotorig * irit.sc( 0.2 ) * irit.sx( (-1 ) ) * irit.rx( 90 ) * irit.rz( 180 )
s = irit.planesrf( (-1 ), (-1 ), 1, 1 ) * irit.sc( 1.7 )
discs = irit.list( s * irit.sc( 0.01 ) * irit.sx( 2 ) * irit.tx( 0.58 ) * irit.tz( 0.42 ), s * irit.sc( 0.01 ) * irit.sx( 2 ) * irit.tx( 0.62 ) * irit.tz( 0.46 ), s * irit.sc( 0.05 ) * irit.sx( 1.5 ) * irit.tx( 0.65 ) * irit.tz( 0.55 ), s * irit.sc( 0.07 ) * irit.sx( 1.5 ) * irit.tx( 0.7 ) * irit.tz( 0.7 ), s * irit.sc( 0.09 ) * irit.sx( 1.5 ) * irit.tx( 0.65 ) * irit.tz( 0.85 ), s * irit.sc( 0.08 ) * irit.sx( 1.5 ) * irit.tx( 0.7 ) * irit.tz( 1 ), s * irit.sc( 0.07 ) * irit.tx( 0.7 ) * irit.tz( 1.1 ) )
tv = irit.tfromsrfs( discs, 3, irit.KV_OPEN )
# Create a refined cylinder to warp out of the teapot...
c = irit.creparam( irit.pcircle( ( 0.5, 0.5, 0.001 ), 0.45 ), 0, 1 )
srf = irit.extrude( c, ( 0, 0, 0.99 ), 0 )
srf = irit.srefine( irit.srefine( srf, irit.COL, 0, irit.list( 0.1, 0.2, 0.3, 0.4, 0.6, 0.7,\
0.8, 0.9 ) ), irit.ROW, 0, irit.list( 0.1, 0.2, 0.3, 0.4, 0.5, 0.6,\
0.7, 0.8, 0.9 ) )
warpedsrf = warpsurface( (-srf ), tv )
irit.attrib( warpedsrf, "ptexture", irit.GenStrObject("g.gif" ))
irit.view( irit.list( teapot, warpedsrf ), irit.ON )
irit.save( "warp3trv", all )
irit.pause()
# ############################################################################
irit.SetViewMatrix( save_mat2)
irit.color(item3, irit.GREEN)
item4 = item1 * irit.rx(90) * irit.rz((-90))
irit.color(item4, irit.YELLOW)
item5 = item1 * irit.rx(90) * irit.ry(90)
irit.color(item5, irit.BLUE)
item6 = item1 * irit.rx(90) * irit.ry((-90))
irit.color(item6, irit.CYAN)
grp1 = irit.list(item2, item3, item5)
grp2 = irit.list(item1, item4, item6)
scl = irit.creparam( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E1, 1 ), \
irit.ctlpt( irit.E1, 1 ), \
irit.ctlpt( irit.E1, 5 ) ), irit.list( irit.KV_OPEN ) ), 0, 1 )
mov_xyz = irit.creparam( irit.cbspline( 4, irit.list( irit.ctlpt( irit.E3, 0, 0, (-3 ) ), \
irit.ctlpt( irit.E3, (-1 ), 1, (-3 ) ), \
irit.ctlpt( irit.E3, (-0.5 ), 0.5, (-0.5 ) ), \
irit.ctlpt( irit.E3, 0, 0, 0 ) ), irit.list( irit.KV_OPEN ) ), 0, 1 )
rot_x = irit.creparam( irit.cbspline( 4, irit.list( irit.ctlpt( irit.E1, 250 ), \
irit.ctlpt( irit.E1, 100 ), \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 0 ) ), irit.list( irit.KV_OPEN ) ), 0, 1 )
rot_y = irit.creparam( irit.cbspline( 4, irit.list( irit.ctlpt( irit.E1, 350 ), \
irit.ctlpt( irit.E1, 100 ), \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 0 ) ), irit.list( irit.KV_OPEN ) ), 0, 1 )
rot_z = irit.creparam( irit.cbspline( 4, irit.list( irit.ctlpt( irit.E1, (-200 ) ), \
def cubeat(x, y, z):
retval = irit.box((x - size / 2.0, y - size / 2.0, z - size / 2.0), size,
size, size)
irit.attrib(
retval, "rgb",
irit.GenStrObject(
str(int(irit.random(64, 255))) + "," +
str(int(irit.random(64, 255))) + "," +
str(int(irit.random(64, 255)))))
return retval
stage1 = irit.list(cubeat(0, 0, 0), cubeat(0, (-size), 0),
cubeat(0, (-2) * size, 0))
rot_x = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 90 ) ) ), 0, 1 )
irit.attrib(stage1, "animation", irit.list(rot_x))
irit.free(rot_x)
stage2 = irit.list(cubeat(0, 0, 0), cubeat(size, 0, 0),
stage1 * irit.trans((2 * size, 0, 0)))
rot_y = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 90 ) ) ), 1, 2 )
irit.attrib(stage2, "animation", irit.list(rot_y))
irit.free(rot_y)
irit.free(stage1)
stage3 = irit.list(cubeat(0, 0, 0), cubeat(0, size, 0),
stage2 * irit.trans((0, 2 * size, 0)))
rot_z = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, (-90 ) ) ) ), 2, 3 )
piece11 = piece * irit.ry(180) * irit.rz(180) * irit.ty(size * 2)
irit.attrib(piece11, "rgb", irit.GenStrObject("100,255,255"))
piece12 = piece * irit.rz(180) * irit.rx((-90)) * irit.tz(size * 2)
irit.attrib(piece12, "rgb", irit.GenStrObject("255,255,100"))
all = irit.list( irit.GetAxes(), piece1, piece2, piece3, piece4, piece5,\
piece6, piece7, piece8, piece9, piece10, piece11,\
piece12 )
irit.view(all, irit.ON)
# save( "puz12pcs", All );
#
# Disassembly into two sub-parts.
#
mov_z1 = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, size * 2 ) ) ), 0, 1 )
mov_y1 = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, (-size ) ) ) ), 1, 2 )
mov_z2 = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, size * 8 ) ) ), 2, 3 )
mov_x1 = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, size * 15 ) ) ), 3, 4 )
mov_z3 = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, (-size ) * 10 ) ) ), 4, 5 )
#
# Disassembly into single pieces.
