def rotatevector2(v, amount):
v1 = irit.normalizeVec(perpvector(v))
v2 = irit.normalizeVec(v1 ^ v) * math.sqrt(irit.FetchRealObject(v * v))
if (amount > 0):
retval = v + v1 * irit.random(0, amount) + v2 * irit.random(0, amount)
else:
retval = v + v1 * irit.random(amount, 0) + v2 * irit.random(amount, 0)
return retval
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
def randompts2(n):
retval = irit.nil()
i = 1
while (i <= n):
r = irit.random((-1), 1)
t = irit.random(0, 2 * math.pi)
irit.snoc((math.cos(t) * r, math.sin(t) * r, 0), retval)
i = i + 1
irit.color(retval, irit.RED)
irit.adwidth(retval, 5)
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 randompts3d(n):
l = irit.nil()
i = 1
while (i <= n):
irit.snoc(
irit.point(irit.random((-1), 1), irit.random((-1), 1),
irit.random((-1), 1)), l)
i = i + 1
retval = l
irit.color(retval, irit.GREEN)
irit.adwidth(retval, 5)
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 genrandomcrv(d, n, size):
ctlpts = irit.nil()
i = 1
while (i <= n):
irit.snoc(
irit.ctlpt(irit.E2, irit.random((-size), size),
irit.random((-size), size)), ctlpts)
i = i + 1
retval = irit.cbspline(
d,
ctlpts * irit.tx(irit.random((-1), 1)) * irit.ty(irit.random((-1), 1)),
irit.list(irit.KV_PERIODIC))
retval = irit.coerce(retval, irit.KV_OPEN)
return retval
def randomctlpt3(n):
l = irit.nil()
i = 1
while (i <= n):
r = irit.random((-0.5), 0.5)
t = irit.random(0, 2 * math.pi)
irit.snoc(
irit.ctlpt(irit.E3,
math.cos(t) * r, irit.random(0.5, 1.5),
math.sin(t) * r), l)
i = i + 1
retval = l
irit.color(retval, irit.GREEN)
irit.adwidth(retval, 3)
return retval
def virttree3(pos, dir, size, blevel, level):
retval = irit.nil()
newpos = (pos + dir)
if (level > 0):
tr = treebranch(pos, newpos, size)
if (level >= blevel):
irit.color(tr, bcolor)
irit.attrib(tr, "ptexture", irit.GenStrObject("trunk.rle"))
irit.attrib(tr, "rgb", irit.GenStrObject(brgb))
else:
irit.color(tr, lcolor)
irit.attrib(tr, "rgb", irit.GenStrObject(lrgb))
irit.attrib(tr, "ptexture", irit.GenStrObject("leaves.rle"))
irit.snoc(tr, retval)
if (level > 1):
tr1 = virttree3(newpos,
rotatevector2(dir, rfactor) * lfactor, size * wfactor,
blevel, level - 1)
tr2 = virttree3(
newpos,
rotatevector2(dir, rfactor * irit.random((-1), 1)) * lfactor,
size * wfactor, blevel, level - 1)
tr3 = virttree3(newpos,
rotatevector2(dir, (-rfactor)) * lfactor,
size * wfactor, blevel, level - 1)
retval = retval + tr1 + tr2 + tr3
return retval
def genrandomcrv(d, n, size):
ctlpts = irit.nil()
i = 1
while (i <= n):
irit.snoc(
irit.ctlpt(irit.E2, irit.random((-size), size),
irit.random((-size), size)), ctlpts)
i = i + 1
if (irit.random(0, 1) > 0.3):
kv = irit.KV_PERIODIC
else:
kv = irit.KV_OPEN
retval = irit.cbspline(
d,
ctlpts * irit.tx(irit.random(
(-0.2), 0.2)) * irit.ty(irit.random((-0.2), 0.2)), irit.list(kv))
retval = irit.coerce(retval, irit.KV_OPEN)
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 randomcrvs(numcrvs, crvdeg, crvlen, size, dwidth):
l = irit.nil()
i = 1
while (i <= numcrvs):
irit.snoc(genrandomcrv(crvdeg, crvlen, size), l)
irit.attrib(irit.nref(l, i), "gray",
irit.GenRealObject(irit.random(0.01, 0.7)))
i = i + 1
i = 1
while (i <= numcrvs):
irit.attrib(irit.nref(l, i), "rgb", irit.GenStrObject(getrandrgb()))
i = i + 1
retval = l
irit.color(retval, irit.RED)
irit.awidth(retval, 0.01)
irit.adwidth(retval, dwidth)
return retval
def getrandrgb():
retval = str(int(irit.random( 50, 255 ))) + "," + \
str(int(irit.random( 50, 255 ))) + "," + \
str(int(irit.random( 50, 255 )))
return retval
irit.viewobj(irit.GetViewMatrix())
irit.viewstate("polyaprx", 1)
ri = irit.iritstate("randominit", irit.GenIntObject(1964))
# Seed-initiate the randomizer,
irit.free(ri)
# ############################################################################
len = 1
numpts = 50
pl1 = irit.nil()
i = 1
while (i <= numpts):
pt = irit.ctlpt(irit.E3, (irit.random((-3.5), 3.5) + len * i * 2) / numpts,
(irit.random((-3.5), 3.5) + len * i * (-5)) / numpts,
(irit.random((-3.5), 3.5) + len * i * math.pi) / numpts)
irit.snoc(pt, pl1)
i = i + 1
lnfit = irit.linterp(pl1)
c1 = (irit.coerce(irit.nth(lnfit, 1) + irit.nth(lnfit, 2) * 10, irit.E3) +
irit.coerce(irit.nth(lnfit, 1) + irit.nth(lnfit, 2) * (-10), irit.E3))
irit.color(c1, irit.RED)
irit.interact(irit.list(c1, pl1) * irit.sc(0.2))
pl1 = irit.nil()
i = 1
while (i <= numpts):
pt = irit.ctlpt(irit.E3, (irit.random(
si2a = irit.selfinter(c2, 0.001, 1e-010, 90, 1)
irit.interact(irit.list(c2, si2a))
# While this one works harder to catch it.
si2a = irit.selfinter(c2, 0.001, 1e-010, 15, 1)
irit.interact(irit.list(c2, si2a))
si2b = irit.selfinter(c2, 0.001, 1e-010, (-1), 1)
irit.interact(irit.list(c2, si2b))
# ################################
pts = irit.nil()
i = 0
while (i <= 100):
irit.snoc(irit.ctlpt(irit.E2, irit.random((-1), 1), irit.random((-1), 1)),
pts)
i = i + 1
c3 = irit.cbspline(4, pts, irit.list(irit.KV_OPEN))
irit.free(pts)
irit.color(c3, irit.BLUE)
# While this one works harder to catch it.
si3a = irit.selfinter(c3, 0.001, (-1e-010), 15, 1)
irit.interact(irit.list(c3, si3a))
si3b = irit.selfinter(c3, 0.001, (-1e-010), (-1), 1)
irit.interact(irit.list(c3, si3b))
irit.save(
"selfint5",
def irandom( min, max ):
retval = math.floor( irit.random( min, max ) )
return retval
equapt )
else:
all = irit.list( prim1, prim2, prim3, circs )
if ( irit.SizeOf( irit.GenStrObject(fname) ) > 0 ):
irit.save( fname, all )
irit.view( all, irit.ON )
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix( irit.sc( 0.8 ))
irit.viewobj( irit.GetViewMatrix() )
# ############################################################################
i = 0
while ( i <= 20 ):
pt1 = irit.point( irit.random( (-0.5 ), 0.5 ), irit.random( (-0.5 ), 0.5 ), 0 )
pt2 = irit.point( irit.random( (-0.5 ), 0.5 ), irit.random( (-0.5 ), 0.5 ), 0 )
pt3 = irit.point( irit.random( (-0.5 ), 0.5 ), irit.random( (-0.5 ), 0.5 ), 0 )
skel2dcolor( pt1, pt2, pt3, 0.01, irit.list( 0.01, (-1e-010 ) ), 1, "" )
irit.milisleep( delay )
i = i + 1
skel2dcolor( pt1, pt2, pt3, 0.01, irit.list( 0.01, (-1e-010 ) ), 1, "skel2d1" )
irit.pause( )
# ############################################################################
i = 0
while ( i <= 20 ):
ln1 = irit.ctlpt( irit.E2, irit.random( (-1 ), 1 ), irit.random( (-1 ), 1 ) ) + \
irit.ctlpt( irit.E2, irit.random( (-1 ), 1 ), irit.random( (-1 ), 1 ) )
irit.viewstate("widthlines", 1)
ri = irit.iritstate("randominit", irit.GenIntObject(1964))
# Seed-initiate the randomizer,
irit.free(ri)
# ############################################################################
#
# Map circles using the inverse of Map3Pt2Eql, creating an bounding ellipse.
#
n = 40
i = 1
while (i <= n):
pt1 = irit.point(irit.random((-1), 1), irit.random((-1), 1), 0)
pt2 = irit.point(irit.random((-1), 1), irit.random((-1), 1), 0)
pt3 = irit.point(irit.random((-1), 1), irit.random((-1), 1), 0)
pl = irit.poly(irit.list(pt1, pt2, pt3), irit.FALSE)
irit.color(pl, irit.GREEN)
ell = boundingellipse(pt1, pt2, pt3)
all = irit.list(pl, ell)
irit.view(all, irit.ON)
irit.milisleep(200)
i = i + 1
irit.save("ellips1", irit.list(all))
# ############################################################################
#
# Compute the bounding ellipse as:
#
# Some routines to test the bspline curve fitting functions.
#
ri = irit.iritstate("randominit", irit.GenIntObject(1960))
# Seed-initiate the randomizer,
# ############################################################################
ptlist = irit.nil()
i = 0
while (i <= 2 * math.pi):
irit.snoc(
irit.point(
math.cos(i) + irit.random((-0.01), 0.01),
math.sin(i) + irit.random((-0.01), 0.01), 0), ptlist)
i = i + 0.1
irit.color(ptlist, irit.RED)
c1 = irit.cbsp_fit(ptlist, irit.list(10, 3, 1), 1, irit.list(20, 0.0001))
irit.color(c1, irit.CYAN)
c2 = irit.cbsp_fit(ptlist, irit.list(10, 3, 1), 2, irit.list(20, 0.0001))
irit.color(c2, irit.YELLOW)
all1 = irit.list(ptlist, c1, c2)
irit.interact(all1)
c1a = irit.cbsp_fit(ptlist, c1, 1, irit.list(3, 0, 0, 0))
irit.color(c1a, irit.CYAN)
view_mat0 = irit.tx( 0 )
# #############################################################################
#
# Point inclusion in a polygon:
#
pl1 = irit.poly( irit.list( ( 0, 0, 0 ), ( 0.3, 0, 0 ), irit.point( 0.3, 0.1, 0 ), irit.point( 0.2, 0.1, 0 ), irit.point( 0.2, 0.5, 0 ), irit.point( 0.3, 0.5, 0 ), irit.point( 0.3, 0.6, 0 ), irit.point( 0, 0.6, 0 ), irit.point( 0, 0.5, 0 ), irit.point( 0.1, 0.5, 0 ), irit.point( 0.1, 0.1, 0 ), irit.point( 0, 0.1, 0 ) ), 0 ) * irit.tx( (-0.15 ) ) * irit.ty( (-0.3 ) )
irit.view( irit.list( irit.GetAxes(), pl1 ), irit.ON )
pts = irit.nil( )
i = 0
while ( i <= 1000 ):
p = irit.point( irit.random( (-0.5 ), 0.5 ), irit.random( (-0.5 ), 0.5 ), 0 )
if ( irit.FetchRealObject(irit.ppinclude( pl1, irit.Fetch3TupleObject(p) ) ) ):
irit.color( p, irit.GREEN )
else:
irit.color( p, irit.RED )
irit.snoc( p * irit.tx( 0 ), pts )
i = i + 1
irit.interact( irit.list( view_mat0, pl1, pts ) )
irit.save( "pt_inpl1", irit.list( irit.GetViewMatrix(), pl1, pts ) )
irit.free( pl1 )
# #############################################################################
#
def printfitresult(str, fittedsrf):
global fitting
irit.snoc(fittedsrf, fitting)
irit.printf("%s:\n", irit.list(str))
i = 1
while (i <= irit.SizeOf(fittedsrf)):
irit.printf("\t%9.6pf\n", irit.list(irit.nth(fittedsrf, i)))
i = i + 1
ptpln = irit.nil()
i = 1
while (i <= 15):
irit.snoc(
irit.point(irit.random((-1), 1), irit.random((-1), 1),
irit.random((-eps), eps)), ptpln)
i = i + 1
printfitresult("bilinear fit: plane xy (15 pts):",
irit.analyfit(ptpln, ptpln, 0, 1))
printfitresult("bilinear fit: plane xy sclx 2 scly 3 (15 pts):",
irit.analyfit(ptpln,
ptpln * irit.sx(2) * irit.sy(3), 0, 1))
printfitresult("bilinear fit: plane xy trasnaled x=1, y=2 (15 pts):",
irit.analyfit(ptpln,
ptpln * irit.tx(1) * irit.ty(2), 0, 1))
printfitresult(
x2 = x1 * irit.rx(45)
irit.view(irit.list(irit.GetAxes(), x2), irit.ON)
planefit = irit.list(irit.fitpmodel(x1, 0, 1e-005, 100),
irit.fitpmodel(x2, 0, 1e-005, 100))
#
# Some a larger test on planes
#
x1 = irit.nil()
i = 0
while (i <= 2):
irit.snoc(
irit.point(irit.random((-1), 1), irit.random((-1), 1),
irit.random((-0.001), 0.001)), x1)
i = i + 1
x1 = irit.poly(x1, irit.FALSE)
i = 0
while (i <= 5):
x1 = x1 ^ (x1 * irit.tx(irit.random(
(-2), 2)) * irit.ty(irit.random(
(-2), 2)) * irit.tz(irit.random((-0.002), 0.002)))
i = i + 1
i = 0
while (i <= 10):
irit.printf(
"%d), error = %f\n",
irit.list(
# 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))
c4a = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E3, 0.53, 0.35, (-0.3 ) ), \
irit.ctlpt( irit.E3, 0.423, (-0.01 ), 0.3 ), \
irit.ctlpt( irit.E3, 0.198, (-0.19 ), 0.4 ), \
irit.ctlpt( irit.E3, 0.263, 0.38, (-0.2 ) ), \
irit.ctlpt( irit.E3, 0.432, 0.48, (-0.3 ) ), \
irit.ctlpt( irit.E3, 0.521, (-0.08 ), 0.4 ) ), irit.list( irit.KV_OPEN ) )
irit.color( c4a, irit.MAGENTA )
c5 = irit.pcircle( ( 0, 0, 0 ), 0.2 )
irit.color( c5, irit.GREEN )
pts = irit.nil( )
i = 0
while ( i <= 20 ):
irit.snoc( irit.point( math.cos( 2 * math.pi * i/20 ) + irit.random( (-0.1 ), 0.1 ), \
math.sin( 2 * math.pi * i/20 ) + irit.random( (-0.1 ), 0.1 ), \
irit.random( (-0.1 ), 0.1 ) ), \
pts )
i = i + 1
c6 = irit.cbspline( 3, pts, irit.list( irit.KV_PERIODIC ) )
irit.free( pts )
c6 = irit.coerce( c6, irit.KV_OPEN )
irit.color( c6, irit.RED )
eps = 1e-010
# view( list( c1, c2, c3, c4, c5, pt1, pt2 ), 1 );
# ############################################################################
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.sc(0.5))
irit.viewobj(irit.GetViewMatrix())
ri = irit.iritstate("randominit", irit.GenIntObject(1964))
# Seed-initiate the randomizer,
irit.free(ri)
# ############################################################################
pts = irit.nil()
len = 1
numpts = 5
i = 0
while (i <= numpts):
r = irit.random(0, 2)
pt = irit.ctlpt(irit.E2, len * r * math.cos(i * 2 * math.pi / numpts),
len * r * math.sin(i * 2 * 3.14159 / numpts))
irit.snoc(pt, pts)
i = i + 1
c0 = irit.coerce(irit.cbspline(4, pts, irit.list(irit.KV_PERIODIC)),
irit.KV_OPEN)
irit.color(c0, irit.RED)
irit.adwidth(c0, 4)
pts = irit.nil()
len = 1
numpts = 7
i = 0
while (i <= numpts):
r = irit.random(0, 2)
def randrgb( ):
return ( str(irit.random( 80, 255 )) +
"," +
str(irit.random( 80, 155 )) +
"," +
str(irit.random( 80, 255 ) ))
def setrandomcolor( obj ):
irit.attrib( obj, "rgb", irit.GenStrObject(str(int( irit.random( 100, 255 ) )) + "," + str(int( irit.random( 100, 255 ) )) + "," + str(int( irit.random( 100, 255 ) ) )))
retval = obj
return retval
#
# Gershon Elber, Aug. 2000
#
ri = irit.iritstate("randominit", irit.GenRealObject(1964))
# Seed-initiate the randomizer,
irit.free(ri)
#
# Two point sets.
#
pt1 = irit.nil()
pt2 = irit.nil()
i = 0
while (i <= 15):
pt = irit.point(irit.random((-0.7), 0.7), irit.random((-0.7), 0.7),
irit.random((-0.7), 0.7))
irit.snoc(pt * irit.tx(0), pt1)
irit.snoc(pt * irit.tx(0), pt2)
i = i + 1
irit.color(pt2, irit.MAGENTA)
pt1f = pt1 * irit.rx(13) * irit.ry(5) * irit.rz(11) * irit.tx(0.1) * irit.ty(
0.03) * irit.tz((-0.05))
irit.color(pt1f, irit.CYAN)
tr = irit.ptregister(pt1f, pt2, 1, 1e-006)
pt1y = pt1f * tr
irit.color(pt1y, irit.YELLOW)
irit.adwidth(pt1y, 2)
