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 createcubicbezier(x1, y1, x2, y2, x3, y3):
x1 = x1 / 1000.0
y1 = y1 / 1000.0
x2 = x2 / 1000.0
y2 = y2 / 1000.0
x3 = x3 / 1000.0
y3 = y3 / 1000.0
retval = irit.cbezier( irit.list( irit.ctlpt( irit.E2, x1, y1 ), \
irit.ctlpt( irit.E2, x1 + ( x2 - x1 ) * 2/3.0, y1 + ( y2 - y1 ) * 2/3.0 ), \
irit.ctlpt( irit.E2, x3 + ( x2 - x3 ) * 2/3.0, y3 + ( y2 - y3 ) * 2/3.0 ), \
irit.ctlpt( irit.E2, x3, y3 ) ) )
return retval
s45 = math.sin(math.pi / 4)
helixaux = irit.cbspline( 3, irit.list( irit.ctlpt( irit.P3, 1, 1, 0, 0 ), \
irit.ctlpt( irit.P3, s45, s45, s45, 0.2 * s45 ), \
irit.ctlpt( irit.P3, 1, 0, 1, 0.4 ), \
irit.ctlpt( irit.P3, s45, (-s45 ), s45, 0.6 * s45 ), \
irit.ctlpt( irit.P3, 1, (-1 ), 0, 0.8 ), \
irit.ctlpt( irit.P3, s45, (-s45 ), (-s45 ), 1 * s45 ), \
irit.ctlpt( irit.P3, 1, 0, (-1 ), 1.2 ), \
irit.ctlpt( irit.P3, s45, s45, (-s45 ), 1.4 * s45 ), \
irit.ctlpt( irit.P3, 1, 1, 0, 1.6 ) ), irit.list( 0, 0, 0, 1, 1, 2,\
2, 3, 3, 4, 4, 4 ) )
helixapx = (helixaux + helixaux * irit.trans(
(0, 0, 1.6)) + helixaux * irit.trans((0, 0, 3.2)))
scalecrv = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, 0.01 ), \
irit.ctlpt( irit.E2, 1, 1 ) ) )
srf4 = irit.swpsclsrf( irit.circle( ( 0, 0, 0 ), 0.8 ),
helixapx,
scalecrv,
irit.GenRealObject(0),
0 ) * \
irit.scale( ( 0.2, 0.2, 0.2 ) ) * irit.trans( ( 0, 0, baselvl ) )
irit.free(helixaux)
irit.free(helixapx)
irit.free(scalecrv)
irit.color(srf4, irit.MAGENTA)
#
# Must make them compatible before doing some morphing.
#
# 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 ) ):
pt = irit.ceval( c1, irit.FetchRealObject(irit.coord( irit.nth( pts, i ), 0 ) ))
irit.snoc( pt, e2pts )
i = i + 10
irit.interact( irit.list( e2pts, c1 ) )
irit.save( "ffptdst1", irit.list( e2pts, c1 ) )
pts = irit.ffptdist( c1, 1, 1000 )
res = "successful"
else:
res = "failed"
all3 = irit.list(irit.nth(bb, 1), irit.nth(bb, 2), res)
irit.printf("projection on srf2nrml bound from %8.5lf to %8.5lf (%s)\n",
all3)
irit.pause()
retval = irit.list(all1, all2, all3)
return retval
# ############################################################################
crv1a = irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0.2 ), \
irit.ctlpt( irit.E2, 0.5, 4 ), \
irit.ctlpt( irit.E2, 1.3, 0.05 ) ) ) * irit.sy( 0.2 )
crv2a = irit.cbezier( irit.list( \
irit.ctlpt( irit.E1, (-0.2 ) ), \
irit.ctlpt( irit.E2, 0.25, 1.9 ), \
irit.ctlpt( irit.E2, 1.3, 0.05 ) ) ) * irit.ty( 0.3 ) * irit.sx( 1.5 )
crv1b = irit.cbezier( irit.list( \
irit.ctlpt( irit.E2, 0.2, (-0.5 ) ), \
irit.ctlpt( irit.E2, 0.5, 4 ), \
irit.ctlpt( irit.E2, 1.3, (-0.45 ) ) ) ) * irit.sy( 0.2 )
crv2b = irit.cbezier( irit.list( \
irit.ctlpt( irit.E2, (-0 ), (-0.5 ) ), \
irit.ctlpt( irit.E2, 0.25, 1.09 ), \
irit.ctlpt( irit.E2, 1.1, (-0.5 ) ) ) ) * irit.ty( 0.3 ) * irit.sx( 1.5 )
irit.save(
"dist2ff1",
#
# Set states.
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.GetViewMatrix() * irit.sc(0.35))
irit.viewobj(irit.GetViewMatrix())
# Faster product using Bezier decomposition.
iprod = irit.iritstate("bspprodmethod", irit.GenIntObject(0))
# ############################################################################
#
# A point and a line in the XY plane
#
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-0.3 ), (-1 ) ), \
irit.ctlpt( irit.E2, (-0.3 ), 1 ) ) )
pt2 = irit.point(0.4, 0.2, 0)
irit.color(c1, irit.RED)
irit.adwidth(c1, 3)
irit.color(pt2, irit.RED)
irit.adwidth(pt2, 3)
t = 0
while (t <= 1):
bisectcrv = irit.calphasector(irit.list(c1, pt2), t)
irit.color(bisectcrv, irit.GREEN)
irit.view(irit.list(c1, pt2, bisectcrv), irit.ON)
t = t + 0.03
irit.save(
"asect2d1",
# A simple example of curve morphing.
#
# Gershon Elber, July 1994.
#
#
# Sets the viewing direction on the display device.
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix( irit.rotx( 0 ))
irit.viewobj( irit.GetViewMatrix() )
irit.SetViewMatrix( save_mat)
# ############################################################################
crv1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0.3, 0 ), \
irit.ctlpt( irit.E2, 0, 0.5 ), \
irit.ctlpt( irit.E2, (-0.2 ), 0 ) ) )
crv1a = crv1 * irit.trans( ( (-0.4 ), 0, 0 ) )
crv1b = crv1a * irit.scale( ( (-1 ), 1, 1 ) )
irit.color( crv1a, irit.GREEN )
irit.color( crv1b, irit.GREEN )
irit.view( irit.list( crv1a, crv1b ), irit.ON )
i = 0
while ( i <= 300 ):
c = irit.cmorph( crv1a, crv1b, 0, i/300.0 )
irit.color( c, irit.YELLOW )
irit.view( irit.list( crv1a, crv1b, c ), irit.ON )
i = i + 1
crvs = irit.cmorph( crv1a, crv1b, 2, 0.005 )
# Blend on a (polynomial approximation of a) sphere using BlSHermite
# with scaling curves:
#
sclcrv = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E1, 0.01 ), \
irit.ctlpt( irit.E1, 0.4 ), \
irit.ctlpt( irit.E1, 0.01 ), \
irit.ctlpt( irit.E1, 0.4 ), \
irit.ctlpt( irit.E1, 0.01 ), \
irit.ctlpt( irit.E1, 0.4 ), \
irit.ctlpt( irit.E1, 0.01 ), \
irit.ctlpt( irit.E1, 0.4 ) ), irit.list( irit.KV_PERIODIC ) )
sclcrv = irit.coerce(sclcrv, irit.KV_OPEN)
s1 = (-irit.blshermite( s, irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, 0.9 ), \
irit.ctlpt( irit.E2, 2, 0.9 ), \
irit.ctlpt( irit.E2, 4, 0.9 ) ) ), csec2, 1, irit.GenRealObject(0.2),\
sclcrv * irit.sc( 5 ) ) )
irit.color(s1, irit.RED)
s2 = (-irit.blshermite( s, irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, 1.5 ), \
irit.ctlpt( irit.E2, 2, 1.5 ), \
irit.ctlpt( irit.E2, 4, 1.5 ) ) ), csec2, 0.7, sclcrv * irit.sc( 0.35 ) * irit.tx( 0.2 ), irit.GenRealObject(1.5) ) )
irit.color(s2, irit.GREEN)
s3 = (-irit.blshermite( s, irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, 0.4 ), \
irit.ctlpt( irit.E2, 2, 0.4 ), \
irit.ctlpt( irit.E2, 4, 0.4 ) ) ), csec2, 0.5, sclcrv * irit.sc( 0.3 ) * irit.tx( 0.12 ), sclcrv * irit.sc( 3 ) ) )
irit.color(s3, irit.YELLOW)
irit.free(sclcrv)
#
# Set states.
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.sc(1))
irit.viewobj(irit.GetViewMatrix())
# Faster product using Bezier decomposition
iprod = irit.iritstate("bspprodmethod", irit.GenRealObject(0))
# ############################################################################
#
# Example 0 - Two simple open curves
#
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-0.441758 ), (-0.503296 ) ), \
irit.ctlpt( irit.E2, 0.560439, (-0.516483 ) ) ) ) * irit.ty( 0.3 )
c2 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0.608924, (-0.358027 ) ), \
irit.ctlpt( irit.E2, 0.164947, (-0.371462 ) ), \
irit.ctlpt( irit.E2, 0.173393, 0.881714 ), \
irit.ctlpt( irit.E2, 0.107802, (-0.37589 ) ), \
irit.ctlpt( irit.E2, (-0.507619 ), (-0.363037 ) ) ) ) * irit.ty( 0.3 )
irit.view(irit.list(c1, c2), irit.ON)
voronoi = irit.cvoronoicell(irit.list(c1, c2))
irit.color(voronoi, irit.GREEN)
irit.attrib(voronoi, "width", irit.GenRealObject(0.005))
irit.interact(irit.list(c1, c2, voronoi))
z = 5
while (z <= 6.5):
tmpbody = tmpbody ^ irit.box((7.9, 0.1, z), 1, 0.4, 0.05)
z = z + 0.2
z = 1
while (z <= 6.5):
tmpbody = tmpbody ^ irit.box((7.95, 4.3, z), 1, 0.6, 0.05)
z = z + 0.3
base = base / tmpbody
stopper = irit.box((6.85, 2.05, 7.37), 0.9, 0.9, 0.13)
rot_y = irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, (-80 ) ) ) )
trns = irit.trans(((-7.75), 0, (-7.45)))
irit.attrib(stopper, "animation", irit.list(trns, rot_y, trns ^ (-1)))
irit.free(rot_y)
irit.free(trns)
#
# Top round.
#
topround = irit.poly( lj8samplecurve( irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, (-0.7 ), 7.5 ), \
irit.ctlpt( irit.E3, 0, 2.5, 8 ), \
irit.ctlpt( irit.E3, 0, 5.7, 7.5 ) ) ), 10 ) + irit.list( ( 0, 5.7, 7.2 ), ( 0, 5.2, 7.2 ), irit.point( 0, 4.9, 6.8 ), irit.point( 0, 4.9, 6 ), irit.point( 0, 0.1, 6 ), irit.point( 0, 0.1, 6.3 ), irit.point( 0, (-0.2 ), 6.3 ), irit.point( 0, (-0.7 ), 7.1 ) ), 0 )
topround = irit.extrude(topround, (2, 0, 0), 3) * irit.tx(0.001)
irit.SetResolution(4)
irit.ctlpt( irit.E3, 0.3, 1, 0 ), \
irit.ctlpt( irit.E3, 0, 2, 1 ) ), irit.list( \
irit.ctlpt( irit.E3, 1.1, 0, 0 ), \
irit.ctlpt( irit.E3, 1.3, 1.5, 2 ), \
irit.ctlpt( irit.E3, 1, 2.1, 0 ) ), irit.list( \
irit.ctlpt( irit.E3, 2.1, 0, 2 ), \
irit.ctlpt( irit.E3, 2.3, 1, 0 ), \
irit.ctlpt( irit.E3, 2, 2, 2 ) ), irit.list( \
irit.ctlpt( irit.E3, 3.1, 0, 0 ), \
irit.ctlpt( irit.E3, 3.3, 1.5, 2 ), \
irit.ctlpt( irit.E3, 3, 2.1, 0 ) ), irit.list( \
irit.ctlpt( irit.E3, 4.1, 0, 1 ), \
irit.ctlpt( irit.E3, 4.3, 1, 0 ), \
irit.ctlpt( irit.E3, 4, 2, 1 ) ) )
cb = irit.cbezier(cbzr) * irit.scale((0.7, 1.4, 1))
irit.color(cb, irit.RED)
sb = irit.sbezier(sbzr)
irit.color(sb, irit.RED)
irit.save(
"bezier1",
irit.list(irit.fforder(cb), irit.ffmsize(cb), irit.ffctlpts(cb),
irit.fforder(sb), irit.ffmsize(sb), irit.ffctlpts(sb)))
if (display == 1):
irit.interact(irit.list(irit.GetAxes(), cb, sb))
irit.viewstate("dsrfmesh", 1)
irit.pause()
i = 1
while (i <= c):
t = irit.coord(irit.coord(irit.nth(tmp, i), deg), 1)
tmp2 = irit.nth(tmp3, i) * irit.sc(irit.FetchRealObject(t))
irit.snoc(irit.coerce(tmp2, irit.E1), net)
i = i + 1
retval = irit.ffmerge(net, ptype)
return retval
# ########################################################################
#
# Matching a curve along a shared boundary between two surfaces.
#
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, 0 ), \
irit.ctlpt( irit.E2, 1, 1 ), \
irit.ctlpt( irit.E2, 2, 0 ), \
irit.ctlpt( irit.E2, 4, 1 ) ) )
irit.awidth(c1, 0.02)
r1 = irit.coerce( irit.cpower( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 0.25 ), \
irit.ctlpt( irit.E1, 0.75 ) ) ), irit.BEZIER_TYPE )
r2 = irit.coerce( irit.cpower( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 1.5 ), \
irit.ctlpt( irit.E1, (-0.5 ) ) ) ), irit.BEZIER_TYPE )
c1a = irit.compose(c1, r1)
c2a = irit.compose(c1, r2)
s1 = irit.sfromcrvs(
irit.list(c1a * irit.ty(1) * irit.tz(3),
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 ), \
pt = irit.point(0, 2, 0)
irit.adwidth(pt, 3)
irit.color(pt, irit.YELLOW)
bisect = irit.sbisector(s, irit.Fetch3TupleObject(pt))
irit.color(bisect, irit.CYAN)
irit.save("sbisect2", irit.list(s, pt, bisect))
irit.interact(irit.list(s, pt, bisect))
# ############################################################################
#
# A quadratic surface
#
s2 = irit.sfromcrvs( irit.list( irit.cbezier( irit.list( irit.ctlpt( irit.E3, (-1 ), (-1 ), 0 ), \
irit.ctlpt( irit.E3, (-1 ), 0, 0.1 ), \
irit.ctlpt( irit.E3, (-1 ), 1, 0 ) ) ), irit.cbezier( irit.list( \
irit.ctlpt( irit.E3, 0, (-1 ), 0.1 ), \
irit.ctlpt( irit.E3, 0, 0, (-0.8 ) ), \
irit.ctlpt( irit.E3, 0, 1, 0.1 ) ) ), irit.cbezier( irit.list( \
irit.ctlpt( irit.E3, 1, (-1 ), 0 ), \
irit.ctlpt( irit.E3, 1, 0, 0.1 ), \
irit.ctlpt( irit.E3, 1, 1, 0 ) ) ) ), 3, irit.KV_OPEN )
irit.color(s2, irit.RED)
pt = irit.point(0, 0, 1)
irit.adwidth(pt, 3)
irit.color(pt, irit.YELLOW)
bisect = irit.sbisector(s2, irit.Fetch3TupleObject(pt))
irit.color(bisect, irit.CYAN)
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# This file existance is justified to demonstrate loops on free form trans.:
#
save_mat = irit.GetViewMatrix()
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 )
vtail1 = irit.ruledsrf( c2, c1 )
vtail2 = irit.ruledsrf( c3, c2 )
if ( do_texture == 1 ):
irit.attrib( vtail1, "texture", texture )
irit.attrib( vtail1, "rgb", irit.GenStrObject(redcolor) )
irit.color( vtail1, irit.RED )
if ( do_texture == 1 ):
irit.attrib( vtail2, "texture", texture )
irit.attrib( vtail2, "rgb", irit.GenStrObject(redcolor) )
irit.color( vtail2, irit.RED )
irit.free( c1 )
irit.free( c2 )
irit.free( c3 )
vtailtop = irit.swpsclsrf( irit.circle( ( 0, 0, 0 ), 0.1 ), irit.cbezier( irit.list( irit.ctlpt( irit.E3, 10.732, 0, 2.048 ), \
irit.ctlpt( irit.E3, 10.972, 0, 2.048 ), \
irit.ctlpt( irit.E3, 11.212, 0, 2.048 ) ) ), irit.cbezier( irit.list( \
irit.ctlpt( irit.E2, 0, 0.01 ), \
irit.ctlpt( irit.E2, 0.5, 1 ), \
irit.ctlpt( irit.E2, 1, 0.01 ) ) ), irit.GenIntObject(0), 1 )
if ( do_texture == 1 ):
irit.attrib( vtailtop, "texture", texture )
irit.attrib( vtailtop, "rgb", irit.GenStrObject(redcolor) )
irit.color( vtailtop, irit.RED )
vtailpara = irit.swpsclsrf( irit.circle( ( 0, 0, 0 ), 0.075 ), irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 9.15, 0, 0.6 ), \
irit.ctlpt( irit.E3, 9.5, 0, 0.6 ), \
irit.ctlpt( irit.E3, 9.9, 0, 0.6 ), \
irit.ctlpt( irit.E3, 10.7, 0, 0.6 ), \
irit.ctlpt( irit.E3, 10.8, 0, 0.6 ), \
irit.ctlpt( irit.E3, 10.85, 0, 0.6 ), \
aaa = int(irit.FetchRealObject(irit.nth(res, 1)) == val)
print title + " test - " + str(aaa)
#
# Line
#
line = irit.circle((0.1, 0.7, 3), math.pi)
printtest("line", irit.isgeom(line, irit.GEOM_LINEAR, 1e-010), 0)
line = ( irit.ctlpt( irit.E3, (-2 ), 10, (-5 ) ) + \
irit.ctlpt( irit.E3, 1, (-2 ), 3 ) )
printtest("line", irit.isgeom(line, irit.GEOM_LINEAR, 1e-010), 1)
line = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 1, (-2 ) ), \
irit.ctlpt( irit.E3, 1, 1, (-2 ) ), \
irit.ctlpt( irit.E3, 4, 1, (-2 ) ) ) )
printtest("line", irit.isgeom(line, irit.GEOM_LINEAR, 1e-010), 1)
line = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 1, (-2 ) ), \
irit.ctlpt( irit.E3, 1, 2, (-2 ) ), \
irit.ctlpt( irit.E3, 4, 1, (-2 ) ) ) )
printtest("line", irit.isgeom(line, irit.GEOM_LINEAR, 1e-010), 0)
#
# Circle
#
printtest("circle", irit.isgeom(line, irit.GEOM_CIRCULAR, 0.001), 0)
circ = irit.circle((0.1, 0.7, 3), math.pi)
printtest("circle", irit.isgeom(circ, irit.GEOM_CIRCULAR, 1e-010), 1)
irit.color(iso, irit.RED)
irit.adwidth(iso, 3)
irit.color(pt, irit.CYAN)
irit.adwidth(pt, 6)
irit.color(bisrf, irit.MAGENTA)
irit.view(irit.list(c1, c2, bisrf, iso, pt), irit.ON)
# ############################################################################
#
# Two linear curves
#
b = 0
while (b <= 1):
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, (-2.1 ), (-b ) ), \
irit.ctlpt( irit.E3, 0, (-2.1 ), b ) ) )
c2 = irit.cbezier( irit.list( \
irit.ctlpt( irit.E3, (-b ), 2.1, 0 ), \
irit.ctlpt( irit.E3, b, 2.1, 0 ) ) )
bisectsrf = irit.cbisector3d(irit.list(c1, c2), 1)
display(c1, c2, bisectsrf)
b = b + 0.01 * speed
b = 2
while (b <= 0):
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, (-0.1 ) - b, (-1 ) ), \
irit.ctlpt( irit.E3, 0, (-0.1 ) - b, 1 ) ) )
c2 = irit.cbezier( irit.list( \
irit.ctlpt( irit.E3, (-1 ), 0.1 + b, 0 ), \
irit.ctlpt( irit.E3, 1, 0.1 + b, 0 ) ) )
bisectsrf = irit.cbisector3d(irit.list(c1, c2), 1)
irit.logfile(fname + "_" + "loffset")
irit.logfile(1)
i = 0
while (i <= steps):
c = irit.offset(crv, dist, t, 1)
c = irit.loffset(crv, dist, 300, irit.SizeOf(c), 4)
computeerror(crv, irit.abs(dist), c)
t = t * math.sqrt(0.1)
i = i + 1
irit.logfile(0)
# ############################################################################
bez = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-0.95 ), 0.7 ), \
irit.ctlpt( irit.E2, (-0.3 ), 0.5 ), \
irit.ctlpt( irit.E2, 0.3, (-2.5 ) ), \
irit.ctlpt( irit.E2, 0.9, (-0.2 ) ) ) )
bez_off = irit.loffset(bez, 0.5, 300, 64, 4)
irit.attrib(bez_off, "width", irit.GenRealObject(0.02))
irit.save("bez_0.4_off", irit.list(bez, bez_off))
cmpoffalltols(bez, "bez_0.4", 0.4, 1, 6)
cpawn = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E2, 0.95, 0.05 ), \
irit.ctlpt( irit.E2, 0.95, 0.76 ), \
irit.ctlpt( irit.E2, 0.3, 1.52 ), \
irit.ctlpt( irit.E2, 0.3, 1.9 ), \
irit.ctlpt( irit.E2, 0.5, 2.09 ), \
irit.ctlpt( irit.E2, 0.72, 2.24 ), \
irit.ctlpt( irit.E2, 0.72, 2.32 ), \
irit.ctlpt( irit.E2, 0.38, 2.5 ), \
i = 1
while (i <= n):
pt = irit.coerce(irit.ceval(crv, t), irit.POINT_TYPE)
nrml = irit.coerce(irit.cnormal(crv, t), irit.VECTOR_TYPE)
irit.snoc(
irit.coerce(pt - nrml * len, irit.E2) +
irit.coerce(pt + nrml * len, irit.E2), retval)
t = t + dt
i = i + 1
return retval
# ############################################################################
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.P2, 1, 0, 0 ), \
irit.ctlpt( irit.P2, 1, 0, 1 ), \
irit.ctlpt( irit.P2, 1, 1, 1 ), \
irit.ctlpt( irit.P2, 1, 1, 0 ) ) )
irit.color(c1, irit.RED)
c1tags = tagcurve(c1, 10, 0.02)
irit.color(c1tags, irit.RED)
c2 = irit.cbezier( irit.list( irit.ctlpt( irit.P2, 0.5, 0, 0 ), \
irit.ctlpt( irit.P2, 1, 0, 1 ), \
irit.ctlpt( irit.P2, 2, 2, 2 ), \
irit.ctlpt( irit.P2, 4, 4, 0 ) ) )
irit.color(c2, irit.GREEN)
c2tags = tagcurve(c2, 10, 0.02)
irit.color(c2tags, irit.GREEN)
c3 = irit.cbezier( irit.list( irit.ctlpt( irit.P2, 0.25, 0, 0 ), \
irit.ctlpt( irit.P2, 1, 0, 1 ), \
irit.adwidth(c1, 3)
irit.color(irit.point(pt[0], pt[1], pt[2]), irit.GREEN)
irit.adwidth(irit.point(pt[0], pt[1], pt[2]), 3)
irit.color(bisrf, irit.MAGENTA)
irit.view(irit.list(c1, pt, bisrf), irit.ON)
# ############################################################################
#
# A line
#
b = 2
while (b <= 0):
pt = (0, 0, 0)
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, (-0.2 ) - b, (-1 ) ), \
irit.ctlpt( irit.E3, 0, (-0.2 ) - b, 1 ) ) )
bisectsrf = irit.cbisector3d(irit.list(c1, pt), 0)
display(c1, pt, bisectsrf)
b = b + (-0.005) * speed
b = 0
while (b <= 2):
pt = (b, 0, 0)
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, (-0.2 ), (-1 ) ), \
irit.ctlpt( irit.E3, 0, (-0.2 ), 1 ) ) )
bisectsrf = irit.cbisector3d(irit.list(c1, pt), 0)
display(c1, pt, bisectsrf)
b = b + 0.0025 * speed
b = 2
while (b <= 0):
save_res = irit.GetResolution()
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix( irit.GetViewMatrix() * irit.sc( 0.3 ))
irit.viewobj( irit.GetViewMatrix() )
irit.SetViewMatrix( save_mat)
# ############################################################################
#
# Cylinder-Cylinder intersection
#
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 ) )
#
def printtest(title, res1, res2):
irit.printf("%9s test - %d\n", irit.list(title, res1 == res2))
if (res1 != res2):
irit.pause()
# 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( \
scone2 = irit.ruledsrf(c1,
c1 * irit.sc(0.1) * irit.tz(1)) * irit.scale((2, 1, 1))
irit.free(c1)
irit.color(scone2, irit.YELLOW)
scone2ev = irit.evolute(scone2)
irit.color(scone2ev, irit.GREEN)
irit.interact(irit.list(irit.GetAxes(), scone2, scone2ev))
irit.free(scone2)
irit.free(scone2ev)
# ############################################################################
# Gaussian curvature of a parametric surface.
# ############################################################################
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)
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 )
#
# Set states.
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.GetViewMatrix() * irit.sc(0.35))
irit.viewobj(irit.GetViewMatrix())
# Faster product using Bezier decomposition.
iprod = irit.iritstate("bspprodmethod", irit.GenIntObject(0))
# ############################################################################
#
# Two linear curves
#
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0.1, (-1 ) ), \
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, 1, (-0.1 ), 0 ) ) )
irit.color(c1, irit.RED)
irit.adwidth(c1, 3)
irit.color(c2, irit.RED)
irit.adwidth(c2, 3)
bisectsrf = irit.cbisector3d(irit.list(c1, c2), 1)
irit.color(bisectsrf, irit.GREEN)
irit.interact(irit.list(c1, c2, bisectsrf))
irit.save("bisectr1", irit.list(c1, c2, bisectsrf))
# ############################################################################
uv = irit.nth(uvs, i)
irit.snoc(
irit.seval(srf, irit.FetchRealObject(irit.coord(uv, 1)),
irit.FetchRealObject(irit.coord(uv, 2))), retval)
i = i + 1
irit.color(retval, clr)
return retval
# ############################################################################
#
# Case 1
#
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 ) ), \
irit.ctlpt( irit.E3, 1, 0, (-1 ) ) ) )
c2 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, (-1 ), 0, 1 ), \
irit.ctlpt( irit.E3, 0, 1, 1 ), \
irit.ctlpt( irit.E3, 0.3, 1, 1 ), \
irit.ctlpt( irit.E3, 1, 0, 1 ) ) )
r1 = irit.ruledsrf(c1, c2)
r2 = r1 * irit.rx(90)
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( bisectlns, irit.MAGENTA )
if ( irit.FetchRealObject(irit.coord( interpt, 1 )) < 10 and \
irit.FetchRealObject(irit.coord( interpt, 1 )) > (-10 ) and \
irit.FetchRealObject(irit.coord( interpt, 2 )) < 10 and \
irit.FetchRealObject(irit.coord( interpt, 2 )) > (-10 ) ):
irit.view( irit.list( crv1, crv2, data, pt1, pt2, interpt, \
bisectlns ), irit.ON )
i = i + 1
# ############################################################################
#
# Two quadratic curves
#
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-0.5 ), (-0.2 ) ), \
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.pause( )
# ############################################################################
#
# Curves
#
# ############################################################################
view_mat1 = irit.sc( 0.5 )
irit.viewobj( view_mat1 )
# ############################################################################
c = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0, (-1 ) ), \
irit.ctlpt( irit.E2, 0, 1 ) ) ) * irit.tx( 0.3 ) * irit.ty( 0.5 )
irit.adwidth( c, 3 )
k = irit.crvkernel( c, 15, 0, irit.GenIntObject(2), 2 )
irit.color( k, irit.YELLOW )
irit.interact( irit.list( c, k, irit.GetAxes() ) )
# ############################################################################
c = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-1 ), 1 ), \
irit.ctlpt( irit.E2, 0, (-1 ) ), \
irit.ctlpt( irit.E2, 1, 1 ) ) )
irit.adwidth( c, 3 )
irit.color( c, irit.RED )
ct = c * irit.tz( 1 )
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)
mov_xyz = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \
irit.ctlpt( irit.E3, ( ca - 1 ) * 3, (-sa ) * 3, 1.4 * 3 ) ) ), 0, 0.25 )
irit.attrib(item4, "animation", mov_xyz)
irit.free(mov_xyz)
mov_xyz = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \
irit.ctlpt( irit.E3, ( ca - 1 ) * 2, (-sa ) * 2, 1.4 * 2 ) ) ), 0.25, 0.5 )
irit.attrib(item3, "animation", mov_xyz)
irit.free(mov_xyz)
mov_xyz = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \
irit.ctlpt( irit.E3, ( 1 - ca ) * 2, sa * 2, 1.4 * 2 ) ) ), 0.5, 0.75 )
irit.attrib(item2, "animation", mov_xyz)
irit.free(mov_xyz)
mov_z = irit.creparam( irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 2 ) ) ), 0.75, 1 )
